5 // These should be provided...somehow...
6 void *memset(void *s, int c, size_t n);
7 void *memcpy(void *dest, const void *src, size_t n);
8 int memcmp(const void *s1, const void *s2, size_t n);
10 extern void __attribute__((noreturn)) abort(void);
11 static inline void assert(bool expression) {
12 if (!expression) { abort(); }
15 uint32_t __attribute__((export_name("test_bigint_pass_deadbeef0badf00d"))) test_bigint_pass_deadbeef0badf00d(uint64_t val) {
16 return val == 0xdeadbeef0badf00dULL;
20 void *malloc(size_t size);
23 #define MALLOC(a, _) malloc(a)
24 #define do_MALLOC(a, _b, _c) malloc(a)
25 #define FREE(p) if ((unsigned long)(p) > 4096) { free(p); }
26 #define DO_ASSERT(a) (void)(a)
28 #define CHECK_ACCESS(p)
29 #define CHECK_INNER_FIELD_ACCESS_OR_NULL(v)
31 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
32 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
33 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
34 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
36 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
38 #define DECL_ARR_TYPE(ty, name) \
39 struct name##array { \
40 uint64_t arr_len; /* uint32_t would suffice but we want to align uint64_ts as well */ \
43 typedef struct name##array * name##Array; \
44 static inline name##Array init_##name##Array(size_t arr_len, int lineno) { \
45 name##Array arr = (name##Array)do_MALLOC(arr_len * sizeof(ty) + sizeof(uint64_t), #name" array init", lineno); \
46 arr->arr_len = arr_len; \
50 DECL_ARR_TYPE(int64_t, int64_t);
51 DECL_ARR_TYPE(uint64_t, uint64_t);
52 DECL_ARR_TYPE(int8_t, int8_t);
53 DECL_ARR_TYPE(int16_t, int16_t);
54 DECL_ARR_TYPE(uint32_t, uint32_t);
55 DECL_ARR_TYPE(void*, ptr);
56 DECL_ARR_TYPE(char, char);
57 typedef charArray jstring;
59 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
60 charArray arr = init_charArray(len, __LINE__);
61 memcpy(arr->elems, chars, len);
64 static inline LDKStr str_ref_to_owned_c(const jstring str) {
65 char* newchars = MALLOC(str->arr_len + 1, "String chars");
66 memcpy(newchars, str->elems, str->arr_len);
67 newchars[str->arr_len] = 0;
71 .chars_is_owned = true
76 typedef bool jboolean;
78 uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) {
79 return (uint32_t)MALLOC(size, "JS-Called malloc");
81 void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) {
85 jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() {
86 const char *res = check_get_ldk_bindings_version();
87 if (res == NULL) return NULL;
88 return str_ref_to_ts(res, strlen(res));
90 jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() {
91 const char *res = check_get_ldk_version();
92 if (res == NULL) return NULL;
93 return str_ref_to_ts(res, strlen(res));
96 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
98 static inline void* untag_ptr(uint64_t ptr) {
99 if (ptr < 4096) return (void*)ptr;
100 if (sizeof(void*) == 4) {
101 // For 32-bit systems, store pointers as 64-bit ints and use the 31st bit
102 return (void*)(uintptr_t)ptr;
104 // For 64-bit systems, assume the top byte is used for tagging, then
105 // use bit 9 ^ bit 10.
106 uint64_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
107 uintptr_t p = (ptr & ~(1ULL << 55)) | (tenth_bit << 55);
108 #ifdef LDK_DEBUG_BUILD
109 // On debug builds we also use the 11th bit as a debug flag
110 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
111 CHECK(tenth_bit != eleventh_bit);
117 static inline bool ptr_is_owned(uint64_t ptr) {
118 if(ptr < 4096) return true;
119 if (sizeof(void*) == 4) {
120 return ptr & (1ULL << 32);
122 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
123 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
124 #ifdef LDK_DEBUG_BUILD
125 // On debug builds we also use the 11th bit as a debug flag
126 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
127 CHECK(tenth_bit != eleventh_bit);
129 return (ninth_bit ^ tenth_bit) ? true : false;
132 static inline uint64_t tag_ptr(const void* ptr, bool is_owned) {
133 if ((uintptr_t)ptr < 4096) return (uint64_t)ptr;
134 if (sizeof(void*) == 4) {
135 return (((uint64_t)ptr) | ((is_owned ? 1ULL : 0) << 32));
137 CHECK(sizeof(uintptr_t) == 8);
138 uintptr_t tenth_bit = (((uintptr_t)ptr) & (1ULL << 54)) >> 54;
139 uintptr_t t = (((uintptr_t)ptr) | (((is_owned ? 1ULL : 0ULL) ^ tenth_bit) << 55));
140 #ifdef LDK_DEBUG_BUILD
141 uintptr_t ninth_bit = (((uintptr_t)ptr) & (1ULL << 55)) >> 55;
142 uintptr_t eleventh_bit = (((uintptr_t)ptr) & (1ULL << 53)) >> 53;
143 CHECK(ninth_bit == tenth_bit);
144 CHECK(ninth_bit == eleventh_bit);
147 CHECK(ptr_is_owned(t) == is_owned);
148 CHECK(untag_ptr(t) == ptr);
153 static inline LDKBolt11SemanticError LDKBolt11SemanticError_from_js(int32_t ord) {
155 case 0: return LDKBolt11SemanticError_NoPaymentHash;
156 case 1: return LDKBolt11SemanticError_MultiplePaymentHashes;
157 case 2: return LDKBolt11SemanticError_NoDescription;
158 case 3: return LDKBolt11SemanticError_MultipleDescriptions;
159 case 4: return LDKBolt11SemanticError_NoPaymentSecret;
160 case 5: return LDKBolt11SemanticError_MultiplePaymentSecrets;
161 case 6: return LDKBolt11SemanticError_InvalidFeatures;
162 case 7: return LDKBolt11SemanticError_InvalidRecoveryId;
163 case 8: return LDKBolt11SemanticError_InvalidSignature;
164 case 9: return LDKBolt11SemanticError_ImpreciseAmount;
168 static inline int32_t LDKBolt11SemanticError_to_js(LDKBolt11SemanticError val) {
170 case LDKBolt11SemanticError_NoPaymentHash: return 0;
171 case LDKBolt11SemanticError_MultiplePaymentHashes: return 1;
172 case LDKBolt11SemanticError_NoDescription: return 2;
173 case LDKBolt11SemanticError_MultipleDescriptions: return 3;
174 case LDKBolt11SemanticError_NoPaymentSecret: return 4;
175 case LDKBolt11SemanticError_MultiplePaymentSecrets: return 5;
176 case LDKBolt11SemanticError_InvalidFeatures: return 6;
177 case LDKBolt11SemanticError_InvalidRecoveryId: return 7;
178 case LDKBolt11SemanticError_InvalidSignature: return 8;
179 case LDKBolt11SemanticError_ImpreciseAmount: return 9;
183 static inline LDKBolt12SemanticError LDKBolt12SemanticError_from_js(int32_t ord) {
185 case 0: return LDKBolt12SemanticError_AlreadyExpired;
186 case 1: return LDKBolt12SemanticError_UnsupportedChain;
187 case 2: return LDKBolt12SemanticError_UnexpectedChain;
188 case 3: return LDKBolt12SemanticError_MissingAmount;
189 case 4: return LDKBolt12SemanticError_InvalidAmount;
190 case 5: return LDKBolt12SemanticError_InsufficientAmount;
191 case 6: return LDKBolt12SemanticError_UnexpectedAmount;
192 case 7: return LDKBolt12SemanticError_UnsupportedCurrency;
193 case 8: return LDKBolt12SemanticError_UnknownRequiredFeatures;
194 case 9: return LDKBolt12SemanticError_UnexpectedFeatures;
195 case 10: return LDKBolt12SemanticError_MissingDescription;
196 case 11: return LDKBolt12SemanticError_MissingSigningPubkey;
197 case 12: return LDKBolt12SemanticError_InvalidSigningPubkey;
198 case 13: return LDKBolt12SemanticError_UnexpectedSigningPubkey;
199 case 14: return LDKBolt12SemanticError_MissingQuantity;
200 case 15: return LDKBolt12SemanticError_InvalidQuantity;
201 case 16: return LDKBolt12SemanticError_UnexpectedQuantity;
202 case 17: return LDKBolt12SemanticError_InvalidMetadata;
203 case 18: return LDKBolt12SemanticError_UnexpectedMetadata;
204 case 19: return LDKBolt12SemanticError_MissingPayerMetadata;
205 case 20: return LDKBolt12SemanticError_MissingPayerId;
206 case 21: return LDKBolt12SemanticError_MissingPaths;
207 case 22: return LDKBolt12SemanticError_InvalidPayInfo;
208 case 23: return LDKBolt12SemanticError_MissingCreationTime;
209 case 24: return LDKBolt12SemanticError_MissingPaymentHash;
210 case 25: return LDKBolt12SemanticError_MissingSignature;
214 static inline int32_t LDKBolt12SemanticError_to_js(LDKBolt12SemanticError val) {
216 case LDKBolt12SemanticError_AlreadyExpired: return 0;
217 case LDKBolt12SemanticError_UnsupportedChain: return 1;
218 case LDKBolt12SemanticError_UnexpectedChain: return 2;
219 case LDKBolt12SemanticError_MissingAmount: return 3;
220 case LDKBolt12SemanticError_InvalidAmount: return 4;
221 case LDKBolt12SemanticError_InsufficientAmount: return 5;
222 case LDKBolt12SemanticError_UnexpectedAmount: return 6;
223 case LDKBolt12SemanticError_UnsupportedCurrency: return 7;
224 case LDKBolt12SemanticError_UnknownRequiredFeatures: return 8;
225 case LDKBolt12SemanticError_UnexpectedFeatures: return 9;
226 case LDKBolt12SemanticError_MissingDescription: return 10;
227 case LDKBolt12SemanticError_MissingSigningPubkey: return 11;
228 case LDKBolt12SemanticError_InvalidSigningPubkey: return 12;
229 case LDKBolt12SemanticError_UnexpectedSigningPubkey: return 13;
230 case LDKBolt12SemanticError_MissingQuantity: return 14;
231 case LDKBolt12SemanticError_InvalidQuantity: return 15;
232 case LDKBolt12SemanticError_UnexpectedQuantity: return 16;
233 case LDKBolt12SemanticError_InvalidMetadata: return 17;
234 case LDKBolt12SemanticError_UnexpectedMetadata: return 18;
235 case LDKBolt12SemanticError_MissingPayerMetadata: return 19;
236 case LDKBolt12SemanticError_MissingPayerId: return 20;
237 case LDKBolt12SemanticError_MissingPaths: return 21;
238 case LDKBolt12SemanticError_InvalidPayInfo: return 22;
239 case LDKBolt12SemanticError_MissingCreationTime: return 23;
240 case LDKBolt12SemanticError_MissingPaymentHash: return 24;
241 case LDKBolt12SemanticError_MissingSignature: return 25;
245 static inline LDKCOption_NoneZ LDKCOption_NoneZ_from_js(int32_t ord) {
247 case 0: return LDKCOption_NoneZ_Some;
248 case 1: return LDKCOption_NoneZ_None;
252 static inline int32_t LDKCOption_NoneZ_to_js(LDKCOption_NoneZ val) {
254 case LDKCOption_NoneZ_Some: return 0;
255 case LDKCOption_NoneZ_None: return 1;
259 static inline LDKChannelMonitorUpdateStatus LDKChannelMonitorUpdateStatus_from_js(int32_t ord) {
261 case 0: return LDKChannelMonitorUpdateStatus_Completed;
262 case 1: return LDKChannelMonitorUpdateStatus_InProgress;
263 case 2: return LDKChannelMonitorUpdateStatus_UnrecoverableError;
267 static inline int32_t LDKChannelMonitorUpdateStatus_to_js(LDKChannelMonitorUpdateStatus val) {
269 case LDKChannelMonitorUpdateStatus_Completed: return 0;
270 case LDKChannelMonitorUpdateStatus_InProgress: return 1;
271 case LDKChannelMonitorUpdateStatus_UnrecoverableError: return 2;
275 static inline LDKChannelShutdownState LDKChannelShutdownState_from_js(int32_t ord) {
277 case 0: return LDKChannelShutdownState_NotShuttingDown;
278 case 1: return LDKChannelShutdownState_ShutdownInitiated;
279 case 2: return LDKChannelShutdownState_ResolvingHTLCs;
280 case 3: return LDKChannelShutdownState_NegotiatingClosingFee;
281 case 4: return LDKChannelShutdownState_ShutdownComplete;
285 static inline int32_t LDKChannelShutdownState_to_js(LDKChannelShutdownState val) {
287 case LDKChannelShutdownState_NotShuttingDown: return 0;
288 case LDKChannelShutdownState_ShutdownInitiated: return 1;
289 case LDKChannelShutdownState_ResolvingHTLCs: return 2;
290 case LDKChannelShutdownState_NegotiatingClosingFee: return 3;
291 case LDKChannelShutdownState_ShutdownComplete: return 4;
295 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
297 case 0: return LDKConfirmationTarget_MempoolMinimum;
298 case 1: return LDKConfirmationTarget_Background;
299 case 2: return LDKConfirmationTarget_Normal;
300 case 3: return LDKConfirmationTarget_HighPriority;
304 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
306 case LDKConfirmationTarget_MempoolMinimum: return 0;
307 case LDKConfirmationTarget_Background: return 1;
308 case LDKConfirmationTarget_Normal: return 2;
309 case LDKConfirmationTarget_HighPriority: return 3;
313 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
315 case 0: return LDKCreationError_DescriptionTooLong;
316 case 1: return LDKCreationError_RouteTooLong;
317 case 2: return LDKCreationError_TimestampOutOfBounds;
318 case 3: return LDKCreationError_InvalidAmount;
319 case 4: return LDKCreationError_MissingRouteHints;
320 case 5: return LDKCreationError_MinFinalCltvExpiryDeltaTooShort;
324 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
326 case LDKCreationError_DescriptionTooLong: return 0;
327 case LDKCreationError_RouteTooLong: return 1;
328 case LDKCreationError_TimestampOutOfBounds: return 2;
329 case LDKCreationError_InvalidAmount: return 3;
330 case LDKCreationError_MissingRouteHints: return 4;
331 case LDKCreationError_MinFinalCltvExpiryDeltaTooShort: return 5;
335 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
337 case 0: return LDKCurrency_Bitcoin;
338 case 1: return LDKCurrency_BitcoinTestnet;
339 case 2: return LDKCurrency_Regtest;
340 case 3: return LDKCurrency_Simnet;
341 case 4: return LDKCurrency_Signet;
345 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
347 case LDKCurrency_Bitcoin: return 0;
348 case LDKCurrency_BitcoinTestnet: return 1;
349 case LDKCurrency_Regtest: return 2;
350 case LDKCurrency_Simnet: return 3;
351 case LDKCurrency_Signet: return 4;
355 static inline LDKHTLCClaim LDKHTLCClaim_from_js(int32_t ord) {
357 case 0: return LDKHTLCClaim_OfferedTimeout;
358 case 1: return LDKHTLCClaim_OfferedPreimage;
359 case 2: return LDKHTLCClaim_AcceptedTimeout;
360 case 3: return LDKHTLCClaim_AcceptedPreimage;
361 case 4: return LDKHTLCClaim_Revocation;
365 static inline int32_t LDKHTLCClaim_to_js(LDKHTLCClaim val) {
367 case LDKHTLCClaim_OfferedTimeout: return 0;
368 case LDKHTLCClaim_OfferedPreimage: return 1;
369 case LDKHTLCClaim_AcceptedTimeout: return 2;
370 case LDKHTLCClaim_AcceptedPreimage: return 3;
371 case LDKHTLCClaim_Revocation: return 4;
375 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
377 case 0: return LDKIOError_NotFound;
378 case 1: return LDKIOError_PermissionDenied;
379 case 2: return LDKIOError_ConnectionRefused;
380 case 3: return LDKIOError_ConnectionReset;
381 case 4: return LDKIOError_ConnectionAborted;
382 case 5: return LDKIOError_NotConnected;
383 case 6: return LDKIOError_AddrInUse;
384 case 7: return LDKIOError_AddrNotAvailable;
385 case 8: return LDKIOError_BrokenPipe;
386 case 9: return LDKIOError_AlreadyExists;
387 case 10: return LDKIOError_WouldBlock;
388 case 11: return LDKIOError_InvalidInput;
389 case 12: return LDKIOError_InvalidData;
390 case 13: return LDKIOError_TimedOut;
391 case 14: return LDKIOError_WriteZero;
392 case 15: return LDKIOError_Interrupted;
393 case 16: return LDKIOError_Other;
394 case 17: return LDKIOError_UnexpectedEof;
398 static inline int32_t LDKIOError_to_js(LDKIOError val) {
400 case LDKIOError_NotFound: return 0;
401 case LDKIOError_PermissionDenied: return 1;
402 case LDKIOError_ConnectionRefused: return 2;
403 case LDKIOError_ConnectionReset: return 3;
404 case LDKIOError_ConnectionAborted: return 4;
405 case LDKIOError_NotConnected: return 5;
406 case LDKIOError_AddrInUse: return 6;
407 case LDKIOError_AddrNotAvailable: return 7;
408 case LDKIOError_BrokenPipe: return 8;
409 case LDKIOError_AlreadyExists: return 9;
410 case LDKIOError_WouldBlock: return 10;
411 case LDKIOError_InvalidInput: return 11;
412 case LDKIOError_InvalidData: return 12;
413 case LDKIOError_TimedOut: return 13;
414 case LDKIOError_WriteZero: return 14;
415 case LDKIOError_Interrupted: return 15;
416 case LDKIOError_Other: return 16;
417 case LDKIOError_UnexpectedEof: return 17;
421 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
423 case 0: return LDKLevel_Gossip;
424 case 1: return LDKLevel_Trace;
425 case 2: return LDKLevel_Debug;
426 case 3: return LDKLevel_Info;
427 case 4: return LDKLevel_Warn;
428 case 5: return LDKLevel_Error;
432 static inline int32_t LDKLevel_to_js(LDKLevel val) {
434 case LDKLevel_Gossip: return 0;
435 case LDKLevel_Trace: return 1;
436 case LDKLevel_Debug: return 2;
437 case LDKLevel_Info: return 3;
438 case LDKLevel_Warn: return 4;
439 case LDKLevel_Error: return 5;
443 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
445 case 0: return LDKNetwork_Bitcoin;
446 case 1: return LDKNetwork_Testnet;
447 case 2: return LDKNetwork_Regtest;
448 case 3: return LDKNetwork_Signet;
452 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
454 case LDKNetwork_Bitcoin: return 0;
455 case LDKNetwork_Testnet: return 1;
456 case LDKNetwork_Regtest: return 2;
457 case LDKNetwork_Signet: return 3;
461 static inline LDKPaymentFailureReason LDKPaymentFailureReason_from_js(int32_t ord) {
463 case 0: return LDKPaymentFailureReason_RecipientRejected;
464 case 1: return LDKPaymentFailureReason_UserAbandoned;
465 case 2: return LDKPaymentFailureReason_RetriesExhausted;
466 case 3: return LDKPaymentFailureReason_PaymentExpired;
467 case 4: return LDKPaymentFailureReason_RouteNotFound;
468 case 5: return LDKPaymentFailureReason_UnexpectedError;
472 static inline int32_t LDKPaymentFailureReason_to_js(LDKPaymentFailureReason val) {
474 case LDKPaymentFailureReason_RecipientRejected: return 0;
475 case LDKPaymentFailureReason_UserAbandoned: return 1;
476 case LDKPaymentFailureReason_RetriesExhausted: return 2;
477 case LDKPaymentFailureReason_PaymentExpired: return 3;
478 case LDKPaymentFailureReason_RouteNotFound: return 4;
479 case LDKPaymentFailureReason_UnexpectedError: return 5;
483 static inline LDKRecipient LDKRecipient_from_js(int32_t ord) {
485 case 0: return LDKRecipient_Node;
486 case 1: return LDKRecipient_PhantomNode;
490 static inline int32_t LDKRecipient_to_js(LDKRecipient val) {
492 case LDKRecipient_Node: return 0;
493 case LDKRecipient_PhantomNode: return 1;
497 static inline LDKRetryableSendFailure LDKRetryableSendFailure_from_js(int32_t ord) {
499 case 0: return LDKRetryableSendFailure_PaymentExpired;
500 case 1: return LDKRetryableSendFailure_RouteNotFound;
501 case 2: return LDKRetryableSendFailure_DuplicatePayment;
505 static inline int32_t LDKRetryableSendFailure_to_js(LDKRetryableSendFailure val) {
507 case LDKRetryableSendFailure_PaymentExpired: return 0;
508 case LDKRetryableSendFailure_RouteNotFound: return 1;
509 case LDKRetryableSendFailure_DuplicatePayment: return 2;
513 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
515 case 0: return LDKSecp256k1Error_IncorrectSignature;
516 case 1: return LDKSecp256k1Error_InvalidMessage;
517 case 2: return LDKSecp256k1Error_InvalidPublicKey;
518 case 3: return LDKSecp256k1Error_InvalidSignature;
519 case 4: return LDKSecp256k1Error_InvalidSecretKey;
520 case 5: return LDKSecp256k1Error_InvalidSharedSecret;
521 case 6: return LDKSecp256k1Error_InvalidRecoveryId;
522 case 7: return LDKSecp256k1Error_InvalidTweak;
523 case 8: return LDKSecp256k1Error_NotEnoughMemory;
524 case 9: return LDKSecp256k1Error_InvalidPublicKeySum;
525 case 10: return LDKSecp256k1Error_InvalidParityValue;
529 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
531 case LDKSecp256k1Error_IncorrectSignature: return 0;
532 case LDKSecp256k1Error_InvalidMessage: return 1;
533 case LDKSecp256k1Error_InvalidPublicKey: return 2;
534 case LDKSecp256k1Error_InvalidSignature: return 3;
535 case LDKSecp256k1Error_InvalidSecretKey: return 4;
536 case LDKSecp256k1Error_InvalidSharedSecret: return 5;
537 case LDKSecp256k1Error_InvalidRecoveryId: return 6;
538 case LDKSecp256k1Error_InvalidTweak: return 7;
539 case LDKSecp256k1Error_NotEnoughMemory: return 8;
540 case LDKSecp256k1Error_InvalidPublicKeySum: return 9;
541 case LDKSecp256k1Error_InvalidParityValue: return 10;
545 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
547 case 0: return LDKSiPrefix_Milli;
548 case 1: return LDKSiPrefix_Micro;
549 case 2: return LDKSiPrefix_Nano;
550 case 3: return LDKSiPrefix_Pico;
554 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
556 case LDKSiPrefix_Milli: return 0;
557 case LDKSiPrefix_Micro: return 1;
558 case LDKSiPrefix_Nano: return 2;
559 case LDKSiPrefix_Pico: return 3;
563 static inline LDKSocketAddressParseError LDKSocketAddressParseError_from_js(int32_t ord) {
565 case 0: return LDKSocketAddressParseError_SocketAddrParse;
566 case 1: return LDKSocketAddressParseError_InvalidInput;
567 case 2: return LDKSocketAddressParseError_InvalidPort;
568 case 3: return LDKSocketAddressParseError_InvalidOnionV3;
572 static inline int32_t LDKSocketAddressParseError_to_js(LDKSocketAddressParseError val) {
574 case LDKSocketAddressParseError_SocketAddrParse: return 0;
575 case LDKSocketAddressParseError_InvalidInput: return 1;
576 case LDKSocketAddressParseError_InvalidPort: return 2;
577 case LDKSocketAddressParseError_InvalidOnionV3: return 3;
581 static inline LDKUtxoLookupError LDKUtxoLookupError_from_js(int32_t ord) {
583 case 0: return LDKUtxoLookupError_UnknownChain;
584 case 1: return LDKUtxoLookupError_UnknownTx;
588 static inline int32_t LDKUtxoLookupError_to_js(LDKUtxoLookupError val) {
590 case LDKUtxoLookupError_UnknownChain: return 0;
591 case LDKUtxoLookupError_UnknownTx: return 1;
595 struct LDKThirtyTwoBytes BigEndianScalar_get_bytes (struct LDKBigEndianScalar* thing) {
596 LDKThirtyTwoBytes ret = { .data = *thing->big_endian_bytes };
599 int8_tArray __attribute__((export_name("TS_BigEndianScalar_get_bytes"))) TS_BigEndianScalar_get_bytes(uint64_t thing) {
600 LDKBigEndianScalar* thing_conv = (LDKBigEndianScalar*)untag_ptr(thing);
601 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
602 memcpy(ret_arr->elems, BigEndianScalar_get_bytes(thing_conv).data, 32);
606 static void BigEndianScalar_free (struct LDKBigEndianScalar thing) {}
607 void __attribute__((export_name("TS_BigEndianScalar_free"))) TS_BigEndianScalar_free(uint64_t thing) {
608 if (!ptr_is_owned(thing)) return;
609 void* thing_ptr = untag_ptr(thing);
610 CHECK_ACCESS(thing_ptr);
611 LDKBigEndianScalar thing_conv = *(LDKBigEndianScalar*)(thing_ptr);
612 FREE(untag_ptr(thing));
613 BigEndianScalar_free(thing_conv);
616 uint32_t __attribute__((export_name("TS_LDKBech32Error_ty_from_ptr"))) TS_LDKBech32Error_ty_from_ptr(uint64_t ptr) {
617 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
619 case LDKBech32Error_MissingSeparator: return 0;
620 case LDKBech32Error_InvalidChecksum: return 1;
621 case LDKBech32Error_InvalidLength: return 2;
622 case LDKBech32Error_InvalidChar: return 3;
623 case LDKBech32Error_InvalidData: return 4;
624 case LDKBech32Error_InvalidPadding: return 5;
625 case LDKBech32Error_MixedCase: return 6;
629 int32_t __attribute__((export_name("TS_LDKBech32Error_InvalidChar_get_invalid_char"))) TS_LDKBech32Error_InvalidChar_get_invalid_char(uint64_t ptr) {
630 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
631 assert(obj->tag == LDKBech32Error_InvalidChar);
632 int32_t invalid_char_conv = obj->invalid_char;
633 return invalid_char_conv;
635 int8_t __attribute__((export_name("TS_LDKBech32Error_InvalidData_get_invalid_data"))) TS_LDKBech32Error_InvalidData_get_invalid_data(uint64_t ptr) {
636 LDKBech32Error *obj = (LDKBech32Error*)untag_ptr(ptr);
637 assert(obj->tag == LDKBech32Error_InvalidData);
638 int8_t invalid_data_conv = obj->invalid_data;
639 return invalid_data_conv;
641 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
642 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
643 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
646 struct LDKWitness TxIn_get_witness (struct LDKTxIn* thing) { return Witness_clone(&thing->witness);}int8_tArray __attribute__((export_name("TS_TxIn_get_witness"))) TS_TxIn_get_witness(uint64_t thing) {
647 LDKTxIn* thing_conv = (LDKTxIn*)untag_ptr(thing);
648 LDKWitness ret_var = TxIn_get_witness(thing_conv);
649 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
650 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
651 Witness_free(ret_var);
655 struct LDKCVec_u8Z TxIn_get_script_sig (struct LDKTxIn* thing) { return CVec_u8Z_clone(&thing->script_sig);}int8_tArray __attribute__((export_name("TS_TxIn_get_script_sig"))) TS_TxIn_get_script_sig(uint64_t thing) {
656 LDKTxIn* thing_conv = (LDKTxIn*)untag_ptr(thing);
657 LDKCVec_u8Z ret_var = TxIn_get_script_sig(thing_conv);
658 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
659 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
660 CVec_u8Z_free(ret_var);
664 LDKThirtyTwoBytes TxIn_get_previous_txid (struct LDKTxIn* thing) { return thing->previous_txid;}int8_tArray __attribute__((export_name("TS_TxIn_get_previous_txid"))) TS_TxIn_get_previous_txid(uint64_t thing) {
665 LDKTxIn* thing_conv = (LDKTxIn*)untag_ptr(thing);
666 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
667 memcpy(ret_arr->elems, TxIn_get_previous_txid(thing_conv).data, 32);
671 uint32_t TxIn_get_previous_vout (struct LDKTxIn* thing) { return thing->previous_vout;}int32_t __attribute__((export_name("TS_TxIn_get_previous_vout"))) TS_TxIn_get_previous_vout(uint64_t thing) {
672 LDKTxIn* thing_conv = (LDKTxIn*)untag_ptr(thing);
673 int32_t ret_conv = TxIn_get_previous_vout(thing_conv);
677 uint32_t TxIn_get_sequence (struct LDKTxIn* thing) { return thing->sequence;}int32_t __attribute__((export_name("TS_TxIn_get_sequence"))) TS_TxIn_get_sequence(uint64_t thing) {
678 LDKTxIn* thing_conv = (LDKTxIn*)untag_ptr(thing);
679 int32_t ret_conv = TxIn_get_sequence(thing_conv);
683 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) {
684 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
685 LDKCVec_u8Z ret_var = TxOut_get_script_pubkey(thing_conv);
686 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
687 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
688 CVec_u8Z_free(ret_var);
692 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) {
693 LDKTxOut* thing_conv = (LDKTxOut*)untag_ptr(thing);
694 int64_t ret_conv = TxOut_get_value(thing_conv);
698 uint32_t __attribute__((export_name("TS_LDKCOption_u64Z_ty_from_ptr"))) TS_LDKCOption_u64Z_ty_from_ptr(uint64_t ptr) {
699 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
701 case LDKCOption_u64Z_Some: return 0;
702 case LDKCOption_u64Z_None: return 1;
706 int64_t __attribute__((export_name("TS_LDKCOption_u64Z_Some_get_some"))) TS_LDKCOption_u64Z_Some_get_some(uint64_t ptr) {
707 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)untag_ptr(ptr);
708 assert(obj->tag == LDKCOption_u64Z_Some);
709 int64_t some_conv = obj->some;
712 static inline LDKCVec_BlindedPathZ CVec_BlindedPathZ_clone(const LDKCVec_BlindedPathZ *orig) {
713 LDKCVec_BlindedPathZ ret = { .data = MALLOC(sizeof(LDKBlindedPath) * orig->datalen, "LDKCVec_BlindedPathZ clone bytes"), .datalen = orig->datalen };
714 for (size_t i = 0; i < ret.datalen; i++) {
715 ret.data[i] = BlindedPath_clone(&orig->data[i]);
719 static inline struct LDKRefund CResult_RefundBolt12ParseErrorZ_get_ok(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner){
720 LDKRefund ret = *owner->contents.result;
721 ret.is_owned = false;
724 uint64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_get_ok"))) TS_CResult_RefundBolt12ParseErrorZ_get_ok(uint64_t owner) {
725 LDKCResult_RefundBolt12ParseErrorZ* owner_conv = (LDKCResult_RefundBolt12ParseErrorZ*)untag_ptr(owner);
726 LDKRefund ret_var = CResult_RefundBolt12ParseErrorZ_get_ok(owner_conv);
727 uint64_t ret_ref = 0;
728 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
729 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
733 static inline struct LDKBolt12ParseError CResult_RefundBolt12ParseErrorZ_get_err(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR owner){
734 LDKBolt12ParseError ret = *owner->contents.err;
735 ret.is_owned = false;
738 uint64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_get_err"))) TS_CResult_RefundBolt12ParseErrorZ_get_err(uint64_t owner) {
739 LDKCResult_RefundBolt12ParseErrorZ* owner_conv = (LDKCResult_RefundBolt12ParseErrorZ*)untag_ptr(owner);
740 LDKBolt12ParseError ret_var = CResult_RefundBolt12ParseErrorZ_get_err(owner_conv);
741 uint64_t ret_ref = 0;
742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
743 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
747 uint32_t __attribute__((export_name("TS_LDKRetry_ty_from_ptr"))) TS_LDKRetry_ty_from_ptr(uint64_t ptr) {
748 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
750 case LDKRetry_Attempts: return 0;
754 int32_t __attribute__((export_name("TS_LDKRetry_Attempts_get_attempts"))) TS_LDKRetry_Attempts_get_attempts(uint64_t ptr) {
755 LDKRetry *obj = (LDKRetry*)untag_ptr(ptr);
756 assert(obj->tag == LDKRetry_Attempts);
757 int32_t attempts_conv = obj->attempts;
758 return attempts_conv;
760 uint32_t __attribute__((export_name("TS_LDKDecodeError_ty_from_ptr"))) TS_LDKDecodeError_ty_from_ptr(uint64_t ptr) {
761 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
763 case LDKDecodeError_UnknownVersion: return 0;
764 case LDKDecodeError_UnknownRequiredFeature: return 1;
765 case LDKDecodeError_InvalidValue: return 2;
766 case LDKDecodeError_ShortRead: return 3;
767 case LDKDecodeError_BadLengthDescriptor: return 4;
768 case LDKDecodeError_Io: return 5;
769 case LDKDecodeError_UnsupportedCompression: return 6;
773 uint32_t __attribute__((export_name("TS_LDKDecodeError_Io_get_io"))) TS_LDKDecodeError_Io_get_io(uint64_t ptr) {
774 LDKDecodeError *obj = (LDKDecodeError*)untag_ptr(ptr);
775 assert(obj->tag == LDKDecodeError_Io);
776 uint32_t io_conv = LDKIOError_to_js(obj->io);
779 static inline struct LDKRetry CResult_RetryDecodeErrorZ_get_ok(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner){
780 CHECK(owner->result_ok);
781 return Retry_clone(&*owner->contents.result);
783 uint64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_get_ok"))) TS_CResult_RetryDecodeErrorZ_get_ok(uint64_t owner) {
784 LDKCResult_RetryDecodeErrorZ* owner_conv = (LDKCResult_RetryDecodeErrorZ*)untag_ptr(owner);
785 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
786 *ret_copy = CResult_RetryDecodeErrorZ_get_ok(owner_conv);
787 uint64_t ret_ref = tag_ptr(ret_copy, true);
791 static inline struct LDKDecodeError CResult_RetryDecodeErrorZ_get_err(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR owner){
792 CHECK(!owner->result_ok);
793 return DecodeError_clone(&*owner->contents.err);
795 uint64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_get_err"))) TS_CResult_RetryDecodeErrorZ_get_err(uint64_t owner) {
796 LDKCResult_RetryDecodeErrorZ* owner_conv = (LDKCResult_RetryDecodeErrorZ*)untag_ptr(owner);
797 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
798 *ret_copy = CResult_RetryDecodeErrorZ_get_err(owner_conv);
799 uint64_t ret_ref = tag_ptr(ret_copy, true);
803 uint32_t __attribute__((export_name("TS_LDKAPIError_ty_from_ptr"))) TS_LDKAPIError_ty_from_ptr(uint64_t ptr) {
804 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
806 case LDKAPIError_APIMisuseError: return 0;
807 case LDKAPIError_FeeRateTooHigh: return 1;
808 case LDKAPIError_InvalidRoute: return 2;
809 case LDKAPIError_ChannelUnavailable: return 3;
810 case LDKAPIError_MonitorUpdateInProgress: return 4;
811 case LDKAPIError_IncompatibleShutdownScript: return 5;
815 jstring __attribute__((export_name("TS_LDKAPIError_APIMisuseError_get_err"))) TS_LDKAPIError_APIMisuseError_get_err(uint64_t ptr) {
816 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
817 assert(obj->tag == LDKAPIError_APIMisuseError);
818 LDKStr err_str = obj->api_misuse_error.err;
819 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
822 jstring __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_err"))) TS_LDKAPIError_FeeRateTooHigh_get_err(uint64_t ptr) {
823 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
824 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
825 LDKStr err_str = obj->fee_rate_too_high.err;
826 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
829 int32_t __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_feerate"))) TS_LDKAPIError_FeeRateTooHigh_get_feerate(uint64_t ptr) {
830 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
831 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
832 int32_t feerate_conv = obj->fee_rate_too_high.feerate;
835 jstring __attribute__((export_name("TS_LDKAPIError_InvalidRoute_get_err"))) TS_LDKAPIError_InvalidRoute_get_err(uint64_t ptr) {
836 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
837 assert(obj->tag == LDKAPIError_InvalidRoute);
838 LDKStr err_str = obj->invalid_route.err;
839 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
842 jstring __attribute__((export_name("TS_LDKAPIError_ChannelUnavailable_get_err"))) TS_LDKAPIError_ChannelUnavailable_get_err(uint64_t ptr) {
843 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
844 assert(obj->tag == LDKAPIError_ChannelUnavailable);
845 LDKStr err_str = obj->channel_unavailable.err;
846 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
849 uint64_t __attribute__((export_name("TS_LDKAPIError_IncompatibleShutdownScript_get_script"))) TS_LDKAPIError_IncompatibleShutdownScript_get_script(uint64_t ptr) {
850 LDKAPIError *obj = (LDKAPIError*)untag_ptr(ptr);
851 assert(obj->tag == LDKAPIError_IncompatibleShutdownScript);
852 LDKShutdownScript script_var = obj->incompatible_shutdown_script.script;
853 uint64_t script_ref = 0;
854 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
855 script_ref = tag_ptr(script_var.inner, false);
858 static inline void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
859 CHECK(owner->result_ok);
860 return *owner->contents.result;
862 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_ok"))) TS_CResult_NoneAPIErrorZ_get_ok(uint64_t owner) {
863 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
864 CResult_NoneAPIErrorZ_get_ok(owner_conv);
867 static inline struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
868 CHECK(!owner->result_ok);
869 return APIError_clone(&*owner->contents.err);
871 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_err"))) TS_CResult_NoneAPIErrorZ_get_err(uint64_t owner) {
872 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(owner);
873 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
874 *ret_copy = CResult_NoneAPIErrorZ_get_err(owner_conv);
875 uint64_t ret_ref = tag_ptr(ret_copy, true);
879 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
880 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
881 for (size_t i = 0; i < ret.datalen; i++) {
882 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
886 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
887 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
888 for (size_t i = 0; i < ret.datalen; i++) {
889 ret.data[i] = APIError_clone(&orig->data[i]);
893 uint32_t __attribute__((export_name("TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr"))) TS_LDKCOption_ThirtyTwoBytesZ_ty_from_ptr(uint64_t ptr) {
894 LDKCOption_ThirtyTwoBytesZ *obj = (LDKCOption_ThirtyTwoBytesZ*)untag_ptr(ptr);
896 case LDKCOption_ThirtyTwoBytesZ_Some: return 0;
897 case LDKCOption_ThirtyTwoBytesZ_None: return 1;
901 int8_tArray __attribute__((export_name("TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some"))) TS_LDKCOption_ThirtyTwoBytesZ_Some_get_some(uint64_t ptr) {
902 LDKCOption_ThirtyTwoBytesZ *obj = (LDKCOption_ThirtyTwoBytesZ*)untag_ptr(ptr);
903 assert(obj->tag == LDKCOption_ThirtyTwoBytesZ_Some);
904 int8_tArray some_arr = init_int8_tArray(32, __LINE__);
905 memcpy(some_arr->elems, obj->some.data, 32);
908 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_ty_from_ptr"))) TS_LDKCOption_CVec_u8ZZ_ty_from_ptr(uint64_t ptr) {
909 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
911 case LDKCOption_CVec_u8ZZ_Some: return 0;
912 case LDKCOption_CVec_u8ZZ_None: return 1;
916 int8_tArray __attribute__((export_name("TS_LDKCOption_CVec_u8ZZ_Some_get_some"))) TS_LDKCOption_CVec_u8ZZ_Some_get_some(uint64_t ptr) {
917 LDKCOption_CVec_u8ZZ *obj = (LDKCOption_CVec_u8ZZ*)untag_ptr(ptr);
918 assert(obj->tag == LDKCOption_CVec_u8ZZ_Some);
919 LDKCVec_u8Z some_var = obj->some;
920 int8_tArray some_arr = init_int8_tArray(some_var.datalen, __LINE__);
921 memcpy(some_arr->elems, some_var.data, some_var.datalen);
924 static inline struct LDKRecipientOnionFields CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
925 LDKRecipientOnionFields ret = *owner->contents.result;
926 ret.is_owned = false;
929 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(uint64_t owner) {
930 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
931 LDKRecipientOnionFields ret_var = CResult_RecipientOnionFieldsDecodeErrorZ_get_ok(owner_conv);
932 uint64_t ret_ref = 0;
933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
934 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
938 static inline struct LDKDecodeError CResult_RecipientOnionFieldsDecodeErrorZ_get_err(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR owner){
939 CHECK(!owner->result_ok);
940 return DecodeError_clone(&*owner->contents.err);
942 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_get_err(uint64_t owner) {
943 LDKCResult_RecipientOnionFieldsDecodeErrorZ* owner_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(owner);
944 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
945 *ret_copy = CResult_RecipientOnionFieldsDecodeErrorZ_get_err(owner_conv);
946 uint64_t ret_ref = tag_ptr(ret_copy, true);
950 static inline uint64_t C2Tuple_u64CVec_u8ZZ_get_a(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner){
953 int64_t __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_get_a"))) TS_C2Tuple_u64CVec_u8ZZ_get_a(uint64_t owner) {
954 LDKC2Tuple_u64CVec_u8ZZ* owner_conv = (LDKC2Tuple_u64CVec_u8ZZ*)untag_ptr(owner);
955 int64_t ret_conv = C2Tuple_u64CVec_u8ZZ_get_a(owner_conv);
959 static inline struct LDKCVec_u8Z C2Tuple_u64CVec_u8ZZ_get_b(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR owner){
960 return CVec_u8Z_clone(&owner->b);
962 int8_tArray __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_get_b"))) TS_C2Tuple_u64CVec_u8ZZ_get_b(uint64_t owner) {
963 LDKC2Tuple_u64CVec_u8ZZ* owner_conv = (LDKC2Tuple_u64CVec_u8ZZ*)untag_ptr(owner);
964 LDKCVec_u8Z ret_var = C2Tuple_u64CVec_u8ZZ_get_b(owner_conv);
965 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
966 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
967 CVec_u8Z_free(ret_var);
971 static inline LDKCVec_C2Tuple_u64CVec_u8ZZZ CVec_C2Tuple_u64CVec_u8ZZZ_clone(const LDKCVec_C2Tuple_u64CVec_u8ZZZ *orig) {
972 LDKCVec_C2Tuple_u64CVec_u8ZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u64CVec_u8ZZ) * orig->datalen, "LDKCVec_C2Tuple_u64CVec_u8ZZZ clone bytes"), .datalen = orig->datalen };
973 for (size_t i = 0; i < ret.datalen; i++) {
974 ret.data[i] = C2Tuple_u64CVec_u8ZZ_clone(&orig->data[i]);
978 static inline struct LDKRecipientOnionFields CResult_RecipientOnionFieldsNoneZ_get_ok(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner){
979 LDKRecipientOnionFields ret = *owner->contents.result;
980 ret.is_owned = false;
983 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_get_ok"))) TS_CResult_RecipientOnionFieldsNoneZ_get_ok(uint64_t owner) {
984 LDKCResult_RecipientOnionFieldsNoneZ* owner_conv = (LDKCResult_RecipientOnionFieldsNoneZ*)untag_ptr(owner);
985 LDKRecipientOnionFields ret_var = CResult_RecipientOnionFieldsNoneZ_get_ok(owner_conv);
986 uint64_t ret_ref = 0;
987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
988 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
992 static inline void CResult_RecipientOnionFieldsNoneZ_get_err(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR owner){
993 CHECK(!owner->result_ok);
994 return *owner->contents.err;
996 void __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_get_err"))) TS_CResult_RecipientOnionFieldsNoneZ_get_err(uint64_t owner) {
997 LDKCResult_RecipientOnionFieldsNoneZ* owner_conv = (LDKCResult_RecipientOnionFieldsNoneZ*)untag_ptr(owner);
998 CResult_RecipientOnionFieldsNoneZ_get_err(owner_conv);
1001 static inline LDKCVec_ThirtyTwoBytesZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_ThirtyTwoBytesZ *orig) {
1002 LDKCVec_ThirtyTwoBytesZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ThirtyTwoBytesZ clone bytes"), .datalen = orig->datalen };
1003 for (size_t i = 0; i < ret.datalen; i++) {
1004 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
1008 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr"))) TS_LDKCOption_CVec_ThirtyTwoBytesZZ_ty_from_ptr(uint64_t ptr) {
1009 LDKCOption_CVec_ThirtyTwoBytesZZ *obj = (LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(ptr);
1011 case LDKCOption_CVec_ThirtyTwoBytesZZ_Some: return 0;
1012 case LDKCOption_CVec_ThirtyTwoBytesZZ_None: return 1;
1016 ptrArray __attribute__((export_name("TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some"))) TS_LDKCOption_CVec_ThirtyTwoBytesZZ_Some_get_some(uint64_t ptr) {
1017 LDKCOption_CVec_ThirtyTwoBytesZZ *obj = (LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(ptr);
1018 assert(obj->tag == LDKCOption_CVec_ThirtyTwoBytesZZ_Some);
1019 LDKCVec_ThirtyTwoBytesZ some_var = obj->some;
1020 ptrArray some_arr = NULL;
1021 some_arr = init_ptrArray(some_var.datalen, __LINE__);
1022 int8_tArray *some_arr_ptr = (int8_tArray*)(((uint8_t*)some_arr) + 8);
1023 for (size_t m = 0; m < some_var.datalen; m++) {
1024 int8_tArray some_conv_12_arr = init_int8_tArray(32, __LINE__);
1025 memcpy(some_conv_12_arr->elems, some_var.data[m].data, 32);
1026 some_arr_ptr[m] = some_conv_12_arr;
1031 static inline struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesNoneZ_get_ok(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner){
1032 CHECK(owner->result_ok);
1033 return ThirtyTwoBytes_clone(&*owner->contents.result);
1035 int8_tArray __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_get_ok"))) TS_CResult_ThirtyTwoBytesNoneZ_get_ok(uint64_t owner) {
1036 LDKCResult_ThirtyTwoBytesNoneZ* owner_conv = (LDKCResult_ThirtyTwoBytesNoneZ*)untag_ptr(owner);
1037 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1038 memcpy(ret_arr->elems, CResult_ThirtyTwoBytesNoneZ_get_ok(owner_conv).data, 32);
1042 static inline void CResult_ThirtyTwoBytesNoneZ_get_err(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR owner){
1043 CHECK(!owner->result_ok);
1044 return *owner->contents.err;
1046 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_get_err"))) TS_CResult_ThirtyTwoBytesNoneZ_get_err(uint64_t owner) {
1047 LDKCResult_ThirtyTwoBytesNoneZ* owner_conv = (LDKCResult_ThirtyTwoBytesNoneZ*)untag_ptr(owner);
1048 CResult_ThirtyTwoBytesNoneZ_get_err(owner_conv);
1051 static inline struct LDKBlindedPayInfo CResult_BlindedPayInfoDecodeErrorZ_get_ok(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1052 LDKBlindedPayInfo ret = *owner->contents.result;
1053 ret.is_owned = false;
1056 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_ok(uint64_t owner) {
1057 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1058 LDKBlindedPayInfo ret_var = CResult_BlindedPayInfoDecodeErrorZ_get_ok(owner_conv);
1059 uint64_t ret_ref = 0;
1060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1061 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1065 static inline struct LDKDecodeError CResult_BlindedPayInfoDecodeErrorZ_get_err(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR owner){
1066 CHECK(!owner->result_ok);
1067 return DecodeError_clone(&*owner->contents.err);
1069 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_get_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_get_err(uint64_t owner) {
1070 LDKCResult_BlindedPayInfoDecodeErrorZ* owner_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(owner);
1071 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1072 *ret_copy = CResult_BlindedPayInfoDecodeErrorZ_get_err(owner_conv);
1073 uint64_t ret_ref = tag_ptr(ret_copy, true);
1077 static inline struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1078 LDKDelayedPaymentOutputDescriptor ret = *owner->contents.result;
1079 ret.is_owned = false;
1082 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
1083 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1084 LDKDelayedPaymentOutputDescriptor ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
1085 uint64_t ret_ref = 0;
1086 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1087 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1091 static inline struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1092 CHECK(!owner->result_ok);
1093 return DecodeError_clone(&*owner->contents.err);
1095 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
1096 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1097 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1098 *ret_copy = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
1099 uint64_t ret_ref = tag_ptr(ret_copy, true);
1103 static inline struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1104 LDKStaticPaymentOutputDescriptor ret = *owner->contents.result;
1105 ret.is_owned = false;
1108 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
1109 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1110 LDKStaticPaymentOutputDescriptor ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
1111 uint64_t ret_ref = 0;
1112 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1113 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1117 static inline struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1118 CHECK(!owner->result_ok);
1119 return DecodeError_clone(&*owner->contents.err);
1121 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
1122 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1123 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1124 *ret_copy = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
1125 uint64_t ret_ref = tag_ptr(ret_copy, true);
1129 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_ty_from_ptr"))) TS_LDKSpendableOutputDescriptor_ty_from_ptr(uint64_t ptr) {
1130 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1132 case LDKSpendableOutputDescriptor_StaticOutput: return 0;
1133 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: return 1;
1134 case LDKSpendableOutputDescriptor_StaticPaymentOutput: return 2;
1138 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(uint64_t ptr) {
1139 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1140 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1141 LDKOutPoint outpoint_var = obj->static_output.outpoint;
1142 uint64_t outpoint_ref = 0;
1143 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
1144 outpoint_ref = tag_ptr(outpoint_var.inner, false);
1145 return outpoint_ref;
1147 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_output"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(uint64_t ptr) {
1148 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1149 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1150 LDKTxOut* output_ref = &obj->static_output.output;
1151 return tag_ptr(output_ref, false);
1153 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output"))) TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(uint64_t ptr) {
1154 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1155 assert(obj->tag == LDKSpendableOutputDescriptor_DelayedPaymentOutput);
1156 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
1157 uint64_t delayed_payment_output_ref = 0;
1158 CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
1159 delayed_payment_output_ref = tag_ptr(delayed_payment_output_var.inner, false);
1160 return delayed_payment_output_ref;
1162 uint64_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output"))) TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(uint64_t ptr) {
1163 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)untag_ptr(ptr);
1164 assert(obj->tag == LDKSpendableOutputDescriptor_StaticPaymentOutput);
1165 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
1166 uint64_t static_payment_output_ref = 0;
1167 CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
1168 static_payment_output_ref = tag_ptr(static_payment_output_var.inner, false);
1169 return static_payment_output_ref;
1171 static inline struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1172 CHECK(owner->result_ok);
1173 return SpendableOutputDescriptor_clone(&*owner->contents.result);
1175 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
1176 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1177 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
1178 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
1179 uint64_t ret_ref = tag_ptr(ret_copy, true);
1183 static inline struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
1184 CHECK(!owner->result_ok);
1185 return DecodeError_clone(&*owner->contents.err);
1187 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint64_t owner) {
1188 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(owner);
1189 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
1190 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner_conv);
1191 uint64_t ret_ref = tag_ptr(ret_copy, true);
1195 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
1196 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
1197 for (size_t i = 0; i < ret.datalen; i++) {
1198 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
1202 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
1203 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
1204 for (size_t i = 0; i < ret.datalen; i++) {
1205 ret.data[i] = TxOut_clone(&orig->data[i]);
1209 uint32_t __attribute__((export_name("TS_LDKCOption_u32Z_ty_from_ptr"))) TS_LDKCOption_u32Z_ty_from_ptr(uint64_t ptr) {
1210 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
1212 case LDKCOption_u32Z_Some: return 0;
1213 case LDKCOption_u32Z_None: return 1;
1217 int32_t __attribute__((export_name("TS_LDKCOption_u32Z_Some_get_some"))) TS_LDKCOption_u32Z_Some_get_some(uint64_t ptr) {
1218 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)untag_ptr(ptr);
1219 assert(obj->tag == LDKCOption_u32Z_Some);
1220 int32_t some_conv = obj->some;
1223 static inline struct LDKCVec_u8Z C2Tuple_CVec_u8ZusizeZ_get_a(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner){
1224 return CVec_u8Z_clone(&owner->a);
1226 int8_tArray __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_get_a"))) TS_C2Tuple_CVec_u8ZusizeZ_get_a(uint64_t owner) {
1227 LDKC2Tuple_CVec_u8ZusizeZ* owner_conv = (LDKC2Tuple_CVec_u8ZusizeZ*)untag_ptr(owner);
1228 LDKCVec_u8Z ret_var = C2Tuple_CVec_u8ZusizeZ_get_a(owner_conv);
1229 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
1230 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
1231 CVec_u8Z_free(ret_var);
1235 static inline uintptr_t C2Tuple_CVec_u8ZusizeZ_get_b(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR owner){
1238 uint32_t __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_get_b"))) TS_C2Tuple_CVec_u8ZusizeZ_get_b(uint64_t owner) {
1239 LDKC2Tuple_CVec_u8ZusizeZ* owner_conv = (LDKC2Tuple_CVec_u8ZusizeZ*)untag_ptr(owner);
1240 uint32_t ret_conv = C2Tuple_CVec_u8ZusizeZ_get_b(owner_conv);
1244 static inline struct LDKC2Tuple_CVec_u8ZusizeZ CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner){
1245 CHECK(owner->result_ok);
1246 return C2Tuple_CVec_u8ZusizeZ_clone(&*owner->contents.result);
1248 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(uint64_t owner) {
1249 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* owner_conv = (LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)untag_ptr(owner);
1250 LDKC2Tuple_CVec_u8ZusizeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_CVec_u8ZusizeZ), "LDKC2Tuple_CVec_u8ZusizeZ");
1251 *ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_ok(owner_conv);
1252 return tag_ptr(ret_conv, true);
1255 static inline void CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR owner){
1256 CHECK(!owner->result_ok);
1257 return *owner->contents.err;
1259 void __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(uint64_t owner) {
1260 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* owner_conv = (LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)untag_ptr(owner);
1261 CResult_C2Tuple_CVec_u8ZusizeZNoneZ_get_err(owner_conv);
1264 static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
1265 CHECK(owner->result_ok);
1266 return *owner->contents.result;
1268 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_ok"))) TS_CResult_NoneNoneZ_get_ok(uint64_t owner) {
1269 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
1270 CResult_NoneNoneZ_get_ok(owner_conv);
1273 static inline void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
1274 CHECK(!owner->result_ok);
1275 return *owner->contents.err;
1277 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_err"))) TS_CResult_NoneNoneZ_get_err(uint64_t owner) {
1278 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)untag_ptr(owner);
1279 CResult_NoneNoneZ_get_err(owner_conv);
1282 static inline struct LDKECDSASignature C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner){
1285 int8_tArray __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(uint64_t owner) {
1286 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* owner_conv = (LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)untag_ptr(owner);
1287 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
1288 memcpy(ret_arr->elems, C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_a(owner_conv).compact_form, 64);
1292 static inline struct LDKCVec_ECDSASignatureZ C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR owner){
1295 ptrArray __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(uint64_t owner) {
1296 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* owner_conv = (LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)untag_ptr(owner);
1297 LDKCVec_ECDSASignatureZ ret_var = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_get_b(owner_conv);
1298 ptrArray ret_arr = NULL;
1299 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
1300 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
1301 for (size_t m = 0; m < ret_var.datalen; m++) {
1302 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
1303 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
1304 ret_arr_ptr[m] = ret_conv_12_arr;
1310 static inline struct LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner){
1311 CHECK(owner->result_ok);
1312 return C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(&*owner->contents.result);
1314 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(uint64_t owner) {
1315 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)untag_ptr(owner);
1316 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ), "LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ");
1317 *ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_ok(owner_conv);
1318 return tag_ptr(ret_conv, true);
1321 static inline void CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR owner){
1322 CHECK(!owner->result_ok);
1323 return *owner->contents.err;
1325 void __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(uint64_t owner) {
1326 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)untag_ptr(owner);
1327 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_get_err(owner_conv);
1330 static inline struct LDKECDSASignature CResult_ECDSASignatureNoneZ_get_ok(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner){
1331 CHECK(owner->result_ok);
1332 return *owner->contents.result;
1334 int8_tArray __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_get_ok"))) TS_CResult_ECDSASignatureNoneZ_get_ok(uint64_t owner) {
1335 LDKCResult_ECDSASignatureNoneZ* owner_conv = (LDKCResult_ECDSASignatureNoneZ*)untag_ptr(owner);
1336 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
1337 memcpy(ret_arr->elems, CResult_ECDSASignatureNoneZ_get_ok(owner_conv).compact_form, 64);
1341 static inline void CResult_ECDSASignatureNoneZ_get_err(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR owner){
1342 CHECK(!owner->result_ok);
1343 return *owner->contents.err;
1345 void __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_get_err"))) TS_CResult_ECDSASignatureNoneZ_get_err(uint64_t owner) {
1346 LDKCResult_ECDSASignatureNoneZ* owner_conv = (LDKCResult_ECDSASignatureNoneZ*)untag_ptr(owner);
1347 CResult_ECDSASignatureNoneZ_get_err(owner_conv);
1350 static inline struct LDKPublicKey CResult_PublicKeyNoneZ_get_ok(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
1351 CHECK(owner->result_ok);
1352 return *owner->contents.result;
1354 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_ok"))) TS_CResult_PublicKeyNoneZ_get_ok(uint64_t owner) {
1355 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
1356 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
1357 memcpy(ret_arr->elems, CResult_PublicKeyNoneZ_get_ok(owner_conv).compressed_form, 33);
1361 static inline void CResult_PublicKeyNoneZ_get_err(LDKCResult_PublicKeyNoneZ *NONNULL_PTR owner){
1362 CHECK(!owner->result_ok);
1363 return *owner->contents.err;
1365 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_get_err"))) TS_CResult_PublicKeyNoneZ_get_err(uint64_t owner) {
1366 LDKCResult_PublicKeyNoneZ* owner_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(owner);
1367 CResult_PublicKeyNoneZ_get_err(owner_conv);
1370 uint32_t __attribute__((export_name("TS_LDKCOption_BigEndianScalarZ_ty_from_ptr"))) TS_LDKCOption_BigEndianScalarZ_ty_from_ptr(uint64_t ptr) {
1371 LDKCOption_BigEndianScalarZ *obj = (LDKCOption_BigEndianScalarZ*)untag_ptr(ptr);
1373 case LDKCOption_BigEndianScalarZ_Some: return 0;
1374 case LDKCOption_BigEndianScalarZ_None: return 1;
1378 uint64_t __attribute__((export_name("TS_LDKCOption_BigEndianScalarZ_Some_get_some"))) TS_LDKCOption_BigEndianScalarZ_Some_get_some(uint64_t ptr) {
1379 LDKCOption_BigEndianScalarZ *obj = (LDKCOption_BigEndianScalarZ*)untag_ptr(ptr);
1380 assert(obj->tag == LDKCOption_BigEndianScalarZ_Some);
1381 LDKBigEndianScalar* some_ref = &obj->some;
1382 return tag_ptr(some_ref, false);
1384 static inline struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
1385 CHECK(owner->result_ok);
1386 return *owner->contents.result;
1388 int8_tArray __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_ok"))) TS_CResult_RecoverableSignatureNoneZ_get_ok(uint64_t owner) {
1389 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
1390 int8_tArray ret_arr = init_int8_tArray(68, __LINE__);
1391 memcpy(ret_arr->elems, CResult_RecoverableSignatureNoneZ_get_ok(owner_conv).serialized_form, 68);
1395 static inline void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
1396 CHECK(!owner->result_ok);
1397 return *owner->contents.err;
1399 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_err"))) TS_CResult_RecoverableSignatureNoneZ_get_err(uint64_t owner) {
1400 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(owner);
1401 CResult_RecoverableSignatureNoneZ_get_err(owner_conv);
1404 static inline struct LDKSchnorrSignature CResult_SchnorrSignatureNoneZ_get_ok(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner){
1405 CHECK(owner->result_ok);
1406 return *owner->contents.result;
1408 int8_tArray __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_get_ok"))) TS_CResult_SchnorrSignatureNoneZ_get_ok(uint64_t owner) {
1409 LDKCResult_SchnorrSignatureNoneZ* owner_conv = (LDKCResult_SchnorrSignatureNoneZ*)untag_ptr(owner);
1410 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
1411 memcpy(ret_arr->elems, CResult_SchnorrSignatureNoneZ_get_ok(owner_conv).compact_form, 64);
1415 static inline void CResult_SchnorrSignatureNoneZ_get_err(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR owner){
1416 CHECK(!owner->result_ok);
1417 return *owner->contents.err;
1419 void __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_get_err"))) TS_CResult_SchnorrSignatureNoneZ_get_err(uint64_t owner) {
1420 LDKCResult_SchnorrSignatureNoneZ* owner_conv = (LDKCResult_SchnorrSignatureNoneZ*)untag_ptr(owner);
1421 CResult_SchnorrSignatureNoneZ_get_err(owner_conv);
1424 typedef struct LDKChannelSigner_JCalls {
1425 atomic_size_t refcnt;
1426 uint32_t instance_ptr;
1427 } LDKChannelSigner_JCalls;
1428 static void LDKChannelSigner_JCalls_free(void* this_arg) {
1429 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1430 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1434 LDKPublicKey get_per_commitment_point_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
1435 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1436 int64_t idx_conv = idx;
1437 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 0, idx_conv, 0, 0, 0, 0, 0);
1438 LDKPublicKey ret_ref;
1439 CHECK(ret->arr_len == 33);
1440 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
1443 LDKThirtyTwoBytes release_commitment_secret_LDKChannelSigner_jcall(const void* this_arg, uint64_t idx) {
1444 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1445 int64_t idx_conv = idx;
1446 int8_tArray ret = (int8_tArray)js_invoke_function_buuuuu(j_calls->instance_ptr, 1, idx_conv, 0, 0, 0, 0, 0);
1447 LDKThirtyTwoBytes ret_ref;
1448 CHECK(ret->arr_len == 32);
1449 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
1452 LDKCResult_NoneNoneZ validate_holder_commitment_LDKChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx, LDKCVec_ThirtyTwoBytesZ preimages) {
1453 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1454 LDKHolderCommitmentTransaction holder_tx_var = *holder_tx;
1455 uint64_t holder_tx_ref = 0;
1456 holder_tx_var = HolderCommitmentTransaction_clone(&holder_tx_var);
1457 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
1458 holder_tx_ref = tag_ptr(holder_tx_var.inner, holder_tx_var.is_owned);
1459 LDKCVec_ThirtyTwoBytesZ preimages_var = preimages;
1460 ptrArray preimages_arr = NULL;
1461 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
1462 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
1463 for (size_t m = 0; m < preimages_var.datalen; m++) {
1464 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
1465 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
1466 preimages_arr_ptr[m] = preimages_conv_12_arr;
1469 FREE(preimages_var.data);
1470 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 2, holder_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
1471 void* ret_ptr = untag_ptr(ret);
1472 CHECK_ACCESS(ret_ptr);
1473 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
1474 FREE(untag_ptr(ret));
1477 LDKThirtyTwoBytes channel_keys_id_LDKChannelSigner_jcall(const void* this_arg) {
1478 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1479 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 3, 0, 0, 0, 0, 0, 0);
1480 LDKThirtyTwoBytes ret_ref;
1481 CHECK(ret->arr_len == 32);
1482 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
1485 void provide_channel_parameters_LDKChannelSigner_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
1486 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) this_arg;
1487 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
1488 uint64_t channel_parameters_ref = 0;
1489 channel_parameters_var = ChannelTransactionParameters_clone(&channel_parameters_var);
1490 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
1491 channel_parameters_ref = tag_ptr(channel_parameters_var.inner, channel_parameters_var.is_owned);
1492 js_invoke_function_buuuuu(j_calls->instance_ptr, 4, channel_parameters_ref, 0, 0, 0, 0, 0);
1494 static void LDKChannelSigner_JCalls_cloned(LDKChannelSigner* new_obj) {
1495 LDKChannelSigner_JCalls *j_calls = (LDKChannelSigner_JCalls*) new_obj->this_arg;
1496 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1498 static inline LDKChannelSigner LDKChannelSigner_init (JSValue o, uint64_t pubkeys) {
1499 LDKChannelSigner_JCalls *calls = MALLOC(sizeof(LDKChannelSigner_JCalls), "LDKChannelSigner_JCalls");
1500 atomic_init(&calls->refcnt, 1);
1501 calls->instance_ptr = o;
1503 LDKChannelPublicKeys pubkeys_conv;
1504 pubkeys_conv.inner = untag_ptr(pubkeys);
1505 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
1506 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
1508 LDKChannelSigner ret = {
1509 .this_arg = (void*) calls,
1510 .get_per_commitment_point = get_per_commitment_point_LDKChannelSigner_jcall,
1511 .release_commitment_secret = release_commitment_secret_LDKChannelSigner_jcall,
1512 .validate_holder_commitment = validate_holder_commitment_LDKChannelSigner_jcall,
1513 .channel_keys_id = channel_keys_id_LDKChannelSigner_jcall,
1514 .provide_channel_parameters = provide_channel_parameters_LDKChannelSigner_jcall,
1515 .free = LDKChannelSigner_JCalls_free,
1516 .pubkeys = pubkeys_conv,
1517 .set_pubkeys = NULL,
1521 uint64_t __attribute__((export_name("TS_LDKChannelSigner_new"))) TS_LDKChannelSigner_new(JSValue o, uint64_t pubkeys) {
1522 LDKChannelSigner *res_ptr = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
1523 *res_ptr = LDKChannelSigner_init(o, pubkeys);
1524 return tag_ptr(res_ptr, true);
1526 int8_tArray __attribute__((export_name("TS_ChannelSigner_get_per_commitment_point"))) TS_ChannelSigner_get_per_commitment_point(uint64_t this_arg, int64_t idx) {
1527 void* this_arg_ptr = untag_ptr(this_arg);
1528 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1529 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1530 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
1531 memcpy(ret_arr->elems, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
1535 int8_tArray __attribute__((export_name("TS_ChannelSigner_release_commitment_secret"))) TS_ChannelSigner_release_commitment_secret(uint64_t this_arg, int64_t idx) {
1536 void* this_arg_ptr = untag_ptr(this_arg);
1537 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1538 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1539 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1540 memcpy(ret_arr->elems, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
1544 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) {
1545 void* this_arg_ptr = untag_ptr(this_arg);
1546 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1547 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1548 LDKHolderCommitmentTransaction holder_tx_conv;
1549 holder_tx_conv.inner = untag_ptr(holder_tx);
1550 holder_tx_conv.is_owned = ptr_is_owned(holder_tx);
1551 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
1552 holder_tx_conv.is_owned = false;
1553 LDKCVec_ThirtyTwoBytesZ preimages_constr;
1554 preimages_constr.datalen = preimages->arr_len;
1555 if (preimages_constr.datalen > 0)
1556 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
1558 preimages_constr.data = NULL;
1559 int8_tArray* preimages_vals = (void*) preimages->elems;
1560 for (size_t m = 0; m < preimages_constr.datalen; m++) {
1561 int8_tArray preimages_conv_12 = preimages_vals[m];
1562 LDKThirtyTwoBytes preimages_conv_12_ref;
1563 CHECK(preimages_conv_12->arr_len == 32);
1564 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
1565 preimages_constr.data[m] = preimages_conv_12_ref;
1568 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
1569 *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv, preimages_constr);
1570 return tag_ptr(ret_conv, true);
1573 int8_tArray __attribute__((export_name("TS_ChannelSigner_channel_keys_id"))) TS_ChannelSigner_channel_keys_id(uint64_t this_arg) {
1574 void* this_arg_ptr = untag_ptr(this_arg);
1575 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1576 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1577 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
1578 memcpy(ret_arr->elems, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
1582 void __attribute__((export_name("TS_ChannelSigner_provide_channel_parameters"))) TS_ChannelSigner_provide_channel_parameters(uint64_t this_arg, uint64_t channel_parameters) {
1583 void* this_arg_ptr = untag_ptr(this_arg);
1584 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1585 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1586 LDKChannelTransactionParameters channel_parameters_conv;
1587 channel_parameters_conv.inner = untag_ptr(channel_parameters);
1588 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
1589 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
1590 channel_parameters_conv.is_owned = false;
1591 (this_arg_conv->provide_channel_parameters)(this_arg_conv->this_arg, &channel_parameters_conv);
1594 LDKChannelPublicKeys LDKChannelSigner_set_get_pubkeys(LDKChannelSigner* this_arg) {
1595 if (this_arg->set_pubkeys != NULL)
1596 this_arg->set_pubkeys(this_arg);
1597 return this_arg->pubkeys;
1599 uint64_t __attribute__((export_name("TS_ChannelSigner_get_pubkeys"))) TS_ChannelSigner_get_pubkeys(uint64_t this_arg) {
1600 void* this_arg_ptr = untag_ptr(this_arg);
1601 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1602 LDKChannelSigner* this_arg_conv = (LDKChannelSigner*)this_arg_ptr;
1603 LDKChannelPublicKeys ret_var = LDKChannelSigner_set_get_pubkeys(this_arg_conv);
1604 uint64_t ret_ref = 0;
1605 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1606 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
1610 typedef struct LDKEcdsaChannelSigner_JCalls {
1611 atomic_size_t refcnt;
1612 uint32_t instance_ptr;
1613 LDKChannelSigner_JCalls* ChannelSigner;
1614 } LDKEcdsaChannelSigner_JCalls;
1615 static void LDKEcdsaChannelSigner_JCalls_free(void* this_arg) {
1616 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1617 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1621 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx, LDKCVec_ThirtyTwoBytesZ preimages) {
1622 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1623 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
1624 uint64_t commitment_tx_ref = 0;
1625 commitment_tx_var = CommitmentTransaction_clone(&commitment_tx_var);
1626 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
1627 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
1628 LDKCVec_ThirtyTwoBytesZ preimages_var = preimages;
1629 ptrArray preimages_arr = NULL;
1630 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
1631 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 8);
1632 for (size_t m = 0; m < preimages_var.datalen; m++) {
1633 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
1634 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
1635 preimages_arr_ptr[m] = preimages_conv_12_arr;
1638 FREE(preimages_var.data);
1639 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 5, commitment_tx_ref, (uint32_t)preimages_arr, 0, 0, 0, 0);
1640 void* ret_ptr = untag_ptr(ret);
1641 CHECK_ACCESS(ret_ptr);
1642 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)(ret_ptr);
1643 FREE(untag_ptr(ret));
1646 LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
1647 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1648 int64_t idx_conv = idx;
1649 int8_tArray secret_arr = init_int8_tArray(32, __LINE__);
1650 memcpy(secret_arr->elems, *secret, 32);
1651 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 6, idx_conv, (uint32_t)secret_arr, 0, 0, 0, 0);
1652 void* ret_ptr = untag_ptr(ret);
1653 CHECK_ACCESS(ret_ptr);
1654 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
1655 FREE(untag_ptr(ret));
1658 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
1659 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1660 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
1661 uint64_t commitment_tx_ref = 0;
1662 commitment_tx_var = HolderCommitmentTransaction_clone(&commitment_tx_var);
1663 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
1664 commitment_tx_ref = tag_ptr(commitment_tx_var.inner, commitment_tx_var.is_owned);
1665 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 7, commitment_tx_ref, 0, 0, 0, 0, 0);
1666 void* ret_ptr = untag_ptr(ret);
1667 CHECK_ACCESS(ret_ptr);
1668 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)(ret_ptr);
1669 FREE(untag_ptr(ret));
1672 LDKCResult_ECDSASignatureNoneZ 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]) {
1673 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1674 LDKTransaction justice_tx_var = justice_tx;
1675 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
1676 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
1677 Transaction_free(justice_tx_var);
1678 uint32_t input_conv = input;
1679 int64_t amount_conv = amount;
1680 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
1681 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
1682 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 8, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, 0, 0);
1683 void* ret_ptr = untag_ptr(ret);
1684 CHECK_ACCESS(ret_ptr);
1685 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1686 FREE(untag_ptr(ret));
1689 LDKCResult_ECDSASignatureNoneZ 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) {
1690 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1691 LDKTransaction justice_tx_var = justice_tx;
1692 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
1693 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
1694 Transaction_free(justice_tx_var);
1695 uint32_t input_conv = input;
1696 int64_t amount_conv = amount;
1697 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
1698 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
1699 LDKHTLCOutputInCommitment htlc_var = *htlc;
1700 uint64_t htlc_ref = 0;
1701 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
1702 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
1703 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
1704 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 9, (uint32_t)justice_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_key_arr, htlc_ref, 0);
1705 void* ret_ptr = untag_ptr(ret);
1706 CHECK_ACCESS(ret_ptr);
1707 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1708 FREE(untag_ptr(ret));
1711 LDKCResult_ECDSASignatureNoneZ sign_holder_htlc_transaction_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, const LDKHTLCDescriptor * htlc_descriptor) {
1712 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1713 LDKTransaction htlc_tx_var = htlc_tx;
1714 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
1715 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
1716 Transaction_free(htlc_tx_var);
1717 uint32_t input_conv = input;
1718 LDKHTLCDescriptor htlc_descriptor_var = *htlc_descriptor;
1719 uint64_t htlc_descriptor_ref = 0;
1720 htlc_descriptor_var = HTLCDescriptor_clone(&htlc_descriptor_var);
1721 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_descriptor_var);
1722 htlc_descriptor_ref = tag_ptr(htlc_descriptor_var.inner, htlc_descriptor_var.is_owned);
1723 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 10, (uint32_t)htlc_tx_arr, input_conv, htlc_descriptor_ref, 0, 0, 0);
1724 void* ret_ptr = untag_ptr(ret);
1725 CHECK_ACCESS(ret_ptr);
1726 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1727 FREE(untag_ptr(ret));
1730 LDKCResult_ECDSASignatureNoneZ 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) {
1731 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1732 LDKTransaction htlc_tx_var = htlc_tx;
1733 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
1734 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
1735 Transaction_free(htlc_tx_var);
1736 uint32_t input_conv = input;
1737 int64_t amount_conv = amount;
1738 int8_tArray per_commitment_point_arr = init_int8_tArray(33, __LINE__);
1739 memcpy(per_commitment_point_arr->elems, per_commitment_point.compressed_form, 33);
1740 LDKHTLCOutputInCommitment htlc_var = *htlc;
1741 uint64_t htlc_ref = 0;
1742 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
1743 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
1744 htlc_ref = tag_ptr(htlc_var.inner, htlc_var.is_owned);
1745 uint64_t ret = js_invoke_function_uububu(j_calls->instance_ptr, 11, (uint32_t)htlc_tx_arr, input_conv, amount_conv, (uint32_t)per_commitment_point_arr, htlc_ref, 0);
1746 void* ret_ptr = untag_ptr(ret);
1747 CHECK_ACCESS(ret_ptr);
1748 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1749 FREE(untag_ptr(ret));
1752 LDKCResult_ECDSASignatureNoneZ sign_closing_transaction_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
1753 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1754 LDKClosingTransaction closing_tx_var = *closing_tx;
1755 uint64_t closing_tx_ref = 0;
1756 closing_tx_var = ClosingTransaction_clone(&closing_tx_var);
1757 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
1758 closing_tx_ref = tag_ptr(closing_tx_var.inner, closing_tx_var.is_owned);
1759 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 12, closing_tx_ref, 0, 0, 0, 0, 0);
1760 void* ret_ptr = untag_ptr(ret);
1761 CHECK_ACCESS(ret_ptr);
1762 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1763 FREE(untag_ptr(ret));
1766 LDKCResult_ECDSASignatureNoneZ sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall(const void* this_arg, LDKTransaction anchor_tx, uintptr_t input) {
1767 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1768 LDKTransaction anchor_tx_var = anchor_tx;
1769 int8_tArray anchor_tx_arr = init_int8_tArray(anchor_tx_var.datalen, __LINE__);
1770 memcpy(anchor_tx_arr->elems, anchor_tx_var.data, anchor_tx_var.datalen);
1771 Transaction_free(anchor_tx_var);
1772 uint32_t input_conv = input;
1773 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 13, (uint32_t)anchor_tx_arr, input_conv, 0, 0, 0, 0);
1774 void* ret_ptr = untag_ptr(ret);
1775 CHECK_ACCESS(ret_ptr);
1776 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1777 FREE(untag_ptr(ret));
1780 LDKCResult_ECDSASignatureNoneZ sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
1781 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) this_arg;
1782 LDKUnsignedChannelAnnouncement msg_var = *msg;
1783 uint64_t msg_ref = 0;
1784 msg_var = UnsignedChannelAnnouncement_clone(&msg_var);
1785 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
1786 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
1787 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 14, msg_ref, 0, 0, 0, 0, 0);
1788 void* ret_ptr = untag_ptr(ret);
1789 CHECK_ACCESS(ret_ptr);
1790 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
1791 FREE(untag_ptr(ret));
1794 static void LDKEcdsaChannelSigner_JCalls_cloned(LDKEcdsaChannelSigner* new_obj) {
1795 LDKEcdsaChannelSigner_JCalls *j_calls = (LDKEcdsaChannelSigner_JCalls*) new_obj->this_arg;
1796 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1797 atomic_fetch_add_explicit(&j_calls->ChannelSigner->refcnt, 1, memory_order_release);
1799 static inline LDKEcdsaChannelSigner LDKEcdsaChannelSigner_init (JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
1800 LDKEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKEcdsaChannelSigner_JCalls), "LDKEcdsaChannelSigner_JCalls");
1801 atomic_init(&calls->refcnt, 1);
1802 calls->instance_ptr = o;
1804 LDKChannelPublicKeys pubkeys_conv;
1805 pubkeys_conv.inner = untag_ptr(pubkeys);
1806 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
1807 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
1809 LDKEcdsaChannelSigner ret = {
1810 .this_arg = (void*) calls,
1811 .sign_counterparty_commitment = sign_counterparty_commitment_LDKEcdsaChannelSigner_jcall,
1812 .validate_counterparty_revocation = validate_counterparty_revocation_LDKEcdsaChannelSigner_jcall,
1813 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKEcdsaChannelSigner_jcall,
1814 .sign_justice_revoked_output = sign_justice_revoked_output_LDKEcdsaChannelSigner_jcall,
1815 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKEcdsaChannelSigner_jcall,
1816 .sign_holder_htlc_transaction = sign_holder_htlc_transaction_LDKEcdsaChannelSigner_jcall,
1817 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKEcdsaChannelSigner_jcall,
1818 .sign_closing_transaction = sign_closing_transaction_LDKEcdsaChannelSigner_jcall,
1819 .sign_holder_anchor_input = sign_holder_anchor_input_LDKEcdsaChannelSigner_jcall,
1820 .sign_channel_announcement_with_funding_key = sign_channel_announcement_with_funding_key_LDKEcdsaChannelSigner_jcall,
1821 .free = LDKEcdsaChannelSigner_JCalls_free,
1822 .ChannelSigner = LDKChannelSigner_init(ChannelSigner, pubkeys),
1824 calls->ChannelSigner = ret.ChannelSigner.this_arg;
1827 uint64_t __attribute__((export_name("TS_LDKEcdsaChannelSigner_new"))) TS_LDKEcdsaChannelSigner_new(JSValue o, JSValue ChannelSigner, uint64_t pubkeys) {
1828 LDKEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
1829 *res_ptr = LDKEcdsaChannelSigner_init(o, ChannelSigner, pubkeys);
1830 return tag_ptr(res_ptr, true);
1832 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) {
1833 void* this_arg_ptr = untag_ptr(this_arg);
1834 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1835 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1836 LDKCommitmentTransaction commitment_tx_conv;
1837 commitment_tx_conv.inner = untag_ptr(commitment_tx);
1838 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
1839 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
1840 commitment_tx_conv.is_owned = false;
1841 LDKCVec_ThirtyTwoBytesZ preimages_constr;
1842 preimages_constr.datalen = preimages->arr_len;
1843 if (preimages_constr.datalen > 0)
1844 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
1846 preimages_constr.data = NULL;
1847 int8_tArray* preimages_vals = (void*) preimages->elems;
1848 for (size_t m = 0; m < preimages_constr.datalen; m++) {
1849 int8_tArray preimages_conv_12 = preimages_vals[m];
1850 LDKThirtyTwoBytes preimages_conv_12_ref;
1851 CHECK(preimages_conv_12->arr_len == 32);
1852 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
1853 preimages_constr.data[m] = preimages_conv_12_ref;
1856 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
1857 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv, preimages_constr);
1858 return tag_ptr(ret_conv, true);
1861 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) {
1862 void* this_arg_ptr = untag_ptr(this_arg);
1863 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1864 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1865 uint8_t secret_arr[32];
1866 CHECK(secret->arr_len == 32);
1867 memcpy(secret_arr, secret->elems, 32); FREE(secret);
1868 uint8_t (*secret_ref)[32] = &secret_arr;
1869 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
1870 *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref);
1871 return tag_ptr(ret_conv, true);
1874 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) {
1875 void* this_arg_ptr = untag_ptr(this_arg);
1876 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1877 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1878 LDKHolderCommitmentTransaction commitment_tx_conv;
1879 commitment_tx_conv.inner = untag_ptr(commitment_tx);
1880 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
1881 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
1882 commitment_tx_conv.is_owned = false;
1883 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
1884 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
1885 return tag_ptr(ret_conv, true);
1888 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) {
1889 void* this_arg_ptr = untag_ptr(this_arg);
1890 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1891 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1892 LDKTransaction justice_tx_ref;
1893 justice_tx_ref.datalen = justice_tx->arr_len;
1894 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
1895 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
1896 justice_tx_ref.data_is_owned = true;
1897 uint8_t per_commitment_key_arr[32];
1898 CHECK(per_commitment_key->arr_len == 32);
1899 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
1900 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
1901 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1902 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
1903 return tag_ptr(ret_conv, true);
1906 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) {
1907 void* this_arg_ptr = untag_ptr(this_arg);
1908 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1909 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1910 LDKTransaction justice_tx_ref;
1911 justice_tx_ref.datalen = justice_tx->arr_len;
1912 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
1913 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
1914 justice_tx_ref.data_is_owned = true;
1915 uint8_t per_commitment_key_arr[32];
1916 CHECK(per_commitment_key->arr_len == 32);
1917 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
1918 uint8_t (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
1919 LDKHTLCOutputInCommitment htlc_conv;
1920 htlc_conv.inner = untag_ptr(htlc);
1921 htlc_conv.is_owned = ptr_is_owned(htlc);
1922 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
1923 htlc_conv.is_owned = false;
1924 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1925 *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);
1926 return tag_ptr(ret_conv, true);
1929 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_holder_htlc_transaction"))) TS_EcdsaChannelSigner_sign_holder_htlc_transaction(uint64_t this_arg, int8_tArray htlc_tx, uint32_t input, uint64_t htlc_descriptor) {
1930 void* this_arg_ptr = untag_ptr(this_arg);
1931 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1932 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1933 LDKTransaction htlc_tx_ref;
1934 htlc_tx_ref.datalen = htlc_tx->arr_len;
1935 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
1936 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
1937 htlc_tx_ref.data_is_owned = true;
1938 LDKHTLCDescriptor htlc_descriptor_conv;
1939 htlc_descriptor_conv.inner = untag_ptr(htlc_descriptor);
1940 htlc_descriptor_conv.is_owned = ptr_is_owned(htlc_descriptor);
1941 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_descriptor_conv);
1942 htlc_descriptor_conv.is_owned = false;
1943 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1944 *ret_conv = (this_arg_conv->sign_holder_htlc_transaction)(this_arg_conv->this_arg, htlc_tx_ref, input, &htlc_descriptor_conv);
1945 return tag_ptr(ret_conv, true);
1948 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) {
1949 void* this_arg_ptr = untag_ptr(this_arg);
1950 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1951 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1952 LDKTransaction htlc_tx_ref;
1953 htlc_tx_ref.datalen = htlc_tx->arr_len;
1954 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
1955 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
1956 htlc_tx_ref.data_is_owned = true;
1957 LDKPublicKey per_commitment_point_ref;
1958 CHECK(per_commitment_point->arr_len == 33);
1959 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
1960 LDKHTLCOutputInCommitment htlc_conv;
1961 htlc_conv.inner = untag_ptr(htlc);
1962 htlc_conv.is_owned = ptr_is_owned(htlc);
1963 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
1964 htlc_conv.is_owned = false;
1965 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1966 *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);
1967 return tag_ptr(ret_conv, true);
1970 uint64_t __attribute__((export_name("TS_EcdsaChannelSigner_sign_closing_transaction"))) TS_EcdsaChannelSigner_sign_closing_transaction(uint64_t this_arg, uint64_t closing_tx) {
1971 void* this_arg_ptr = untag_ptr(this_arg);
1972 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1973 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1974 LDKClosingTransaction closing_tx_conv;
1975 closing_tx_conv.inner = untag_ptr(closing_tx);
1976 closing_tx_conv.is_owned = ptr_is_owned(closing_tx);
1977 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
1978 closing_tx_conv.is_owned = false;
1979 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1980 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
1981 return tag_ptr(ret_conv, true);
1984 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) {
1985 void* this_arg_ptr = untag_ptr(this_arg);
1986 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
1987 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
1988 LDKTransaction anchor_tx_ref;
1989 anchor_tx_ref.datalen = anchor_tx->arr_len;
1990 anchor_tx_ref.data = MALLOC(anchor_tx_ref.datalen, "LDKTransaction Bytes");
1991 memcpy(anchor_tx_ref.data, anchor_tx->elems, anchor_tx_ref.datalen); FREE(anchor_tx);
1992 anchor_tx_ref.data_is_owned = true;
1993 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
1994 *ret_conv = (this_arg_conv->sign_holder_anchor_input)(this_arg_conv->this_arg, anchor_tx_ref, input);
1995 return tag_ptr(ret_conv, true);
1998 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) {
1999 void* this_arg_ptr = untag_ptr(this_arg);
2000 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
2001 LDKEcdsaChannelSigner* this_arg_conv = (LDKEcdsaChannelSigner*)this_arg_ptr;
2002 LDKUnsignedChannelAnnouncement msg_conv;
2003 msg_conv.inner = untag_ptr(msg);
2004 msg_conv.is_owned = ptr_is_owned(msg);
2005 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
2006 msg_conv.is_owned = false;
2007 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
2008 *ret_conv = (this_arg_conv->sign_channel_announcement_with_funding_key)(this_arg_conv->this_arg, &msg_conv);
2009 return tag_ptr(ret_conv, true);
2012 typedef struct LDKWriteableEcdsaChannelSigner_JCalls {
2013 atomic_size_t refcnt;
2014 uint32_t instance_ptr;
2015 LDKEcdsaChannelSigner_JCalls* EcdsaChannelSigner;
2016 LDKChannelSigner_JCalls* ChannelSigner;
2017 } LDKWriteableEcdsaChannelSigner_JCalls;
2018 static void LDKWriteableEcdsaChannelSigner_JCalls_free(void* this_arg) {
2019 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
2020 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2024 LDKCVec_u8Z write_LDKWriteableEcdsaChannelSigner_jcall(const void* this_arg) {
2025 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) this_arg;
2026 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 15, 0, 0, 0, 0, 0, 0);
2027 LDKCVec_u8Z ret_ref;
2028 ret_ref.datalen = ret->arr_len;
2029 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
2030 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
2033 static void LDKWriteableEcdsaChannelSigner_JCalls_cloned(LDKWriteableEcdsaChannelSigner* new_obj) {
2034 LDKWriteableEcdsaChannelSigner_JCalls *j_calls = (LDKWriteableEcdsaChannelSigner_JCalls*) new_obj->this_arg;
2035 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2036 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->refcnt, 1, memory_order_release);
2037 atomic_fetch_add_explicit(&j_calls->EcdsaChannelSigner->ChannelSigner->refcnt, 1, memory_order_release);
2039 static inline LDKWriteableEcdsaChannelSigner LDKWriteableEcdsaChannelSigner_init (JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
2040 LDKWriteableEcdsaChannelSigner_JCalls *calls = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner_JCalls), "LDKWriteableEcdsaChannelSigner_JCalls");
2041 atomic_init(&calls->refcnt, 1);
2042 calls->instance_ptr = o;
2044 LDKChannelPublicKeys pubkeys_conv;
2045 pubkeys_conv.inner = untag_ptr(pubkeys);
2046 pubkeys_conv.is_owned = ptr_is_owned(pubkeys);
2047 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
2049 LDKWriteableEcdsaChannelSigner ret = {
2050 .this_arg = (void*) calls,
2051 .write = write_LDKWriteableEcdsaChannelSigner_jcall,
2052 .cloned = LDKWriteableEcdsaChannelSigner_JCalls_cloned,
2053 .free = LDKWriteableEcdsaChannelSigner_JCalls_free,
2054 .EcdsaChannelSigner = LDKEcdsaChannelSigner_init(EcdsaChannelSigner, ChannelSigner, pubkeys),
2056 calls->EcdsaChannelSigner = ret.EcdsaChannelSigner.this_arg;
2057 calls->ChannelSigner = ret.EcdsaChannelSigner.ChannelSigner.this_arg;
2060 uint64_t __attribute__((export_name("TS_LDKWriteableEcdsaChannelSigner_new"))) TS_LDKWriteableEcdsaChannelSigner_new(JSValue o, JSValue EcdsaChannelSigner, JSValue ChannelSigner, uint64_t pubkeys) {
2061 LDKWriteableEcdsaChannelSigner *res_ptr = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
2062 *res_ptr = LDKWriteableEcdsaChannelSigner_init(o, EcdsaChannelSigner, ChannelSigner, pubkeys);
2063 return tag_ptr(res_ptr, true);
2065 int8_tArray __attribute__((export_name("TS_WriteableEcdsaChannelSigner_write"))) TS_WriteableEcdsaChannelSigner_write(uint64_t this_arg) {
2066 void* this_arg_ptr = untag_ptr(this_arg);
2067 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
2068 LDKWriteableEcdsaChannelSigner* this_arg_conv = (LDKWriteableEcdsaChannelSigner*)this_arg_ptr;
2069 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
2070 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2071 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2072 CVec_u8Z_free(ret_var);
2076 static inline struct LDKWriteableEcdsaChannelSigner CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
2077 CHECK(owner->result_ok);
2078 return WriteableEcdsaChannelSigner_clone(&*owner->contents.result);
2080 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(uint64_t owner) {
2081 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
2082 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
2083 *ret_ret = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_ok(owner_conv);
2084 return tag_ptr(ret_ret, true);
2087 static inline struct LDKDecodeError CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR owner){
2088 CHECK(!owner->result_ok);
2089 return DecodeError_clone(&*owner->contents.err);
2091 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(uint64_t owner) {
2092 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* owner_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(owner);
2093 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2094 *ret_copy = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_get_err(owner_conv);
2095 uint64_t ret_ref = tag_ptr(ret_copy, true);
2099 static inline struct LDKCVec_u8Z CResult_CVec_u8ZNoneZ_get_ok(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner){
2100 CHECK(owner->result_ok);
2101 return CVec_u8Z_clone(&*owner->contents.result);
2103 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_get_ok"))) TS_CResult_CVec_u8ZNoneZ_get_ok(uint64_t owner) {
2104 LDKCResult_CVec_u8ZNoneZ* owner_conv = (LDKCResult_CVec_u8ZNoneZ*)untag_ptr(owner);
2105 LDKCVec_u8Z ret_var = CResult_CVec_u8ZNoneZ_get_ok(owner_conv);
2106 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2107 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2108 CVec_u8Z_free(ret_var);
2112 static inline void CResult_CVec_u8ZNoneZ_get_err(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR owner){
2113 CHECK(!owner->result_ok);
2114 return *owner->contents.err;
2116 void __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_get_err"))) TS_CResult_CVec_u8ZNoneZ_get_err(uint64_t owner) {
2117 LDKCResult_CVec_u8ZNoneZ* owner_conv = (LDKCResult_CVec_u8ZNoneZ*)untag_ptr(owner);
2118 CResult_CVec_u8ZNoneZ_get_err(owner_conv);
2121 static inline struct LDKShutdownScript CResult_ShutdownScriptNoneZ_get_ok(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner){
2122 LDKShutdownScript ret = *owner->contents.result;
2123 ret.is_owned = false;
2126 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_get_ok"))) TS_CResult_ShutdownScriptNoneZ_get_ok(uint64_t owner) {
2127 LDKCResult_ShutdownScriptNoneZ* owner_conv = (LDKCResult_ShutdownScriptNoneZ*)untag_ptr(owner);
2128 LDKShutdownScript ret_var = CResult_ShutdownScriptNoneZ_get_ok(owner_conv);
2129 uint64_t ret_ref = 0;
2130 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2131 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2135 static inline void CResult_ShutdownScriptNoneZ_get_err(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR owner){
2136 CHECK(!owner->result_ok);
2137 return *owner->contents.err;
2139 void __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_get_err"))) TS_CResult_ShutdownScriptNoneZ_get_err(uint64_t owner) {
2140 LDKCResult_ShutdownScriptNoneZ* owner_conv = (LDKCResult_ShutdownScriptNoneZ*)untag_ptr(owner);
2141 CResult_ShutdownScriptNoneZ_get_err(owner_conv);
2144 uint32_t __attribute__((export_name("TS_LDKCOption_u16Z_ty_from_ptr"))) TS_LDKCOption_u16Z_ty_from_ptr(uint64_t ptr) {
2145 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
2147 case LDKCOption_u16Z_Some: return 0;
2148 case LDKCOption_u16Z_None: return 1;
2152 int16_t __attribute__((export_name("TS_LDKCOption_u16Z_Some_get_some"))) TS_LDKCOption_u16Z_Some_get_some(uint64_t ptr) {
2153 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)untag_ptr(ptr);
2154 assert(obj->tag == LDKCOption_u16Z_Some);
2155 int16_t some_conv = obj->some;
2158 uint32_t __attribute__((export_name("TS_LDKCOption_boolZ_ty_from_ptr"))) TS_LDKCOption_boolZ_ty_from_ptr(uint64_t ptr) {
2159 LDKCOption_boolZ *obj = (LDKCOption_boolZ*)untag_ptr(ptr);
2161 case LDKCOption_boolZ_Some: return 0;
2162 case LDKCOption_boolZ_None: return 1;
2166 jboolean __attribute__((export_name("TS_LDKCOption_boolZ_Some_get_some"))) TS_LDKCOption_boolZ_Some_get_some(uint64_t ptr) {
2167 LDKCOption_boolZ *obj = (LDKCOption_boolZ*)untag_ptr(ptr);
2168 assert(obj->tag == LDKCOption_boolZ_Some);
2169 jboolean some_conv = obj->some;
2172 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
2173 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
2174 for (size_t i = 0; i < ret.datalen; i++) {
2175 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
2179 static inline struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
2180 CHECK(owner->result_ok);
2181 return CVec_CVec_u8ZZ_clone(&*owner->contents.result);
2183 ptrArray __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(uint64_t owner) {
2184 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
2185 LDKCVec_CVec_u8ZZ ret_var = CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner_conv);
2186 ptrArray ret_arr = NULL;
2187 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
2188 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
2189 for (size_t m = 0; m < ret_var.datalen; m++) {
2190 LDKCVec_u8Z ret_conv_12_var = ret_var.data[m];
2191 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
2192 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
2193 CVec_u8Z_free(ret_conv_12_var);
2194 ret_arr_ptr[m] = ret_conv_12_arr;
2201 static inline void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
2202 CHECK(!owner->result_ok);
2203 return *owner->contents.err;
2205 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(uint64_t owner) {
2206 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(owner);
2207 CResult_CVec_CVec_u8ZZNoneZ_get_err(owner_conv);
2210 static inline struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
2211 LDKInMemorySigner ret = *owner->contents.result;
2212 ret.is_owned = false;
2215 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_get_ok(uint64_t owner) {
2216 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
2217 LDKInMemorySigner ret_var = CResult_InMemorySignerDecodeErrorZ_get_ok(owner_conv);
2218 uint64_t ret_ref = 0;
2219 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2220 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2224 static inline struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
2225 CHECK(!owner->result_ok);
2226 return DecodeError_clone(&*owner->contents.err);
2228 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_err"))) TS_CResult_InMemorySignerDecodeErrorZ_get_err(uint64_t owner) {
2229 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(owner);
2230 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2231 *ret_copy = CResult_InMemorySignerDecodeErrorZ_get_err(owner_conv);
2232 uint64_t ret_ref = tag_ptr(ret_copy, true);
2236 static inline struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
2237 CHECK(owner->result_ok);
2238 return *owner->contents.result;
2240 int8_tArray __attribute__((export_name("TS_CResult_TransactionNoneZ_get_ok"))) TS_CResult_TransactionNoneZ_get_ok(uint64_t owner) {
2241 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
2242 LDKTransaction ret_var = CResult_TransactionNoneZ_get_ok(owner_conv);
2243 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2244 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2248 static inline void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
2249 CHECK(!owner->result_ok);
2250 return *owner->contents.err;
2252 void __attribute__((export_name("TS_CResult_TransactionNoneZ_get_err"))) TS_CResult_TransactionNoneZ_get_err(uint64_t owner) {
2253 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(owner);
2254 CResult_TransactionNoneZ_get_err(owner_conv);
2257 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
2258 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
2259 for (size_t i = 0; i < ret.datalen; i++) {
2260 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
2264 static inline struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
2265 LDKRoute ret = *owner->contents.result;
2266 ret.is_owned = false;
2269 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_ok"))) TS_CResult_RouteLightningErrorZ_get_ok(uint64_t owner) {
2270 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
2271 LDKRoute ret_var = CResult_RouteLightningErrorZ_get_ok(owner_conv);
2272 uint64_t ret_ref = 0;
2273 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2274 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2278 static inline struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
2279 LDKLightningError ret = *owner->contents.err;
2280 ret.is_owned = false;
2283 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_err"))) TS_CResult_RouteLightningErrorZ_get_err(uint64_t owner) {
2284 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(owner);
2285 LDKLightningError ret_var = CResult_RouteLightningErrorZ_get_err(owner_conv);
2286 uint64_t ret_ref = 0;
2287 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2288 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2292 static inline struct LDKInFlightHtlcs CResult_InFlightHtlcsDecodeErrorZ_get_ok(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
2293 LDKInFlightHtlcs ret = *owner->contents.result;
2294 ret.is_owned = false;
2297 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_ok(uint64_t owner) {
2298 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
2299 LDKInFlightHtlcs ret_var = CResult_InFlightHtlcsDecodeErrorZ_get_ok(owner_conv);
2300 uint64_t ret_ref = 0;
2301 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2302 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2306 static inline struct LDKDecodeError CResult_InFlightHtlcsDecodeErrorZ_get_err(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR owner){
2307 CHECK(!owner->result_ok);
2308 return DecodeError_clone(&*owner->contents.err);
2310 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_get_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_get_err(uint64_t owner) {
2311 LDKCResult_InFlightHtlcsDecodeErrorZ* owner_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(owner);
2312 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2313 *ret_copy = CResult_InFlightHtlcsDecodeErrorZ_get_err(owner_conv);
2314 uint64_t ret_ref = tag_ptr(ret_copy, true);
2318 static inline struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
2319 LDKRouteHop ret = *owner->contents.result;
2320 ret.is_owned = false;
2323 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHopDecodeErrorZ_get_ok(uint64_t owner) {
2324 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
2325 LDKRouteHop ret_var = CResult_RouteHopDecodeErrorZ_get_ok(owner_conv);
2326 uint64_t ret_ref = 0;
2327 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2328 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2332 static inline struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
2333 CHECK(!owner->result_ok);
2334 return DecodeError_clone(&*owner->contents.err);
2336 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_err"))) TS_CResult_RouteHopDecodeErrorZ_get_err(uint64_t owner) {
2337 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(owner);
2338 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2339 *ret_copy = CResult_RouteHopDecodeErrorZ_get_err(owner_conv);
2340 uint64_t ret_ref = tag_ptr(ret_copy, true);
2344 static inline LDKCVec_BlindedHopZ CVec_BlindedHopZ_clone(const LDKCVec_BlindedHopZ *orig) {
2345 LDKCVec_BlindedHopZ ret = { .data = MALLOC(sizeof(LDKBlindedHop) * orig->datalen, "LDKCVec_BlindedHopZ clone bytes"), .datalen = orig->datalen };
2346 for (size_t i = 0; i < ret.datalen; i++) {
2347 ret.data[i] = BlindedHop_clone(&orig->data[i]);
2351 static inline struct LDKBlindedTail CResult_BlindedTailDecodeErrorZ_get_ok(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
2352 LDKBlindedTail ret = *owner->contents.result;
2353 ret.is_owned = false;
2356 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_ok"))) TS_CResult_BlindedTailDecodeErrorZ_get_ok(uint64_t owner) {
2357 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
2358 LDKBlindedTail ret_var = CResult_BlindedTailDecodeErrorZ_get_ok(owner_conv);
2359 uint64_t ret_ref = 0;
2360 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2361 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2365 static inline struct LDKDecodeError CResult_BlindedTailDecodeErrorZ_get_err(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR owner){
2366 CHECK(!owner->result_ok);
2367 return DecodeError_clone(&*owner->contents.err);
2369 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_get_err"))) TS_CResult_BlindedTailDecodeErrorZ_get_err(uint64_t owner) {
2370 LDKCResult_BlindedTailDecodeErrorZ* owner_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(owner);
2371 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2372 *ret_copy = CResult_BlindedTailDecodeErrorZ_get_err(owner_conv);
2373 uint64_t ret_ref = tag_ptr(ret_copy, true);
2377 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
2378 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
2379 for (size_t i = 0; i < ret.datalen; i++) {
2380 ret.data[i] = RouteHop_clone(&orig->data[i]);
2384 static inline LDKCVec_PathZ CVec_PathZ_clone(const LDKCVec_PathZ *orig) {
2385 LDKCVec_PathZ ret = { .data = MALLOC(sizeof(LDKPath) * orig->datalen, "LDKCVec_PathZ clone bytes"), .datalen = orig->datalen };
2386 for (size_t i = 0; i < ret.datalen; i++) {
2387 ret.data[i] = Path_clone(&orig->data[i]);
2391 static inline struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
2392 LDKRoute ret = *owner->contents.result;
2393 ret.is_owned = false;
2396 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_ok"))) TS_CResult_RouteDecodeErrorZ_get_ok(uint64_t owner) {
2397 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
2398 LDKRoute ret_var = CResult_RouteDecodeErrorZ_get_ok(owner_conv);
2399 uint64_t ret_ref = 0;
2400 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2401 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2405 static inline struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
2406 CHECK(!owner->result_ok);
2407 return DecodeError_clone(&*owner->contents.err);
2409 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_err"))) TS_CResult_RouteDecodeErrorZ_get_err(uint64_t owner) {
2410 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(owner);
2411 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2412 *ret_copy = CResult_RouteDecodeErrorZ_get_err(owner_conv);
2413 uint64_t ret_ref = tag_ptr(ret_copy, true);
2417 static inline struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
2418 LDKRouteParameters ret = *owner->contents.result;
2419 ret.is_owned = false;
2422 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_ok"))) TS_CResult_RouteParametersDecodeErrorZ_get_ok(uint64_t owner) {
2423 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
2424 LDKRouteParameters ret_var = CResult_RouteParametersDecodeErrorZ_get_ok(owner_conv);
2425 uint64_t ret_ref = 0;
2426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2431 static inline struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
2432 CHECK(!owner->result_ok);
2433 return DecodeError_clone(&*owner->contents.err);
2435 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_err"))) TS_CResult_RouteParametersDecodeErrorZ_get_err(uint64_t owner) {
2436 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(owner);
2437 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2438 *ret_copy = CResult_RouteParametersDecodeErrorZ_get_err(owner_conv);
2439 uint64_t ret_ref = tag_ptr(ret_copy, true);
2443 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
2444 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
2445 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
2448 static inline struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
2449 LDKPaymentParameters ret = *owner->contents.result;
2450 ret.is_owned = false;
2453 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_get_ok(uint64_t owner) {
2454 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
2455 LDKPaymentParameters ret_var = CResult_PaymentParametersDecodeErrorZ_get_ok(owner_conv);
2456 uint64_t ret_ref = 0;
2457 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2458 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2462 static inline struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
2463 CHECK(!owner->result_ok);
2464 return DecodeError_clone(&*owner->contents.err);
2466 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_err"))) TS_CResult_PaymentParametersDecodeErrorZ_get_err(uint64_t owner) {
2467 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(owner);
2468 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2469 *ret_copy = CResult_PaymentParametersDecodeErrorZ_get_err(owner_conv);
2470 uint64_t ret_ref = tag_ptr(ret_copy, true);
2474 static inline struct LDKBlindedPayInfo C2Tuple_BlindedPayInfoBlindedPathZ_get_a(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
2475 LDKBlindedPayInfo ret = owner->a;
2476 ret.is_owned = false;
2479 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_a(uint64_t owner) {
2480 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
2481 LDKBlindedPayInfo ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_a(owner_conv);
2482 uint64_t ret_ref = 0;
2483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2484 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2488 static inline struct LDKBlindedPath C2Tuple_BlindedPayInfoBlindedPathZ_get_b(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR owner){
2489 LDKBlindedPath ret = owner->b;
2490 ret.is_owned = false;
2493 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_get_b(uint64_t owner) {
2494 LDKC2Tuple_BlindedPayInfoBlindedPathZ* owner_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(owner);
2495 LDKBlindedPath ret_var = C2Tuple_BlindedPayInfoBlindedPathZ_get_b(owner_conv);
2496 uint64_t ret_ref = 0;
2497 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2498 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2502 static inline LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_clone(const LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ *orig) {
2503 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ) * orig->datalen, "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ clone bytes"), .datalen = orig->datalen };
2504 for (size_t i = 0; i < ret.datalen; i++) {
2505 ret.data[i] = C2Tuple_BlindedPayInfoBlindedPathZ_clone(&orig->data[i]);
2509 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
2510 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
2511 for (size_t i = 0; i < ret.datalen; i++) {
2512 ret.data[i] = RouteHint_clone(&orig->data[i]);
2516 static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
2517 LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
2518 for (size_t i = 0; i < ret.datalen; i++) {
2519 ret.data[i] = RouteHintHop_clone(&orig->data[i]);
2523 static inline struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
2524 LDKRouteHint ret = *owner->contents.result;
2525 ret.is_owned = false;
2528 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_ok"))) TS_CResult_RouteHintDecodeErrorZ_get_ok(uint64_t owner) {
2529 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
2530 LDKRouteHint ret_var = CResult_RouteHintDecodeErrorZ_get_ok(owner_conv);
2531 uint64_t ret_ref = 0;
2532 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2533 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2537 static inline struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
2538 CHECK(!owner->result_ok);
2539 return DecodeError_clone(&*owner->contents.err);
2541 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_err"))) TS_CResult_RouteHintDecodeErrorZ_get_err(uint64_t owner) {
2542 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(owner);
2543 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2544 *ret_copy = CResult_RouteHintDecodeErrorZ_get_err(owner_conv);
2545 uint64_t ret_ref = tag_ptr(ret_copy, true);
2549 static inline struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
2550 LDKRouteHintHop ret = *owner->contents.result;
2551 ret.is_owned = false;
2554 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_get_ok(uint64_t owner) {
2555 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
2556 LDKRouteHintHop ret_var = CResult_RouteHintHopDecodeErrorZ_get_ok(owner_conv);
2557 uint64_t ret_ref = 0;
2558 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2559 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2563 static inline struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
2564 CHECK(!owner->result_ok);
2565 return DecodeError_clone(&*owner->contents.err);
2567 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_err"))) TS_CResult_RouteHintHopDecodeErrorZ_get_err(uint64_t owner) {
2568 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(owner);
2569 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2570 *ret_copy = CResult_RouteHintHopDecodeErrorZ_get_err(owner_conv);
2571 uint64_t ret_ref = tag_ptr(ret_copy, true);
2575 static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2576 LDKFixedPenaltyScorer ret = *owner->contents.result;
2577 ret.is_owned = false;
2580 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(uint64_t owner) {
2581 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
2582 LDKFixedPenaltyScorer ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner_conv);
2583 uint64_t ret_ref = 0;
2584 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2585 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2589 static inline struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2590 CHECK(!owner->result_ok);
2591 return DecodeError_clone(&*owner->contents.err);
2593 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(uint64_t owner) {
2594 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(owner);
2595 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2596 *ret_copy = CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner_conv);
2597 uint64_t ret_ref = tag_ptr(ret_copy, true);
2601 static inline LDKCVec_NodeIdZ CVec_NodeIdZ_clone(const LDKCVec_NodeIdZ *orig) {
2602 LDKCVec_NodeIdZ ret = { .data = MALLOC(sizeof(LDKNodeId) * orig->datalen, "LDKCVec_NodeIdZ clone bytes"), .datalen = orig->datalen };
2603 for (size_t i = 0; i < ret.datalen; i++) {
2604 ret.data[i] = NodeId_clone(&orig->data[i]);
2608 static inline uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2611 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_a"))) TS_C2Tuple_u64u64Z_get_a(uint64_t owner) {
2612 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
2613 int64_t ret_conv = C2Tuple_u64u64Z_get_a(owner_conv);
2617 static inline uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2620 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_b"))) TS_C2Tuple_u64u64Z_get_b(uint64_t owner) {
2621 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(owner);
2622 int64_t ret_conv = C2Tuple_u64u64Z_get_b(owner_conv);
2626 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(uint64_t ptr) {
2627 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
2629 case LDKCOption_C2Tuple_u64u64ZZ_Some: return 0;
2630 case LDKCOption_C2Tuple_u64u64ZZ_None: return 1;
2634 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(uint64_t ptr) {
2635 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(ptr);
2636 assert(obj->tag == LDKCOption_C2Tuple_u64u64ZZ_Some);
2637 LDKC2Tuple_u64u64Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
2638 *some_conv = obj->some;
2639 *some_conv = C2Tuple_u64u64Z_clone(some_conv);
2640 return tag_ptr(some_conv, true);
2642 static inline struct LDKThirtyTwoU16s C2Tuple_Z_get_a(LDKC2Tuple_Z *NONNULL_PTR owner){
2645 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_a"))) TS_C2Tuple_Z_get_a(uint64_t owner) {
2646 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
2647 int16_tArray ret_arr = init_int16_tArray(32, __LINE__);
2648 memcpy(ret_arr->elems, C2Tuple_Z_get_a(owner_conv).data, 32 * 2);
2652 static inline struct LDKThirtyTwoU16s C2Tuple_Z_get_b(LDKC2Tuple_Z *NONNULL_PTR owner){
2655 int16_tArray __attribute__((export_name("TS_C2Tuple_Z_get_b"))) TS_C2Tuple_Z_get_b(uint64_t owner) {
2656 LDKC2Tuple_Z* owner_conv = (LDKC2Tuple_Z*)untag_ptr(owner);
2657 int16_tArray ret_arr = init_int16_tArray(32, __LINE__);
2658 memcpy(ret_arr->elems, C2Tuple_Z_get_b(owner_conv).data, 32 * 2);
2662 static inline struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_a(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner){
2665 int16_tArray __attribute__((export_name("TS_C2Tuple__u1632_u1632Z_get_a"))) TS_C2Tuple__u1632_u1632Z_get_a(uint64_t owner) {
2666 LDKC2Tuple__u1632_u1632Z* owner_conv = (LDKC2Tuple__u1632_u1632Z*)untag_ptr(owner);
2667 int16_tArray ret_arr = init_int16_tArray(32, __LINE__);
2668 memcpy(ret_arr->elems, C2Tuple__u1632_u1632Z_get_a(owner_conv).data, 32 * 2);
2672 static inline struct LDKThirtyTwoU16s C2Tuple__u1632_u1632Z_get_b(LDKC2Tuple__u1632_u1632Z *NONNULL_PTR owner){
2675 int16_tArray __attribute__((export_name("TS_C2Tuple__u1632_u1632Z_get_b"))) TS_C2Tuple__u1632_u1632Z_get_b(uint64_t owner) {
2676 LDKC2Tuple__u1632_u1632Z* owner_conv = (LDKC2Tuple__u1632_u1632Z*)untag_ptr(owner);
2677 int16_tArray ret_arr = init_int16_tArray(32, __LINE__);
2678 memcpy(ret_arr->elems, C2Tuple__u1632_u1632Z_get_b(owner_conv).data, 32 * 2);
2682 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_ty_from_ptr(uint64_t ptr) {
2683 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ *obj = (LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ*)untag_ptr(ptr);
2685 case LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some: return 0;
2686 case LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_None: return 1;
2690 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some_get_some(uint64_t ptr) {
2691 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ *obj = (LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ*)untag_ptr(ptr);
2692 assert(obj->tag == LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_Some);
2693 LDKC2Tuple__u1632_u1632Z* some_conv = &obj->some;
2694 // WARNING: we really need to clone here, but no clone is available for LDKC2Tuple__u1632_u1632Z
2695 return tag_ptr(some_conv, false);
2697 uint32_t __attribute__((export_name("TS_LDKCOption_f64Z_ty_from_ptr"))) TS_LDKCOption_f64Z_ty_from_ptr(uint64_t ptr) {
2698 LDKCOption_f64Z *obj = (LDKCOption_f64Z*)untag_ptr(ptr);
2700 case LDKCOption_f64Z_Some: return 0;
2701 case LDKCOption_f64Z_None: return 1;
2705 double __attribute__((export_name("TS_LDKCOption_f64Z_Some_get_some"))) TS_LDKCOption_f64Z_Some_get_some(uint64_t ptr) {
2706 LDKCOption_f64Z *obj = (LDKCOption_f64Z*)untag_ptr(ptr);
2707 assert(obj->tag == LDKCOption_f64Z_Some);
2708 double some_conv = obj->some;
2711 typedef struct LDKLogger_JCalls {
2712 atomic_size_t refcnt;
2713 uint32_t instance_ptr;
2715 static void LDKLogger_JCalls_free(void* this_arg) {
2716 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2717 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2721 void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
2722 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2723 LDKRecord record_var = *record;
2724 uint64_t record_ref = 0;
2725 record_var = Record_clone(&record_var);
2726 CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
2727 record_ref = tag_ptr(record_var.inner, record_var.is_owned);
2728 js_invoke_function_buuuuu(j_calls->instance_ptr, 16, record_ref, 0, 0, 0, 0, 0);
2730 static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
2731 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
2732 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2734 static inline LDKLogger LDKLogger_init (JSValue o) {
2735 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
2736 atomic_init(&calls->refcnt, 1);
2737 calls->instance_ptr = o;
2740 .this_arg = (void*) calls,
2741 .log = log_LDKLogger_jcall,
2742 .free = LDKLogger_JCalls_free,
2746 uint64_t __attribute__((export_name("TS_LDKLogger_new"))) TS_LDKLogger_new(JSValue o) {
2747 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
2748 *res_ptr = LDKLogger_init(o);
2749 return tag_ptr(res_ptr, true);
2751 static inline struct LDKProbabilisticScorer CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2752 LDKProbabilisticScorer ret = *owner->contents.result;
2753 ret.is_owned = false;
2756 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(uint64_t owner) {
2757 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
2758 LDKProbabilisticScorer ret_var = CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner_conv);
2759 uint64_t ret_ref = 0;
2760 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2761 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2765 static inline struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2766 CHECK(!owner->result_ok);
2767 return DecodeError_clone(&*owner->contents.err);
2769 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(uint64_t owner) {
2770 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(owner);
2771 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2772 *ret_copy = CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner_conv);
2773 uint64_t ret_ref = tag_ptr(ret_copy, true);
2777 static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2780 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_a"))) TS_C2Tuple_usizeTransactionZ_get_a(uint64_t owner) {
2781 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
2782 uint32_t ret_conv = C2Tuple_usizeTransactionZ_get_a(owner_conv);
2786 static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2789 int8_tArray __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_b"))) TS_C2Tuple_usizeTransactionZ_get_b(uint64_t owner) {
2790 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(owner);
2791 LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(owner_conv);
2792 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2793 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2797 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
2798 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
2799 for (size_t i = 0; i < ret.datalen; i++) {
2800 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
2804 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner){
2805 return ThirtyTwoBytes_clone(&owner->a);
2807 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(uint64_t owner) {
2808 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)untag_ptr(owner);
2809 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
2810 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_a(owner_conv).data, 32);
2814 static inline struct LDKCOption_ThirtyTwoBytesZ C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR owner){
2815 return COption_ThirtyTwoBytesZ_clone(&owner->b);
2817 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(uint64_t owner) {
2818 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)untag_ptr(owner);
2819 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
2820 *ret_copy = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_get_b(owner_conv);
2821 uint64_t ret_ref = tag_ptr(ret_copy, true);
2825 static inline LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ *orig) {
2826 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ clone bytes"), .datalen = orig->datalen };
2827 for (size_t i = 0; i < ret.datalen; i++) {
2828 ret.data[i] = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(&orig->data[i]);
2832 static inline enum LDKChannelMonitorUpdateStatus CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner){
2833 CHECK(owner->result_ok);
2834 return ChannelMonitorUpdateStatus_clone(&*owner->contents.result);
2836 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(uint64_t owner) {
2837 LDKCResult_ChannelMonitorUpdateStatusNoneZ* owner_conv = (LDKCResult_ChannelMonitorUpdateStatusNoneZ*)untag_ptr(owner);
2838 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(CResult_ChannelMonitorUpdateStatusNoneZ_get_ok(owner_conv));
2842 static inline void CResult_ChannelMonitorUpdateStatusNoneZ_get_err(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR owner){
2843 CHECK(!owner->result_ok);
2844 return *owner->contents.err;
2846 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_get_err(uint64_t owner) {
2847 LDKCResult_ChannelMonitorUpdateStatusNoneZ* owner_conv = (LDKCResult_ChannelMonitorUpdateStatusNoneZ*)untag_ptr(owner);
2848 CResult_ChannelMonitorUpdateStatusNoneZ_get_err(owner_conv);
2851 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_ty_from_ptr"))) TS_LDKMonitorEvent_ty_from_ptr(uint64_t ptr) {
2852 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2854 case LDKMonitorEvent_HTLCEvent: return 0;
2855 case LDKMonitorEvent_HolderForceClosed: return 1;
2856 case LDKMonitorEvent_Completed: return 2;
2860 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_HTLCEvent_get_htlc_event"))) TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(uint64_t ptr) {
2861 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2862 assert(obj->tag == LDKMonitorEvent_HTLCEvent);
2863 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
2864 uint64_t htlc_event_ref = 0;
2865 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
2866 htlc_event_ref = tag_ptr(htlc_event_var.inner, false);
2867 return htlc_event_ref;
2869 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed"))) TS_LDKMonitorEvent_HolderForceClosed_get_holder_force_closed(uint64_t ptr) {
2870 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2871 assert(obj->tag == LDKMonitorEvent_HolderForceClosed);
2872 LDKOutPoint holder_force_closed_var = obj->holder_force_closed;
2873 uint64_t holder_force_closed_ref = 0;
2874 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_force_closed_var);
2875 holder_force_closed_ref = tag_ptr(holder_force_closed_var.inner, false);
2876 return holder_force_closed_ref;
2878 uint64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_funding_txo"))) TS_LDKMonitorEvent_Completed_get_funding_txo(uint64_t ptr) {
2879 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2880 assert(obj->tag == LDKMonitorEvent_Completed);
2881 LDKOutPoint funding_txo_var = obj->completed.funding_txo;
2882 uint64_t funding_txo_ref = 0;
2883 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
2884 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
2885 return funding_txo_ref;
2887 int64_t __attribute__((export_name("TS_LDKMonitorEvent_Completed_get_monitor_update_id"))) TS_LDKMonitorEvent_Completed_get_monitor_update_id(uint64_t ptr) {
2888 LDKMonitorEvent *obj = (LDKMonitorEvent*)untag_ptr(ptr);
2889 assert(obj->tag == LDKMonitorEvent_Completed);
2890 int64_t monitor_update_id_conv = obj->completed.monitor_update_id;
2891 return monitor_update_id_conv;
2893 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
2894 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
2895 for (size_t i = 0; i < ret.datalen; i++) {
2896 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
2900 static inline struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2901 LDKOutPoint ret = owner->a;
2902 ret.is_owned = false;
2905 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(uint64_t owner) {
2906 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2907 LDKOutPoint ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner_conv);
2908 uint64_t ret_ref = 0;
2909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2914 static inline struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2915 return CVec_MonitorEventZ_clone(&owner->b);
2917 uint64_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(uint64_t owner) {
2918 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2919 LDKCVec_MonitorEventZ ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner_conv);
2920 uint64_tArray ret_arr = NULL;
2921 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
2922 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
2923 for (size_t o = 0; o < ret_var.datalen; o++) {
2924 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
2925 *ret_conv_14_copy = ret_var.data[o];
2926 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
2927 ret_arr_ptr[o] = ret_conv_14_ref;
2934 static inline struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2937 int8_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(uint64_t owner) {
2938 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(owner);
2939 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
2940 memcpy(ret_arr->elems, C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner_conv).compressed_form, 33);
2944 static inline LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_clone(const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ *orig) {
2945 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ) * orig->datalen, "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ clone bytes"), .datalen = orig->datalen };
2946 for (size_t i = 0; i < ret.datalen; i++) {
2947 ret.data[i] = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(&orig->data[i]);
2951 static inline struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2952 LDKInitFeatures ret = *owner->contents.result;
2953 ret.is_owned = false;
2956 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2957 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
2958 LDKInitFeatures ret_var = CResult_InitFeaturesDecodeErrorZ_get_ok(owner_conv);
2959 uint64_t ret_ref = 0;
2960 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2961 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2965 static inline struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2966 CHECK(!owner->result_ok);
2967 return DecodeError_clone(&*owner->contents.err);
2969 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_err"))) TS_CResult_InitFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2970 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(owner);
2971 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2972 *ret_copy = CResult_InitFeaturesDecodeErrorZ_get_err(owner_conv);
2973 uint64_t ret_ref = tag_ptr(ret_copy, true);
2977 static inline struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2978 LDKChannelFeatures ret = *owner->contents.result;
2979 ret.is_owned = false;
2982 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
2983 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
2984 LDKChannelFeatures ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner_conv);
2985 uint64_t ret_ref = 0;
2986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
2991 static inline struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2992 CHECK(!owner->result_ok);
2993 return DecodeError_clone(&*owner->contents.err);
2995 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(uint64_t owner) {
2996 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(owner);
2997 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
2998 *ret_copy = CResult_ChannelFeaturesDecodeErrorZ_get_err(owner_conv);
2999 uint64_t ret_ref = tag_ptr(ret_copy, true);
3003 static inline struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3004 LDKNodeFeatures ret = *owner->contents.result;
3005 ret.is_owned = false;
3008 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3009 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
3010 LDKNodeFeatures ret_var = CResult_NodeFeaturesDecodeErrorZ_get_ok(owner_conv);
3011 uint64_t ret_ref = 0;
3012 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3013 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3017 static inline struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3018 CHECK(!owner->result_ok);
3019 return DecodeError_clone(&*owner->contents.err);
3021 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3022 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(owner);
3023 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3024 *ret_copy = CResult_NodeFeaturesDecodeErrorZ_get_err(owner_conv);
3025 uint64_t ret_ref = tag_ptr(ret_copy, true);
3029 static inline struct LDKBolt11InvoiceFeatures CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3030 LDKBolt11InvoiceFeatures ret = *owner->contents.result;
3031 ret.is_owned = false;
3034 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3035 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
3036 LDKBolt11InvoiceFeatures ret_var = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
3037 uint64_t ret_ref = 0;
3038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3039 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3043 static inline struct LDKDecodeError CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3044 CHECK(!owner->result_ok);
3045 return DecodeError_clone(&*owner->contents.err);
3047 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3048 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
3049 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3050 *ret_copy = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
3051 uint64_t ret_ref = tag_ptr(ret_copy, true);
3055 static inline struct LDKBolt12InvoiceFeatures CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3056 LDKBolt12InvoiceFeatures ret = *owner->contents.result;
3057 ret.is_owned = false;
3060 uint64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3061 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
3062 LDKBolt12InvoiceFeatures ret_var = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
3063 uint64_t ret_ref = 0;
3064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3065 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3069 static inline struct LDKDecodeError CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3070 CHECK(!owner->result_ok);
3071 return DecodeError_clone(&*owner->contents.err);
3073 uint64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3074 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)untag_ptr(owner);
3075 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3076 *ret_copy = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
3077 uint64_t ret_ref = tag_ptr(ret_copy, true);
3081 static inline struct LDKBlindedHopFeatures CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
3082 LDKBlindedHopFeatures ret = *owner->contents.result;
3083 ret.is_owned = false;
3086 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3087 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
3088 LDKBlindedHopFeatures ret_var = CResult_BlindedHopFeaturesDecodeErrorZ_get_ok(owner_conv);
3089 uint64_t ret_ref = 0;
3090 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3091 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3095 static inline struct LDKDecodeError CResult_BlindedHopFeaturesDecodeErrorZ_get_err(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR owner){
3096 CHECK(!owner->result_ok);
3097 return DecodeError_clone(&*owner->contents.err);
3099 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3100 LDKCResult_BlindedHopFeaturesDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(owner);
3101 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3102 *ret_copy = CResult_BlindedHopFeaturesDecodeErrorZ_get_err(owner_conv);
3103 uint64_t ret_ref = tag_ptr(ret_copy, true);
3107 static inline struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3108 LDKChannelTypeFeatures ret = *owner->contents.result;
3109 ret.is_owned = false;
3112 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(uint64_t owner) {
3113 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
3114 LDKChannelTypeFeatures ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner_conv);
3115 uint64_t ret_ref = 0;
3116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3117 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3121 static inline struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3122 CHECK(!owner->result_ok);
3123 return DecodeError_clone(&*owner->contents.err);
3125 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(uint64_t owner) {
3126 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(owner);
3127 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3128 *ret_copy = CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner_conv);
3129 uint64_t ret_ref = tag_ptr(ret_copy, true);
3133 static inline struct LDKOffer CResult_OfferBolt12ParseErrorZ_get_ok(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner){
3134 LDKOffer ret = *owner->contents.result;
3135 ret.is_owned = false;
3138 uint64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_get_ok"))) TS_CResult_OfferBolt12ParseErrorZ_get_ok(uint64_t owner) {
3139 LDKCResult_OfferBolt12ParseErrorZ* owner_conv = (LDKCResult_OfferBolt12ParseErrorZ*)untag_ptr(owner);
3140 LDKOffer ret_var = CResult_OfferBolt12ParseErrorZ_get_ok(owner_conv);
3141 uint64_t ret_ref = 0;
3142 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3143 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3147 static inline struct LDKBolt12ParseError CResult_OfferBolt12ParseErrorZ_get_err(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR owner){
3148 LDKBolt12ParseError ret = *owner->contents.err;
3149 ret.is_owned = false;
3152 uint64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_get_err"))) TS_CResult_OfferBolt12ParseErrorZ_get_err(uint64_t owner) {
3153 LDKCResult_OfferBolt12ParseErrorZ* owner_conv = (LDKCResult_OfferBolt12ParseErrorZ*)untag_ptr(owner);
3154 LDKBolt12ParseError ret_var = CResult_OfferBolt12ParseErrorZ_get_err(owner_conv);
3155 uint64_t ret_ref = 0;
3156 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3157 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3161 static inline struct LDKPublicKey CResult_PublicKeySecp256k1ErrorZ_get_ok(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner){
3162 CHECK(owner->result_ok);
3163 return *owner->contents.result;
3165 int8_tArray __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_get_ok"))) TS_CResult_PublicKeySecp256k1ErrorZ_get_ok(uint64_t owner) {
3166 LDKCResult_PublicKeySecp256k1ErrorZ* owner_conv = (LDKCResult_PublicKeySecp256k1ErrorZ*)untag_ptr(owner);
3167 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
3168 memcpy(ret_arr->elems, CResult_PublicKeySecp256k1ErrorZ_get_ok(owner_conv).compressed_form, 33);
3172 static inline enum LDKSecp256k1Error CResult_PublicKeySecp256k1ErrorZ_get_err(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR owner){
3173 CHECK(!owner->result_ok);
3174 return *owner->contents.err;
3176 uint32_t __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_get_err"))) TS_CResult_PublicKeySecp256k1ErrorZ_get_err(uint64_t owner) {
3177 LDKCResult_PublicKeySecp256k1ErrorZ* owner_conv = (LDKCResult_PublicKeySecp256k1ErrorZ*)untag_ptr(owner);
3178 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PublicKeySecp256k1ErrorZ_get_err(owner_conv));
3182 static inline struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3183 LDKNodeId ret = *owner->contents.result;
3184 ret.is_owned = false;
3187 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_ok"))) TS_CResult_NodeIdDecodeErrorZ_get_ok(uint64_t owner) {
3188 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3189 LDKNodeId ret_var = CResult_NodeIdDecodeErrorZ_get_ok(owner_conv);
3190 uint64_t ret_ref = 0;
3191 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3192 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3196 static inline struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3197 CHECK(!owner->result_ok);
3198 return DecodeError_clone(&*owner->contents.err);
3200 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_err"))) TS_CResult_NodeIdDecodeErrorZ_get_err(uint64_t owner) {
3201 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(owner);
3202 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3203 *ret_copy = CResult_NodeIdDecodeErrorZ_get_err(owner_conv);
3204 uint64_t ret_ref = tag_ptr(ret_copy, true);
3208 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ty_from_ptr"))) TS_LDKNetworkUpdate_ty_from_ptr(uint64_t ptr) {
3209 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3211 case LDKNetworkUpdate_ChannelUpdateMessage: return 0;
3212 case LDKNetworkUpdate_ChannelFailure: return 1;
3213 case LDKNetworkUpdate_NodeFailure: return 2;
3217 uint64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg"))) TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(uint64_t ptr) {
3218 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3219 assert(obj->tag == LDKNetworkUpdate_ChannelUpdateMessage);
3220 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
3221 uint64_t msg_ref = 0;
3222 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3223 msg_ref = tag_ptr(msg_var.inner, false);
3226 int64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id"))) TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(uint64_t ptr) {
3227 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3228 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
3229 int64_t short_channel_id_conv = obj->channel_failure.short_channel_id;
3230 return short_channel_id_conv;
3232 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent"))) TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(uint64_t ptr) {
3233 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3234 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
3235 jboolean is_permanent_conv = obj->channel_failure.is_permanent;
3236 return is_permanent_conv;
3238 int8_tArray __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_node_id"))) TS_LDKNetworkUpdate_NodeFailure_get_node_id(uint64_t ptr) {
3239 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3240 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
3241 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3242 memcpy(node_id_arr->elems, obj->node_failure.node_id.compressed_form, 33);
3245 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_is_permanent"))) TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(uint64_t ptr) {
3246 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)untag_ptr(ptr);
3247 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
3248 jboolean is_permanent_conv = obj->node_failure.is_permanent;
3249 return is_permanent_conv;
3251 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_ty_from_ptr"))) TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(uint64_t ptr) {
3252 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
3254 case LDKCOption_NetworkUpdateZ_Some: return 0;
3255 case LDKCOption_NetworkUpdateZ_None: return 1;
3259 uint64_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_Some_get_some"))) TS_LDKCOption_NetworkUpdateZ_Some_get_some(uint64_t ptr) {
3260 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)untag_ptr(ptr);
3261 assert(obj->tag == LDKCOption_NetworkUpdateZ_Some);
3262 uint64_t some_ref = tag_ptr(&obj->some, false);
3265 static inline struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3266 CHECK(owner->result_ok);
3267 return COption_NetworkUpdateZ_clone(&*owner->contents.result);
3269 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint64_t owner) {
3270 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3271 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
3272 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner_conv);
3273 uint64_t ret_ref = tag_ptr(ret_copy, true);
3277 static inline struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3278 CHECK(!owner->result_ok);
3279 return DecodeError_clone(&*owner->contents.err);
3281 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint64_t owner) {
3282 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(owner);
3283 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
3284 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner_conv);
3285 uint64_t ret_ref = tag_ptr(ret_copy, true);
3289 static inline struct LDKTxOut CResult_TxOutUtxoLookupErrorZ_get_ok(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3290 CHECK(owner->result_ok);
3291 return TxOut_clone(&*owner->contents.result);
3293 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_get_ok(uint64_t owner) {
3294 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3295 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
3296 *ret_ref = CResult_TxOutUtxoLookupErrorZ_get_ok(owner_conv);
3297 return tag_ptr(ret_ref, true);
3300 static inline enum LDKUtxoLookupError CResult_TxOutUtxoLookupErrorZ_get_err(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR owner){
3301 CHECK(!owner->result_ok);
3302 return UtxoLookupError_clone(&*owner->contents.err);
3304 uint32_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_get_err"))) TS_CResult_TxOutUtxoLookupErrorZ_get_err(uint64_t owner) {
3305 LDKCResult_TxOutUtxoLookupErrorZ* owner_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(owner);
3306 uint32_t ret_conv = LDKUtxoLookupError_to_js(CResult_TxOutUtxoLookupErrorZ_get_err(owner_conv));
3310 uint32_t __attribute__((export_name("TS_LDKUtxoResult_ty_from_ptr"))) TS_LDKUtxoResult_ty_from_ptr(uint64_t ptr) {
3311 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3313 case LDKUtxoResult_Sync: return 0;
3314 case LDKUtxoResult_Async: return 1;
3318 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Sync_get_sync"))) TS_LDKUtxoResult_Sync_get_sync(uint64_t ptr) {
3319 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3320 assert(obj->tag == LDKUtxoResult_Sync);
3321 LDKCResult_TxOutUtxoLookupErrorZ* sync_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
3322 *sync_conv = obj->sync;
3323 *sync_conv = CResult_TxOutUtxoLookupErrorZ_clone(sync_conv);
3324 return tag_ptr(sync_conv, true);
3326 uint64_t __attribute__((export_name("TS_LDKUtxoResult_Async_get_async"))) TS_LDKUtxoResult_Async_get_async(uint64_t ptr) {
3327 LDKUtxoResult *obj = (LDKUtxoResult*)untag_ptr(ptr);
3328 assert(obj->tag == LDKUtxoResult_Async);
3329 LDKUtxoFuture async_var = obj->async;
3330 uint64_t async_ref = 0;
3331 CHECK_INNER_FIELD_ACCESS_OR_NULL(async_var);
3332 async_ref = tag_ptr(async_var.inner, false);
3335 typedef struct LDKUtxoLookup_JCalls {
3336 atomic_size_t refcnt;
3337 uint32_t instance_ptr;
3338 } LDKUtxoLookup_JCalls;
3339 static void LDKUtxoLookup_JCalls_free(void* this_arg) {
3340 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3341 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3345 LDKUtxoResult get_utxo_LDKUtxoLookup_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
3346 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) this_arg;
3347 int8_tArray genesis_hash_arr = init_int8_tArray(32, __LINE__);
3348 memcpy(genesis_hash_arr->elems, *genesis_hash, 32);
3349 int64_t short_channel_id_conv = short_channel_id;
3350 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 17, (uint32_t)genesis_hash_arr, short_channel_id_conv, 0, 0, 0, 0);
3351 void* ret_ptr = untag_ptr(ret);
3352 CHECK_ACCESS(ret_ptr);
3353 LDKUtxoResult ret_conv = *(LDKUtxoResult*)(ret_ptr);
3354 FREE(untag_ptr(ret));
3357 static void LDKUtxoLookup_JCalls_cloned(LDKUtxoLookup* new_obj) {
3358 LDKUtxoLookup_JCalls *j_calls = (LDKUtxoLookup_JCalls*) new_obj->this_arg;
3359 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3361 static inline LDKUtxoLookup LDKUtxoLookup_init (JSValue o) {
3362 LDKUtxoLookup_JCalls *calls = MALLOC(sizeof(LDKUtxoLookup_JCalls), "LDKUtxoLookup_JCalls");
3363 atomic_init(&calls->refcnt, 1);
3364 calls->instance_ptr = o;
3366 LDKUtxoLookup ret = {
3367 .this_arg = (void*) calls,
3368 .get_utxo = get_utxo_LDKUtxoLookup_jcall,
3369 .free = LDKUtxoLookup_JCalls_free,
3373 uint64_t __attribute__((export_name("TS_LDKUtxoLookup_new"))) TS_LDKUtxoLookup_new(JSValue o) {
3374 LDKUtxoLookup *res_ptr = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3375 *res_ptr = LDKUtxoLookup_init(o);
3376 return tag_ptr(res_ptr, true);
3378 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) {
3379 void* this_arg_ptr = untag_ptr(this_arg);
3380 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
3381 LDKUtxoLookup* this_arg_conv = (LDKUtxoLookup*)this_arg_ptr;
3382 uint8_t genesis_hash_arr[32];
3383 CHECK(genesis_hash->arr_len == 32);
3384 memcpy(genesis_hash_arr, genesis_hash->elems, 32); FREE(genesis_hash);
3385 uint8_t (*genesis_hash_ref)[32] = &genesis_hash_arr;
3386 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
3387 *ret_copy = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
3388 uint64_t ret_ref = tag_ptr(ret_copy, true);
3392 uint32_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_ty_from_ptr"))) TS_LDKCOption_UtxoLookupZ_ty_from_ptr(uint64_t ptr) {
3393 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3395 case LDKCOption_UtxoLookupZ_Some: return 0;
3396 case LDKCOption_UtxoLookupZ_None: return 1;
3400 uint64_t __attribute__((export_name("TS_LDKCOption_UtxoLookupZ_Some_get_some"))) TS_LDKCOption_UtxoLookupZ_Some_get_some(uint64_t ptr) {
3401 LDKCOption_UtxoLookupZ *obj = (LDKCOption_UtxoLookupZ*)untag_ptr(ptr);
3402 assert(obj->tag == LDKCOption_UtxoLookupZ_Some);
3403 LDKUtxoLookup* some_ret = MALLOC(sizeof(LDKUtxoLookup), "LDKUtxoLookup");
3404 *some_ret = obj->some;
3405 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
3406 if ((*some_ret).free == LDKUtxoLookup_JCalls_free) {
3407 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
3408 LDKUtxoLookup_JCalls_cloned(&(*some_ret));
3410 return tag_ptr(some_ret, true);
3412 static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3413 CHECK(owner->result_ok);
3414 return *owner->contents.result;
3416 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_ok"))) TS_CResult_NoneLightningErrorZ_get_ok(uint64_t owner) {
3417 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3418 CResult_NoneLightningErrorZ_get_ok(owner_conv);
3421 static inline struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3422 LDKLightningError ret = *owner->contents.err;
3423 ret.is_owned = false;
3426 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_err"))) TS_CResult_NoneLightningErrorZ_get_err(uint64_t owner) {
3427 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(owner);
3428 LDKLightningError ret_var = CResult_NoneLightningErrorZ_get_err(owner_conv);
3429 uint64_t ret_ref = 0;
3430 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3431 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3435 static inline bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3436 CHECK(owner->result_ok);
3437 return *owner->contents.result;
3439 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_ok"))) TS_CResult_boolLightningErrorZ_get_ok(uint64_t owner) {
3440 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3441 jboolean ret_conv = CResult_boolLightningErrorZ_get_ok(owner_conv);
3445 static inline struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3446 LDKLightningError ret = *owner->contents.err;
3447 ret.is_owned = false;
3450 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_err"))) TS_CResult_boolLightningErrorZ_get_err(uint64_t owner) {
3451 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(owner);
3452 LDKLightningError ret_var = CResult_boolLightningErrorZ_get_err(owner_conv);
3453 uint64_t ret_ref = 0;
3454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3459 static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3460 LDKChannelAnnouncement ret = owner->a;
3461 ret.is_owned = false;
3464 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint64_t owner) {
3465 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3466 LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(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 LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3474 LDKChannelUpdate ret = owner->b;
3475 ret.is_owned = false;
3478 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint64_t owner) {
3479 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3480 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner_conv);
3481 uint64_t ret_ref = 0;
3482 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3483 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3487 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3488 LDKChannelUpdate ret = owner->c;
3489 ret.is_owned = false;
3492 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint64_t owner) {
3493 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(owner);
3494 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner_conv);
3495 uint64_t ret_ref = 0;
3496 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3497 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
3501 uint32_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_ty_from_ptr(uint64_t ptr) {
3502 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3504 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some: return 0;
3505 case LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_None: return 1;
3509 uint64_t __attribute__((export_name("TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some"))) TS_LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some_get_some(uint64_t ptr) {
3510 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *obj = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(ptr);
3511 assert(obj->tag == LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_Some);
3512 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* some_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
3513 *some_conv = obj->some;
3514 *some_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(some_conv);
3515 return tag_ptr(some_conv, true);
3517 uint32_t __attribute__((export_name("TS_LDKErrorAction_ty_from_ptr"))) TS_LDKErrorAction_ty_from_ptr(uint64_t ptr) {
3518 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3520 case LDKErrorAction_DisconnectPeer: return 0;
3521 case LDKErrorAction_DisconnectPeerWithWarning: return 1;
3522 case LDKErrorAction_IgnoreError: return 2;
3523 case LDKErrorAction_IgnoreAndLog: return 3;
3524 case LDKErrorAction_IgnoreDuplicateGossip: return 4;
3525 case LDKErrorAction_SendErrorMessage: return 5;
3526 case LDKErrorAction_SendWarningMessage: return 6;
3530 uint64_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeer_get_msg"))) TS_LDKErrorAction_DisconnectPeer_get_msg(uint64_t ptr) {
3531 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3532 assert(obj->tag == LDKErrorAction_DisconnectPeer);
3533 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
3534 uint64_t msg_ref = 0;
3535 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3536 msg_ref = tag_ptr(msg_var.inner, false);
3539 uint64_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg"))) TS_LDKErrorAction_DisconnectPeerWithWarning_get_msg(uint64_t ptr) {
3540 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3541 assert(obj->tag == LDKErrorAction_DisconnectPeerWithWarning);
3542 LDKWarningMessage msg_var = obj->disconnect_peer_with_warning.msg;
3543 uint64_t msg_ref = 0;
3544 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3545 msg_ref = tag_ptr(msg_var.inner, false);
3548 uint32_t __attribute__((export_name("TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log"))) TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(uint64_t ptr) {
3549 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3550 assert(obj->tag == LDKErrorAction_IgnoreAndLog);
3551 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
3552 return ignore_and_log_conv;
3554 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendErrorMessage_get_msg"))) TS_LDKErrorAction_SendErrorMessage_get_msg(uint64_t ptr) {
3555 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3556 assert(obj->tag == LDKErrorAction_SendErrorMessage);
3557 LDKErrorMessage msg_var = obj->send_error_message.msg;
3558 uint64_t msg_ref = 0;
3559 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3560 msg_ref = tag_ptr(msg_var.inner, false);
3563 uint64_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_msg"))) TS_LDKErrorAction_SendWarningMessage_get_msg(uint64_t ptr) {
3564 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3565 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3566 LDKWarningMessage msg_var = obj->send_warning_message.msg;
3567 uint64_t msg_ref = 0;
3568 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3569 msg_ref = tag_ptr(msg_var.inner, false);
3572 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_log_level"))) TS_LDKErrorAction_SendWarningMessage_get_log_level(uint64_t ptr) {
3573 LDKErrorAction *obj = (LDKErrorAction*)untag_ptr(ptr);
3574 assert(obj->tag == LDKErrorAction_SendWarningMessage);
3575 uint32_t log_level_conv = LDKLevel_to_js(obj->send_warning_message.log_level);
3576 return log_level_conv;
3578 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_ty_from_ptr"))) TS_LDKMessageSendEvent_ty_from_ptr(uint64_t ptr) {
3579 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3581 case LDKMessageSendEvent_SendAcceptChannel: return 0;
3582 case LDKMessageSendEvent_SendAcceptChannelV2: return 1;
3583 case LDKMessageSendEvent_SendOpenChannel: return 2;
3584 case LDKMessageSendEvent_SendOpenChannelV2: return 3;
3585 case LDKMessageSendEvent_SendFundingCreated: return 4;
3586 case LDKMessageSendEvent_SendFundingSigned: return 5;
3587 case LDKMessageSendEvent_SendTxAddInput: return 6;
3588 case LDKMessageSendEvent_SendTxAddOutput: return 7;
3589 case LDKMessageSendEvent_SendTxRemoveInput: return 8;
3590 case LDKMessageSendEvent_SendTxRemoveOutput: return 9;
3591 case LDKMessageSendEvent_SendTxComplete: return 10;
3592 case LDKMessageSendEvent_SendTxSignatures: return 11;
3593 case LDKMessageSendEvent_SendTxInitRbf: return 12;
3594 case LDKMessageSendEvent_SendTxAckRbf: return 13;
3595 case LDKMessageSendEvent_SendTxAbort: return 14;
3596 case LDKMessageSendEvent_SendChannelReady: return 15;
3597 case LDKMessageSendEvent_SendAnnouncementSignatures: return 16;
3598 case LDKMessageSendEvent_UpdateHTLCs: return 17;
3599 case LDKMessageSendEvent_SendRevokeAndACK: return 18;
3600 case LDKMessageSendEvent_SendClosingSigned: return 19;
3601 case LDKMessageSendEvent_SendShutdown: return 20;
3602 case LDKMessageSendEvent_SendChannelReestablish: return 21;
3603 case LDKMessageSendEvent_SendChannelAnnouncement: return 22;
3604 case LDKMessageSendEvent_BroadcastChannelAnnouncement: return 23;
3605 case LDKMessageSendEvent_BroadcastChannelUpdate: return 24;
3606 case LDKMessageSendEvent_BroadcastNodeAnnouncement: return 25;
3607 case LDKMessageSendEvent_SendChannelUpdate: return 26;
3608 case LDKMessageSendEvent_HandleError: return 27;
3609 case LDKMessageSendEvent_SendChannelRangeQuery: return 28;
3610 case LDKMessageSendEvent_SendShortIdsQuery: return 29;
3611 case LDKMessageSendEvent_SendReplyChannelRange: return 30;
3612 case LDKMessageSendEvent_SendGossipTimestampFilter: return 31;
3616 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(uint64_t ptr) {
3617 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3618 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3619 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3620 memcpy(node_id_arr->elems, obj->send_accept_channel.node_id.compressed_form, 33);
3623 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(uint64_t ptr) {
3624 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3625 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
3626 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
3627 uint64_t msg_ref = 0;
3628 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3629 msg_ref = tag_ptr(msg_var.inner, false);
3632 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannelV2_get_node_id(uint64_t ptr) {
3633 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3634 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannelV2);
3635 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3636 memcpy(node_id_arr->elems, obj->send_accept_channel_v2.node_id.compressed_form, 33);
3639 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannelV2_get_msg(uint64_t ptr) {
3640 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3641 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannelV2);
3642 LDKAcceptChannelV2 msg_var = obj->send_accept_channel_v2.msg;
3643 uint64_t msg_ref = 0;
3644 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3645 msg_ref = tag_ptr(msg_var.inner, false);
3648 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(uint64_t ptr) {
3649 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3650 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3651 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3652 memcpy(node_id_arr->elems, obj->send_open_channel.node_id.compressed_form, 33);
3655 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannel_get_msg(uint64_t ptr) {
3656 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3657 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
3658 LDKOpenChannel msg_var = obj->send_open_channel.msg;
3659 uint64_t msg_ref = 0;
3660 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3661 msg_ref = tag_ptr(msg_var.inner, false);
3664 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannelV2_get_node_id(uint64_t ptr) {
3665 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3666 assert(obj->tag == LDKMessageSendEvent_SendOpenChannelV2);
3667 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3668 memcpy(node_id_arr->elems, obj->send_open_channel_v2.node_id.compressed_form, 33);
3671 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannelV2_get_msg(uint64_t ptr) {
3672 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3673 assert(obj->tag == LDKMessageSendEvent_SendOpenChannelV2);
3674 LDKOpenChannelV2 msg_var = obj->send_open_channel_v2.msg;
3675 uint64_t msg_ref = 0;
3676 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3677 msg_ref = tag_ptr(msg_var.inner, false);
3680 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_node_id"))) TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(uint64_t ptr) {
3681 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3682 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3683 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3684 memcpy(node_id_arr->elems, obj->send_funding_created.node_id.compressed_form, 33);
3687 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_msg"))) TS_LDKMessageSendEvent_SendFundingCreated_get_msg(uint64_t ptr) {
3688 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3689 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
3690 LDKFundingCreated msg_var = obj->send_funding_created.msg;
3691 uint64_t msg_ref = 0;
3692 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3693 msg_ref = tag_ptr(msg_var.inner, false);
3696 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(uint64_t ptr) {
3697 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3698 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3699 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3700 memcpy(node_id_arr->elems, obj->send_funding_signed.node_id.compressed_form, 33);
3703 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_msg"))) TS_LDKMessageSendEvent_SendFundingSigned_get_msg(uint64_t ptr) {
3704 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3705 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
3706 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
3707 uint64_t msg_ref = 0;
3708 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3709 msg_ref = tag_ptr(msg_var.inner, false);
3712 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAddInput_get_node_id"))) TS_LDKMessageSendEvent_SendTxAddInput_get_node_id(uint64_t ptr) {
3713 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3714 assert(obj->tag == LDKMessageSendEvent_SendTxAddInput);
3715 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3716 memcpy(node_id_arr->elems, obj->send_tx_add_input.node_id.compressed_form, 33);
3719 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAddInput_get_msg"))) TS_LDKMessageSendEvent_SendTxAddInput_get_msg(uint64_t ptr) {
3720 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3721 assert(obj->tag == LDKMessageSendEvent_SendTxAddInput);
3722 LDKTxAddInput msg_var = obj->send_tx_add_input.msg;
3723 uint64_t msg_ref = 0;
3724 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3725 msg_ref = tag_ptr(msg_var.inner, false);
3728 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id"))) TS_LDKMessageSendEvent_SendTxAddOutput_get_node_id(uint64_t ptr) {
3729 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3730 assert(obj->tag == LDKMessageSendEvent_SendTxAddOutput);
3731 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3732 memcpy(node_id_arr->elems, obj->send_tx_add_output.node_id.compressed_form, 33);
3735 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAddOutput_get_msg"))) TS_LDKMessageSendEvent_SendTxAddOutput_get_msg(uint64_t ptr) {
3736 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3737 assert(obj->tag == LDKMessageSendEvent_SendTxAddOutput);
3738 LDKTxAddOutput msg_var = obj->send_tx_add_output.msg;
3739 uint64_t msg_ref = 0;
3740 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3741 msg_ref = tag_ptr(msg_var.inner, false);
3744 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id"))) TS_LDKMessageSendEvent_SendTxRemoveInput_get_node_id(uint64_t ptr) {
3745 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3746 assert(obj->tag == LDKMessageSendEvent_SendTxRemoveInput);
3747 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3748 memcpy(node_id_arr->elems, obj->send_tx_remove_input.node_id.compressed_form, 33);
3751 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg"))) TS_LDKMessageSendEvent_SendTxRemoveInput_get_msg(uint64_t ptr) {
3752 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3753 assert(obj->tag == LDKMessageSendEvent_SendTxRemoveInput);
3754 LDKTxRemoveInput msg_var = obj->send_tx_remove_input.msg;
3755 uint64_t msg_ref = 0;
3756 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3757 msg_ref = tag_ptr(msg_var.inner, false);
3760 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id"))) TS_LDKMessageSendEvent_SendTxRemoveOutput_get_node_id(uint64_t ptr) {
3761 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3762 assert(obj->tag == LDKMessageSendEvent_SendTxRemoveOutput);
3763 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3764 memcpy(node_id_arr->elems, obj->send_tx_remove_output.node_id.compressed_form, 33);
3767 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg"))) TS_LDKMessageSendEvent_SendTxRemoveOutput_get_msg(uint64_t ptr) {
3768 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3769 assert(obj->tag == LDKMessageSendEvent_SendTxRemoveOutput);
3770 LDKTxRemoveOutput msg_var = obj->send_tx_remove_output.msg;
3771 uint64_t msg_ref = 0;
3772 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3773 msg_ref = tag_ptr(msg_var.inner, false);
3776 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxComplete_get_node_id"))) TS_LDKMessageSendEvent_SendTxComplete_get_node_id(uint64_t ptr) {
3777 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3778 assert(obj->tag == LDKMessageSendEvent_SendTxComplete);
3779 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3780 memcpy(node_id_arr->elems, obj->send_tx_complete.node_id.compressed_form, 33);
3783 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxComplete_get_msg"))) TS_LDKMessageSendEvent_SendTxComplete_get_msg(uint64_t ptr) {
3784 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3785 assert(obj->tag == LDKMessageSendEvent_SendTxComplete);
3786 LDKTxComplete msg_var = obj->send_tx_complete.msg;
3787 uint64_t msg_ref = 0;
3788 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3789 msg_ref = tag_ptr(msg_var.inner, false);
3792 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendTxSignatures_get_node_id(uint64_t ptr) {
3793 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3794 assert(obj->tag == LDKMessageSendEvent_SendTxSignatures);
3795 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3796 memcpy(node_id_arr->elems, obj->send_tx_signatures.node_id.compressed_form, 33);
3799 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxSignatures_get_msg"))) TS_LDKMessageSendEvent_SendTxSignatures_get_msg(uint64_t ptr) {
3800 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3801 assert(obj->tag == LDKMessageSendEvent_SendTxSignatures);
3802 LDKTxSignatures msg_var = obj->send_tx_signatures.msg;
3803 uint64_t msg_ref = 0;
3804 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3805 msg_ref = tag_ptr(msg_var.inner, false);
3808 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id"))) TS_LDKMessageSendEvent_SendTxInitRbf_get_node_id(uint64_t ptr) {
3809 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3810 assert(obj->tag == LDKMessageSendEvent_SendTxInitRbf);
3811 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3812 memcpy(node_id_arr->elems, obj->send_tx_init_rbf.node_id.compressed_form, 33);
3815 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxInitRbf_get_msg"))) TS_LDKMessageSendEvent_SendTxInitRbf_get_msg(uint64_t ptr) {
3816 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3817 assert(obj->tag == LDKMessageSendEvent_SendTxInitRbf);
3818 LDKTxInitRbf msg_var = obj->send_tx_init_rbf.msg;
3819 uint64_t msg_ref = 0;
3820 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3821 msg_ref = tag_ptr(msg_var.inner, false);
3824 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id"))) TS_LDKMessageSendEvent_SendTxAckRbf_get_node_id(uint64_t ptr) {
3825 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3826 assert(obj->tag == LDKMessageSendEvent_SendTxAckRbf);
3827 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3828 memcpy(node_id_arr->elems, obj->send_tx_ack_rbf.node_id.compressed_form, 33);
3831 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAckRbf_get_msg"))) TS_LDKMessageSendEvent_SendTxAckRbf_get_msg(uint64_t ptr) {
3832 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3833 assert(obj->tag == LDKMessageSendEvent_SendTxAckRbf);
3834 LDKTxAckRbf msg_var = obj->send_tx_ack_rbf.msg;
3835 uint64_t msg_ref = 0;
3836 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3837 msg_ref = tag_ptr(msg_var.inner, false);
3840 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAbort_get_node_id"))) TS_LDKMessageSendEvent_SendTxAbort_get_node_id(uint64_t ptr) {
3841 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3842 assert(obj->tag == LDKMessageSendEvent_SendTxAbort);
3843 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3844 memcpy(node_id_arr->elems, obj->send_tx_abort.node_id.compressed_form, 33);
3847 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendTxAbort_get_msg"))) TS_LDKMessageSendEvent_SendTxAbort_get_msg(uint64_t ptr) {
3848 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3849 assert(obj->tag == LDKMessageSendEvent_SendTxAbort);
3850 LDKTxAbort msg_var = obj->send_tx_abort.msg;
3851 uint64_t msg_ref = 0;
3852 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3853 msg_ref = tag_ptr(msg_var.inner, false);
3856 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReady_get_node_id(uint64_t ptr) {
3857 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3858 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3859 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3860 memcpy(node_id_arr->elems, obj->send_channel_ready.node_id.compressed_form, 33);
3863 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_msg"))) TS_LDKMessageSendEvent_SendChannelReady_get_msg(uint64_t ptr) {
3864 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3865 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
3866 LDKChannelReady msg_var = obj->send_channel_ready.msg;
3867 uint64_t msg_ref = 0;
3868 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3869 msg_ref = tag_ptr(msg_var.inner, false);
3872 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(uint64_t ptr) {
3873 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3874 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3875 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3876 memcpy(node_id_arr->elems, obj->send_announcement_signatures.node_id.compressed_form, 33);
3879 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(uint64_t ptr) {
3880 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3881 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
3882 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
3883 uint64_t msg_ref = 0;
3884 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3885 msg_ref = tag_ptr(msg_var.inner, false);
3888 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(uint64_t ptr) {
3889 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3890 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3891 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3892 memcpy(node_id_arr->elems, obj->update_htl_cs.node_id.compressed_form, 33);
3895 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_updates"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(uint64_t ptr) {
3896 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3897 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
3898 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
3899 uint64_t updates_ref = 0;
3900 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
3901 updates_ref = tag_ptr(updates_var.inner, false);
3904 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(uint64_t ptr) {
3905 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3906 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3907 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3908 memcpy(node_id_arr->elems, obj->send_revoke_and_ack.node_id.compressed_form, 33);
3911 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(uint64_t ptr) {
3912 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3913 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
3914 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
3915 uint64_t msg_ref = 0;
3916 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3917 msg_ref = tag_ptr(msg_var.inner, false);
3920 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(uint64_t ptr) {
3921 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3922 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3923 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3924 memcpy(node_id_arr->elems, obj->send_closing_signed.node_id.compressed_form, 33);
3927 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_msg"))) TS_LDKMessageSendEvent_SendClosingSigned_get_msg(uint64_t ptr) {
3928 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3929 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
3930 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
3931 uint64_t msg_ref = 0;
3932 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3933 msg_ref = tag_ptr(msg_var.inner, false);
3936 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_node_id"))) TS_LDKMessageSendEvent_SendShutdown_get_node_id(uint64_t ptr) {
3937 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3938 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3939 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3940 memcpy(node_id_arr->elems, obj->send_shutdown.node_id.compressed_form, 33);
3943 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_msg"))) TS_LDKMessageSendEvent_SendShutdown_get_msg(uint64_t ptr) {
3944 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3945 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
3946 LDKShutdown msg_var = obj->send_shutdown.msg;
3947 uint64_t msg_ref = 0;
3948 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3949 msg_ref = tag_ptr(msg_var.inner, false);
3952 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(uint64_t ptr) {
3953 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3954 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3955 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3956 memcpy(node_id_arr->elems, obj->send_channel_reestablish.node_id.compressed_form, 33);
3959 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_msg"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(uint64_t ptr) {
3960 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3961 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
3962 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
3963 uint64_t msg_ref = 0;
3964 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3965 msg_ref = tag_ptr(msg_var.inner, false);
3968 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_node_id(uint64_t ptr) {
3969 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3970 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3971 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
3972 memcpy(node_id_arr->elems, obj->send_channel_announcement.node_id.compressed_form, 33);
3975 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_msg(uint64_t ptr) {
3976 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3977 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3978 LDKChannelAnnouncement msg_var = obj->send_channel_announcement.msg;
3979 uint64_t msg_ref = 0;
3980 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3981 msg_ref = tag_ptr(msg_var.inner, false);
3984 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_SendChannelAnnouncement_get_update_msg(uint64_t ptr) {
3985 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3986 assert(obj->tag == LDKMessageSendEvent_SendChannelAnnouncement);
3987 LDKChannelUpdate update_msg_var = obj->send_channel_announcement.update_msg;
3988 uint64_t update_msg_ref = 0;
3989 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
3990 update_msg_ref = tag_ptr(update_msg_var.inner, false);
3991 return update_msg_ref;
3993 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(uint64_t ptr) {
3994 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
3995 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
3996 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
3997 uint64_t msg_ref = 0;
3998 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
3999 msg_ref = tag_ptr(msg_var.inner, false);
4002 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(uint64_t ptr) {
4003 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4004 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
4005 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
4006 uint64_t update_msg_ref = 0;
4007 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
4008 update_msg_ref = tag_ptr(update_msg_var.inner, false);
4009 return update_msg_ref;
4011 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(uint64_t ptr) {
4012 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4013 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelUpdate);
4014 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
4015 uint64_t msg_ref = 0;
4016 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4017 msg_ref = tag_ptr(msg_var.inner, false);
4020 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(uint64_t ptr) {
4021 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4022 assert(obj->tag == LDKMessageSendEvent_BroadcastNodeAnnouncement);
4023 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
4024 uint64_t msg_ref = 0;
4025 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4026 msg_ref = tag_ptr(msg_var.inner, false);
4029 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(uint64_t ptr) {
4030 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4031 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
4032 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4033 memcpy(node_id_arr->elems, obj->send_channel_update.node_id.compressed_form, 33);
4036 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(uint64_t ptr) {
4037 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4038 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
4039 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
4040 uint64_t msg_ref = 0;
4041 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4042 msg_ref = tag_ptr(msg_var.inner, false);
4045 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_node_id"))) TS_LDKMessageSendEvent_HandleError_get_node_id(uint64_t ptr) {
4046 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4047 assert(obj->tag == LDKMessageSendEvent_HandleError);
4048 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4049 memcpy(node_id_arr->elems, obj->handle_error.node_id.compressed_form, 33);
4052 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_action"))) TS_LDKMessageSendEvent_HandleError_get_action(uint64_t ptr) {
4053 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4054 assert(obj->tag == LDKMessageSendEvent_HandleError);
4055 uint64_t action_ref = tag_ptr(&obj->handle_error.action, false);
4058 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(uint64_t ptr) {
4059 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4060 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
4061 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4062 memcpy(node_id_arr->elems, obj->send_channel_range_query.node_id.compressed_form, 33);
4065 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(uint64_t ptr) {
4066 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4067 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
4068 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
4069 uint64_t msg_ref = 0;
4070 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4071 msg_ref = tag_ptr(msg_var.inner, false);
4074 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(uint64_t ptr) {
4075 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4076 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
4077 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4078 memcpy(node_id_arr->elems, obj->send_short_ids_query.node_id.compressed_form, 33);
4081 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(uint64_t ptr) {
4082 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4083 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
4084 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
4085 uint64_t msg_ref = 0;
4086 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4087 msg_ref = tag_ptr(msg_var.inner, false);
4090 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(uint64_t ptr) {
4091 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4092 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
4093 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4094 memcpy(node_id_arr->elems, obj->send_reply_channel_range.node_id.compressed_form, 33);
4097 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(uint64_t ptr) {
4098 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4099 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
4100 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
4101 uint64_t msg_ref = 0;
4102 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4103 msg_ref = tag_ptr(msg_var.inner, false);
4106 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(uint64_t ptr) {
4107 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4108 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
4109 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
4110 memcpy(node_id_arr->elems, obj->send_gossip_timestamp_filter.node_id.compressed_form, 33);
4113 uint64_t __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(uint64_t ptr) {
4114 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)untag_ptr(ptr);
4115 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
4116 LDKGossipTimestampFilter msg_var = obj->send_gossip_timestamp_filter.msg;
4117 uint64_t msg_ref = 0;
4118 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4119 msg_ref = tag_ptr(msg_var.inner, false);
4122 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
4123 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
4124 for (size_t i = 0; i < ret.datalen; i++) {
4125 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
4129 static inline struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
4130 LDKChannelUpdateInfo ret = *owner->contents.result;
4131 ret.is_owned = false;
4134 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(uint64_t owner) {
4135 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
4136 LDKChannelUpdateInfo ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner_conv);
4137 uint64_t ret_ref = 0;
4138 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4139 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4143 static inline struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
4144 CHECK(!owner->result_ok);
4145 return DecodeError_clone(&*owner->contents.err);
4147 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(uint64_t owner) {
4148 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(owner);
4149 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4150 *ret_copy = CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner_conv);
4151 uint64_t ret_ref = tag_ptr(ret_copy, true);
4155 static inline struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
4156 LDKChannelInfo ret = *owner->contents.result;
4157 ret.is_owned = false;
4160 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_get_ok(uint64_t owner) {
4161 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
4162 LDKChannelInfo ret_var = CResult_ChannelInfoDecodeErrorZ_get_ok(owner_conv);
4163 uint64_t ret_ref = 0;
4164 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4165 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4169 static inline struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
4170 CHECK(!owner->result_ok);
4171 return DecodeError_clone(&*owner->contents.err);
4173 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelInfoDecodeErrorZ_get_err(uint64_t owner) {
4174 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(owner);
4175 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4176 *ret_copy = CResult_ChannelInfoDecodeErrorZ_get_err(owner_conv);
4177 uint64_t ret_ref = tag_ptr(ret_copy, true);
4181 static inline struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
4182 LDKRoutingFees ret = *owner->contents.result;
4183 ret.is_owned = false;
4186 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_get_ok(uint64_t owner) {
4187 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
4188 LDKRoutingFees ret_var = CResult_RoutingFeesDecodeErrorZ_get_ok(owner_conv);
4189 uint64_t ret_ref = 0;
4190 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4191 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4195 static inline struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
4196 CHECK(!owner->result_ok);
4197 return DecodeError_clone(&*owner->contents.err);
4199 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_err"))) TS_CResult_RoutingFeesDecodeErrorZ_get_err(uint64_t owner) {
4200 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(owner);
4201 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4202 *ret_copy = CResult_RoutingFeesDecodeErrorZ_get_err(owner_conv);
4203 uint64_t ret_ref = tag_ptr(ret_copy, true);
4207 uint32_t __attribute__((export_name("TS_LDKSocketAddress_ty_from_ptr"))) TS_LDKSocketAddress_ty_from_ptr(uint64_t ptr) {
4208 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4210 case LDKSocketAddress_TcpIpV4: return 0;
4211 case LDKSocketAddress_TcpIpV6: return 1;
4212 case LDKSocketAddress_OnionV2: return 2;
4213 case LDKSocketAddress_OnionV3: return 3;
4214 case LDKSocketAddress_Hostname: return 4;
4218 int8_tArray __attribute__((export_name("TS_LDKSocketAddress_TcpIpV4_get_addr"))) TS_LDKSocketAddress_TcpIpV4_get_addr(uint64_t ptr) {
4219 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4220 assert(obj->tag == LDKSocketAddress_TcpIpV4);
4221 int8_tArray addr_arr = init_int8_tArray(4, __LINE__);
4222 memcpy(addr_arr->elems, obj->tcp_ip_v4.addr.data, 4);
4225 int16_t __attribute__((export_name("TS_LDKSocketAddress_TcpIpV4_get_port"))) TS_LDKSocketAddress_TcpIpV4_get_port(uint64_t ptr) {
4226 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4227 assert(obj->tag == LDKSocketAddress_TcpIpV4);
4228 int16_t port_conv = obj->tcp_ip_v4.port;
4231 int8_tArray __attribute__((export_name("TS_LDKSocketAddress_TcpIpV6_get_addr"))) TS_LDKSocketAddress_TcpIpV6_get_addr(uint64_t ptr) {
4232 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4233 assert(obj->tag == LDKSocketAddress_TcpIpV6);
4234 int8_tArray addr_arr = init_int8_tArray(16, __LINE__);
4235 memcpy(addr_arr->elems, obj->tcp_ip_v6.addr.data, 16);
4238 int16_t __attribute__((export_name("TS_LDKSocketAddress_TcpIpV6_get_port"))) TS_LDKSocketAddress_TcpIpV6_get_port(uint64_t ptr) {
4239 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4240 assert(obj->tag == LDKSocketAddress_TcpIpV6);
4241 int16_t port_conv = obj->tcp_ip_v6.port;
4244 int8_tArray __attribute__((export_name("TS_LDKSocketAddress_OnionV2_get_onion_v2"))) TS_LDKSocketAddress_OnionV2_get_onion_v2(uint64_t ptr) {
4245 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4246 assert(obj->tag == LDKSocketAddress_OnionV2);
4247 int8_tArray onion_v2_arr = init_int8_tArray(12, __LINE__);
4248 memcpy(onion_v2_arr->elems, obj->onion_v2.data, 12);
4249 return onion_v2_arr;
4251 int8_tArray __attribute__((export_name("TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey"))) TS_LDKSocketAddress_OnionV3_get_ed25519_pubkey(uint64_t ptr) {
4252 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4253 assert(obj->tag == LDKSocketAddress_OnionV3);
4254 int8_tArray ed25519_pubkey_arr = init_int8_tArray(32, __LINE__);
4255 memcpy(ed25519_pubkey_arr->elems, obj->onion_v3.ed25519_pubkey.data, 32);
4256 return ed25519_pubkey_arr;
4258 int16_t __attribute__((export_name("TS_LDKSocketAddress_OnionV3_get_checksum"))) TS_LDKSocketAddress_OnionV3_get_checksum(uint64_t ptr) {
4259 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4260 assert(obj->tag == LDKSocketAddress_OnionV3);
4261 int16_t checksum_conv = obj->onion_v3.checksum;
4262 return checksum_conv;
4264 int8_t __attribute__((export_name("TS_LDKSocketAddress_OnionV3_get_version"))) TS_LDKSocketAddress_OnionV3_get_version(uint64_t ptr) {
4265 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4266 assert(obj->tag == LDKSocketAddress_OnionV3);
4267 int8_t version_conv = obj->onion_v3.version;
4268 return version_conv;
4270 int16_t __attribute__((export_name("TS_LDKSocketAddress_OnionV3_get_port"))) TS_LDKSocketAddress_OnionV3_get_port(uint64_t ptr) {
4271 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4272 assert(obj->tag == LDKSocketAddress_OnionV3);
4273 int16_t port_conv = obj->onion_v3.port;
4276 uint64_t __attribute__((export_name("TS_LDKSocketAddress_Hostname_get_hostname"))) TS_LDKSocketAddress_Hostname_get_hostname(uint64_t ptr) {
4277 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4278 assert(obj->tag == LDKSocketAddress_Hostname);
4279 LDKHostname hostname_var = obj->hostname.hostname;
4280 uint64_t hostname_ref = 0;
4281 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_var);
4282 hostname_ref = tag_ptr(hostname_var.inner, false);
4283 return hostname_ref;
4285 int16_t __attribute__((export_name("TS_LDKSocketAddress_Hostname_get_port"))) TS_LDKSocketAddress_Hostname_get_port(uint64_t ptr) {
4286 LDKSocketAddress *obj = (LDKSocketAddress*)untag_ptr(ptr);
4287 assert(obj->tag == LDKSocketAddress_Hostname);
4288 int16_t port_conv = obj->hostname.port;
4291 static inline LDKCVec_SocketAddressZ CVec_SocketAddressZ_clone(const LDKCVec_SocketAddressZ *orig) {
4292 LDKCVec_SocketAddressZ ret = { .data = MALLOC(sizeof(LDKSocketAddress) * orig->datalen, "LDKCVec_SocketAddressZ clone bytes"), .datalen = orig->datalen };
4293 for (size_t i = 0; i < ret.datalen; i++) {
4294 ret.data[i] = SocketAddress_clone(&orig->data[i]);
4298 static inline struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
4299 LDKNodeAnnouncementInfo ret = *owner->contents.result;
4300 ret.is_owned = false;
4303 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint64_t owner) {
4304 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
4305 LDKNodeAnnouncementInfo ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner_conv);
4306 uint64_t ret_ref = 0;
4307 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4308 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4312 static inline struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
4313 CHECK(!owner->result_ok);
4314 return DecodeError_clone(&*owner->contents.err);
4316 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint64_t owner) {
4317 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(owner);
4318 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4319 *ret_copy = CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner_conv);
4320 uint64_t ret_ref = tag_ptr(ret_copy, true);
4324 static inline struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
4325 LDKNodeAlias ret = *owner->contents.result;
4326 ret.is_owned = false;
4329 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_ok"))) TS_CResult_NodeAliasDecodeErrorZ_get_ok(uint64_t owner) {
4330 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
4331 LDKNodeAlias ret_var = CResult_NodeAliasDecodeErrorZ_get_ok(owner_conv);
4332 uint64_t ret_ref = 0;
4333 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4334 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4338 static inline struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
4339 CHECK(!owner->result_ok);
4340 return DecodeError_clone(&*owner->contents.err);
4342 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_err"))) TS_CResult_NodeAliasDecodeErrorZ_get_err(uint64_t owner) {
4343 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(owner);
4344 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4345 *ret_copy = CResult_NodeAliasDecodeErrorZ_get_err(owner_conv);
4346 uint64_t ret_ref = tag_ptr(ret_copy, true);
4350 static inline struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
4351 LDKNodeInfo ret = *owner->contents.result;
4352 ret.is_owned = false;
4355 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeInfoDecodeErrorZ_get_ok(uint64_t owner) {
4356 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
4357 LDKNodeInfo ret_var = CResult_NodeInfoDecodeErrorZ_get_ok(owner_conv);
4358 uint64_t ret_ref = 0;
4359 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4360 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4364 static inline struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
4365 CHECK(!owner->result_ok);
4366 return DecodeError_clone(&*owner->contents.err);
4368 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_err"))) TS_CResult_NodeInfoDecodeErrorZ_get_err(uint64_t owner) {
4369 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(owner);
4370 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4371 *ret_copy = CResult_NodeInfoDecodeErrorZ_get_err(owner_conv);
4372 uint64_t ret_ref = tag_ptr(ret_copy, true);
4376 static inline struct LDKNetworkGraph CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
4377 LDKNetworkGraph ret = *owner->contents.result;
4378 ret.is_owned = false;
4381 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_get_ok(uint64_t owner) {
4382 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
4383 LDKNetworkGraph ret_var = CResult_NetworkGraphDecodeErrorZ_get_ok(owner_conv);
4384 uint64_t ret_ref = 0;
4385 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4386 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4390 static inline struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
4391 CHECK(!owner->result_ok);
4392 return DecodeError_clone(&*owner->contents.err);
4394 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_err"))) TS_CResult_NetworkGraphDecodeErrorZ_get_err(uint64_t owner) {
4395 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(owner);
4396 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4397 *ret_copy = CResult_NetworkGraphDecodeErrorZ_get_err(owner_conv);
4398 uint64_t ret_ref = tag_ptr(ret_copy, true);
4402 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr"))) TS_LDKCOption_CVec_SocketAddressZZ_ty_from_ptr(uint64_t ptr) {
4403 LDKCOption_CVec_SocketAddressZZ *obj = (LDKCOption_CVec_SocketAddressZZ*)untag_ptr(ptr);
4405 case LDKCOption_CVec_SocketAddressZZ_Some: return 0;
4406 case LDKCOption_CVec_SocketAddressZZ_None: return 1;
4410 uint64_tArray __attribute__((export_name("TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some"))) TS_LDKCOption_CVec_SocketAddressZZ_Some_get_some(uint64_t ptr) {
4411 LDKCOption_CVec_SocketAddressZZ *obj = (LDKCOption_CVec_SocketAddressZZ*)untag_ptr(ptr);
4412 assert(obj->tag == LDKCOption_CVec_SocketAddressZZ_Some);
4413 LDKCVec_SocketAddressZ some_var = obj->some;
4414 uint64_tArray some_arr = NULL;
4415 some_arr = init_uint64_tArray(some_var.datalen, __LINE__);
4416 uint64_t *some_arr_ptr = (uint64_t*)(((uint8_t*)some_arr) + 8);
4417 for (size_t p = 0; p < some_var.datalen; p++) {
4418 uint64_t some_conv_15_ref = tag_ptr(&some_var.data[p], false);
4419 some_arr_ptr[p] = some_conv_15_ref;
4424 static inline struct LDKChannelDerivationParameters CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner){
4425 LDKChannelDerivationParameters ret = *owner->contents.result;
4426 ret.is_owned = false;
4429 uint64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(uint64_t owner) {
4430 LDKCResult_ChannelDerivationParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelDerivationParametersDecodeErrorZ*)untag_ptr(owner);
4431 LDKChannelDerivationParameters ret_var = CResult_ChannelDerivationParametersDecodeErrorZ_get_ok(owner_conv);
4432 uint64_t ret_ref = 0;
4433 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4434 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4438 static inline struct LDKDecodeError CResult_ChannelDerivationParametersDecodeErrorZ_get_err(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR owner){
4439 CHECK(!owner->result_ok);
4440 return DecodeError_clone(&*owner->contents.err);
4442 uint64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_get_err(uint64_t owner) {
4443 LDKCResult_ChannelDerivationParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelDerivationParametersDecodeErrorZ*)untag_ptr(owner);
4444 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4445 *ret_copy = CResult_ChannelDerivationParametersDecodeErrorZ_get_err(owner_conv);
4446 uint64_t ret_ref = tag_ptr(ret_copy, true);
4450 static inline struct LDKHTLCDescriptor CResult_HTLCDescriptorDecodeErrorZ_get_ok(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner){
4451 LDKHTLCDescriptor ret = *owner->contents.result;
4452 ret.is_owned = false;
4455 uint64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok"))) TS_CResult_HTLCDescriptorDecodeErrorZ_get_ok(uint64_t owner) {
4456 LDKCResult_HTLCDescriptorDecodeErrorZ* owner_conv = (LDKCResult_HTLCDescriptorDecodeErrorZ*)untag_ptr(owner);
4457 LDKHTLCDescriptor ret_var = CResult_HTLCDescriptorDecodeErrorZ_get_ok(owner_conv);
4458 uint64_t ret_ref = 0;
4459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4464 static inline struct LDKDecodeError CResult_HTLCDescriptorDecodeErrorZ_get_err(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR owner){
4465 CHECK(!owner->result_ok);
4466 return DecodeError_clone(&*owner->contents.err);
4468 uint64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_get_err"))) TS_CResult_HTLCDescriptorDecodeErrorZ_get_err(uint64_t owner) {
4469 LDKCResult_HTLCDescriptorDecodeErrorZ* owner_conv = (LDKCResult_HTLCDescriptorDecodeErrorZ*)untag_ptr(owner);
4470 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
4471 *ret_copy = CResult_HTLCDescriptorDecodeErrorZ_get_err(owner_conv);
4472 uint64_t ret_ref = tag_ptr(ret_copy, true);
4476 static inline LDKCVec_HTLCOutputInCommitmentZ CVec_HTLCOutputInCommitmentZ_clone(const LDKCVec_HTLCOutputInCommitmentZ *orig) {
4477 LDKCVec_HTLCOutputInCommitmentZ ret = { .data = MALLOC(sizeof(LDKHTLCOutputInCommitment) * orig->datalen, "LDKCVec_HTLCOutputInCommitmentZ clone bytes"), .datalen = orig->datalen };
4478 for (size_t i = 0; i < ret.datalen; i++) {
4479 ret.data[i] = HTLCOutputInCommitment_clone(&orig->data[i]);
4483 static inline LDKCVec_HTLCDescriptorZ CVec_HTLCDescriptorZ_clone(const LDKCVec_HTLCDescriptorZ *orig) {
4484 LDKCVec_HTLCDescriptorZ ret = { .data = MALLOC(sizeof(LDKHTLCDescriptor) * orig->datalen, "LDKCVec_HTLCDescriptorZ clone bytes"), .datalen = orig->datalen };
4485 for (size_t i = 0; i < ret.datalen; i++) {
4486 ret.data[i] = HTLCDescriptor_clone(&orig->data[i]);
4490 static inline LDKCVec_UtxoZ CVec_UtxoZ_clone(const LDKCVec_UtxoZ *orig) {
4491 LDKCVec_UtxoZ ret = { .data = MALLOC(sizeof(LDKUtxo) * orig->datalen, "LDKCVec_UtxoZ clone bytes"), .datalen = orig->datalen };
4492 for (size_t i = 0; i < ret.datalen; i++) {
4493 ret.data[i] = Utxo_clone(&orig->data[i]);
4497 uint32_t __attribute__((export_name("TS_LDKCOption_TxOutZ_ty_from_ptr"))) TS_LDKCOption_TxOutZ_ty_from_ptr(uint64_t ptr) {
4498 LDKCOption_TxOutZ *obj = (LDKCOption_TxOutZ*)untag_ptr(ptr);
4500 case LDKCOption_TxOutZ_Some: return 0;
4501 case LDKCOption_TxOutZ_None: return 1;
4505 uint64_t __attribute__((export_name("TS_LDKCOption_TxOutZ_Some_get_some"))) TS_LDKCOption_TxOutZ_Some_get_some(uint64_t ptr) {
4506 LDKCOption_TxOutZ *obj = (LDKCOption_TxOutZ*)untag_ptr(ptr);
4507 assert(obj->tag == LDKCOption_TxOutZ_Some);
4508 LDKTxOut* some_ref = &obj->some;
4509 return tag_ptr(some_ref, false);
4511 static inline LDKCVec_InputZ CVec_InputZ_clone(const LDKCVec_InputZ *orig) {
4512 LDKCVec_InputZ ret = { .data = MALLOC(sizeof(LDKInput) * orig->datalen, "LDKCVec_InputZ clone bytes"), .datalen = orig->datalen };
4513 for (size_t i = 0; i < ret.datalen; i++) {
4514 ret.data[i] = Input_clone(&orig->data[i]);
4518 static inline struct LDKCoinSelection CResult_CoinSelectionNoneZ_get_ok(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner){
4519 LDKCoinSelection ret = *owner->contents.result;
4520 ret.is_owned = false;
4523 uint64_t __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_get_ok"))) TS_CResult_CoinSelectionNoneZ_get_ok(uint64_t owner) {
4524 LDKCResult_CoinSelectionNoneZ* owner_conv = (LDKCResult_CoinSelectionNoneZ*)untag_ptr(owner);
4525 LDKCoinSelection ret_var = CResult_CoinSelectionNoneZ_get_ok(owner_conv);
4526 uint64_t ret_ref = 0;
4527 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4528 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
4532 static inline void CResult_CoinSelectionNoneZ_get_err(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR owner){
4533 CHECK(!owner->result_ok);
4534 return *owner->contents.err;
4536 void __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_get_err"))) TS_CResult_CoinSelectionNoneZ_get_err(uint64_t owner) {
4537 LDKCResult_CoinSelectionNoneZ* owner_conv = (LDKCResult_CoinSelectionNoneZ*)untag_ptr(owner);
4538 CResult_CoinSelectionNoneZ_get_err(owner_conv);
4541 static inline struct LDKCVec_UtxoZ CResult_CVec_UtxoZNoneZ_get_ok(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner){
4542 CHECK(owner->result_ok);
4543 return CVec_UtxoZ_clone(&*owner->contents.result);
4545 uint64_tArray __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_get_ok"))) TS_CResult_CVec_UtxoZNoneZ_get_ok(uint64_t owner) {
4546 LDKCResult_CVec_UtxoZNoneZ* owner_conv = (LDKCResult_CVec_UtxoZNoneZ*)untag_ptr(owner);
4547 LDKCVec_UtxoZ ret_var = CResult_CVec_UtxoZNoneZ_get_ok(owner_conv);
4548 uint64_tArray ret_arr = NULL;
4549 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
4550 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
4551 for (size_t g = 0; g < ret_var.datalen; g++) {
4552 LDKUtxo ret_conv_6_var = ret_var.data[g];
4553 uint64_t ret_conv_6_ref = 0;
4554 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_6_var);
4555 ret_conv_6_ref = tag_ptr(ret_conv_6_var.inner, ret_conv_6_var.is_owned);
4556 ret_arr_ptr[g] = ret_conv_6_ref;
4563 static inline void CResult_CVec_UtxoZNoneZ_get_err(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR owner){
4564 CHECK(!owner->result_ok);
4565 return *owner->contents.err;
4567 void __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_get_err"))) TS_CResult_CVec_UtxoZNoneZ_get_err(uint64_t owner) {
4568 LDKCResult_CVec_UtxoZNoneZ* owner_conv = (LDKCResult_CVec_UtxoZNoneZ*)untag_ptr(owner);
4569 CResult_CVec_UtxoZNoneZ_get_err(owner_conv);
4572 static inline uint64_t C2Tuple_u64u16Z_get_a(LDKC2Tuple_u64u16Z *NONNULL_PTR owner){
4575 int64_t __attribute__((export_name("TS_C2Tuple_u64u16Z_get_a"))) TS_C2Tuple_u64u16Z_get_a(uint64_t owner) {
4576 LDKC2Tuple_u64u16Z* owner_conv = (LDKC2Tuple_u64u16Z*)untag_ptr(owner);
4577 int64_t ret_conv = C2Tuple_u64u16Z_get_a(owner_conv);
4581 static inline uint16_t C2Tuple_u64u16Z_get_b(LDKC2Tuple_u64u16Z *NONNULL_PTR owner){
4584 int16_t __attribute__((export_name("TS_C2Tuple_u64u16Z_get_b"))) TS_C2Tuple_u64u16Z_get_b(uint64_t owner) {
4585 LDKC2Tuple_u64u16Z* owner_conv = (LDKC2Tuple_u64u16Z*)untag_ptr(owner);
4586 int16_t ret_conv = C2Tuple_u64u16Z_get_b(owner_conv);
4590 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u16ZZ_ty_from_ptr(uint64_t ptr) {
4591 LDKCOption_C2Tuple_u64u16ZZ *obj = (LDKCOption_C2Tuple_u64u16ZZ*)untag_ptr(ptr);
4593 case LDKCOption_C2Tuple_u64u16ZZ_Some: return 0;
4594 case LDKCOption_C2Tuple_u64u16ZZ_None: return 1;
4598 uint64_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u16ZZ_Some_get_some(uint64_t ptr) {
4599 LDKCOption_C2Tuple_u64u16ZZ *obj = (LDKCOption_C2Tuple_u64u16ZZ*)untag_ptr(ptr);
4600 assert(obj->tag == LDKCOption_C2Tuple_u64u16ZZ_Some);
4601 LDKC2Tuple_u64u16Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u16Z), "LDKC2Tuple_u64u16Z");
4602 *some_conv = obj->some;
4603 *some_conv = C2Tuple_u64u16Z_clone(some_conv);
4604 return tag_ptr(some_conv, true);
4606 uint32_t __attribute__((export_name("TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr"))) TS_LDKCOption_ChannelShutdownStateZ_ty_from_ptr(uint64_t ptr) {
4607 LDKCOption_ChannelShutdownStateZ *obj = (LDKCOption_ChannelShutdownStateZ*)untag_ptr(ptr);
4609 case LDKCOption_ChannelShutdownStateZ_Some: return 0;
4610 case LDKCOption_ChannelShutdownStateZ_None: return 1;
4614 uint32_t __attribute__((export_name("TS_LDKCOption_ChannelShutdownStateZ_Some_get_some"))) TS_LDKCOption_ChannelShutdownStateZ_Some_get_some(uint64_t ptr) {
4615 LDKCOption_ChannelShutdownStateZ *obj = (LDKCOption_ChannelShutdownStateZ*)untag_ptr(ptr);
4616 assert(obj->tag == LDKCOption_ChannelShutdownStateZ_Some);
4617 uint32_t some_conv = LDKChannelShutdownState_to_js(obj->some);
4620 static inline struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesAPIErrorZ_get_ok(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner){
4621 CHECK(owner->result_ok);
4622 return ThirtyTwoBytes_clone(&*owner->contents.result);
4624 int8_tArray __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_get_ok(uint64_t owner) {
4625 LDKCResult_ThirtyTwoBytesAPIErrorZ* owner_conv = (LDKCResult_ThirtyTwoBytesAPIErrorZ*)untag_ptr(owner);
4626 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4627 memcpy(ret_arr->elems, CResult_ThirtyTwoBytesAPIErrorZ_get_ok(owner_conv).data, 32);
4631 static inline struct LDKAPIError CResult_ThirtyTwoBytesAPIErrorZ_get_err(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR owner){
4632 CHECK(!owner->result_ok);
4633 return APIError_clone(&*owner->contents.err);
4635 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_get_err(uint64_t owner) {
4636 LDKCResult_ThirtyTwoBytesAPIErrorZ* owner_conv = (LDKCResult_ThirtyTwoBytesAPIErrorZ*)untag_ptr(owner);
4637 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4638 *ret_copy = CResult_ThirtyTwoBytesAPIErrorZ_get_err(owner_conv);
4639 uint64_t ret_ref = tag_ptr(ret_copy, true);
4643 uint32_t __attribute__((export_name("TS_LDKRecentPaymentDetails_ty_from_ptr"))) TS_LDKRecentPaymentDetails_ty_from_ptr(uint64_t ptr) {
4644 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4646 case LDKRecentPaymentDetails_AwaitingInvoice: return 0;
4647 case LDKRecentPaymentDetails_Pending: return 1;
4648 case LDKRecentPaymentDetails_Fulfilled: return 2;
4649 case LDKRecentPaymentDetails_Abandoned: return 3;
4653 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id"))) TS_LDKRecentPaymentDetails_AwaitingInvoice_get_payment_id(uint64_t ptr) {
4654 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4655 assert(obj->tag == LDKRecentPaymentDetails_AwaitingInvoice);
4656 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4657 memcpy(payment_id_arr->elems, obj->awaiting_invoice.payment_id.data, 32);
4658 return payment_id_arr;
4660 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_payment_id"))) TS_LDKRecentPaymentDetails_Pending_get_payment_id(uint64_t ptr) {
4661 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4662 assert(obj->tag == LDKRecentPaymentDetails_Pending);
4663 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4664 memcpy(payment_id_arr->elems, obj->pending.payment_id.data, 32);
4665 return payment_id_arr;
4667 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_payment_hash"))) TS_LDKRecentPaymentDetails_Pending_get_payment_hash(uint64_t ptr) {
4668 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4669 assert(obj->tag == LDKRecentPaymentDetails_Pending);
4670 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
4671 memcpy(payment_hash_arr->elems, obj->pending.payment_hash.data, 32);
4672 return payment_hash_arr;
4674 int64_t __attribute__((export_name("TS_LDKRecentPaymentDetails_Pending_get_total_msat"))) TS_LDKRecentPaymentDetails_Pending_get_total_msat(uint64_t ptr) {
4675 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4676 assert(obj->tag == LDKRecentPaymentDetails_Pending);
4677 int64_t total_msat_conv = obj->pending.total_msat;
4678 return total_msat_conv;
4680 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id"))) TS_LDKRecentPaymentDetails_Fulfilled_get_payment_id(uint64_t ptr) {
4681 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4682 assert(obj->tag == LDKRecentPaymentDetails_Fulfilled);
4683 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4684 memcpy(payment_id_arr->elems, obj->fulfilled.payment_id.data, 32);
4685 return payment_id_arr;
4687 uint64_t __attribute__((export_name("TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash"))) TS_LDKRecentPaymentDetails_Fulfilled_get_payment_hash(uint64_t ptr) {
4688 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4689 assert(obj->tag == LDKRecentPaymentDetails_Fulfilled);
4690 uint64_t payment_hash_ref = tag_ptr(&obj->fulfilled.payment_hash, false);
4691 return payment_hash_ref;
4693 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Abandoned_get_payment_id"))) TS_LDKRecentPaymentDetails_Abandoned_get_payment_id(uint64_t ptr) {
4694 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4695 assert(obj->tag == LDKRecentPaymentDetails_Abandoned);
4696 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4697 memcpy(payment_id_arr->elems, obj->abandoned.payment_id.data, 32);
4698 return payment_id_arr;
4700 int8_tArray __attribute__((export_name("TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash"))) TS_LDKRecentPaymentDetails_Abandoned_get_payment_hash(uint64_t ptr) {
4701 LDKRecentPaymentDetails *obj = (LDKRecentPaymentDetails*)untag_ptr(ptr);
4702 assert(obj->tag == LDKRecentPaymentDetails_Abandoned);
4703 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
4704 memcpy(payment_hash_arr->elems, obj->abandoned.payment_hash.data, 32);
4705 return payment_hash_arr;
4707 static inline LDKCVec_RecentPaymentDetailsZ CVec_RecentPaymentDetailsZ_clone(const LDKCVec_RecentPaymentDetailsZ *orig) {
4708 LDKCVec_RecentPaymentDetailsZ ret = { .data = MALLOC(sizeof(LDKRecentPaymentDetails) * orig->datalen, "LDKCVec_RecentPaymentDetailsZ clone bytes"), .datalen = orig->datalen };
4709 for (size_t i = 0; i < ret.datalen; i++) {
4710 ret.data[i] = RecentPaymentDetails_clone(&orig->data[i]);
4714 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ty_from_ptr"))) TS_LDKPaymentSendFailure_ty_from_ptr(uint64_t ptr) {
4715 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4717 case LDKPaymentSendFailure_ParameterError: return 0;
4718 case LDKPaymentSendFailure_PathParameterError: return 1;
4719 case LDKPaymentSendFailure_AllFailedResendSafe: return 2;
4720 case LDKPaymentSendFailure_DuplicatePayment: return 3;
4721 case LDKPaymentSendFailure_PartialFailure: return 4;
4725 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_ParameterError_get_parameter_error"))) TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(uint64_t ptr) {
4726 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4727 assert(obj->tag == LDKPaymentSendFailure_ParameterError);
4728 uint64_t parameter_error_ref = tag_ptr(&obj->parameter_error, false);
4729 return parameter_error_ref;
4731 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error"))) TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(uint64_t ptr) {
4732 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4733 assert(obj->tag == LDKPaymentSendFailure_PathParameterError);
4734 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
4735 uint64_tArray path_parameter_error_arr = NULL;
4736 path_parameter_error_arr = init_uint64_tArray(path_parameter_error_var.datalen, __LINE__);
4737 uint64_t *path_parameter_error_arr_ptr = (uint64_t*)(((uint8_t*)path_parameter_error_arr) + 8);
4738 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
4739 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4740 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
4741 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
4742 path_parameter_error_arr_ptr[w] = tag_ptr(path_parameter_error_conv_22_conv, true);
4745 return path_parameter_error_arr;
4747 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe"))) TS_LDKPaymentSendFailure_AllFailedResendSafe_get_all_failed_resend_safe(uint64_t ptr) {
4748 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4749 assert(obj->tag == LDKPaymentSendFailure_AllFailedResendSafe);
4750 LDKCVec_APIErrorZ all_failed_resend_safe_var = obj->all_failed_resend_safe;
4751 uint64_tArray all_failed_resend_safe_arr = NULL;
4752 all_failed_resend_safe_arr = init_uint64_tArray(all_failed_resend_safe_var.datalen, __LINE__);
4753 uint64_t *all_failed_resend_safe_arr_ptr = (uint64_t*)(((uint8_t*)all_failed_resend_safe_arr) + 8);
4754 for (size_t k = 0; k < all_failed_resend_safe_var.datalen; k++) {
4755 uint64_t all_failed_resend_safe_conv_10_ref = tag_ptr(&all_failed_resend_safe_var.data[k], false);
4756 all_failed_resend_safe_arr_ptr[k] = all_failed_resend_safe_conv_10_ref;
4759 return all_failed_resend_safe_arr;
4761 uint64_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_results"))) TS_LDKPaymentSendFailure_PartialFailure_get_results(uint64_t ptr) {
4762 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4763 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4764 LDKCVec_CResult_NoneAPIErrorZZ results_var = obj->partial_failure.results;
4765 uint64_tArray results_arr = NULL;
4766 results_arr = init_uint64_tArray(results_var.datalen, __LINE__);
4767 uint64_t *results_arr_ptr = (uint64_t*)(((uint8_t*)results_arr) + 8);
4768 for (size_t w = 0; w < results_var.datalen; w++) {
4769 LDKCResult_NoneAPIErrorZ* results_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4770 *results_conv_22_conv = results_var.data[w];
4771 *results_conv_22_conv = CResult_NoneAPIErrorZ_clone(results_conv_22_conv);
4772 results_arr_ptr[w] = tag_ptr(results_conv_22_conv, true);
4777 uint64_t __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry"))) TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(uint64_t ptr) {
4778 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4779 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4780 LDKRouteParameters failed_paths_retry_var = obj->partial_failure.failed_paths_retry;
4781 uint64_t failed_paths_retry_ref = 0;
4782 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
4783 failed_paths_retry_ref = tag_ptr(failed_paths_retry_var.inner, false);
4784 return failed_paths_retry_ref;
4786 int8_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_payment_id"))) TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(uint64_t ptr) {
4787 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)untag_ptr(ptr);
4788 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4789 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4790 memcpy(payment_id_arr->elems, obj->partial_failure.payment_id.data, 32);
4791 return payment_id_arr;
4793 static inline void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4794 CHECK(owner->result_ok);
4795 return *owner->contents.result;
4797 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_ok"))) TS_CResult_NonePaymentSendFailureZ_get_ok(uint64_t owner) {
4798 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
4799 CResult_NonePaymentSendFailureZ_get_ok(owner_conv);
4802 static inline struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4803 CHECK(!owner->result_ok);
4804 return PaymentSendFailure_clone(&*owner->contents.err);
4806 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_err"))) TS_CResult_NonePaymentSendFailureZ_get_err(uint64_t owner) {
4807 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(owner);
4808 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4809 *ret_copy = CResult_NonePaymentSendFailureZ_get_err(owner_conv);
4810 uint64_t ret_ref = tag_ptr(ret_copy, true);
4814 static inline void CResult_NoneRetryableSendFailureZ_get_ok(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
4815 CHECK(owner->result_ok);
4816 return *owner->contents.result;
4818 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_ok"))) TS_CResult_NoneRetryableSendFailureZ_get_ok(uint64_t owner) {
4819 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
4820 CResult_NoneRetryableSendFailureZ_get_ok(owner_conv);
4823 static inline enum LDKRetryableSendFailure CResult_NoneRetryableSendFailureZ_get_err(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR owner){
4824 CHECK(!owner->result_ok);
4825 return RetryableSendFailure_clone(&*owner->contents.err);
4827 uint32_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_get_err"))) TS_CResult_NoneRetryableSendFailureZ_get_err(uint64_t owner) {
4828 LDKCResult_NoneRetryableSendFailureZ* owner_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(owner);
4829 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_NoneRetryableSendFailureZ_get_err(owner_conv));
4833 static inline struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner){
4834 CHECK(owner->result_ok);
4835 return ThirtyTwoBytes_clone(&*owner->contents.result);
4837 int8_tArray __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(uint64_t owner) {
4838 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* owner_conv = (LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)untag_ptr(owner);
4839 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4840 memcpy(ret_arr->elems, CResult_ThirtyTwoBytesPaymentSendFailureZ_get_ok(owner_conv).data, 32);
4844 static inline struct LDKPaymentSendFailure CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR owner){
4845 CHECK(!owner->result_ok);
4846 return PaymentSendFailure_clone(&*owner->contents.err);
4848 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(uint64_t owner) {
4849 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* owner_conv = (LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)untag_ptr(owner);
4850 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4851 *ret_copy = CResult_ThirtyTwoBytesPaymentSendFailureZ_get_err(owner_conv);
4852 uint64_t ret_ref = tag_ptr(ret_copy, true);
4856 static inline struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner){
4857 CHECK(owner->result_ok);
4858 return ThirtyTwoBytes_clone(&*owner->contents.result);
4860 int8_tArray __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(uint64_t owner) {
4861 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* owner_conv = (LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)untag_ptr(owner);
4862 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4863 memcpy(ret_arr->elems, CResult_ThirtyTwoBytesRetryableSendFailureZ_get_ok(owner_conv).data, 32);
4867 static inline enum LDKRetryableSendFailure CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR owner){
4868 CHECK(!owner->result_ok);
4869 return RetryableSendFailure_clone(&*owner->contents.err);
4871 uint32_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(uint64_t owner) {
4872 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* owner_conv = (LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)untag_ptr(owner);
4873 uint32_t ret_conv = LDKRetryableSendFailure_to_js(CResult_ThirtyTwoBytesRetryableSendFailureZ_get_err(owner_conv));
4877 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner){
4878 return ThirtyTwoBytes_clone(&owner->a);
4880 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(uint64_t owner) {
4881 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(owner);
4882 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4883 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_a(owner_conv).data, 32);
4887 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR owner){
4888 return ThirtyTwoBytes_clone(&owner->b);
4890 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(uint64_t owner) {
4891 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(owner);
4892 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4893 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_get_b(owner_conv).data, 32);
4897 static inline struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner){
4898 CHECK(owner->result_ok);
4899 return C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(&*owner->contents.result);
4901 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(uint64_t owner) {
4902 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)untag_ptr(owner);
4903 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
4904 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_ok(owner_conv);
4905 return tag_ptr(ret_conv, true);
4908 static inline struct LDKPaymentSendFailure CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR owner){
4909 CHECK(!owner->result_ok);
4910 return PaymentSendFailure_clone(&*owner->contents.err);
4912 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(uint64_t owner) {
4913 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)untag_ptr(owner);
4914 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4915 *ret_copy = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_get_err(owner_conv);
4916 uint64_t ret_ref = tag_ptr(ret_copy, true);
4920 static inline LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ *orig) {
4921 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ clone bytes"), .datalen = orig->datalen };
4922 for (size_t i = 0; i < ret.datalen; i++) {
4923 ret.data[i] = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(&orig->data[i]);
4927 uint32_t __attribute__((export_name("TS_LDKProbeSendFailure_ty_from_ptr"))) TS_LDKProbeSendFailure_ty_from_ptr(uint64_t ptr) {
4928 LDKProbeSendFailure *obj = (LDKProbeSendFailure*)untag_ptr(ptr);
4930 case LDKProbeSendFailure_RouteNotFound: return 0;
4931 case LDKProbeSendFailure_SendingFailed: return 1;
4935 uint64_t __attribute__((export_name("TS_LDKProbeSendFailure_SendingFailed_get_sending_failed"))) TS_LDKProbeSendFailure_SendingFailed_get_sending_failed(uint64_t ptr) {
4936 LDKProbeSendFailure *obj = (LDKProbeSendFailure*)untag_ptr(ptr);
4937 assert(obj->tag == LDKProbeSendFailure_SendingFailed);
4938 uint64_t sending_failed_ref = tag_ptr(&obj->sending_failed, false);
4939 return sending_failed_ref;
4941 static inline struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner){
4942 CHECK(owner->result_ok);
4943 return CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_clone(&*owner->contents.result);
4945 uint64_tArray __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(uint64_t owner) {
4946 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)untag_ptr(owner);
4947 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ ret_var = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_ok(owner_conv);
4948 uint64_tArray ret_arr = NULL;
4949 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
4950 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
4951 for (size_t o = 0; o < ret_var.datalen; o++) {
4952 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
4953 *ret_conv_40_conv = ret_var.data[o];
4954 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
4961 static inline struct LDKProbeSendFailure CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR owner){
4962 CHECK(!owner->result_ok);
4963 return ProbeSendFailure_clone(&*owner->contents.err);
4965 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(uint64_t owner) {
4966 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)untag_ptr(owner);
4967 LDKProbeSendFailure *ret_copy = MALLOC(sizeof(LDKProbeSendFailure), "LDKProbeSendFailure");
4968 *ret_copy = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_get_err(owner_conv);
4969 uint64_t ret_ref = tag_ptr(ret_copy, true);
4973 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner){
4974 return ThirtyTwoBytes_clone(&owner->a);
4976 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(uint64_t owner) {
4977 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)untag_ptr(owner);
4978 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4979 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesPublicKeyZ_get_a(owner_conv).data, 32);
4983 static inline struct LDKPublicKey C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR owner){
4986 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(uint64_t owner) {
4987 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)untag_ptr(owner);
4988 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4989 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesPublicKeyZ_get_b(owner_conv).compressed_form, 33);
4993 static inline LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ *orig) {
4994 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ clone bytes"), .datalen = orig->datalen };
4995 for (size_t i = 0; i < ret.datalen; i++) {
4996 ret.data[i] = C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(&orig->data[i]);
5000 static inline struct LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner){
5001 CHECK(owner->result_ok);
5002 return C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(&*owner->contents.result);
5004 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(uint64_t owner) {
5005 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)untag_ptr(owner);
5006 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
5007 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_ok(owner_conv);
5008 return tag_ptr(ret_conv, true);
5011 static inline void CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR owner){
5012 CHECK(!owner->result_ok);
5013 return *owner->contents.err;
5015 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(uint64_t owner) {
5016 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)untag_ptr(owner);
5017 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_get_err(owner_conv);
5020 static inline struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5021 LDKCounterpartyForwardingInfo ret = *owner->contents.result;
5022 ret.is_owned = false;
5025 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(uint64_t owner) {
5026 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5027 LDKCounterpartyForwardingInfo ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner_conv);
5028 uint64_t ret_ref = 0;
5029 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5030 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5034 static inline struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5035 CHECK(!owner->result_ok);
5036 return DecodeError_clone(&*owner->contents.err);
5038 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(uint64_t owner) {
5039 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(owner);
5040 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5041 *ret_copy = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner_conv);
5042 uint64_t ret_ref = tag_ptr(ret_copy, true);
5046 static inline struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5047 LDKChannelCounterparty ret = *owner->contents.result;
5048 ret.is_owned = false;
5051 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(uint64_t owner) {
5052 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5053 LDKChannelCounterparty ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner_conv);
5054 uint64_t ret_ref = 0;
5055 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5056 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5060 static inline struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5061 CHECK(!owner->result_ok);
5062 return DecodeError_clone(&*owner->contents.err);
5064 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(uint64_t owner) {
5065 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(owner);
5066 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5067 *ret_copy = CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner_conv);
5068 uint64_t ret_ref = tag_ptr(ret_copy, true);
5072 static inline struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5073 LDKChannelDetails ret = *owner->contents.result;
5074 ret.is_owned = false;
5077 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(uint64_t owner) {
5078 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5079 LDKChannelDetails ret_var = CResult_ChannelDetailsDecodeErrorZ_get_ok(owner_conv);
5080 uint64_t ret_ref = 0;
5081 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5082 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5086 static inline struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5087 CHECK(!owner->result_ok);
5088 return DecodeError_clone(&*owner->contents.err);
5090 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_err(uint64_t owner) {
5091 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(owner);
5092 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5093 *ret_copy = CResult_ChannelDetailsDecodeErrorZ_get_err(owner_conv);
5094 uint64_t ret_ref = tag_ptr(ret_copy, true);
5098 static inline struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5099 LDKPhantomRouteHints ret = *owner->contents.result;
5100 ret.is_owned = false;
5103 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(uint64_t owner) {
5104 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5105 LDKPhantomRouteHints ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner_conv);
5106 uint64_t ret_ref = 0;
5107 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5108 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
5112 static inline struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5113 CHECK(!owner->result_ok);
5114 return DecodeError_clone(&*owner->contents.err);
5116 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(uint64_t owner) {
5117 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(owner);
5118 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5119 *ret_copy = CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner_conv);
5120 uint64_t ret_ref = tag_ptr(ret_copy, true);
5124 static inline enum LDKChannelShutdownState CResult_ChannelShutdownStateDecodeErrorZ_get_ok(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner){
5125 CHECK(owner->result_ok);
5126 return ChannelShutdownState_clone(&*owner->contents.result);
5128 uint32_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_get_ok(uint64_t owner) {
5129 LDKCResult_ChannelShutdownStateDecodeErrorZ* owner_conv = (LDKCResult_ChannelShutdownStateDecodeErrorZ*)untag_ptr(owner);
5130 uint32_t ret_conv = LDKChannelShutdownState_to_js(CResult_ChannelShutdownStateDecodeErrorZ_get_ok(owner_conv));
5134 static inline struct LDKDecodeError CResult_ChannelShutdownStateDecodeErrorZ_get_err(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR owner){
5135 CHECK(!owner->result_ok);
5136 return DecodeError_clone(&*owner->contents.err);
5138 uint64_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_get_err(uint64_t owner) {
5139 LDKCResult_ChannelShutdownStateDecodeErrorZ* owner_conv = (LDKCResult_ChannelShutdownStateDecodeErrorZ*)untag_ptr(owner);
5140 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
5141 *ret_copy = CResult_ChannelShutdownStateDecodeErrorZ_get_err(owner_conv);
5142 uint64_t ret_ref = tag_ptr(ret_copy, true);
5146 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
5147 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
5148 for (size_t i = 0; i < ret.datalen; i++) {
5149 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
5153 typedef struct LDKWatch_JCalls {
5154 atomic_size_t refcnt;
5155 uint32_t instance_ptr;
5157 static void LDKWatch_JCalls_free(void* this_arg) {
5158 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5159 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5163 LDKCResult_ChannelMonitorUpdateStatusNoneZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
5164 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5165 LDKOutPoint funding_txo_var = funding_txo;
5166 uint64_t funding_txo_ref = 0;
5167 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5168 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5169 LDKChannelMonitor monitor_var = monitor;
5170 uint64_t monitor_ref = 0;
5171 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
5172 monitor_ref = tag_ptr(monitor_var.inner, monitor_var.is_owned);
5173 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 18, funding_txo_ref, monitor_ref, 0, 0, 0, 0);
5174 void* ret_ptr = untag_ptr(ret);
5175 CHECK_ACCESS(ret_ptr);
5176 LDKCResult_ChannelMonitorUpdateStatusNoneZ ret_conv = *(LDKCResult_ChannelMonitorUpdateStatusNoneZ*)(ret_ptr);
5177 FREE(untag_ptr(ret));
5180 LDKChannelMonitorUpdateStatus update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, const LDKChannelMonitorUpdate * update) {
5181 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5182 LDKOutPoint funding_txo_var = funding_txo;
5183 uint64_t funding_txo_ref = 0;
5184 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5185 funding_txo_ref = tag_ptr(funding_txo_var.inner, funding_txo_var.is_owned);
5186 LDKChannelMonitorUpdate update_var = *update;
5187 uint64_t update_ref = 0;
5188 update_var = ChannelMonitorUpdate_clone(&update_var);
5189 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
5190 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
5191 uint64_t ret = js_invoke_function_bbuuuu(j_calls->instance_ptr, 19, funding_txo_ref, update_ref, 0, 0, 0, 0);
5192 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
5195 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
5196 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5197 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 20, 0, 0, 0, 0, 0, 0);
5198 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_constr;
5199 ret_constr.datalen = ret->arr_len;
5200 if (ret_constr.datalen > 0)
5201 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
5203 ret_constr.data = NULL;
5204 uint64_t* ret_vals = ret->elems;
5205 for (size_t x = 0; x < ret_constr.datalen; x++) {
5206 uint64_t ret_conv_49 = ret_vals[x];
5207 void* ret_conv_49_ptr = untag_ptr(ret_conv_49);
5208 CHECK_ACCESS(ret_conv_49_ptr);
5209 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ ret_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(ret_conv_49_ptr);
5210 FREE(untag_ptr(ret_conv_49));
5211 ret_constr.data[x] = ret_conv_49_conv;
5216 static void LDKWatch_JCalls_cloned(LDKWatch* new_obj) {
5217 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) new_obj->this_arg;
5218 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5220 static inline LDKWatch LDKWatch_init (JSValue o) {
5221 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
5222 atomic_init(&calls->refcnt, 1);
5223 calls->instance_ptr = o;
5226 .this_arg = (void*) calls,
5227 .watch_channel = watch_channel_LDKWatch_jcall,
5228 .update_channel = update_channel_LDKWatch_jcall,
5229 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
5230 .free = LDKWatch_JCalls_free,
5234 uint64_t __attribute__((export_name("TS_LDKWatch_new"))) TS_LDKWatch_new(JSValue o) {
5235 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
5236 *res_ptr = LDKWatch_init(o);
5237 return tag_ptr(res_ptr, true);
5239 uint64_t __attribute__((export_name("TS_Watch_watch_channel"))) TS_Watch_watch_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t monitor) {
5240 void* this_arg_ptr = untag_ptr(this_arg);
5241 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5242 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5243 LDKOutPoint funding_txo_conv;
5244 funding_txo_conv.inner = untag_ptr(funding_txo);
5245 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5246 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5247 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5248 LDKChannelMonitor monitor_conv;
5249 monitor_conv.inner = untag_ptr(monitor);
5250 monitor_conv.is_owned = ptr_is_owned(monitor);
5251 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
5252 monitor_conv = ChannelMonitor_clone(&monitor_conv);
5253 LDKCResult_ChannelMonitorUpdateStatusNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ), "LDKCResult_ChannelMonitorUpdateStatusNoneZ");
5254 *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
5255 return tag_ptr(ret_conv, true);
5258 uint32_t __attribute__((export_name("TS_Watch_update_channel"))) TS_Watch_update_channel(uint64_t this_arg, uint64_t funding_txo, uint64_t update) {
5259 void* this_arg_ptr = untag_ptr(this_arg);
5260 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5261 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5262 LDKOutPoint funding_txo_conv;
5263 funding_txo_conv.inner = untag_ptr(funding_txo);
5264 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
5265 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5266 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5267 LDKChannelMonitorUpdate update_conv;
5268 update_conv.inner = untag_ptr(update);
5269 update_conv.is_owned = ptr_is_owned(update);
5270 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
5271 update_conv.is_owned = false;
5272 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js((this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, &update_conv));
5276 uint64_tArray __attribute__((export_name("TS_Watch_release_pending_monitor_events"))) TS_Watch_release_pending_monitor_events(uint64_t this_arg) {
5277 void* this_arg_ptr = untag_ptr(this_arg);
5278 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5279 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5280 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
5281 uint64_tArray ret_arr = NULL;
5282 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
5283 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
5284 for (size_t x = 0; x < ret_var.datalen; x++) {
5285 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv_49_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
5286 *ret_conv_49_conv = ret_var.data[x];
5287 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
5294 typedef struct LDKBroadcasterInterface_JCalls {
5295 atomic_size_t refcnt;
5296 uint32_t instance_ptr;
5297 } LDKBroadcasterInterface_JCalls;
5298 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
5299 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5300 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5304 void broadcast_transactions_LDKBroadcasterInterface_jcall(const void* this_arg, LDKCVec_TransactionZ txs) {
5305 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5306 LDKCVec_TransactionZ txs_var = txs;
5307 ptrArray txs_arr = NULL;
5308 txs_arr = init_ptrArray(txs_var.datalen, __LINE__);
5309 int8_tArray *txs_arr_ptr = (int8_tArray*)(((uint8_t*)txs_arr) + 8);
5310 for (size_t m = 0; m < txs_var.datalen; m++) {
5311 LDKTransaction txs_conv_12_var = txs_var.data[m];
5312 int8_tArray txs_conv_12_arr = init_int8_tArray(txs_conv_12_var.datalen, __LINE__);
5313 memcpy(txs_conv_12_arr->elems, txs_conv_12_var.data, txs_conv_12_var.datalen);
5314 Transaction_free(txs_conv_12_var);
5315 txs_arr_ptr[m] = txs_conv_12_arr;
5319 js_invoke_function_uuuuuu(j_calls->instance_ptr, 21, (uint32_t)txs_arr, 0, 0, 0, 0, 0);
5321 static void LDKBroadcasterInterface_JCalls_cloned(LDKBroadcasterInterface* new_obj) {
5322 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) new_obj->this_arg;
5323 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5325 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JSValue o) {
5326 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
5327 atomic_init(&calls->refcnt, 1);
5328 calls->instance_ptr = o;
5330 LDKBroadcasterInterface ret = {
5331 .this_arg = (void*) calls,
5332 .broadcast_transactions = broadcast_transactions_LDKBroadcasterInterface_jcall,
5333 .free = LDKBroadcasterInterface_JCalls_free,
5337 uint64_t __attribute__((export_name("TS_LDKBroadcasterInterface_new"))) TS_LDKBroadcasterInterface_new(JSValue o) {
5338 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
5339 *res_ptr = LDKBroadcasterInterface_init(o);
5340 return tag_ptr(res_ptr, true);
5342 void __attribute__((export_name("TS_BroadcasterInterface_broadcast_transactions"))) TS_BroadcasterInterface_broadcast_transactions(uint64_t this_arg, ptrArray txs) {
5343 void* this_arg_ptr = untag_ptr(this_arg);
5344 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5345 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)this_arg_ptr;
5346 LDKCVec_TransactionZ txs_constr;
5347 txs_constr.datalen = txs->arr_len;
5348 if (txs_constr.datalen > 0)
5349 txs_constr.data = MALLOC(txs_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
5351 txs_constr.data = NULL;
5352 int8_tArray* txs_vals = (void*) txs->elems;
5353 for (size_t m = 0; m < txs_constr.datalen; m++) {
5354 int8_tArray txs_conv_12 = txs_vals[m];
5355 LDKTransaction txs_conv_12_ref;
5356 txs_conv_12_ref.datalen = txs_conv_12->arr_len;
5357 txs_conv_12_ref.data = MALLOC(txs_conv_12_ref.datalen, "LDKTransaction Bytes");
5358 memcpy(txs_conv_12_ref.data, txs_conv_12->elems, txs_conv_12_ref.datalen); FREE(txs_conv_12);
5359 txs_conv_12_ref.data_is_owned = true;
5360 txs_constr.data[m] = txs_conv_12_ref;
5363 (this_arg_conv->broadcast_transactions)(this_arg_conv->this_arg, txs_constr);
5366 typedef struct LDKEntropySource_JCalls {
5367 atomic_size_t refcnt;
5368 uint32_t instance_ptr;
5369 } LDKEntropySource_JCalls;
5370 static void LDKEntropySource_JCalls_free(void* this_arg) {
5371 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5372 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5376 LDKThirtyTwoBytes get_secure_random_bytes_LDKEntropySource_jcall(const void* this_arg) {
5377 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) this_arg;
5378 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 22, 0, 0, 0, 0, 0, 0);
5379 LDKThirtyTwoBytes ret_ref;
5380 CHECK(ret->arr_len == 32);
5381 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5384 static void LDKEntropySource_JCalls_cloned(LDKEntropySource* new_obj) {
5385 LDKEntropySource_JCalls *j_calls = (LDKEntropySource_JCalls*) new_obj->this_arg;
5386 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5388 static inline LDKEntropySource LDKEntropySource_init (JSValue o) {
5389 LDKEntropySource_JCalls *calls = MALLOC(sizeof(LDKEntropySource_JCalls), "LDKEntropySource_JCalls");
5390 atomic_init(&calls->refcnt, 1);
5391 calls->instance_ptr = o;
5393 LDKEntropySource ret = {
5394 .this_arg = (void*) calls,
5395 .get_secure_random_bytes = get_secure_random_bytes_LDKEntropySource_jcall,
5396 .free = LDKEntropySource_JCalls_free,
5400 uint64_t __attribute__((export_name("TS_LDKEntropySource_new"))) TS_LDKEntropySource_new(JSValue o) {
5401 LDKEntropySource *res_ptr = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
5402 *res_ptr = LDKEntropySource_init(o);
5403 return tag_ptr(res_ptr, true);
5405 int8_tArray __attribute__((export_name("TS_EntropySource_get_secure_random_bytes"))) TS_EntropySource_get_secure_random_bytes(uint64_t this_arg) {
5406 void* this_arg_ptr = untag_ptr(this_arg);
5407 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5408 LDKEntropySource* this_arg_conv = (LDKEntropySource*)this_arg_ptr;
5409 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5410 memcpy(ret_arr->elems, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
5414 uint32_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ty_from_ptr"))) TS_LDKUnsignedGossipMessage_ty_from_ptr(uint64_t ptr) {
5415 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5417 case LDKUnsignedGossipMessage_ChannelAnnouncement: return 0;
5418 case LDKUnsignedGossipMessage_ChannelUpdate: return 1;
5419 case LDKUnsignedGossipMessage_NodeAnnouncement: return 2;
5423 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement"))) TS_LDKUnsignedGossipMessage_ChannelAnnouncement_get_channel_announcement(uint64_t ptr) {
5424 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5425 assert(obj->tag == LDKUnsignedGossipMessage_ChannelAnnouncement);
5426 LDKUnsignedChannelAnnouncement channel_announcement_var = obj->channel_announcement;
5427 uint64_t channel_announcement_ref = 0;
5428 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_announcement_var);
5429 channel_announcement_ref = tag_ptr(channel_announcement_var.inner, false);
5430 return channel_announcement_ref;
5432 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update"))) TS_LDKUnsignedGossipMessage_ChannelUpdate_get_channel_update(uint64_t ptr) {
5433 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5434 assert(obj->tag == LDKUnsignedGossipMessage_ChannelUpdate);
5435 LDKUnsignedChannelUpdate channel_update_var = obj->channel_update;
5436 uint64_t channel_update_ref = 0;
5437 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_update_var);
5438 channel_update_ref = tag_ptr(channel_update_var.inner, false);
5439 return channel_update_ref;
5441 uint64_t __attribute__((export_name("TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement"))) TS_LDKUnsignedGossipMessage_NodeAnnouncement_get_node_announcement(uint64_t ptr) {
5442 LDKUnsignedGossipMessage *obj = (LDKUnsignedGossipMessage*)untag_ptr(ptr);
5443 assert(obj->tag == LDKUnsignedGossipMessage_NodeAnnouncement);
5444 LDKUnsignedNodeAnnouncement node_announcement_var = obj->node_announcement;
5445 uint64_t node_announcement_ref = 0;
5446 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_announcement_var);
5447 node_announcement_ref = tag_ptr(node_announcement_var.inner, false);
5448 return node_announcement_ref;
5450 typedef struct LDKNodeSigner_JCalls {
5451 atomic_size_t refcnt;
5452 uint32_t instance_ptr;
5453 } LDKNodeSigner_JCalls;
5454 static void LDKNodeSigner_JCalls_free(void* this_arg) {
5455 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5456 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5460 LDKThirtyTwoBytes get_inbound_payment_key_material_LDKNodeSigner_jcall(const void* this_arg) {
5461 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5462 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 23, 0, 0, 0, 0, 0, 0);
5463 LDKThirtyTwoBytes ret_ref;
5464 CHECK(ret->arr_len == 32);
5465 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5468 LDKCResult_PublicKeyNoneZ get_node_id_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient) {
5469 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5470 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5471 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 24, recipient_conv, 0, 0, 0, 0, 0);
5472 void* ret_ptr = untag_ptr(ret);
5473 CHECK_ACCESS(ret_ptr);
5474 LDKCResult_PublicKeyNoneZ ret_conv = *(LDKCResult_PublicKeyNoneZ*)(ret_ptr);
5475 FREE(untag_ptr(ret));
5478 LDKCResult_ThirtyTwoBytesNoneZ ecdh_LDKNodeSigner_jcall(const void* this_arg, LDKRecipient recipient, LDKPublicKey other_key, LDKCOption_BigEndianScalarZ tweak) {
5479 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5480 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5481 int8_tArray other_key_arr = init_int8_tArray(33, __LINE__);
5482 memcpy(other_key_arr->elems, other_key.compressed_form, 33);
5483 LDKCOption_BigEndianScalarZ *tweak_copy = MALLOC(sizeof(LDKCOption_BigEndianScalarZ), "LDKCOption_BigEndianScalarZ");
5484 *tweak_copy = tweak;
5485 uint64_t tweak_ref = tag_ptr(tweak_copy, true);
5486 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 25, recipient_conv, (uint32_t)other_key_arr, tweak_ref, 0, 0, 0);
5487 void* ret_ptr = untag_ptr(ret);
5488 CHECK_ACCESS(ret_ptr);
5489 LDKCResult_ThirtyTwoBytesNoneZ ret_conv = *(LDKCResult_ThirtyTwoBytesNoneZ*)(ret_ptr);
5490 FREE(untag_ptr(ret));
5493 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKNodeSigner_jcall(const void* this_arg, LDKu8slice hrp_bytes, LDKCVec_U5Z invoice_data, LDKRecipient recipient) {
5494 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5495 LDKu8slice hrp_bytes_var = hrp_bytes;
5496 int8_tArray hrp_bytes_arr = init_int8_tArray(hrp_bytes_var.datalen, __LINE__);
5497 memcpy(hrp_bytes_arr->elems, hrp_bytes_var.data, hrp_bytes_var.datalen);
5498 LDKCVec_U5Z invoice_data_var = invoice_data;
5499 ptrArray invoice_data_arr = NULL;
5500 invoice_data_arr = init_ptrArray(invoice_data_var.datalen, __LINE__);
5501 int8_t *invoice_data_arr_ptr = (int8_t*)(((uint8_t*)invoice_data_arr) + 8);
5502 for (size_t h = 0; h < invoice_data_var.datalen; h++) {
5503 uint8_t invoice_data_conv_7_val = invoice_data_var.data[h]._0;
5504 invoice_data_arr_ptr[h] = invoice_data_conv_7_val;
5507 FREE(invoice_data_var.data);
5508 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5509 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 26, (uint32_t)hrp_bytes_arr, (uint32_t)invoice_data_arr, recipient_conv, 0, 0, 0);
5510 void* ret_ptr = untag_ptr(ret);
5511 CHECK_ACCESS(ret_ptr);
5512 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
5513 FREE(untag_ptr(ret));
5516 LDKCResult_SchnorrSignatureNoneZ sign_bolt12_invoice_request_LDKNodeSigner_jcall(const void* this_arg, const LDKUnsignedInvoiceRequest * invoice_request) {
5517 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5518 LDKUnsignedInvoiceRequest invoice_request_var = *invoice_request;
5519 uint64_t invoice_request_ref = 0;
5520 // WARNING: we may need a move here but no clone is available for LDKUnsignedInvoiceRequest
5521 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_request_var);
5522 invoice_request_ref = tag_ptr(invoice_request_var.inner, invoice_request_var.is_owned);
5523 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 27, invoice_request_ref, 0, 0, 0, 0, 0);
5524 void* ret_ptr = untag_ptr(ret);
5525 CHECK_ACCESS(ret_ptr);
5526 LDKCResult_SchnorrSignatureNoneZ ret_conv = *(LDKCResult_SchnorrSignatureNoneZ*)(ret_ptr);
5527 FREE(untag_ptr(ret));
5530 LDKCResult_SchnorrSignatureNoneZ sign_bolt12_invoice_LDKNodeSigner_jcall(const void* this_arg, const LDKUnsignedBolt12Invoice * invoice) {
5531 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5532 LDKUnsignedBolt12Invoice invoice_var = *invoice;
5533 uint64_t invoice_ref = 0;
5534 // WARNING: we may need a move here but no clone is available for LDKUnsignedBolt12Invoice
5535 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_var);
5536 invoice_ref = tag_ptr(invoice_var.inner, invoice_var.is_owned);
5537 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 28, invoice_ref, 0, 0, 0, 0, 0);
5538 void* ret_ptr = untag_ptr(ret);
5539 CHECK_ACCESS(ret_ptr);
5540 LDKCResult_SchnorrSignatureNoneZ ret_conv = *(LDKCResult_SchnorrSignatureNoneZ*)(ret_ptr);
5541 FREE(untag_ptr(ret));
5544 LDKCResult_ECDSASignatureNoneZ sign_gossip_message_LDKNodeSigner_jcall(const void* this_arg, LDKUnsignedGossipMessage msg) {
5545 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) this_arg;
5546 LDKUnsignedGossipMessage *msg_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
5548 uint64_t msg_ref = tag_ptr(msg_copy, true);
5549 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 29, msg_ref, 0, 0, 0, 0, 0);
5550 void* ret_ptr = untag_ptr(ret);
5551 CHECK_ACCESS(ret_ptr);
5552 LDKCResult_ECDSASignatureNoneZ ret_conv = *(LDKCResult_ECDSASignatureNoneZ*)(ret_ptr);
5553 FREE(untag_ptr(ret));
5556 static void LDKNodeSigner_JCalls_cloned(LDKNodeSigner* new_obj) {
5557 LDKNodeSigner_JCalls *j_calls = (LDKNodeSigner_JCalls*) new_obj->this_arg;
5558 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5560 static inline LDKNodeSigner LDKNodeSigner_init (JSValue o) {
5561 LDKNodeSigner_JCalls *calls = MALLOC(sizeof(LDKNodeSigner_JCalls), "LDKNodeSigner_JCalls");
5562 atomic_init(&calls->refcnt, 1);
5563 calls->instance_ptr = o;
5565 LDKNodeSigner ret = {
5566 .this_arg = (void*) calls,
5567 .get_inbound_payment_key_material = get_inbound_payment_key_material_LDKNodeSigner_jcall,
5568 .get_node_id = get_node_id_LDKNodeSigner_jcall,
5569 .ecdh = ecdh_LDKNodeSigner_jcall,
5570 .sign_invoice = sign_invoice_LDKNodeSigner_jcall,
5571 .sign_bolt12_invoice_request = sign_bolt12_invoice_request_LDKNodeSigner_jcall,
5572 .sign_bolt12_invoice = sign_bolt12_invoice_LDKNodeSigner_jcall,
5573 .sign_gossip_message = sign_gossip_message_LDKNodeSigner_jcall,
5574 .free = LDKNodeSigner_JCalls_free,
5578 uint64_t __attribute__((export_name("TS_LDKNodeSigner_new"))) TS_LDKNodeSigner_new(JSValue o) {
5579 LDKNodeSigner *res_ptr = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
5580 *res_ptr = LDKNodeSigner_init(o);
5581 return tag_ptr(res_ptr, true);
5583 int8_tArray __attribute__((export_name("TS_NodeSigner_get_inbound_payment_key_material"))) TS_NodeSigner_get_inbound_payment_key_material(uint64_t this_arg) {
5584 void* this_arg_ptr = untag_ptr(this_arg);
5585 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5586 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5587 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5588 memcpy(ret_arr->elems, (this_arg_conv->get_inbound_payment_key_material)(this_arg_conv->this_arg).data, 32);
5592 uint64_t __attribute__((export_name("TS_NodeSigner_get_node_id"))) TS_NodeSigner_get_node_id(uint64_t this_arg, uint32_t recipient) {
5593 void* this_arg_ptr = untag_ptr(this_arg);
5594 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5595 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5596 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5597 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
5598 *ret_conv = (this_arg_conv->get_node_id)(this_arg_conv->this_arg, recipient_conv);
5599 return tag_ptr(ret_conv, true);
5602 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) {
5603 void* this_arg_ptr = untag_ptr(this_arg);
5604 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5605 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5606 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5607 LDKPublicKey other_key_ref;
5608 CHECK(other_key->arr_len == 33);
5609 memcpy(other_key_ref.compressed_form, other_key->elems, 33); FREE(other_key);
5610 void* tweak_ptr = untag_ptr(tweak);
5611 CHECK_ACCESS(tweak_ptr);
5612 LDKCOption_BigEndianScalarZ tweak_conv = *(LDKCOption_BigEndianScalarZ*)(tweak_ptr);
5613 tweak_conv = COption_BigEndianScalarZ_clone((LDKCOption_BigEndianScalarZ*)untag_ptr(tweak));
5614 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
5615 *ret_conv = (this_arg_conv->ecdh)(this_arg_conv->this_arg, recipient_conv, other_key_ref, tweak_conv);
5616 return tag_ptr(ret_conv, true);
5619 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) {
5620 void* this_arg_ptr = untag_ptr(this_arg);
5621 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5622 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5623 LDKu8slice hrp_bytes_ref;
5624 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
5625 hrp_bytes_ref.data = hrp_bytes->elems;
5626 LDKCVec_U5Z invoice_data_constr;
5627 invoice_data_constr.datalen = invoice_data->arr_len;
5628 if (invoice_data_constr.datalen > 0)
5629 invoice_data_constr.data = MALLOC(invoice_data_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
5631 invoice_data_constr.data = NULL;
5632 int8_t* invoice_data_vals = (void*) invoice_data->elems;
5633 for (size_t h = 0; h < invoice_data_constr.datalen; h++) {
5634 int8_t invoice_data_conv_7 = invoice_data_vals[h];
5636 invoice_data_constr.data[h] = (LDKU5){ ._0 = invoice_data_conv_7 };
5639 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5640 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
5641 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, hrp_bytes_ref, invoice_data_constr, recipient_conv);
5643 return tag_ptr(ret_conv, true);
5646 uint64_t __attribute__((export_name("TS_NodeSigner_sign_bolt12_invoice_request"))) TS_NodeSigner_sign_bolt12_invoice_request(uint64_t this_arg, uint64_t invoice_request) {
5647 void* this_arg_ptr = untag_ptr(this_arg);
5648 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5649 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5650 LDKUnsignedInvoiceRequest invoice_request_conv;
5651 invoice_request_conv.inner = untag_ptr(invoice_request);
5652 invoice_request_conv.is_owned = ptr_is_owned(invoice_request);
5653 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_request_conv);
5654 invoice_request_conv.is_owned = false;
5655 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
5656 *ret_conv = (this_arg_conv->sign_bolt12_invoice_request)(this_arg_conv->this_arg, &invoice_request_conv);
5657 return tag_ptr(ret_conv, true);
5660 uint64_t __attribute__((export_name("TS_NodeSigner_sign_bolt12_invoice"))) TS_NodeSigner_sign_bolt12_invoice(uint64_t this_arg, uint64_t invoice) {
5661 void* this_arg_ptr = untag_ptr(this_arg);
5662 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5663 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5664 LDKUnsignedBolt12Invoice invoice_conv;
5665 invoice_conv.inner = untag_ptr(invoice);
5666 invoice_conv.is_owned = ptr_is_owned(invoice);
5667 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
5668 invoice_conv.is_owned = false;
5669 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
5670 *ret_conv = (this_arg_conv->sign_bolt12_invoice)(this_arg_conv->this_arg, &invoice_conv);
5671 return tag_ptr(ret_conv, true);
5674 uint64_t __attribute__((export_name("TS_NodeSigner_sign_gossip_message"))) TS_NodeSigner_sign_gossip_message(uint64_t this_arg, uint64_t msg) {
5675 void* this_arg_ptr = untag_ptr(this_arg);
5676 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5677 LDKNodeSigner* this_arg_conv = (LDKNodeSigner*)this_arg_ptr;
5678 void* msg_ptr = untag_ptr(msg);
5679 CHECK_ACCESS(msg_ptr);
5680 LDKUnsignedGossipMessage msg_conv = *(LDKUnsignedGossipMessage*)(msg_ptr);
5681 msg_conv = UnsignedGossipMessage_clone((LDKUnsignedGossipMessage*)untag_ptr(msg));
5682 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
5683 *ret_conv = (this_arg_conv->sign_gossip_message)(this_arg_conv->this_arg, msg_conv);
5684 return tag_ptr(ret_conv, true);
5687 typedef struct LDKSignerProvider_JCalls {
5688 atomic_size_t refcnt;
5689 uint32_t instance_ptr;
5690 } LDKSignerProvider_JCalls;
5691 static void LDKSignerProvider_JCalls_free(void* this_arg) {
5692 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5693 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5697 LDKThirtyTwoBytes generate_channel_keys_id_LDKSignerProvider_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis, LDKU128 user_channel_id) {
5698 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5699 jboolean inbound_conv = inbound;
5700 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5701 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
5702 memcpy(user_channel_id_arr->elems, user_channel_id.le_bytes, 16);
5703 int8_tArray ret = (int8_tArray)js_invoke_function_ubuuuu(j_calls->instance_ptr, 30, inbound_conv, channel_value_satoshis_conv, (uint32_t)user_channel_id_arr, 0, 0, 0);
5704 LDKThirtyTwoBytes ret_ref;
5705 CHECK(ret->arr_len == 32);
5706 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5709 LDKWriteableEcdsaChannelSigner derive_channel_signer_LDKSignerProvider_jcall(const void* this_arg, uint64_t channel_value_satoshis, LDKThirtyTwoBytes channel_keys_id) {
5710 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5711 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5712 int8_tArray channel_keys_id_arr = init_int8_tArray(32, __LINE__);
5713 memcpy(channel_keys_id_arr->elems, channel_keys_id.data, 32);
5714 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 31, channel_value_satoshis_conv, (uint32_t)channel_keys_id_arr, 0, 0, 0, 0);
5715 void* ret_ptr = untag_ptr(ret);
5716 CHECK_ACCESS(ret_ptr);
5717 LDKWriteableEcdsaChannelSigner ret_conv = *(LDKWriteableEcdsaChannelSigner*)(ret_ptr);
5718 FREE(untag_ptr(ret));
5721 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ read_chan_signer_LDKSignerProvider_jcall(const void* this_arg, LDKu8slice reader) {
5722 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5723 LDKu8slice reader_var = reader;
5724 int8_tArray reader_arr = init_int8_tArray(reader_var.datalen, __LINE__);
5725 memcpy(reader_arr->elems, reader_var.data, reader_var.datalen);
5726 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 32, (uint32_t)reader_arr, 0, 0, 0, 0, 0);
5727 void* ret_ptr = untag_ptr(ret);
5728 CHECK_ACCESS(ret_ptr);
5729 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ ret_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(ret_ptr);
5730 FREE(untag_ptr(ret));
5733 LDKCResult_CVec_u8ZNoneZ get_destination_script_LDKSignerProvider_jcall(const void* this_arg) {
5734 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5735 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 33, 0, 0, 0, 0, 0, 0);
5736 void* ret_ptr = untag_ptr(ret);
5737 CHECK_ACCESS(ret_ptr);
5738 LDKCResult_CVec_u8ZNoneZ ret_conv = *(LDKCResult_CVec_u8ZNoneZ*)(ret_ptr);
5739 FREE(untag_ptr(ret));
5742 LDKCResult_ShutdownScriptNoneZ get_shutdown_scriptpubkey_LDKSignerProvider_jcall(const void* this_arg) {
5743 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) this_arg;
5744 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 34, 0, 0, 0, 0, 0, 0);
5745 void* ret_ptr = untag_ptr(ret);
5746 CHECK_ACCESS(ret_ptr);
5747 LDKCResult_ShutdownScriptNoneZ ret_conv = *(LDKCResult_ShutdownScriptNoneZ*)(ret_ptr);
5748 FREE(untag_ptr(ret));
5751 static void LDKSignerProvider_JCalls_cloned(LDKSignerProvider* new_obj) {
5752 LDKSignerProvider_JCalls *j_calls = (LDKSignerProvider_JCalls*) new_obj->this_arg;
5753 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5755 static inline LDKSignerProvider LDKSignerProvider_init (JSValue o) {
5756 LDKSignerProvider_JCalls *calls = MALLOC(sizeof(LDKSignerProvider_JCalls), "LDKSignerProvider_JCalls");
5757 atomic_init(&calls->refcnt, 1);
5758 calls->instance_ptr = o;
5760 LDKSignerProvider ret = {
5761 .this_arg = (void*) calls,
5762 .generate_channel_keys_id = generate_channel_keys_id_LDKSignerProvider_jcall,
5763 .derive_channel_signer = derive_channel_signer_LDKSignerProvider_jcall,
5764 .read_chan_signer = read_chan_signer_LDKSignerProvider_jcall,
5765 .get_destination_script = get_destination_script_LDKSignerProvider_jcall,
5766 .get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKSignerProvider_jcall,
5767 .free = LDKSignerProvider_JCalls_free,
5771 uint64_t __attribute__((export_name("TS_LDKSignerProvider_new"))) TS_LDKSignerProvider_new(JSValue o) {
5772 LDKSignerProvider *res_ptr = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
5773 *res_ptr = LDKSignerProvider_init(o);
5774 return tag_ptr(res_ptr, true);
5776 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) {
5777 void* this_arg_ptr = untag_ptr(this_arg);
5778 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5779 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
5780 LDKU128 user_channel_id_ref;
5781 CHECK(user_channel_id->arr_len == 16);
5782 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
5783 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5784 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);
5788 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) {
5789 void* this_arg_ptr = untag_ptr(this_arg);
5790 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5791 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
5792 LDKThirtyTwoBytes channel_keys_id_ref;
5793 CHECK(channel_keys_id->arr_len == 32);
5794 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
5795 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
5796 *ret_ret = (this_arg_conv->derive_channel_signer)(this_arg_conv->this_arg, channel_value_satoshis, channel_keys_id_ref);
5797 return tag_ptr(ret_ret, true);
5800 uint64_t __attribute__((export_name("TS_SignerProvider_read_chan_signer"))) TS_SignerProvider_read_chan_signer(uint64_t this_arg, int8_tArray reader) {
5801 void* this_arg_ptr = untag_ptr(this_arg);
5802 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5803 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
5804 LDKu8slice reader_ref;
5805 reader_ref.datalen = reader->arr_len;
5806 reader_ref.data = reader->elems;
5807 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
5808 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
5810 return tag_ptr(ret_conv, true);
5813 uint64_t __attribute__((export_name("TS_SignerProvider_get_destination_script"))) TS_SignerProvider_get_destination_script(uint64_t this_arg) {
5814 void* this_arg_ptr = untag_ptr(this_arg);
5815 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5816 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
5817 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
5818 *ret_conv = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
5819 return tag_ptr(ret_conv, true);
5822 uint64_t __attribute__((export_name("TS_SignerProvider_get_shutdown_scriptpubkey"))) TS_SignerProvider_get_shutdown_scriptpubkey(uint64_t this_arg) {
5823 void* this_arg_ptr = untag_ptr(this_arg);
5824 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5825 LDKSignerProvider* this_arg_conv = (LDKSignerProvider*)this_arg_ptr;
5826 LDKCResult_ShutdownScriptNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptNoneZ), "LDKCResult_ShutdownScriptNoneZ");
5827 *ret_conv = (this_arg_conv->get_shutdown_scriptpubkey)(this_arg_conv->this_arg);
5828 return tag_ptr(ret_conv, true);
5831 typedef struct LDKFeeEstimator_JCalls {
5832 atomic_size_t refcnt;
5833 uint32_t instance_ptr;
5834 } LDKFeeEstimator_JCalls;
5835 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
5836 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5837 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5841 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
5842 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5843 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
5844 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 35, confirmation_target_conv, 0, 0, 0, 0, 0);
5846 static void LDKFeeEstimator_JCalls_cloned(LDKFeeEstimator* new_obj) {
5847 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) new_obj->this_arg;
5848 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5850 static inline LDKFeeEstimator LDKFeeEstimator_init (JSValue o) {
5851 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
5852 atomic_init(&calls->refcnt, 1);
5853 calls->instance_ptr = o;
5855 LDKFeeEstimator ret = {
5856 .this_arg = (void*) calls,
5857 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
5858 .free = LDKFeeEstimator_JCalls_free,
5862 uint64_t __attribute__((export_name("TS_LDKFeeEstimator_new"))) TS_LDKFeeEstimator_new(JSValue o) {
5863 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
5864 *res_ptr = LDKFeeEstimator_init(o);
5865 return tag_ptr(res_ptr, true);
5867 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) {
5868 void* this_arg_ptr = untag_ptr(this_arg);
5869 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5870 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)this_arg_ptr;
5871 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
5872 int32_t ret_conv = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
5876 typedef struct LDKRouter_JCalls {
5877 atomic_size_t refcnt;
5878 uint32_t instance_ptr;
5880 static void LDKRouter_JCalls_free(void* this_arg) {
5881 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
5882 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5886 LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, LDKInFlightHtlcs inflight_htlcs) {
5887 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
5888 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
5889 memcpy(payer_arr->elems, payer.compressed_form, 33);
5890 LDKRouteParameters route_params_var = *route_params;
5891 uint64_t route_params_ref = 0;
5892 route_params_var = RouteParameters_clone(&route_params_var);
5893 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
5894 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
5895 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
5896 uint64_tArray first_hops_arr = NULL;
5897 if (first_hops != NULL) {
5898 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
5899 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
5900 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
5901 for (size_t q = 0; q < first_hops_var.datalen; q++) {
5902 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
5903 uint64_t first_hops_conv_16_ref = 0;
5904 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
5905 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
5906 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
5910 LDKInFlightHtlcs inflight_htlcs_var = inflight_htlcs;
5911 uint64_t inflight_htlcs_ref = 0;
5912 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
5913 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
5914 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 36, (uint32_t)payer_arr, route_params_ref, (uint32_t)first_hops_arr, inflight_htlcs_ref, 0, 0);
5915 void* ret_ptr = untag_ptr(ret);
5916 CHECK_ACCESS(ret_ptr);
5917 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
5918 FREE(untag_ptr(ret));
5921 LDKCResult_RouteLightningErrorZ find_route_with_id_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, LDKCVec_ChannelDetailsZ * first_hops, LDKInFlightHtlcs inflight_htlcs, LDKThirtyTwoBytes _payment_hash, LDKThirtyTwoBytes _payment_id) {
5922 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
5923 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
5924 memcpy(payer_arr->elems, payer.compressed_form, 33);
5925 LDKRouteParameters route_params_var = *route_params;
5926 uint64_t route_params_ref = 0;
5927 route_params_var = RouteParameters_clone(&route_params_var);
5928 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
5929 route_params_ref = tag_ptr(route_params_var.inner, route_params_var.is_owned);
5930 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
5931 uint64_tArray first_hops_arr = NULL;
5932 if (first_hops != NULL) {
5933 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
5934 first_hops_arr = init_uint64_tArray(first_hops_var.datalen, __LINE__);
5935 uint64_t *first_hops_arr_ptr = (uint64_t*)(((uint8_t*)first_hops_arr) + 8);
5936 for (size_t q = 0; q < first_hops_var.datalen; q++) {
5937 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
5938 uint64_t first_hops_conv_16_ref = 0;
5939 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
5940 first_hops_conv_16_ref = tag_ptr(first_hops_conv_16_var.inner, first_hops_conv_16_var.is_owned);
5941 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
5945 LDKInFlightHtlcs inflight_htlcs_var = inflight_htlcs;
5946 uint64_t inflight_htlcs_ref = 0;
5947 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_var);
5948 inflight_htlcs_ref = tag_ptr(inflight_htlcs_var.inner, inflight_htlcs_var.is_owned);
5949 int8_tArray _payment_hash_arr = init_int8_tArray(32, __LINE__);
5950 memcpy(_payment_hash_arr->elems, _payment_hash.data, 32);
5951 int8_tArray _payment_id_arr = init_int8_tArray(32, __LINE__);
5952 memcpy(_payment_id_arr->elems, _payment_id.data, 32);
5953 uint64_t ret = js_invoke_function_ububuu(j_calls->instance_ptr, 37, (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);
5954 void* ret_ptr = untag_ptr(ret);
5955 CHECK_ACCESS(ret_ptr);
5956 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
5957 FREE(untag_ptr(ret));
5960 static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
5961 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
5962 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5964 static inline LDKRouter LDKRouter_init (JSValue o) {
5965 LDKRouter_JCalls *calls = MALLOC(sizeof(LDKRouter_JCalls), "LDKRouter_JCalls");
5966 atomic_init(&calls->refcnt, 1);
5967 calls->instance_ptr = o;
5970 .this_arg = (void*) calls,
5971 .find_route = find_route_LDKRouter_jcall,
5972 .find_route_with_id = find_route_with_id_LDKRouter_jcall,
5973 .free = LDKRouter_JCalls_free,
5977 uint64_t __attribute__((export_name("TS_LDKRouter_new"))) TS_LDKRouter_new(JSValue o) {
5978 LDKRouter *res_ptr = MALLOC(sizeof(LDKRouter), "LDKRouter");
5979 *res_ptr = LDKRouter_init(o);
5980 return tag_ptr(res_ptr, true);
5982 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) {
5983 void* this_arg_ptr = untag_ptr(this_arg);
5984 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
5985 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
5986 LDKPublicKey payer_ref;
5987 CHECK(payer->arr_len == 33);
5988 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
5989 LDKRouteParameters route_params_conv;
5990 route_params_conv.inner = untag_ptr(route_params);
5991 route_params_conv.is_owned = ptr_is_owned(route_params);
5992 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
5993 route_params_conv.is_owned = false;
5994 LDKCVec_ChannelDetailsZ first_hops_constr;
5995 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
5996 if (first_hops != 0) {
5997 first_hops_constr.datalen = first_hops->arr_len;
5998 if (first_hops_constr.datalen > 0)
5999 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6001 first_hops_constr.data = NULL;
6002 uint64_t* first_hops_vals = first_hops->elems;
6003 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6004 uint64_t first_hops_conv_16 = first_hops_vals[q];
6005 LDKChannelDetails first_hops_conv_16_conv;
6006 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6007 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6008 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6009 first_hops_conv_16_conv.is_owned = false;
6010 first_hops_constr.data[q] = first_hops_conv_16_conv;
6013 first_hops_ptr = &first_hops_constr;
6015 LDKInFlightHtlcs inflight_htlcs_conv;
6016 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6017 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6018 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6019 inflight_htlcs_conv = InFlightHtlcs_clone(&inflight_htlcs_conv);
6020 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6021 *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, first_hops_ptr, inflight_htlcs_conv);
6022 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6023 return tag_ptr(ret_conv, true);
6026 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) {
6027 void* this_arg_ptr = untag_ptr(this_arg);
6028 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6029 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
6030 LDKPublicKey payer_ref;
6031 CHECK(payer->arr_len == 33);
6032 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
6033 LDKRouteParameters route_params_conv;
6034 route_params_conv.inner = untag_ptr(route_params);
6035 route_params_conv.is_owned = ptr_is_owned(route_params);
6036 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
6037 route_params_conv.is_owned = false;
6038 LDKCVec_ChannelDetailsZ first_hops_constr;
6039 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
6040 if (first_hops != 0) {
6041 first_hops_constr.datalen = first_hops->arr_len;
6042 if (first_hops_constr.datalen > 0)
6043 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
6045 first_hops_constr.data = NULL;
6046 uint64_t* first_hops_vals = first_hops->elems;
6047 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
6048 uint64_t first_hops_conv_16 = first_hops_vals[q];
6049 LDKChannelDetails first_hops_conv_16_conv;
6050 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
6051 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
6052 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
6053 first_hops_conv_16_conv.is_owned = false;
6054 first_hops_constr.data[q] = first_hops_conv_16_conv;
6057 first_hops_ptr = &first_hops_constr;
6059 LDKInFlightHtlcs inflight_htlcs_conv;
6060 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
6061 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
6062 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
6063 inflight_htlcs_conv = InFlightHtlcs_clone(&inflight_htlcs_conv);
6064 LDKThirtyTwoBytes _payment_hash_ref;
6065 CHECK(_payment_hash->arr_len == 32);
6066 memcpy(_payment_hash_ref.data, _payment_hash->elems, 32); FREE(_payment_hash);
6067 LDKThirtyTwoBytes _payment_id_ref;
6068 CHECK(_payment_id->arr_len == 32);
6069 memcpy(_payment_id_ref.data, _payment_id->elems, 32); FREE(_payment_id);
6070 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
6071 *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);
6072 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
6073 return tag_ptr(ret_conv, true);
6076 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner){
6077 return ThirtyTwoBytes_clone(&owner->a);
6079 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(uint64_t owner) {
6080 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesChannelManagerZ*)untag_ptr(owner);
6081 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6082 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesChannelManagerZ_get_a(owner_conv).data, 32);
6086 static inline struct LDKChannelManager C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *NONNULL_PTR owner){
6087 LDKChannelManager ret = owner->b;
6088 ret.is_owned = false;
6091 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(uint64_t owner) {
6092 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesChannelManagerZ*)untag_ptr(owner);
6093 LDKChannelManager ret_var = C2Tuple_ThirtyTwoBytesChannelManagerZ_get_b(owner_conv);
6094 uint64_t ret_ref = 0;
6095 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6096 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6100 static inline struct LDKC2Tuple_ThirtyTwoBytesChannelManagerZ *CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6101 CHECK(owner->result_ok);
6102 return &*owner->contents.result;
6104 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(uint64_t owner) {
6105 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6106 uint64_t ret_ret = tag_ptr(CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_ok(owner_conv), false);
6110 static inline struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
6111 CHECK(!owner->result_ok);
6112 return DecodeError_clone(&*owner->contents.err);
6114 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(uint64_t owner) {
6115 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ*)untag_ptr(owner);
6116 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6117 *ret_copy = CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_get_err(owner_conv);
6118 uint64_t ret_ref = tag_ptr(ret_copy, true);
6122 uint32_t __attribute__((export_name("TS_LDKMaxDustHTLCExposure_ty_from_ptr"))) TS_LDKMaxDustHTLCExposure_ty_from_ptr(uint64_t ptr) {
6123 LDKMaxDustHTLCExposure *obj = (LDKMaxDustHTLCExposure*)untag_ptr(ptr);
6125 case LDKMaxDustHTLCExposure_FixedLimitMsat: return 0;
6126 case LDKMaxDustHTLCExposure_FeeRateMultiplier: return 1;
6130 int64_t __attribute__((export_name("TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat"))) TS_LDKMaxDustHTLCExposure_FixedLimitMsat_get_fixed_limit_msat(uint64_t ptr) {
6131 LDKMaxDustHTLCExposure *obj = (LDKMaxDustHTLCExposure*)untag_ptr(ptr);
6132 assert(obj->tag == LDKMaxDustHTLCExposure_FixedLimitMsat);
6133 int64_t fixed_limit_msat_conv = obj->fixed_limit_msat;
6134 return fixed_limit_msat_conv;
6136 int64_t __attribute__((export_name("TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier"))) TS_LDKMaxDustHTLCExposure_FeeRateMultiplier_get_fee_rate_multiplier(uint64_t ptr) {
6137 LDKMaxDustHTLCExposure *obj = (LDKMaxDustHTLCExposure*)untag_ptr(ptr);
6138 assert(obj->tag == LDKMaxDustHTLCExposure_FeeRateMultiplier);
6139 int64_t fee_rate_multiplier_conv = obj->fee_rate_multiplier;
6140 return fee_rate_multiplier_conv;
6142 static inline struct LDKMaxDustHTLCExposure CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner){
6143 CHECK(owner->result_ok);
6144 return MaxDustHTLCExposure_clone(&*owner->contents.result);
6146 uint64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(uint64_t owner) {
6147 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* owner_conv = (LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)untag_ptr(owner);
6148 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
6149 *ret_copy = CResult_MaxDustHTLCExposureDecodeErrorZ_get_ok(owner_conv);
6150 uint64_t ret_ref = tag_ptr(ret_copy, true);
6154 static inline struct LDKDecodeError CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR owner){
6155 CHECK(!owner->result_ok);
6156 return DecodeError_clone(&*owner->contents.err);
6158 uint64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(uint64_t owner) {
6159 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* owner_conv = (LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)untag_ptr(owner);
6160 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6161 *ret_copy = CResult_MaxDustHTLCExposureDecodeErrorZ_get_err(owner_conv);
6162 uint64_t ret_ref = tag_ptr(ret_copy, true);
6166 static inline struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6167 LDKChannelConfig ret = *owner->contents.result;
6168 ret.is_owned = false;
6171 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_get_ok(uint64_t owner) {
6172 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6173 LDKChannelConfig ret_var = CResult_ChannelConfigDecodeErrorZ_get_ok(owner_conv);
6174 uint64_t ret_ref = 0;
6175 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6176 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6180 static inline struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
6181 CHECK(!owner->result_ok);
6182 return DecodeError_clone(&*owner->contents.err);
6184 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_err"))) TS_CResult_ChannelConfigDecodeErrorZ_get_err(uint64_t owner) {
6185 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(owner);
6186 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6187 *ret_copy = CResult_ChannelConfigDecodeErrorZ_get_err(owner_conv);
6188 uint64_t ret_ref = tag_ptr(ret_copy, true);
6192 uint32_t __attribute__((export_name("TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr"))) TS_LDKCOption_MaxDustHTLCExposureZ_ty_from_ptr(uint64_t ptr) {
6193 LDKCOption_MaxDustHTLCExposureZ *obj = (LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(ptr);
6195 case LDKCOption_MaxDustHTLCExposureZ_Some: return 0;
6196 case LDKCOption_MaxDustHTLCExposureZ_None: return 1;
6200 uint64_t __attribute__((export_name("TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some"))) TS_LDKCOption_MaxDustHTLCExposureZ_Some_get_some(uint64_t ptr) {
6201 LDKCOption_MaxDustHTLCExposureZ *obj = (LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(ptr);
6202 assert(obj->tag == LDKCOption_MaxDustHTLCExposureZ_Some);
6203 uint64_t some_ref = tag_ptr(&obj->some, false);
6206 uint32_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_ty_from_ptr"))) TS_LDKCOption_APIErrorZ_ty_from_ptr(uint64_t ptr) {
6207 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6209 case LDKCOption_APIErrorZ_Some: return 0;
6210 case LDKCOption_APIErrorZ_None: return 1;
6214 uint64_t __attribute__((export_name("TS_LDKCOption_APIErrorZ_Some_get_some"))) TS_LDKCOption_APIErrorZ_Some_get_some(uint64_t ptr) {
6215 LDKCOption_APIErrorZ *obj = (LDKCOption_APIErrorZ*)untag_ptr(ptr);
6216 assert(obj->tag == LDKCOption_APIErrorZ_Some);
6217 uint64_t some_ref = tag_ptr(&obj->some, false);
6220 static inline struct LDKCOption_APIErrorZ CResult_COption_APIErrorZDecodeErrorZ_get_ok(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6221 CHECK(owner->result_ok);
6222 return COption_APIErrorZ_clone(&*owner->contents.result);
6224 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_ok(uint64_t owner) {
6225 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6226 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
6227 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_ok(owner_conv);
6228 uint64_t ret_ref = tag_ptr(ret_copy, true);
6232 static inline struct LDKDecodeError CResult_COption_APIErrorZDecodeErrorZ_get_err(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR owner){
6233 CHECK(!owner->result_ok);
6234 return DecodeError_clone(&*owner->contents.err);
6236 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_get_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_get_err(uint64_t owner) {
6237 LDKCResult_COption_APIErrorZDecodeErrorZ* owner_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(owner);
6238 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6239 *ret_copy = CResult_COption_APIErrorZDecodeErrorZ_get_err(owner_conv);
6240 uint64_t ret_ref = tag_ptr(ret_copy, true);
6244 static inline struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6245 LDKChannelMonitorUpdate ret = *owner->contents.result;
6246 ret.is_owned = false;
6249 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6250 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6251 LDKChannelMonitorUpdate ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner_conv);
6252 uint64_t ret_ref = 0;
6253 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6254 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6258 static inline struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6259 CHECK(!owner->result_ok);
6260 return DecodeError_clone(&*owner->contents.err);
6262 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint64_t owner) {
6263 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(owner);
6264 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6265 *ret_copy = CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner_conv);
6266 uint64_t ret_ref = tag_ptr(ret_copy, true);
6270 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_ty_from_ptr"))) TS_LDKCOption_MonitorEventZ_ty_from_ptr(uint64_t ptr) {
6271 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6273 case LDKCOption_MonitorEventZ_Some: return 0;
6274 case LDKCOption_MonitorEventZ_None: return 1;
6278 uint64_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_Some_get_some"))) TS_LDKCOption_MonitorEventZ_Some_get_some(uint64_t ptr) {
6279 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)untag_ptr(ptr);
6280 assert(obj->tag == LDKCOption_MonitorEventZ_Some);
6281 uint64_t some_ref = tag_ptr(&obj->some, false);
6284 static inline struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6285 CHECK(owner->result_ok);
6286 return COption_MonitorEventZ_clone(&*owner->contents.result);
6288 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint64_t owner) {
6289 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6290 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
6291 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner_conv);
6292 uint64_t ret_ref = tag_ptr(ret_copy, true);
6296 static inline struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6297 CHECK(!owner->result_ok);
6298 return DecodeError_clone(&*owner->contents.err);
6300 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(uint64_t owner) {
6301 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(owner);
6302 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6303 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner_conv);
6304 uint64_t ret_ref = tag_ptr(ret_copy, true);
6308 static inline struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6309 LDKHTLCUpdate ret = *owner->contents.result;
6310 ret.is_owned = false;
6313 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(uint64_t owner) {
6314 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6315 LDKHTLCUpdate ret_var = CResult_HTLCUpdateDecodeErrorZ_get_ok(owner_conv);
6316 uint64_t ret_ref = 0;
6317 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6318 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6322 static inline struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6323 CHECK(!owner->result_ok);
6324 return DecodeError_clone(&*owner->contents.err);
6326 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_err(uint64_t owner) {
6327 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(owner);
6328 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6329 *ret_copy = CResult_HTLCUpdateDecodeErrorZ_get_err(owner_conv);
6330 uint64_t ret_ref = tag_ptr(ret_copy, true);
6334 static inline struct LDKOutPoint C2Tuple_OutPointCVec_u8ZZ_get_a(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner){
6335 LDKOutPoint ret = owner->a;
6336 ret.is_owned = false;
6339 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_get_a"))) TS_C2Tuple_OutPointCVec_u8ZZ_get_a(uint64_t owner) {
6340 LDKC2Tuple_OutPointCVec_u8ZZ* owner_conv = (LDKC2Tuple_OutPointCVec_u8ZZ*)untag_ptr(owner);
6341 LDKOutPoint ret_var = C2Tuple_OutPointCVec_u8ZZ_get_a(owner_conv);
6342 uint64_t ret_ref = 0;
6343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6348 static inline struct LDKCVec_u8Z C2Tuple_OutPointCVec_u8ZZ_get_b(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR owner){
6349 return CVec_u8Z_clone(&owner->b);
6351 int8_tArray __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_get_b"))) TS_C2Tuple_OutPointCVec_u8ZZ_get_b(uint64_t owner) {
6352 LDKC2Tuple_OutPointCVec_u8ZZ* owner_conv = (LDKC2Tuple_OutPointCVec_u8ZZ*)untag_ptr(owner);
6353 LDKCVec_u8Z ret_var = C2Tuple_OutPointCVec_u8ZZ_get_b(owner_conv);
6354 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6355 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6356 CVec_u8Z_free(ret_var);
6360 static inline uint32_t C2Tuple_u32CVec_u8ZZ_get_a(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner){
6363 int32_t __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_get_a"))) TS_C2Tuple_u32CVec_u8ZZ_get_a(uint64_t owner) {
6364 LDKC2Tuple_u32CVec_u8ZZ* owner_conv = (LDKC2Tuple_u32CVec_u8ZZ*)untag_ptr(owner);
6365 int32_t ret_conv = C2Tuple_u32CVec_u8ZZ_get_a(owner_conv);
6369 static inline struct LDKCVec_u8Z C2Tuple_u32CVec_u8ZZ_get_b(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR owner){
6370 return CVec_u8Z_clone(&owner->b);
6372 int8_tArray __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_get_b"))) TS_C2Tuple_u32CVec_u8ZZ_get_b(uint64_t owner) {
6373 LDKC2Tuple_u32CVec_u8ZZ* owner_conv = (LDKC2Tuple_u32CVec_u8ZZ*)untag_ptr(owner);
6374 LDKCVec_u8Z ret_var = C2Tuple_u32CVec_u8ZZ_get_b(owner_conv);
6375 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6376 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6377 CVec_u8Z_free(ret_var);
6381 static inline LDKCVec_C2Tuple_u32CVec_u8ZZZ CVec_C2Tuple_u32CVec_u8ZZZ_clone(const LDKCVec_C2Tuple_u32CVec_u8ZZZ *orig) {
6382 LDKCVec_C2Tuple_u32CVec_u8ZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32CVec_u8ZZ) * orig->datalen, "LDKCVec_C2Tuple_u32CVec_u8ZZZ clone bytes"), .datalen = orig->datalen };
6383 for (size_t i = 0; i < ret.datalen; i++) {
6384 ret.data[i] = C2Tuple_u32CVec_u8ZZ_clone(&orig->data[i]);
6388 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner){
6389 return ThirtyTwoBytes_clone(&owner->a);
6391 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(uint64_t owner) {
6392 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)untag_ptr(owner);
6393 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6394 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_a(owner_conv).data, 32);
6398 static inline struct LDKCVec_C2Tuple_u32CVec_u8ZZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR owner){
6399 return CVec_C2Tuple_u32CVec_u8ZZZ_clone(&owner->b);
6401 uint64_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(uint64_t owner) {
6402 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)untag_ptr(owner);
6403 LDKCVec_C2Tuple_u32CVec_u8ZZZ ret_var = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_get_b(owner_conv);
6404 uint64_tArray ret_arr = NULL;
6405 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6406 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6407 for (size_t x = 0; x < ret_var.datalen; x++) {
6408 LDKC2Tuple_u32CVec_u8ZZ* ret_conv_23_conv = MALLOC(sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKC2Tuple_u32CVec_u8ZZ");
6409 *ret_conv_23_conv = ret_var.data[x];
6410 ret_arr_ptr[x] = tag_ptr(ret_conv_23_conv, true);
6417 static inline LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ *orig) {
6418 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ clone bytes"), .datalen = orig->datalen };
6419 for (size_t i = 0; i < ret.datalen; i++) {
6420 ret.data[i] = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(&orig->data[i]);
6424 static inline LDKCVec_CommitmentTransactionZ CVec_CommitmentTransactionZ_clone(const LDKCVec_CommitmentTransactionZ *orig) {
6425 LDKCVec_CommitmentTransactionZ ret = { .data = MALLOC(sizeof(LDKCommitmentTransaction) * orig->datalen, "LDKCVec_CommitmentTransactionZ clone bytes"), .datalen = orig->datalen };
6426 for (size_t i = 0; i < ret.datalen; i++) {
6427 ret.data[i] = CommitmentTransaction_clone(&orig->data[i]);
6431 static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6434 int32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_a"))) TS_C2Tuple_u32TxOutZ_get_a(uint64_t owner) {
6435 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6436 int32_t ret_conv = C2Tuple_u32TxOutZ_get_a(owner_conv);
6440 static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6441 return TxOut_clone(&owner->b);
6443 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_b"))) TS_C2Tuple_u32TxOutZ_get_b(uint64_t owner) {
6444 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(owner);
6445 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6446 *ret_ref = C2Tuple_u32TxOutZ_get_b(owner_conv);
6447 return tag_ptr(ret_ref, true);
6450 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
6451 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
6452 for (size_t i = 0; i < ret.datalen; i++) {
6453 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
6457 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6458 return ThirtyTwoBytes_clone(&owner->a);
6460 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(uint64_t owner) {
6461 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6462 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6463 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_a(owner_conv).data, 32);
6467 static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6468 return CVec_C2Tuple_u32TxOutZZ_clone(&owner->b);
6470 uint64_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(uint64_t owner) {
6471 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(owner);
6472 LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_get_b(owner_conv);
6473 uint64_tArray ret_arr = NULL;
6474 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
6475 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
6476 for (size_t u = 0; u < ret_var.datalen; u++) {
6477 LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
6478 *ret_conv_20_conv = ret_var.data[u];
6479 ret_arr_ptr[u] = tag_ptr(ret_conv_20_conv, true);
6486 static inline LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ *orig) {
6487 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
6488 for (size_t i = 0; i < ret.datalen; i++) {
6489 ret.data[i] = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
6493 uint32_t __attribute__((export_name("TS_LDKBalance_ty_from_ptr"))) TS_LDKBalance_ty_from_ptr(uint64_t ptr) {
6494 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6496 case LDKBalance_ClaimableOnChannelClose: return 0;
6497 case LDKBalance_ClaimableAwaitingConfirmations: return 1;
6498 case LDKBalance_ContentiousClaimable: return 2;
6499 case LDKBalance_MaybeTimeoutClaimableHTLC: return 3;
6500 case LDKBalance_MaybePreimageClaimableHTLC: return 4;
6501 case LDKBalance_CounterpartyRevokedOutputClaimable: return 5;
6505 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis"))) TS_LDKBalance_ClaimableOnChannelClose_get_amount_satoshis(uint64_t ptr) {
6506 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6507 assert(obj->tag == LDKBalance_ClaimableOnChannelClose);
6508 int64_t amount_satoshis_conv = obj->claimable_on_channel_close.amount_satoshis;
6509 return amount_satoshis_conv;
6511 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_amount_satoshis(uint64_t ptr) {
6512 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6513 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6514 int64_t amount_satoshis_conv = obj->claimable_awaiting_confirmations.amount_satoshis;
6515 return amount_satoshis_conv;
6517 int32_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(uint64_t ptr) {
6518 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6519 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6520 int32_t confirmation_height_conv = obj->claimable_awaiting_confirmations.confirmation_height;
6521 return confirmation_height_conv;
6523 int64_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_amount_satoshis"))) TS_LDKBalance_ContentiousClaimable_get_amount_satoshis(uint64_t ptr) {
6524 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6525 assert(obj->tag == LDKBalance_ContentiousClaimable);
6526 int64_t amount_satoshis_conv = obj->contentious_claimable.amount_satoshis;
6527 return amount_satoshis_conv;
6529 int32_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_timeout_height"))) TS_LDKBalance_ContentiousClaimable_get_timeout_height(uint64_t ptr) {
6530 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6531 assert(obj->tag == LDKBalance_ContentiousClaimable);
6532 int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
6533 return timeout_height_conv;
6535 int8_tArray __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_payment_hash"))) TS_LDKBalance_ContentiousClaimable_get_payment_hash(uint64_t ptr) {
6536 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6537 assert(obj->tag == LDKBalance_ContentiousClaimable);
6538 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
6539 memcpy(payment_hash_arr->elems, obj->contentious_claimable.payment_hash.data, 32);
6540 return payment_hash_arr;
6542 int8_tArray __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_payment_preimage"))) TS_LDKBalance_ContentiousClaimable_get_payment_preimage(uint64_t ptr) {
6543 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6544 assert(obj->tag == LDKBalance_ContentiousClaimable);
6545 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
6546 memcpy(payment_preimage_arr->elems, obj->contentious_claimable.payment_preimage.data, 32);
6547 return payment_preimage_arr;
6549 int64_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_amount_satoshis(uint64_t ptr) {
6550 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6551 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
6552 int64_t amount_satoshis_conv = obj->maybe_timeout_claimable_htlc.amount_satoshis;
6553 return amount_satoshis_conv;
6555 int32_t __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_claimable_height(uint64_t ptr) {
6556 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6557 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
6558 int32_t claimable_height_conv = obj->maybe_timeout_claimable_htlc.claimable_height;
6559 return claimable_height_conv;
6561 int8_tArray __attribute__((export_name("TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash"))) TS_LDKBalance_MaybeTimeoutClaimableHTLC_get_payment_hash(uint64_t ptr) {
6562 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6563 assert(obj->tag == LDKBalance_MaybeTimeoutClaimableHTLC);
6564 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
6565 memcpy(payment_hash_arr->elems, obj->maybe_timeout_claimable_htlc.payment_hash.data, 32);
6566 return payment_hash_arr;
6568 int64_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_amount_satoshis(uint64_t ptr) {
6569 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6570 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
6571 int64_t amount_satoshis_conv = obj->maybe_preimage_claimable_htlc.amount_satoshis;
6572 return amount_satoshis_conv;
6574 int32_t __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_expiry_height(uint64_t ptr) {
6575 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6576 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
6577 int32_t expiry_height_conv = obj->maybe_preimage_claimable_htlc.expiry_height;
6578 return expiry_height_conv;
6580 int8_tArray __attribute__((export_name("TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash"))) TS_LDKBalance_MaybePreimageClaimableHTLC_get_payment_hash(uint64_t ptr) {
6581 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6582 assert(obj->tag == LDKBalance_MaybePreimageClaimableHTLC);
6583 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
6584 memcpy(payment_hash_arr->elems, obj->maybe_preimage_claimable_htlc.payment_hash.data, 32);
6585 return payment_hash_arr;
6587 int64_t __attribute__((export_name("TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis"))) TS_LDKBalance_CounterpartyRevokedOutputClaimable_get_amount_satoshis(uint64_t ptr) {
6588 LDKBalance *obj = (LDKBalance*)untag_ptr(ptr);
6589 assert(obj->tag == LDKBalance_CounterpartyRevokedOutputClaimable);
6590 int64_t amount_satoshis_conv = obj->counterparty_revoked_output_claimable.amount_satoshis;
6591 return amount_satoshis_conv;
6593 static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
6594 LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
6595 for (size_t i = 0; i < ret.datalen; i++) {
6596 ret.data[i] = Balance_clone(&orig->data[i]);
6600 static inline struct LDKThirtyTwoBytes C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner){
6601 return ThirtyTwoBytes_clone(&owner->a);
6603 int8_tArray __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(uint64_t owner) {
6604 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(owner);
6605 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6606 memcpy(ret_arr->elems, C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_a(owner_conv).data, 32);
6610 static inline struct LDKChannelMonitor C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR owner){
6611 LDKChannelMonitor ret = owner->b;
6612 ret.is_owned = false;
6615 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(uint64_t owner) {
6616 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* owner_conv = (LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(owner);
6617 LDKChannelMonitor ret_var = C2Tuple_ThirtyTwoBytesChannelMonitorZ_get_b(owner_conv);
6618 uint64_t ret_ref = 0;
6619 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6620 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
6624 static inline struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6625 CHECK(owner->result_ok);
6626 return C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(&*owner->contents.result);
6628 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(uint64_t owner) {
6629 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
6630 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
6631 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_ok(owner_conv);
6632 return tag_ptr(ret_conv, true);
6635 static inline struct LDKDecodeError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6636 CHECK(!owner->result_ok);
6637 return DecodeError_clone(&*owner->contents.err);
6639 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(uint64_t owner) {
6640 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)untag_ptr(owner);
6641 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6642 *ret_copy = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_get_err(owner_conv);
6643 uint64_t ret_ref = tag_ptr(ret_copy, true);
6647 typedef struct LDKType_JCalls {
6648 atomic_size_t refcnt;
6649 uint32_t instance_ptr;
6651 static void LDKType_JCalls_free(void* this_arg) {
6652 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6653 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6657 uint16_t type_id_LDKType_jcall(const void* this_arg) {
6658 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6659 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 38, 0, 0, 0, 0, 0, 0);
6661 LDKStr debug_str_LDKType_jcall(const void* this_arg) {
6662 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6663 jstring ret = (jstring)js_invoke_function_uuuuuu(j_calls->instance_ptr, 39, 0, 0, 0, 0, 0, 0);
6664 LDKStr ret_conv = str_ref_to_owned_c(ret);
6667 LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) {
6668 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
6669 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 40, 0, 0, 0, 0, 0, 0);
6670 LDKCVec_u8Z ret_ref;
6671 ret_ref.datalen = ret->arr_len;
6672 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6673 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6676 static void LDKType_JCalls_cloned(LDKType* new_obj) {
6677 LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg;
6678 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6680 static inline LDKType LDKType_init (JSValue o) {
6681 LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls");
6682 atomic_init(&calls->refcnt, 1);
6683 calls->instance_ptr = o;
6686 .this_arg = (void*) calls,
6687 .type_id = type_id_LDKType_jcall,
6688 .debug_str = debug_str_LDKType_jcall,
6689 .write = write_LDKType_jcall,
6690 .cloned = LDKType_JCalls_cloned,
6691 .free = LDKType_JCalls_free,
6695 uint64_t __attribute__((export_name("TS_LDKType_new"))) TS_LDKType_new(JSValue o) {
6696 LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType");
6697 *res_ptr = LDKType_init(o);
6698 return tag_ptr(res_ptr, true);
6700 int16_t __attribute__((export_name("TS_Type_type_id"))) TS_Type_type_id(uint64_t this_arg) {
6701 void* this_arg_ptr = untag_ptr(this_arg);
6702 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6703 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6704 int16_t ret_conv = (this_arg_conv->type_id)(this_arg_conv->this_arg);
6708 jstring __attribute__((export_name("TS_Type_debug_str"))) TS_Type_debug_str(uint64_t this_arg) {
6709 void* this_arg_ptr = untag_ptr(this_arg);
6710 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6711 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6712 LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg);
6713 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6718 int8_tArray __attribute__((export_name("TS_Type_write"))) TS_Type_write(uint64_t this_arg) {
6719 void* this_arg_ptr = untag_ptr(this_arg);
6720 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6721 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
6722 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
6723 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6724 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6725 CVec_u8Z_free(ret_var);
6729 static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6732 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_a"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint64_t owner) {
6733 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
6734 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
6735 memcpy(ret_arr->elems, C2Tuple_PublicKeyTypeZ_get_a(owner_conv).compressed_form, 33);
6739 static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6740 return Type_clone(&owner->b);
6742 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_b"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint64_t owner) {
6743 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(owner);
6744 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
6745 *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(owner_conv);
6746 return tag_ptr(ret_ret, true);
6749 static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
6750 LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
6751 for (size_t i = 0; i < ret.datalen; i++) {
6752 ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]);
6756 uint32_t __attribute__((export_name("TS_LDKOffersMessage_ty_from_ptr"))) TS_LDKOffersMessage_ty_from_ptr(uint64_t ptr) {
6757 LDKOffersMessage *obj = (LDKOffersMessage*)untag_ptr(ptr);
6759 case LDKOffersMessage_InvoiceRequest: return 0;
6760 case LDKOffersMessage_Invoice: return 1;
6761 case LDKOffersMessage_InvoiceError: return 2;
6765 uint64_t __attribute__((export_name("TS_LDKOffersMessage_InvoiceRequest_get_invoice_request"))) TS_LDKOffersMessage_InvoiceRequest_get_invoice_request(uint64_t ptr) {
6766 LDKOffersMessage *obj = (LDKOffersMessage*)untag_ptr(ptr);
6767 assert(obj->tag == LDKOffersMessage_InvoiceRequest);
6768 LDKInvoiceRequest invoice_request_var = obj->invoice_request;
6769 uint64_t invoice_request_ref = 0;
6770 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_request_var);
6771 invoice_request_ref = tag_ptr(invoice_request_var.inner, false);
6772 return invoice_request_ref;
6774 uint64_t __attribute__((export_name("TS_LDKOffersMessage_Invoice_get_invoice"))) TS_LDKOffersMessage_Invoice_get_invoice(uint64_t ptr) {
6775 LDKOffersMessage *obj = (LDKOffersMessage*)untag_ptr(ptr);
6776 assert(obj->tag == LDKOffersMessage_Invoice);
6777 LDKBolt12Invoice invoice_var = obj->invoice;
6778 uint64_t invoice_ref = 0;
6779 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_var);
6780 invoice_ref = tag_ptr(invoice_var.inner, false);
6783 uint64_t __attribute__((export_name("TS_LDKOffersMessage_InvoiceError_get_invoice_error"))) TS_LDKOffersMessage_InvoiceError_get_invoice_error(uint64_t ptr) {
6784 LDKOffersMessage *obj = (LDKOffersMessage*)untag_ptr(ptr);
6785 assert(obj->tag == LDKOffersMessage_InvoiceError);
6786 LDKInvoiceError invoice_error_var = obj->invoice_error;
6787 uint64_t invoice_error_ref = 0;
6788 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_error_var);
6789 invoice_error_ref = tag_ptr(invoice_error_var.inner, false);
6790 return invoice_error_ref;
6792 uint32_t __attribute__((export_name("TS_LDKCOption_OffersMessageZ_ty_from_ptr"))) TS_LDKCOption_OffersMessageZ_ty_from_ptr(uint64_t ptr) {
6793 LDKCOption_OffersMessageZ *obj = (LDKCOption_OffersMessageZ*)untag_ptr(ptr);
6795 case LDKCOption_OffersMessageZ_Some: return 0;
6796 case LDKCOption_OffersMessageZ_None: return 1;
6800 uint64_t __attribute__((export_name("TS_LDKCOption_OffersMessageZ_Some_get_some"))) TS_LDKCOption_OffersMessageZ_Some_get_some(uint64_t ptr) {
6801 LDKCOption_OffersMessageZ *obj = (LDKCOption_OffersMessageZ*)untag_ptr(ptr);
6802 assert(obj->tag == LDKCOption_OffersMessageZ_Some);
6803 uint64_t some_ref = tag_ptr(&obj->some, false);
6806 typedef struct LDKCustomOnionMessageContents_JCalls {
6807 atomic_size_t refcnt;
6808 uint32_t instance_ptr;
6809 } LDKCustomOnionMessageContents_JCalls;
6810 static void LDKCustomOnionMessageContents_JCalls_free(void* this_arg) {
6811 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6812 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6816 uint64_t tlv_type_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
6817 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6818 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 41, 0, 0, 0, 0, 0, 0);
6820 LDKCVec_u8Z write_LDKCustomOnionMessageContents_jcall(const void* this_arg) {
6821 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) this_arg;
6822 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 42, 0, 0, 0, 0, 0, 0);
6823 LDKCVec_u8Z ret_ref;
6824 ret_ref.datalen = ret->arr_len;
6825 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
6826 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
6829 static void LDKCustomOnionMessageContents_JCalls_cloned(LDKCustomOnionMessageContents* new_obj) {
6830 LDKCustomOnionMessageContents_JCalls *j_calls = (LDKCustomOnionMessageContents_JCalls*) new_obj->this_arg;
6831 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6833 static inline LDKCustomOnionMessageContents LDKCustomOnionMessageContents_init (JSValue o) {
6834 LDKCustomOnionMessageContents_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageContents_JCalls), "LDKCustomOnionMessageContents_JCalls");
6835 atomic_init(&calls->refcnt, 1);
6836 calls->instance_ptr = o;
6838 LDKCustomOnionMessageContents ret = {
6839 .this_arg = (void*) calls,
6840 .tlv_type = tlv_type_LDKCustomOnionMessageContents_jcall,
6841 .write = write_LDKCustomOnionMessageContents_jcall,
6842 .cloned = LDKCustomOnionMessageContents_JCalls_cloned,
6843 .free = LDKCustomOnionMessageContents_JCalls_free,
6847 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageContents_new"))) TS_LDKCustomOnionMessageContents_new(JSValue o) {
6848 LDKCustomOnionMessageContents *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
6849 *res_ptr = LDKCustomOnionMessageContents_init(o);
6850 return tag_ptr(res_ptr, true);
6852 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_tlv_type"))) TS_CustomOnionMessageContents_tlv_type(uint64_t this_arg) {
6853 void* this_arg_ptr = untag_ptr(this_arg);
6854 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6855 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
6856 int64_t ret_conv = (this_arg_conv->tlv_type)(this_arg_conv->this_arg);
6860 int8_tArray __attribute__((export_name("TS_CustomOnionMessageContents_write"))) TS_CustomOnionMessageContents_write(uint64_t this_arg) {
6861 void* this_arg_ptr = untag_ptr(this_arg);
6862 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
6863 LDKCustomOnionMessageContents* this_arg_conv = (LDKCustomOnionMessageContents*)this_arg_ptr;
6864 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
6865 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6866 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6867 CVec_u8Z_free(ret_var);
6871 uint32_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr"))) TS_LDKCOption_CustomOnionMessageContentsZ_ty_from_ptr(uint64_t ptr) {
6872 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
6874 case LDKCOption_CustomOnionMessageContentsZ_Some: return 0;
6875 case LDKCOption_CustomOnionMessageContentsZ_None: return 1;
6879 uint64_t __attribute__((export_name("TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some"))) TS_LDKCOption_CustomOnionMessageContentsZ_Some_get_some(uint64_t ptr) {
6880 LDKCOption_CustomOnionMessageContentsZ *obj = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(ptr);
6881 assert(obj->tag == LDKCOption_CustomOnionMessageContentsZ_Some);
6882 LDKCustomOnionMessageContents* some_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
6883 *some_ret = CustomOnionMessageContents_clone(&obj->some);
6884 return tag_ptr(some_ret, true);
6886 static inline struct LDKCOption_CustomOnionMessageContentsZ CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
6887 CHECK(owner->result_ok);
6888 return COption_CustomOnionMessageContentsZ_clone(&*owner->contents.result);
6890 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(uint64_t owner) {
6891 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
6892 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
6893 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_ok(owner_conv);
6894 uint64_t ret_ref = tag_ptr(ret_copy, true);
6898 static inline struct LDKDecodeError CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR owner){
6899 CHECK(!owner->result_ok);
6900 return DecodeError_clone(&*owner->contents.err);
6902 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(uint64_t owner) {
6903 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* owner_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(owner);
6904 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6905 *ret_copy = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_get_err(owner_conv);
6906 uint64_t ret_ref = tag_ptr(ret_copy, true);
6910 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_ty_from_ptr"))) TS_LDKCOption_TypeZ_ty_from_ptr(uint64_t ptr) {
6911 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6913 case LDKCOption_TypeZ_Some: return 0;
6914 case LDKCOption_TypeZ_None: return 1;
6918 uint64_t __attribute__((export_name("TS_LDKCOption_TypeZ_Some_get_some"))) TS_LDKCOption_TypeZ_Some_get_some(uint64_t ptr) {
6919 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)untag_ptr(ptr);
6920 assert(obj->tag == LDKCOption_TypeZ_Some);
6921 LDKType* some_ret = MALLOC(sizeof(LDKType), "LDKType");
6922 *some_ret = Type_clone(&obj->some);
6923 return tag_ptr(some_ret, true);
6925 static inline struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6926 CHECK(owner->result_ok);
6927 return COption_TypeZ_clone(&*owner->contents.result);
6929 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_get_ok(uint64_t owner) {
6930 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6931 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
6932 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_ok(owner_conv);
6933 uint64_t ret_ref = tag_ptr(ret_copy, true);
6937 static inline struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
6938 CHECK(!owner->result_ok);
6939 return DecodeError_clone(&*owner->contents.err);
6941 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_err"))) TS_CResult_COption_TypeZDecodeErrorZ_get_err(uint64_t owner) {
6942 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(owner);
6943 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
6944 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_err(owner_conv);
6945 uint64_t ret_ref = tag_ptr(ret_copy, true);
6949 uint32_t __attribute__((export_name("TS_LDKCOption_SocketAddressZ_ty_from_ptr"))) TS_LDKCOption_SocketAddressZ_ty_from_ptr(uint64_t ptr) {
6950 LDKCOption_SocketAddressZ *obj = (LDKCOption_SocketAddressZ*)untag_ptr(ptr);
6952 case LDKCOption_SocketAddressZ_Some: return 0;
6953 case LDKCOption_SocketAddressZ_None: return 1;
6957 uint64_t __attribute__((export_name("TS_LDKCOption_SocketAddressZ_Some_get_some"))) TS_LDKCOption_SocketAddressZ_Some_get_some(uint64_t ptr) {
6958 LDKCOption_SocketAddressZ *obj = (LDKCOption_SocketAddressZ*)untag_ptr(ptr);
6959 assert(obj->tag == LDKCOption_SocketAddressZ_Some);
6960 uint64_t some_ref = tag_ptr(&obj->some, false);
6963 static inline struct LDKPublicKey C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner){
6966 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(uint64_t owner) {
6967 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)untag_ptr(owner);
6968 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
6969 memcpy(ret_arr->elems, C2Tuple_PublicKeyCOption_SocketAddressZZ_get_a(owner_conv).compressed_form, 33);
6973 static inline struct LDKCOption_SocketAddressZ C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR owner){
6974 return COption_SocketAddressZ_clone(&owner->b);
6976 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(uint64_t owner) {
6977 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* owner_conv = (LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)untag_ptr(owner);
6978 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
6979 *ret_copy = C2Tuple_PublicKeyCOption_SocketAddressZZ_get_b(owner_conv);
6980 uint64_t ret_ref = tag_ptr(ret_copy, true);
6984 static inline LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_clone(const LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ *orig) {
6985 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ clone bytes"), .datalen = orig->datalen };
6986 for (size_t i = 0; i < ret.datalen; i++) {
6987 ret.data[i] = C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(&orig->data[i]);
6991 static inline struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
6992 CHECK(owner->result_ok);
6993 return CVec_u8Z_clone(&*owner->contents.result);
6995 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint64_t owner) {
6996 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
6997 LDKCVec_u8Z ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner_conv);
6998 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6999 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7000 CVec_u8Z_free(ret_var);
7004 static inline struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
7005 LDKPeerHandleError ret = *owner->contents.err;
7006 ret.is_owned = false;
7009 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(uint64_t owner) {
7010 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(owner);
7011 LDKPeerHandleError ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner_conv);
7012 uint64_t ret_ref = 0;
7013 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7014 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7018 static inline void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7019 CHECK(owner->result_ok);
7020 return *owner->contents.result;
7022 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_ok"))) TS_CResult_NonePeerHandleErrorZ_get_ok(uint64_t owner) {
7023 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7024 CResult_NonePeerHandleErrorZ_get_ok(owner_conv);
7027 static inline struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
7028 LDKPeerHandleError ret = *owner->contents.err;
7029 ret.is_owned = false;
7032 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_err"))) TS_CResult_NonePeerHandleErrorZ_get_err(uint64_t owner) {
7033 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(owner);
7034 LDKPeerHandleError ret_var = CResult_NonePeerHandleErrorZ_get_err(owner_conv);
7035 uint64_t ret_ref = 0;
7036 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7037 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7041 static inline bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7042 CHECK(owner->result_ok);
7043 return *owner->contents.result;
7045 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_ok"))) TS_CResult_boolPeerHandleErrorZ_get_ok(uint64_t owner) {
7046 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7047 jboolean ret_conv = CResult_boolPeerHandleErrorZ_get_ok(owner_conv);
7051 static inline struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
7052 LDKPeerHandleError ret = *owner->contents.err;
7053 ret.is_owned = false;
7056 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_err"))) TS_CResult_boolPeerHandleErrorZ_get_err(uint64_t owner) {
7057 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(owner);
7058 LDKPeerHandleError ret_var = CResult_boolPeerHandleErrorZ_get_err(owner_conv);
7059 uint64_t ret_ref = 0;
7060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7061 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7065 uint32_t __attribute__((export_name("TS_LDKGraphSyncError_ty_from_ptr"))) TS_LDKGraphSyncError_ty_from_ptr(uint64_t ptr) {
7066 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7068 case LDKGraphSyncError_DecodeError: return 0;
7069 case LDKGraphSyncError_LightningError: return 1;
7073 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_DecodeError_get_decode_error"))) TS_LDKGraphSyncError_DecodeError_get_decode_error(uint64_t ptr) {
7074 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7075 assert(obj->tag == LDKGraphSyncError_DecodeError);
7076 uint64_t decode_error_ref = tag_ptr(&obj->decode_error, false);
7077 return decode_error_ref;
7079 uint64_t __attribute__((export_name("TS_LDKGraphSyncError_LightningError_get_lightning_error"))) TS_LDKGraphSyncError_LightningError_get_lightning_error(uint64_t ptr) {
7080 LDKGraphSyncError *obj = (LDKGraphSyncError*)untag_ptr(ptr);
7081 assert(obj->tag == LDKGraphSyncError_LightningError);
7082 LDKLightningError lightning_error_var = obj->lightning_error;
7083 uint64_t lightning_error_ref = 0;
7084 CHECK_INNER_FIELD_ACCESS_OR_NULL(lightning_error_var);
7085 lightning_error_ref = tag_ptr(lightning_error_var.inner, false);
7086 return lightning_error_ref;
7088 static inline uint32_t CResult_u32GraphSyncErrorZ_get_ok(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7089 CHECK(owner->result_ok);
7090 return *owner->contents.result;
7092 int32_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_ok"))) TS_CResult_u32GraphSyncErrorZ_get_ok(uint64_t owner) {
7093 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7094 int32_t ret_conv = CResult_u32GraphSyncErrorZ_get_ok(owner_conv);
7098 static inline struct LDKGraphSyncError CResult_u32GraphSyncErrorZ_get_err(LDKCResult_u32GraphSyncErrorZ *NONNULL_PTR owner){
7099 CHECK(!owner->result_ok);
7100 return GraphSyncError_clone(&*owner->contents.err);
7102 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_get_err"))) TS_CResult_u32GraphSyncErrorZ_get_err(uint64_t owner) {
7103 LDKCResult_u32GraphSyncErrorZ* owner_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(owner);
7104 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
7105 *ret_copy = CResult_u32GraphSyncErrorZ_get_err(owner_conv);
7106 uint64_t ret_ref = tag_ptr(ret_copy, true);
7110 static inline struct LDKCVec_u8Z CResult_CVec_u8ZIOErrorZ_get_ok(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner){
7111 CHECK(owner->result_ok);
7112 return CVec_u8Z_clone(&*owner->contents.result);
7114 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_get_ok"))) TS_CResult_CVec_u8ZIOErrorZ_get_ok(uint64_t owner) {
7115 LDKCResult_CVec_u8ZIOErrorZ* owner_conv = (LDKCResult_CVec_u8ZIOErrorZ*)untag_ptr(owner);
7116 LDKCVec_u8Z ret_var = CResult_CVec_u8ZIOErrorZ_get_ok(owner_conv);
7117 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
7118 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
7119 CVec_u8Z_free(ret_var);
7123 static inline enum LDKIOError CResult_CVec_u8ZIOErrorZ_get_err(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR owner){
7124 CHECK(!owner->result_ok);
7125 return *owner->contents.err;
7127 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_get_err"))) TS_CResult_CVec_u8ZIOErrorZ_get_err(uint64_t owner) {
7128 LDKCResult_CVec_u8ZIOErrorZ* owner_conv = (LDKCResult_CVec_u8ZIOErrorZ*)untag_ptr(owner);
7129 uint32_t ret_conv = LDKIOError_to_js(CResult_CVec_u8ZIOErrorZ_get_err(owner_conv));
7133 static inline void CResult_NoneIOErrorZ_get_ok(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner){
7134 CHECK(owner->result_ok);
7135 return *owner->contents.result;
7137 void __attribute__((export_name("TS_CResult_NoneIOErrorZ_get_ok"))) TS_CResult_NoneIOErrorZ_get_ok(uint64_t owner) {
7138 LDKCResult_NoneIOErrorZ* owner_conv = (LDKCResult_NoneIOErrorZ*)untag_ptr(owner);
7139 CResult_NoneIOErrorZ_get_ok(owner_conv);
7142 static inline enum LDKIOError CResult_NoneIOErrorZ_get_err(LDKCResult_NoneIOErrorZ *NONNULL_PTR owner){
7143 CHECK(!owner->result_ok);
7144 return *owner->contents.err;
7146 uint32_t __attribute__((export_name("TS_CResult_NoneIOErrorZ_get_err"))) TS_CResult_NoneIOErrorZ_get_err(uint64_t owner) {
7147 LDKCResult_NoneIOErrorZ* owner_conv = (LDKCResult_NoneIOErrorZ*)untag_ptr(owner);
7148 uint32_t ret_conv = LDKIOError_to_js(CResult_NoneIOErrorZ_get_err(owner_conv));
7152 static inline struct LDKCVec_StrZ CResult_CVec_StrZIOErrorZ_get_ok(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner){
7153 CHECK(owner->result_ok);
7154 return *owner->contents.result;
7156 ptrArray __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_get_ok"))) TS_CResult_CVec_StrZIOErrorZ_get_ok(uint64_t owner) {
7157 LDKCResult_CVec_StrZIOErrorZ* owner_conv = (LDKCResult_CVec_StrZIOErrorZ*)untag_ptr(owner);
7158 LDKCVec_StrZ ret_var = CResult_CVec_StrZIOErrorZ_get_ok(owner_conv);
7159 ptrArray ret_arr = NULL;
7160 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
7161 jstring *ret_arr_ptr = (jstring*)(((uint8_t*)ret_arr) + 8);
7162 for (size_t i = 0; i < ret_var.datalen; i++) {
7163 LDKStr ret_conv_8_str = ret_var.data[i];
7164 jstring ret_conv_8_conv = str_ref_to_ts(ret_conv_8_str.chars, ret_conv_8_str.len);
7165 ret_arr_ptr[i] = ret_conv_8_conv;
7171 static inline enum LDKIOError CResult_CVec_StrZIOErrorZ_get_err(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR owner){
7172 CHECK(!owner->result_ok);
7173 return *owner->contents.err;
7175 uint32_t __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_get_err"))) TS_CResult_CVec_StrZIOErrorZ_get_err(uint64_t owner) {
7176 LDKCResult_CVec_StrZIOErrorZ* owner_conv = (LDKCResult_CVec_StrZIOErrorZ*)untag_ptr(owner);
7177 uint32_t ret_conv = LDKIOError_to_js(CResult_CVec_StrZIOErrorZ_get_err(owner_conv));
7181 static inline LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_clone(const LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ *orig) {
7182 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ clone bytes"), .datalen = orig->datalen };
7183 for (size_t i = 0; i < ret.datalen; i++) {
7184 ret.data[i] = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(&orig->data[i]);
7188 static inline struct LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner){
7189 CHECK(owner->result_ok);
7190 return CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_clone(&*owner->contents.result);
7192 uint64_tArray __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(uint64_t owner) {
7193 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)untag_ptr(owner);
7194 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ ret_var = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_ok(owner_conv);
7195 uint64_tArray ret_arr = NULL;
7196 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
7197 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
7198 for (size_t o = 0; o < ret_var.datalen; o++) {
7199 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
7200 *ret_conv_40_conv = ret_var.data[o];
7201 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
7208 static inline enum LDKIOError CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR owner){
7209 CHECK(!owner->result_ok);
7210 return *owner->contents.err;
7212 uint32_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(uint64_t owner) {
7213 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)untag_ptr(owner);
7214 uint32_t ret_conv = LDKIOError_to_js(CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_get_err(owner_conv));
7218 static inline struct LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner){
7219 CHECK(owner->result_ok);
7220 return C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(&*owner->contents.result);
7222 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(uint64_t owner) {
7223 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)untag_ptr(owner);
7224 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
7225 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_ok(owner_conv);
7226 return tag_ptr(ret_conv, true);
7229 static inline enum LDKIOError CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR owner){
7230 CHECK(!owner->result_ok);
7231 return *owner->contents.err;
7233 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(uint64_t owner) {
7234 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* owner_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)untag_ptr(owner);
7235 uint32_t ret_conv = LDKIOError_to_js(CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_get_err(owner_conv));
7239 uint32_t __attribute__((export_name("TS_LDKCOption_SecretKeyZ_ty_from_ptr"))) TS_LDKCOption_SecretKeyZ_ty_from_ptr(uint64_t ptr) {
7240 LDKCOption_SecretKeyZ *obj = (LDKCOption_SecretKeyZ*)untag_ptr(ptr);
7242 case LDKCOption_SecretKeyZ_Some: return 0;
7243 case LDKCOption_SecretKeyZ_None: return 1;
7247 int8_tArray __attribute__((export_name("TS_LDKCOption_SecretKeyZ_Some_get_some"))) TS_LDKCOption_SecretKeyZ_Some_get_some(uint64_t ptr) {
7248 LDKCOption_SecretKeyZ *obj = (LDKCOption_SecretKeyZ*)untag_ptr(ptr);
7249 assert(obj->tag == LDKCOption_SecretKeyZ_Some);
7250 int8_tArray some_arr = init_int8_tArray(32, __LINE__);
7251 memcpy(some_arr->elems, obj->some.bytes, 32);
7254 static inline struct LDKVerifiedInvoiceRequest CResult_VerifiedInvoiceRequestNoneZ_get_ok(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner){
7255 LDKVerifiedInvoiceRequest ret = *owner->contents.result;
7256 ret.is_owned = false;
7259 uint64_t __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok"))) TS_CResult_VerifiedInvoiceRequestNoneZ_get_ok(uint64_t owner) {
7260 LDKCResult_VerifiedInvoiceRequestNoneZ* owner_conv = (LDKCResult_VerifiedInvoiceRequestNoneZ*)untag_ptr(owner);
7261 LDKVerifiedInvoiceRequest ret_var = CResult_VerifiedInvoiceRequestNoneZ_get_ok(owner_conv);
7262 uint64_t ret_ref = 0;
7263 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7264 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7268 static inline void CResult_VerifiedInvoiceRequestNoneZ_get_err(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR owner){
7269 CHECK(!owner->result_ok);
7270 return *owner->contents.err;
7272 void __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_get_err"))) TS_CResult_VerifiedInvoiceRequestNoneZ_get_err(uint64_t owner) {
7273 LDKCResult_VerifiedInvoiceRequestNoneZ* owner_conv = (LDKCResult_VerifiedInvoiceRequestNoneZ*)untag_ptr(owner);
7274 CResult_VerifiedInvoiceRequestNoneZ_get_err(owner_conv);
7277 static inline LDKCVec_WitnessZ CVec_WitnessZ_clone(const LDKCVec_WitnessZ *orig) {
7278 LDKCVec_WitnessZ ret = { .data = MALLOC(sizeof(LDKWitness) * orig->datalen, "LDKCVec_WitnessZ clone bytes"), .datalen = orig->datalen };
7279 for (size_t i = 0; i < ret.datalen; i++) {
7280 ret.data[i] = Witness_clone(&orig->data[i]);
7284 uint32_t __attribute__((export_name("TS_LDKCOption_i64Z_ty_from_ptr"))) TS_LDKCOption_i64Z_ty_from_ptr(uint64_t ptr) {
7285 LDKCOption_i64Z *obj = (LDKCOption_i64Z*)untag_ptr(ptr);
7287 case LDKCOption_i64Z_Some: return 0;
7288 case LDKCOption_i64Z_None: return 1;
7292 int64_t __attribute__((export_name("TS_LDKCOption_i64Z_Some_get_some"))) TS_LDKCOption_i64Z_Some_get_some(uint64_t ptr) {
7293 LDKCOption_i64Z *obj = (LDKCOption_i64Z*)untag_ptr(ptr);
7294 assert(obj->tag == LDKCOption_i64Z_Some);
7295 int64_t some_conv = obj->some;
7298 static inline struct LDKSocketAddress CResult_SocketAddressDecodeErrorZ_get_ok(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner){
7299 CHECK(owner->result_ok);
7300 return SocketAddress_clone(&*owner->contents.result);
7302 uint64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_get_ok"))) TS_CResult_SocketAddressDecodeErrorZ_get_ok(uint64_t owner) {
7303 LDKCResult_SocketAddressDecodeErrorZ* owner_conv = (LDKCResult_SocketAddressDecodeErrorZ*)untag_ptr(owner);
7304 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
7305 *ret_copy = CResult_SocketAddressDecodeErrorZ_get_ok(owner_conv);
7306 uint64_t ret_ref = tag_ptr(ret_copy, true);
7310 static inline struct LDKDecodeError CResult_SocketAddressDecodeErrorZ_get_err(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR owner){
7311 CHECK(!owner->result_ok);
7312 return DecodeError_clone(&*owner->contents.err);
7314 uint64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_get_err"))) TS_CResult_SocketAddressDecodeErrorZ_get_err(uint64_t owner) {
7315 LDKCResult_SocketAddressDecodeErrorZ* owner_conv = (LDKCResult_SocketAddressDecodeErrorZ*)untag_ptr(owner);
7316 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7317 *ret_copy = CResult_SocketAddressDecodeErrorZ_get_err(owner_conv);
7318 uint64_t ret_ref = tag_ptr(ret_copy, true);
7322 static inline struct LDKSocketAddress CResult_SocketAddressSocketAddressParseErrorZ_get_ok(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner){
7323 CHECK(owner->result_ok);
7324 return SocketAddress_clone(&*owner->contents.result);
7326 uint64_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_get_ok(uint64_t owner) {
7327 LDKCResult_SocketAddressSocketAddressParseErrorZ* owner_conv = (LDKCResult_SocketAddressSocketAddressParseErrorZ*)untag_ptr(owner);
7328 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
7329 *ret_copy = CResult_SocketAddressSocketAddressParseErrorZ_get_ok(owner_conv);
7330 uint64_t ret_ref = tag_ptr(ret_copy, true);
7334 static inline enum LDKSocketAddressParseError CResult_SocketAddressSocketAddressParseErrorZ_get_err(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR owner){
7335 CHECK(!owner->result_ok);
7336 return SocketAddressParseError_clone(&*owner->contents.err);
7338 uint32_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_get_err(uint64_t owner) {
7339 LDKCResult_SocketAddressSocketAddressParseErrorZ* owner_conv = (LDKCResult_SocketAddressSocketAddressParseErrorZ*)untag_ptr(owner);
7340 uint32_t ret_conv = LDKSocketAddressParseError_to_js(CResult_SocketAddressSocketAddressParseErrorZ_get_err(owner_conv));
7344 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
7345 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
7346 for (size_t i = 0; i < ret.datalen; i++) {
7347 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
7351 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
7352 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
7353 for (size_t i = 0; i < ret.datalen; i++) {
7354 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
7358 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
7359 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
7360 for (size_t i = 0; i < ret.datalen; i++) {
7361 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
7365 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
7366 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
7367 for (size_t i = 0; i < ret.datalen; i++) {
7368 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
7372 static inline struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7373 LDKAcceptChannel ret = *owner->contents.result;
7374 ret.is_owned = false;
7377 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_get_ok(uint64_t owner) {
7378 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7379 LDKAcceptChannel ret_var = CResult_AcceptChannelDecodeErrorZ_get_ok(owner_conv);
7380 uint64_t ret_ref = 0;
7381 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7382 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7386 static inline struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7387 CHECK(!owner->result_ok);
7388 return DecodeError_clone(&*owner->contents.err);
7390 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_err"))) TS_CResult_AcceptChannelDecodeErrorZ_get_err(uint64_t owner) {
7391 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(owner);
7392 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7393 *ret_copy = CResult_AcceptChannelDecodeErrorZ_get_err(owner_conv);
7394 uint64_t ret_ref = tag_ptr(ret_copy, true);
7398 static inline struct LDKAcceptChannelV2 CResult_AcceptChannelV2DecodeErrorZ_get_ok(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner){
7399 LDKAcceptChannelV2 ret = *owner->contents.result;
7400 ret.is_owned = false;
7403 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelV2DecodeErrorZ_get_ok(uint64_t owner) {
7404 LDKCResult_AcceptChannelV2DecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelV2DecodeErrorZ*)untag_ptr(owner);
7405 LDKAcceptChannelV2 ret_var = CResult_AcceptChannelV2DecodeErrorZ_get_ok(owner_conv);
7406 uint64_t ret_ref = 0;
7407 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7408 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7412 static inline struct LDKDecodeError CResult_AcceptChannelV2DecodeErrorZ_get_err(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR owner){
7413 CHECK(!owner->result_ok);
7414 return DecodeError_clone(&*owner->contents.err);
7416 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_get_err"))) TS_CResult_AcceptChannelV2DecodeErrorZ_get_err(uint64_t owner) {
7417 LDKCResult_AcceptChannelV2DecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelV2DecodeErrorZ*)untag_ptr(owner);
7418 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7419 *ret_copy = CResult_AcceptChannelV2DecodeErrorZ_get_err(owner_conv);
7420 uint64_t ret_ref = tag_ptr(ret_copy, true);
7424 static inline struct LDKTxAddInput CResult_TxAddInputDecodeErrorZ_get_ok(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner){
7425 LDKTxAddInput ret = *owner->contents.result;
7426 ret.is_owned = false;
7429 uint64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_get_ok"))) TS_CResult_TxAddInputDecodeErrorZ_get_ok(uint64_t owner) {
7430 LDKCResult_TxAddInputDecodeErrorZ* owner_conv = (LDKCResult_TxAddInputDecodeErrorZ*)untag_ptr(owner);
7431 LDKTxAddInput ret_var = CResult_TxAddInputDecodeErrorZ_get_ok(owner_conv);
7432 uint64_t ret_ref = 0;
7433 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7434 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7438 static inline struct LDKDecodeError CResult_TxAddInputDecodeErrorZ_get_err(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR owner){
7439 CHECK(!owner->result_ok);
7440 return DecodeError_clone(&*owner->contents.err);
7442 uint64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_get_err"))) TS_CResult_TxAddInputDecodeErrorZ_get_err(uint64_t owner) {
7443 LDKCResult_TxAddInputDecodeErrorZ* owner_conv = (LDKCResult_TxAddInputDecodeErrorZ*)untag_ptr(owner);
7444 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7445 *ret_copy = CResult_TxAddInputDecodeErrorZ_get_err(owner_conv);
7446 uint64_t ret_ref = tag_ptr(ret_copy, true);
7450 static inline struct LDKTxAddOutput CResult_TxAddOutputDecodeErrorZ_get_ok(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner){
7451 LDKTxAddOutput ret = *owner->contents.result;
7452 ret.is_owned = false;
7455 uint64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_get_ok"))) TS_CResult_TxAddOutputDecodeErrorZ_get_ok(uint64_t owner) {
7456 LDKCResult_TxAddOutputDecodeErrorZ* owner_conv = (LDKCResult_TxAddOutputDecodeErrorZ*)untag_ptr(owner);
7457 LDKTxAddOutput ret_var = CResult_TxAddOutputDecodeErrorZ_get_ok(owner_conv);
7458 uint64_t ret_ref = 0;
7459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7464 static inline struct LDKDecodeError CResult_TxAddOutputDecodeErrorZ_get_err(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR owner){
7465 CHECK(!owner->result_ok);
7466 return DecodeError_clone(&*owner->contents.err);
7468 uint64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_get_err"))) TS_CResult_TxAddOutputDecodeErrorZ_get_err(uint64_t owner) {
7469 LDKCResult_TxAddOutputDecodeErrorZ* owner_conv = (LDKCResult_TxAddOutputDecodeErrorZ*)untag_ptr(owner);
7470 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7471 *ret_copy = CResult_TxAddOutputDecodeErrorZ_get_err(owner_conv);
7472 uint64_t ret_ref = tag_ptr(ret_copy, true);
7476 static inline struct LDKTxRemoveInput CResult_TxRemoveInputDecodeErrorZ_get_ok(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner){
7477 LDKTxRemoveInput ret = *owner->contents.result;
7478 ret.is_owned = false;
7481 uint64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_get_ok"))) TS_CResult_TxRemoveInputDecodeErrorZ_get_ok(uint64_t owner) {
7482 LDKCResult_TxRemoveInputDecodeErrorZ* owner_conv = (LDKCResult_TxRemoveInputDecodeErrorZ*)untag_ptr(owner);
7483 LDKTxRemoveInput ret_var = CResult_TxRemoveInputDecodeErrorZ_get_ok(owner_conv);
7484 uint64_t ret_ref = 0;
7485 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7486 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7490 static inline struct LDKDecodeError CResult_TxRemoveInputDecodeErrorZ_get_err(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR owner){
7491 CHECK(!owner->result_ok);
7492 return DecodeError_clone(&*owner->contents.err);
7494 uint64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_get_err"))) TS_CResult_TxRemoveInputDecodeErrorZ_get_err(uint64_t owner) {
7495 LDKCResult_TxRemoveInputDecodeErrorZ* owner_conv = (LDKCResult_TxRemoveInputDecodeErrorZ*)untag_ptr(owner);
7496 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7497 *ret_copy = CResult_TxRemoveInputDecodeErrorZ_get_err(owner_conv);
7498 uint64_t ret_ref = tag_ptr(ret_copy, true);
7502 static inline struct LDKTxRemoveOutput CResult_TxRemoveOutputDecodeErrorZ_get_ok(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner){
7503 LDKTxRemoveOutput ret = *owner->contents.result;
7504 ret.is_owned = false;
7507 uint64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok"))) TS_CResult_TxRemoveOutputDecodeErrorZ_get_ok(uint64_t owner) {
7508 LDKCResult_TxRemoveOutputDecodeErrorZ* owner_conv = (LDKCResult_TxRemoveOutputDecodeErrorZ*)untag_ptr(owner);
7509 LDKTxRemoveOutput ret_var = CResult_TxRemoveOutputDecodeErrorZ_get_ok(owner_conv);
7510 uint64_t ret_ref = 0;
7511 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7512 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7516 static inline struct LDKDecodeError CResult_TxRemoveOutputDecodeErrorZ_get_err(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR owner){
7517 CHECK(!owner->result_ok);
7518 return DecodeError_clone(&*owner->contents.err);
7520 uint64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_get_err"))) TS_CResult_TxRemoveOutputDecodeErrorZ_get_err(uint64_t owner) {
7521 LDKCResult_TxRemoveOutputDecodeErrorZ* owner_conv = (LDKCResult_TxRemoveOutputDecodeErrorZ*)untag_ptr(owner);
7522 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7523 *ret_copy = CResult_TxRemoveOutputDecodeErrorZ_get_err(owner_conv);
7524 uint64_t ret_ref = tag_ptr(ret_copy, true);
7528 static inline struct LDKTxComplete CResult_TxCompleteDecodeErrorZ_get_ok(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner){
7529 LDKTxComplete ret = *owner->contents.result;
7530 ret.is_owned = false;
7533 uint64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_get_ok"))) TS_CResult_TxCompleteDecodeErrorZ_get_ok(uint64_t owner) {
7534 LDKCResult_TxCompleteDecodeErrorZ* owner_conv = (LDKCResult_TxCompleteDecodeErrorZ*)untag_ptr(owner);
7535 LDKTxComplete ret_var = CResult_TxCompleteDecodeErrorZ_get_ok(owner_conv);
7536 uint64_t ret_ref = 0;
7537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7542 static inline struct LDKDecodeError CResult_TxCompleteDecodeErrorZ_get_err(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR owner){
7543 CHECK(!owner->result_ok);
7544 return DecodeError_clone(&*owner->contents.err);
7546 uint64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_get_err"))) TS_CResult_TxCompleteDecodeErrorZ_get_err(uint64_t owner) {
7547 LDKCResult_TxCompleteDecodeErrorZ* owner_conv = (LDKCResult_TxCompleteDecodeErrorZ*)untag_ptr(owner);
7548 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7549 *ret_copy = CResult_TxCompleteDecodeErrorZ_get_err(owner_conv);
7550 uint64_t ret_ref = tag_ptr(ret_copy, true);
7554 static inline struct LDKTxSignatures CResult_TxSignaturesDecodeErrorZ_get_ok(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner){
7555 LDKTxSignatures ret = *owner->contents.result;
7556 ret.is_owned = false;
7559 uint64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_get_ok"))) TS_CResult_TxSignaturesDecodeErrorZ_get_ok(uint64_t owner) {
7560 LDKCResult_TxSignaturesDecodeErrorZ* owner_conv = (LDKCResult_TxSignaturesDecodeErrorZ*)untag_ptr(owner);
7561 LDKTxSignatures ret_var = CResult_TxSignaturesDecodeErrorZ_get_ok(owner_conv);
7562 uint64_t ret_ref = 0;
7563 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7564 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7568 static inline struct LDKDecodeError CResult_TxSignaturesDecodeErrorZ_get_err(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR owner){
7569 CHECK(!owner->result_ok);
7570 return DecodeError_clone(&*owner->contents.err);
7572 uint64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_get_err"))) TS_CResult_TxSignaturesDecodeErrorZ_get_err(uint64_t owner) {
7573 LDKCResult_TxSignaturesDecodeErrorZ* owner_conv = (LDKCResult_TxSignaturesDecodeErrorZ*)untag_ptr(owner);
7574 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7575 *ret_copy = CResult_TxSignaturesDecodeErrorZ_get_err(owner_conv);
7576 uint64_t ret_ref = tag_ptr(ret_copy, true);
7580 static inline struct LDKTxInitRbf CResult_TxInitRbfDecodeErrorZ_get_ok(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner){
7581 LDKTxInitRbf ret = *owner->contents.result;
7582 ret.is_owned = false;
7585 uint64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_get_ok"))) TS_CResult_TxInitRbfDecodeErrorZ_get_ok(uint64_t owner) {
7586 LDKCResult_TxInitRbfDecodeErrorZ* owner_conv = (LDKCResult_TxInitRbfDecodeErrorZ*)untag_ptr(owner);
7587 LDKTxInitRbf ret_var = CResult_TxInitRbfDecodeErrorZ_get_ok(owner_conv);
7588 uint64_t ret_ref = 0;
7589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7594 static inline struct LDKDecodeError CResult_TxInitRbfDecodeErrorZ_get_err(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR owner){
7595 CHECK(!owner->result_ok);
7596 return DecodeError_clone(&*owner->contents.err);
7598 uint64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_get_err"))) TS_CResult_TxInitRbfDecodeErrorZ_get_err(uint64_t owner) {
7599 LDKCResult_TxInitRbfDecodeErrorZ* owner_conv = (LDKCResult_TxInitRbfDecodeErrorZ*)untag_ptr(owner);
7600 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7601 *ret_copy = CResult_TxInitRbfDecodeErrorZ_get_err(owner_conv);
7602 uint64_t ret_ref = tag_ptr(ret_copy, true);
7606 static inline struct LDKTxAckRbf CResult_TxAckRbfDecodeErrorZ_get_ok(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner){
7607 LDKTxAckRbf ret = *owner->contents.result;
7608 ret.is_owned = false;
7611 uint64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_get_ok"))) TS_CResult_TxAckRbfDecodeErrorZ_get_ok(uint64_t owner) {
7612 LDKCResult_TxAckRbfDecodeErrorZ* owner_conv = (LDKCResult_TxAckRbfDecodeErrorZ*)untag_ptr(owner);
7613 LDKTxAckRbf ret_var = CResult_TxAckRbfDecodeErrorZ_get_ok(owner_conv);
7614 uint64_t ret_ref = 0;
7615 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7616 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7620 static inline struct LDKDecodeError CResult_TxAckRbfDecodeErrorZ_get_err(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR owner){
7621 CHECK(!owner->result_ok);
7622 return DecodeError_clone(&*owner->contents.err);
7624 uint64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_get_err"))) TS_CResult_TxAckRbfDecodeErrorZ_get_err(uint64_t owner) {
7625 LDKCResult_TxAckRbfDecodeErrorZ* owner_conv = (LDKCResult_TxAckRbfDecodeErrorZ*)untag_ptr(owner);
7626 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7627 *ret_copy = CResult_TxAckRbfDecodeErrorZ_get_err(owner_conv);
7628 uint64_t ret_ref = tag_ptr(ret_copy, true);
7632 static inline struct LDKTxAbort CResult_TxAbortDecodeErrorZ_get_ok(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner){
7633 LDKTxAbort ret = *owner->contents.result;
7634 ret.is_owned = false;
7637 uint64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_get_ok"))) TS_CResult_TxAbortDecodeErrorZ_get_ok(uint64_t owner) {
7638 LDKCResult_TxAbortDecodeErrorZ* owner_conv = (LDKCResult_TxAbortDecodeErrorZ*)untag_ptr(owner);
7639 LDKTxAbort ret_var = CResult_TxAbortDecodeErrorZ_get_ok(owner_conv);
7640 uint64_t ret_ref = 0;
7641 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7642 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7646 static inline struct LDKDecodeError CResult_TxAbortDecodeErrorZ_get_err(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR owner){
7647 CHECK(!owner->result_ok);
7648 return DecodeError_clone(&*owner->contents.err);
7650 uint64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_get_err"))) TS_CResult_TxAbortDecodeErrorZ_get_err(uint64_t owner) {
7651 LDKCResult_TxAbortDecodeErrorZ* owner_conv = (LDKCResult_TxAbortDecodeErrorZ*)untag_ptr(owner);
7652 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7653 *ret_copy = CResult_TxAbortDecodeErrorZ_get_err(owner_conv);
7654 uint64_t ret_ref = tag_ptr(ret_copy, true);
7658 static inline struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7659 LDKAnnouncementSignatures ret = *owner->contents.result;
7660 ret.is_owned = false;
7663 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint64_t owner) {
7664 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7665 LDKAnnouncementSignatures ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner_conv);
7666 uint64_t ret_ref = 0;
7667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7668 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7672 static inline struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7673 CHECK(!owner->result_ok);
7674 return DecodeError_clone(&*owner->contents.err);
7676 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint64_t owner) {
7677 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(owner);
7678 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7679 *ret_copy = CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner_conv);
7680 uint64_t ret_ref = tag_ptr(ret_copy, true);
7684 static inline struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7685 LDKChannelReestablish ret = *owner->contents.result;
7686 ret.is_owned = false;
7689 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(uint64_t owner) {
7690 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7691 LDKChannelReestablish ret_var = CResult_ChannelReestablishDecodeErrorZ_get_ok(owner_conv);
7692 uint64_t ret_ref = 0;
7693 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7694 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7698 static inline struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7699 CHECK(!owner->result_ok);
7700 return DecodeError_clone(&*owner->contents.err);
7702 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_err(uint64_t owner) {
7703 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(owner);
7704 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7705 *ret_copy = CResult_ChannelReestablishDecodeErrorZ_get_err(owner_conv);
7706 uint64_t ret_ref = tag_ptr(ret_copy, true);
7710 static inline struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7711 LDKClosingSigned ret = *owner->contents.result;
7712 ret.is_owned = false;
7715 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7716 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7717 LDKClosingSigned ret_var = CResult_ClosingSignedDecodeErrorZ_get_ok(owner_conv);
7718 uint64_t ret_ref = 0;
7719 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7720 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7724 static inline struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7725 CHECK(!owner->result_ok);
7726 return DecodeError_clone(&*owner->contents.err);
7728 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedDecodeErrorZ_get_err(uint64_t owner) {
7729 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(owner);
7730 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7731 *ret_copy = CResult_ClosingSignedDecodeErrorZ_get_err(owner_conv);
7732 uint64_t ret_ref = tag_ptr(ret_copy, true);
7736 static inline struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7737 LDKClosingSignedFeeRange ret = *owner->contents.result;
7738 ret.is_owned = false;
7741 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint64_t owner) {
7742 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7743 LDKClosingSignedFeeRange ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner_conv);
7744 uint64_t ret_ref = 0;
7745 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7746 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7750 static inline struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7751 CHECK(!owner->result_ok);
7752 return DecodeError_clone(&*owner->contents.err);
7754 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(uint64_t owner) {
7755 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(owner);
7756 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7757 *ret_copy = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner_conv);
7758 uint64_t ret_ref = tag_ptr(ret_copy, true);
7762 static inline struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7763 LDKCommitmentSigned ret = *owner->contents.result;
7764 ret.is_owned = false;
7767 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(uint64_t owner) {
7768 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7769 LDKCommitmentSigned ret_var = CResult_CommitmentSignedDecodeErrorZ_get_ok(owner_conv);
7770 uint64_t ret_ref = 0;
7771 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7772 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7776 static inline struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7777 CHECK(!owner->result_ok);
7778 return DecodeError_clone(&*owner->contents.err);
7780 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_err(uint64_t owner) {
7781 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(owner);
7782 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7783 *ret_copy = CResult_CommitmentSignedDecodeErrorZ_get_err(owner_conv);
7784 uint64_t ret_ref = tag_ptr(ret_copy, true);
7788 static inline struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7789 LDKFundingCreated ret = *owner->contents.result;
7790 ret.is_owned = false;
7793 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_get_ok(uint64_t owner) {
7794 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7795 LDKFundingCreated ret_var = CResult_FundingCreatedDecodeErrorZ_get_ok(owner_conv);
7796 uint64_t ret_ref = 0;
7797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7798 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7802 static inline struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7803 CHECK(!owner->result_ok);
7804 return DecodeError_clone(&*owner->contents.err);
7806 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_err"))) TS_CResult_FundingCreatedDecodeErrorZ_get_err(uint64_t owner) {
7807 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(owner);
7808 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7809 *ret_copy = CResult_FundingCreatedDecodeErrorZ_get_err(owner_conv);
7810 uint64_t ret_ref = tag_ptr(ret_copy, true);
7814 static inline struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7815 LDKFundingSigned ret = *owner->contents.result;
7816 ret.is_owned = false;
7819 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_ok"))) TS_CResult_FundingSignedDecodeErrorZ_get_ok(uint64_t owner) {
7820 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7821 LDKFundingSigned ret_var = CResult_FundingSignedDecodeErrorZ_get_ok(owner_conv);
7822 uint64_t ret_ref = 0;
7823 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7824 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7828 static inline struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7829 CHECK(!owner->result_ok);
7830 return DecodeError_clone(&*owner->contents.err);
7832 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_err"))) TS_CResult_FundingSignedDecodeErrorZ_get_err(uint64_t owner) {
7833 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(owner);
7834 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7835 *ret_copy = CResult_FundingSignedDecodeErrorZ_get_err(owner_conv);
7836 uint64_t ret_ref = tag_ptr(ret_copy, true);
7840 static inline struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7841 LDKChannelReady ret = *owner->contents.result;
7842 ret.is_owned = false;
7845 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_get_ok(uint64_t owner) {
7846 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7847 LDKChannelReady ret_var = CResult_ChannelReadyDecodeErrorZ_get_ok(owner_conv);
7848 uint64_t ret_ref = 0;
7849 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7850 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7854 static inline struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7855 CHECK(!owner->result_ok);
7856 return DecodeError_clone(&*owner->contents.err);
7858 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_err"))) TS_CResult_ChannelReadyDecodeErrorZ_get_err(uint64_t owner) {
7859 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(owner);
7860 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7861 *ret_copy = CResult_ChannelReadyDecodeErrorZ_get_err(owner_conv);
7862 uint64_t ret_ref = tag_ptr(ret_copy, true);
7866 static inline struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7867 LDKInit ret = *owner->contents.result;
7868 ret.is_owned = false;
7871 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_ok"))) TS_CResult_InitDecodeErrorZ_get_ok(uint64_t owner) {
7872 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7873 LDKInit ret_var = CResult_InitDecodeErrorZ_get_ok(owner_conv);
7874 uint64_t ret_ref = 0;
7875 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7876 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7880 static inline struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7881 CHECK(!owner->result_ok);
7882 return DecodeError_clone(&*owner->contents.err);
7884 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_err"))) TS_CResult_InitDecodeErrorZ_get_err(uint64_t owner) {
7885 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(owner);
7886 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7887 *ret_copy = CResult_InitDecodeErrorZ_get_err(owner_conv);
7888 uint64_t ret_ref = tag_ptr(ret_copy, true);
7892 static inline struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7893 LDKOpenChannel ret = *owner->contents.result;
7894 ret.is_owned = false;
7897 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_ok"))) TS_CResult_OpenChannelDecodeErrorZ_get_ok(uint64_t owner) {
7898 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7899 LDKOpenChannel ret_var = CResult_OpenChannelDecodeErrorZ_get_ok(owner_conv);
7900 uint64_t ret_ref = 0;
7901 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7902 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7906 static inline struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7907 CHECK(!owner->result_ok);
7908 return DecodeError_clone(&*owner->contents.err);
7910 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_err"))) TS_CResult_OpenChannelDecodeErrorZ_get_err(uint64_t owner) {
7911 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(owner);
7912 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7913 *ret_copy = CResult_OpenChannelDecodeErrorZ_get_err(owner_conv);
7914 uint64_t ret_ref = tag_ptr(ret_copy, true);
7918 static inline struct LDKOpenChannelV2 CResult_OpenChannelV2DecodeErrorZ_get_ok(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner){
7919 LDKOpenChannelV2 ret = *owner->contents.result;
7920 ret.is_owned = false;
7923 uint64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_get_ok"))) TS_CResult_OpenChannelV2DecodeErrorZ_get_ok(uint64_t owner) {
7924 LDKCResult_OpenChannelV2DecodeErrorZ* owner_conv = (LDKCResult_OpenChannelV2DecodeErrorZ*)untag_ptr(owner);
7925 LDKOpenChannelV2 ret_var = CResult_OpenChannelV2DecodeErrorZ_get_ok(owner_conv);
7926 uint64_t ret_ref = 0;
7927 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7928 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7932 static inline struct LDKDecodeError CResult_OpenChannelV2DecodeErrorZ_get_err(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR owner){
7933 CHECK(!owner->result_ok);
7934 return DecodeError_clone(&*owner->contents.err);
7936 uint64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_get_err"))) TS_CResult_OpenChannelV2DecodeErrorZ_get_err(uint64_t owner) {
7937 LDKCResult_OpenChannelV2DecodeErrorZ* owner_conv = (LDKCResult_OpenChannelV2DecodeErrorZ*)untag_ptr(owner);
7938 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7939 *ret_copy = CResult_OpenChannelV2DecodeErrorZ_get_err(owner_conv);
7940 uint64_t ret_ref = tag_ptr(ret_copy, true);
7944 static inline struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7945 LDKRevokeAndACK ret = *owner->contents.result;
7946 ret.is_owned = false;
7949 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(uint64_t owner) {
7950 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7951 LDKRevokeAndACK ret_var = CResult_RevokeAndACKDecodeErrorZ_get_ok(owner_conv);
7952 uint64_t ret_ref = 0;
7953 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7954 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7958 static inline struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7959 CHECK(!owner->result_ok);
7960 return DecodeError_clone(&*owner->contents.err);
7962 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_err(uint64_t owner) {
7963 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(owner);
7964 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7965 *ret_copy = CResult_RevokeAndACKDecodeErrorZ_get_err(owner_conv);
7966 uint64_t ret_ref = tag_ptr(ret_copy, true);
7970 static inline struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7971 LDKShutdown ret = *owner->contents.result;
7972 ret.is_owned = false;
7975 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_ok"))) TS_CResult_ShutdownDecodeErrorZ_get_ok(uint64_t owner) {
7976 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7977 LDKShutdown ret_var = CResult_ShutdownDecodeErrorZ_get_ok(owner_conv);
7978 uint64_t ret_ref = 0;
7979 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7980 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
7984 static inline struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7985 CHECK(!owner->result_ok);
7986 return DecodeError_clone(&*owner->contents.err);
7988 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_err"))) TS_CResult_ShutdownDecodeErrorZ_get_err(uint64_t owner) {
7989 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(owner);
7990 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
7991 *ret_copy = CResult_ShutdownDecodeErrorZ_get_err(owner_conv);
7992 uint64_t ret_ref = tag_ptr(ret_copy, true);
7996 static inline struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7997 LDKUpdateFailHTLC ret = *owner->contents.result;
7998 ret.is_owned = false;
8001 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8002 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
8003 LDKUpdateFailHTLC ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner_conv);
8004 uint64_t ret_ref = 0;
8005 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8006 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8010 static inline struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
8011 CHECK(!owner->result_ok);
8012 return DecodeError_clone(&*owner->contents.err);
8014 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(uint64_t owner) {
8015 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(owner);
8016 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8017 *ret_copy = CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner_conv);
8018 uint64_t ret_ref = tag_ptr(ret_copy, true);
8022 static inline struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
8023 LDKUpdateFailMalformedHTLC ret = *owner->contents.result;
8024 ret.is_owned = false;
8027 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8028 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
8029 LDKUpdateFailMalformedHTLC ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner_conv);
8030 uint64_t ret_ref = 0;
8031 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8032 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8036 static inline struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
8037 CHECK(!owner->result_ok);
8038 return DecodeError_clone(&*owner->contents.err);
8040 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint64_t owner) {
8041 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(owner);
8042 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8043 *ret_copy = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner_conv);
8044 uint64_t ret_ref = tag_ptr(ret_copy, true);
8048 static inline struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
8049 LDKUpdateFee ret = *owner->contents.result;
8050 ret.is_owned = false;
8053 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_get_ok(uint64_t owner) {
8054 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
8055 LDKUpdateFee ret_var = CResult_UpdateFeeDecodeErrorZ_get_ok(owner_conv);
8056 uint64_t ret_ref = 0;
8057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8062 static inline struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
8063 CHECK(!owner->result_ok);
8064 return DecodeError_clone(&*owner->contents.err);
8066 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_err"))) TS_CResult_UpdateFeeDecodeErrorZ_get_err(uint64_t owner) {
8067 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(owner);
8068 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8069 *ret_copy = CResult_UpdateFeeDecodeErrorZ_get_err(owner_conv);
8070 uint64_t ret_ref = tag_ptr(ret_copy, true);
8074 static inline struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8075 LDKUpdateFulfillHTLC ret = *owner->contents.result;
8076 ret.is_owned = false;
8079 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8080 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8081 LDKUpdateFulfillHTLC ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner_conv);
8082 uint64_t ret_ref = 0;
8083 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8084 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8088 static inline struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
8089 CHECK(!owner->result_ok);
8090 return DecodeError_clone(&*owner->contents.err);
8092 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint64_t owner) {
8093 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(owner);
8094 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8095 *ret_copy = CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner_conv);
8096 uint64_t ret_ref = tag_ptr(ret_copy, true);
8100 static inline struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8101 LDKUpdateAddHTLC ret = *owner->contents.result;
8102 ret.is_owned = false;
8105 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint64_t owner) {
8106 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8107 LDKUpdateAddHTLC ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner_conv);
8108 uint64_t ret_ref = 0;
8109 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8110 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8114 static inline struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
8115 CHECK(!owner->result_ok);
8116 return DecodeError_clone(&*owner->contents.err);
8118 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(uint64_t owner) {
8119 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(owner);
8120 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8121 *ret_copy = CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner_conv);
8122 uint64_t ret_ref = tag_ptr(ret_copy, true);
8126 static inline struct LDKOnionMessage CResult_OnionMessageDecodeErrorZ_get_ok(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8127 LDKOnionMessage ret = *owner->contents.result;
8128 ret.is_owned = false;
8131 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_ok"))) TS_CResult_OnionMessageDecodeErrorZ_get_ok(uint64_t owner) {
8132 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8133 LDKOnionMessage ret_var = CResult_OnionMessageDecodeErrorZ_get_ok(owner_conv);
8134 uint64_t ret_ref = 0;
8135 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8136 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8140 static inline struct LDKDecodeError CResult_OnionMessageDecodeErrorZ_get_err(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR owner){
8141 CHECK(!owner->result_ok);
8142 return DecodeError_clone(&*owner->contents.err);
8144 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_get_err"))) TS_CResult_OnionMessageDecodeErrorZ_get_err(uint64_t owner) {
8145 LDKCResult_OnionMessageDecodeErrorZ* owner_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(owner);
8146 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8147 *ret_copy = CResult_OnionMessageDecodeErrorZ_get_err(owner_conv);
8148 uint64_t ret_ref = tag_ptr(ret_copy, true);
8152 static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8153 LDKPing ret = *owner->contents.result;
8154 ret.is_owned = false;
8157 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_ok"))) TS_CResult_PingDecodeErrorZ_get_ok(uint64_t owner) {
8158 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8159 LDKPing ret_var = CResult_PingDecodeErrorZ_get_ok(owner_conv);
8160 uint64_t ret_ref = 0;
8161 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8162 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8166 static inline struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
8167 CHECK(!owner->result_ok);
8168 return DecodeError_clone(&*owner->contents.err);
8170 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_err"))) TS_CResult_PingDecodeErrorZ_get_err(uint64_t owner) {
8171 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(owner);
8172 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8173 *ret_copy = CResult_PingDecodeErrorZ_get_err(owner_conv);
8174 uint64_t ret_ref = tag_ptr(ret_copy, true);
8178 static inline struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8179 LDKPong ret = *owner->contents.result;
8180 ret.is_owned = false;
8183 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_ok"))) TS_CResult_PongDecodeErrorZ_get_ok(uint64_t owner) {
8184 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8185 LDKPong ret_var = CResult_PongDecodeErrorZ_get_ok(owner_conv);
8186 uint64_t ret_ref = 0;
8187 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8188 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8192 static inline struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
8193 CHECK(!owner->result_ok);
8194 return DecodeError_clone(&*owner->contents.err);
8196 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_err"))) TS_CResult_PongDecodeErrorZ_get_err(uint64_t owner) {
8197 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(owner);
8198 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8199 *ret_copy = CResult_PongDecodeErrorZ_get_err(owner_conv);
8200 uint64_t ret_ref = tag_ptr(ret_copy, true);
8204 static inline struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8205 LDKUnsignedChannelAnnouncement ret = *owner->contents.result;
8206 ret.is_owned = false;
8209 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8210 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8211 LDKUnsignedChannelAnnouncement ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8212 uint64_t ret_ref = 0;
8213 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8214 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8218 static inline struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8219 CHECK(!owner->result_ok);
8220 return DecodeError_clone(&*owner->contents.err);
8222 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8223 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8224 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8225 *ret_copy = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8226 uint64_t ret_ref = tag_ptr(ret_copy, true);
8230 static inline struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8231 LDKChannelAnnouncement ret = *owner->contents.result;
8232 ret.is_owned = false;
8235 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8236 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8237 LDKChannelAnnouncement ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
8238 uint64_t ret_ref = 0;
8239 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8240 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8244 static inline struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8245 CHECK(!owner->result_ok);
8246 return DecodeError_clone(&*owner->contents.err);
8248 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8249 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(owner);
8250 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8251 *ret_copy = CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
8252 uint64_t ret_ref = tag_ptr(ret_copy, true);
8256 static inline struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8257 LDKUnsignedChannelUpdate ret = *owner->contents.result;
8258 ret.is_owned = false;
8261 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8262 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8263 LDKUnsignedChannelUpdate ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8264 uint64_t ret_ref = 0;
8265 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8266 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8270 static inline struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8271 CHECK(!owner->result_ok);
8272 return DecodeError_clone(&*owner->contents.err);
8274 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8275 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8276 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8277 *ret_copy = CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner_conv);
8278 uint64_t ret_ref = tag_ptr(ret_copy, true);
8282 static inline struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8283 LDKChannelUpdate ret = *owner->contents.result;
8284 ret.is_owned = false;
8287 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(uint64_t owner) {
8288 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8289 LDKChannelUpdate ret_var = CResult_ChannelUpdateDecodeErrorZ_get_ok(owner_conv);
8290 uint64_t ret_ref = 0;
8291 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8292 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8296 static inline struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
8297 CHECK(!owner->result_ok);
8298 return DecodeError_clone(&*owner->contents.err);
8300 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_err(uint64_t owner) {
8301 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(owner);
8302 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8303 *ret_copy = CResult_ChannelUpdateDecodeErrorZ_get_err(owner_conv);
8304 uint64_t ret_ref = tag_ptr(ret_copy, true);
8308 static inline struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8309 LDKErrorMessage ret = *owner->contents.result;
8310 ret.is_owned = false;
8313 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_get_ok(uint64_t owner) {
8314 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8315 LDKErrorMessage ret_var = CResult_ErrorMessageDecodeErrorZ_get_ok(owner_conv);
8316 uint64_t ret_ref = 0;
8317 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8318 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8322 static inline struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
8323 CHECK(!owner->result_ok);
8324 return DecodeError_clone(&*owner->contents.err);
8326 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_err"))) TS_CResult_ErrorMessageDecodeErrorZ_get_err(uint64_t owner) {
8327 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(owner);
8328 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8329 *ret_copy = CResult_ErrorMessageDecodeErrorZ_get_err(owner_conv);
8330 uint64_t ret_ref = tag_ptr(ret_copy, true);
8334 static inline struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8335 LDKWarningMessage ret = *owner->contents.result;
8336 ret.is_owned = false;
8339 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_ok"))) TS_CResult_WarningMessageDecodeErrorZ_get_ok(uint64_t owner) {
8340 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8341 LDKWarningMessage ret_var = CResult_WarningMessageDecodeErrorZ_get_ok(owner_conv);
8342 uint64_t ret_ref = 0;
8343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8348 static inline struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
8349 CHECK(!owner->result_ok);
8350 return DecodeError_clone(&*owner->contents.err);
8352 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_err"))) TS_CResult_WarningMessageDecodeErrorZ_get_err(uint64_t owner) {
8353 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(owner);
8354 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8355 *ret_copy = CResult_WarningMessageDecodeErrorZ_get_err(owner_conv);
8356 uint64_t ret_ref = tag_ptr(ret_copy, true);
8360 static inline struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8361 LDKUnsignedNodeAnnouncement ret = *owner->contents.result;
8362 ret.is_owned = false;
8365 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8366 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8367 LDKUnsignedNodeAnnouncement ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8368 uint64_t ret_ref = 0;
8369 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8370 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8374 static inline struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8375 CHECK(!owner->result_ok);
8376 return DecodeError_clone(&*owner->contents.err);
8378 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8379 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8380 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8381 *ret_copy = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8382 uint64_t ret_ref = tag_ptr(ret_copy, true);
8386 static inline struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8387 LDKNodeAnnouncement ret = *owner->contents.result;
8388 ret.is_owned = false;
8391 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(uint64_t owner) {
8392 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8393 LDKNodeAnnouncement ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8394 uint64_t ret_ref = 0;
8395 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8396 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8400 static inline struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8401 CHECK(!owner->result_ok);
8402 return DecodeError_clone(&*owner->contents.err);
8404 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(uint64_t owner) {
8405 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(owner);
8406 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8407 *ret_copy = CResult_NodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8408 uint64_t ret_ref = tag_ptr(ret_copy, true);
8412 static inline struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8413 LDKQueryShortChannelIds ret = *owner->contents.result;
8414 ret.is_owned = false;
8417 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint64_t owner) {
8418 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8419 LDKQueryShortChannelIds ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner_conv);
8420 uint64_t ret_ref = 0;
8421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8422 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8426 static inline struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8427 CHECK(!owner->result_ok);
8428 return DecodeError_clone(&*owner->contents.err);
8430 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint64_t owner) {
8431 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(owner);
8432 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8433 *ret_copy = CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner_conv);
8434 uint64_t ret_ref = tag_ptr(ret_copy, true);
8438 static inline struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8439 LDKReplyShortChannelIdsEnd ret = *owner->contents.result;
8440 ret.is_owned = false;
8443 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint64_t owner) {
8444 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8445 LDKReplyShortChannelIdsEnd ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner_conv);
8446 uint64_t ret_ref = 0;
8447 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8448 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8452 static inline struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8453 CHECK(!owner->result_ok);
8454 return DecodeError_clone(&*owner->contents.err);
8456 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint64_t owner) {
8457 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(owner);
8458 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8459 *ret_copy = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner_conv);
8460 uint64_t ret_ref = tag_ptr(ret_copy, true);
8464 static inline struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8465 LDKQueryChannelRange ret = *owner->contents.result;
8466 ret.is_owned = false;
8469 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8470 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8471 LDKQueryChannelRange ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner_conv);
8472 uint64_t ret_ref = 0;
8473 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8474 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8478 static inline struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8479 CHECK(!owner->result_ok);
8480 return DecodeError_clone(&*owner->contents.err);
8482 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8483 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(owner);
8484 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8485 *ret_copy = CResult_QueryChannelRangeDecodeErrorZ_get_err(owner_conv);
8486 uint64_t ret_ref = tag_ptr(ret_copy, true);
8490 static inline struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8491 LDKReplyChannelRange ret = *owner->contents.result;
8492 ret.is_owned = false;
8495 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint64_t owner) {
8496 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8497 LDKReplyChannelRange ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner_conv);
8498 uint64_t ret_ref = 0;
8499 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8500 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8504 static inline struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8505 CHECK(!owner->result_ok);
8506 return DecodeError_clone(&*owner->contents.err);
8508 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(uint64_t owner) {
8509 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(owner);
8510 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8511 *ret_copy = CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner_conv);
8512 uint64_t ret_ref = tag_ptr(ret_copy, true);
8516 static inline struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8517 LDKGossipTimestampFilter ret = *owner->contents.result;
8518 ret.is_owned = false;
8521 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint64_t owner) {
8522 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8523 LDKGossipTimestampFilter ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner_conv);
8524 uint64_t ret_ref = 0;
8525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8526 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8530 static inline struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8531 CHECK(!owner->result_ok);
8532 return DecodeError_clone(&*owner->contents.err);
8534 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(uint64_t owner) {
8535 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(owner);
8536 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8537 *ret_copy = CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner_conv);
8538 uint64_t ret_ref = tag_ptr(ret_copy, true);
8542 static inline LDKCVec_PhantomRouteHintsZ CVec_PhantomRouteHintsZ_clone(const LDKCVec_PhantomRouteHintsZ *orig) {
8543 LDKCVec_PhantomRouteHintsZ ret = { .data = MALLOC(sizeof(LDKPhantomRouteHints) * orig->datalen, "LDKCVec_PhantomRouteHintsZ clone bytes"), .datalen = orig->datalen };
8544 for (size_t i = 0; i < ret.datalen; i++) {
8545 ret.data[i] = PhantomRouteHints_clone(&orig->data[i]);
8549 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_ty_from_ptr"))) TS_LDKSignOrCreationError_ty_from_ptr(uint64_t ptr) {
8550 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8552 case LDKSignOrCreationError_SignError: return 0;
8553 case LDKSignOrCreationError_CreationError: return 1;
8557 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_CreationError_get_creation_error"))) TS_LDKSignOrCreationError_CreationError_get_creation_error(uint64_t ptr) {
8558 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)untag_ptr(ptr);
8559 assert(obj->tag == LDKSignOrCreationError_CreationError);
8560 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
8561 return creation_error_conv;
8563 static inline struct LDKBolt11Invoice CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8564 LDKBolt11Invoice ret = *owner->contents.result;
8565 ret.is_owned = false;
8568 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(uint64_t owner) {
8569 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8570 LDKBolt11Invoice ret_var = CResult_Bolt11InvoiceSignOrCreationErrorZ_get_ok(owner_conv);
8571 uint64_t ret_ref = 0;
8572 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8573 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8577 static inline struct LDKSignOrCreationError CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8578 CHECK(!owner->result_ok);
8579 return SignOrCreationError_clone(&*owner->contents.err);
8581 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(uint64_t owner) {
8582 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)untag_ptr(owner);
8583 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
8584 *ret_copy = CResult_Bolt11InvoiceSignOrCreationErrorZ_get_err(owner_conv);
8585 uint64_t ret_ref = tag_ptr(ret_copy, true);
8589 static inline struct LDKOffersMessage CResult_OffersMessageDecodeErrorZ_get_ok(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner){
8590 CHECK(owner->result_ok);
8591 return OffersMessage_clone(&*owner->contents.result);
8593 uint64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_get_ok"))) TS_CResult_OffersMessageDecodeErrorZ_get_ok(uint64_t owner) {
8594 LDKCResult_OffersMessageDecodeErrorZ* owner_conv = (LDKCResult_OffersMessageDecodeErrorZ*)untag_ptr(owner);
8595 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
8596 *ret_copy = CResult_OffersMessageDecodeErrorZ_get_ok(owner_conv);
8597 uint64_t ret_ref = tag_ptr(ret_copy, true);
8601 static inline struct LDKDecodeError CResult_OffersMessageDecodeErrorZ_get_err(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR owner){
8602 CHECK(!owner->result_ok);
8603 return DecodeError_clone(&*owner->contents.err);
8605 uint64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_get_err"))) TS_CResult_OffersMessageDecodeErrorZ_get_err(uint64_t owner) {
8606 LDKCResult_OffersMessageDecodeErrorZ* owner_conv = (LDKCResult_OffersMessageDecodeErrorZ*)untag_ptr(owner);
8607 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8608 *ret_copy = CResult_OffersMessageDecodeErrorZ_get_err(owner_conv);
8609 uint64_t ret_ref = tag_ptr(ret_copy, true);
8613 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_ty_from_ptr"))) TS_LDKCOption_HTLCClaimZ_ty_from_ptr(uint64_t ptr) {
8614 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
8616 case LDKCOption_HTLCClaimZ_Some: return 0;
8617 case LDKCOption_HTLCClaimZ_None: return 1;
8621 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCClaimZ_Some_get_some"))) TS_LDKCOption_HTLCClaimZ_Some_get_some(uint64_t ptr) {
8622 LDKCOption_HTLCClaimZ *obj = (LDKCOption_HTLCClaimZ*)untag_ptr(ptr);
8623 assert(obj->tag == LDKCOption_HTLCClaimZ_Some);
8624 uint32_t some_conv = LDKHTLCClaim_to_js(obj->some);
8627 static inline struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
8628 LDKCounterpartyCommitmentSecrets ret = *owner->contents.result;
8629 ret.is_owned = false;
8632 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(uint64_t owner) {
8633 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
8634 LDKCounterpartyCommitmentSecrets ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner_conv);
8635 uint64_t ret_ref = 0;
8636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8637 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8641 static inline struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
8642 CHECK(!owner->result_ok);
8643 return DecodeError_clone(&*owner->contents.err);
8645 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(uint64_t owner) {
8646 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(owner);
8647 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8648 *ret_copy = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner_conv);
8649 uint64_t ret_ref = tag_ptr(ret_copy, true);
8653 static inline struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
8654 LDKTxCreationKeys ret = *owner->contents.result;
8655 ret.is_owned = false;
8658 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(uint64_t owner) {
8659 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
8660 LDKTxCreationKeys ret_var = CResult_TxCreationKeysDecodeErrorZ_get_ok(owner_conv);
8661 uint64_t ret_ref = 0;
8662 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8663 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8667 static inline struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
8668 CHECK(!owner->result_ok);
8669 return DecodeError_clone(&*owner->contents.err);
8671 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_err(uint64_t owner) {
8672 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(owner);
8673 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8674 *ret_copy = CResult_TxCreationKeysDecodeErrorZ_get_err(owner_conv);
8675 uint64_t ret_ref = tag_ptr(ret_copy, true);
8679 static inline struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
8680 LDKChannelPublicKeys ret = *owner->contents.result;
8681 ret.is_owned = false;
8684 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint64_t owner) {
8685 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
8686 LDKChannelPublicKeys ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner_conv);
8687 uint64_t ret_ref = 0;
8688 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8689 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8693 static inline struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
8694 CHECK(!owner->result_ok);
8695 return DecodeError_clone(&*owner->contents.err);
8697 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(uint64_t owner) {
8698 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(owner);
8699 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8700 *ret_copy = CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner_conv);
8701 uint64_t ret_ref = tag_ptr(ret_copy, true);
8705 static inline struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
8706 LDKHTLCOutputInCommitment ret = *owner->contents.result;
8707 ret.is_owned = false;
8710 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint64_t owner) {
8711 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
8712 LDKHTLCOutputInCommitment ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner_conv);
8713 uint64_t ret_ref = 0;
8714 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8715 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8719 static inline struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
8720 CHECK(!owner->result_ok);
8721 return DecodeError_clone(&*owner->contents.err);
8723 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint64_t owner) {
8724 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(owner);
8725 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8726 *ret_copy = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner_conv);
8727 uint64_t ret_ref = tag_ptr(ret_copy, true);
8731 static inline struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
8732 LDKCounterpartyChannelTransactionParameters ret = *owner->contents.result;
8733 ret.is_owned = false;
8736 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
8737 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
8738 LDKCounterpartyChannelTransactionParameters ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
8739 uint64_t ret_ref = 0;
8740 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8741 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8745 static inline struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
8746 CHECK(!owner->result_ok);
8747 return DecodeError_clone(&*owner->contents.err);
8749 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
8750 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
8751 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8752 *ret_copy = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
8753 uint64_t ret_ref = tag_ptr(ret_copy, true);
8757 static inline struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
8758 LDKChannelTransactionParameters ret = *owner->contents.result;
8759 ret.is_owned = false;
8762 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint64_t owner) {
8763 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
8764 LDKChannelTransactionParameters ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
8765 uint64_t ret_ref = 0;
8766 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8767 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8771 static inline struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
8772 CHECK(!owner->result_ok);
8773 return DecodeError_clone(&*owner->contents.err);
8775 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint64_t owner) {
8776 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(owner);
8777 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8778 *ret_copy = CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
8779 uint64_t ret_ref = tag_ptr(ret_copy, true);
8783 static inline struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8784 LDKHolderCommitmentTransaction ret = *owner->contents.result;
8785 ret.is_owned = false;
8788 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
8789 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8790 LDKHolderCommitmentTransaction ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
8791 uint64_t ret_ref = 0;
8792 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8793 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8797 static inline struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8798 CHECK(!owner->result_ok);
8799 return DecodeError_clone(&*owner->contents.err);
8801 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
8802 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8803 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8804 *ret_copy = CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
8805 uint64_t ret_ref = tag_ptr(ret_copy, true);
8809 static inline struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8810 LDKBuiltCommitmentTransaction ret = *owner->contents.result;
8811 ret.is_owned = false;
8814 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
8815 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8816 LDKBuiltCommitmentTransaction ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
8817 uint64_t ret_ref = 0;
8818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8819 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8823 static inline struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8824 CHECK(!owner->result_ok);
8825 return DecodeError_clone(&*owner->contents.err);
8827 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
8828 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8829 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8830 *ret_copy = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
8831 uint64_t ret_ref = tag_ptr(ret_copy, true);
8835 static inline struct LDKTrustedClosingTransaction CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
8836 LDKTrustedClosingTransaction ret = *owner->contents.result;
8837 ret.is_owned = false;
8840 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_get_ok(uint64_t owner) {
8841 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
8842 LDKTrustedClosingTransaction ret_var = CResult_TrustedClosingTransactionNoneZ_get_ok(owner_conv);
8843 uint64_t ret_ref = 0;
8844 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8845 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8849 static inline void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
8850 CHECK(!owner->result_ok);
8851 return *owner->contents.err;
8853 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_err"))) TS_CResult_TrustedClosingTransactionNoneZ_get_err(uint64_t owner) {
8854 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(owner);
8855 CResult_TrustedClosingTransactionNoneZ_get_err(owner_conv);
8858 static inline struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8859 LDKCommitmentTransaction ret = *owner->contents.result;
8860 ret.is_owned = false;
8863 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(uint64_t owner) {
8864 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8865 LDKCommitmentTransaction ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
8866 uint64_t ret_ref = 0;
8867 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8868 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8872 static inline struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
8873 CHECK(!owner->result_ok);
8874 return DecodeError_clone(&*owner->contents.err);
8876 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(uint64_t owner) {
8877 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(owner);
8878 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8879 *ret_copy = CResult_CommitmentTransactionDecodeErrorZ_get_err(owner_conv);
8880 uint64_t ret_ref = tag_ptr(ret_copy, true);
8884 static inline struct LDKTrustedCommitmentTransaction CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
8885 LDKTrustedCommitmentTransaction ret = *owner->contents.result;
8886 ret.is_owned = false;
8889 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(uint64_t owner) {
8890 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
8891 LDKTrustedCommitmentTransaction ret_var = CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner_conv);
8892 uint64_t ret_ref = 0;
8893 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8894 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8898 static inline void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
8899 CHECK(!owner->result_ok);
8900 return *owner->contents.err;
8902 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(uint64_t owner) {
8903 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(owner);
8904 CResult_TrustedCommitmentTransactionNoneZ_get_err(owner_conv);
8907 static inline struct LDKCVec_ECDSASignatureZ CResult_CVec_ECDSASignatureZNoneZ_get_ok(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner){
8908 CHECK(owner->result_ok);
8909 return *owner->contents.result;
8911 ptrArray __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok"))) TS_CResult_CVec_ECDSASignatureZNoneZ_get_ok(uint64_t owner) {
8912 LDKCResult_CVec_ECDSASignatureZNoneZ* owner_conv = (LDKCResult_CVec_ECDSASignatureZNoneZ*)untag_ptr(owner);
8913 LDKCVec_ECDSASignatureZ ret_var = CResult_CVec_ECDSASignatureZNoneZ_get_ok(owner_conv);
8914 ptrArray ret_arr = NULL;
8915 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
8916 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
8917 for (size_t m = 0; m < ret_var.datalen; m++) {
8918 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
8919 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
8920 ret_arr_ptr[m] = ret_conv_12_arr;
8926 static inline void CResult_CVec_ECDSASignatureZNoneZ_get_err(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR owner){
8927 CHECK(!owner->result_ok);
8928 return *owner->contents.err;
8930 void __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_get_err"))) TS_CResult_CVec_ECDSASignatureZNoneZ_get_err(uint64_t owner) {
8931 LDKCResult_CVec_ECDSASignatureZNoneZ* owner_conv = (LDKCResult_CVec_ECDSASignatureZNoneZ*)untag_ptr(owner);
8932 CResult_CVec_ECDSASignatureZNoneZ_get_err(owner_conv);
8935 uint32_t __attribute__((export_name("TS_LDKCOption_usizeZ_ty_from_ptr"))) TS_LDKCOption_usizeZ_ty_from_ptr(uint64_t ptr) {
8936 LDKCOption_usizeZ *obj = (LDKCOption_usizeZ*)untag_ptr(ptr);
8938 case LDKCOption_usizeZ_Some: return 0;
8939 case LDKCOption_usizeZ_None: return 1;
8943 uint32_t __attribute__((export_name("TS_LDKCOption_usizeZ_Some_get_some"))) TS_LDKCOption_usizeZ_Some_get_some(uint64_t ptr) {
8944 LDKCOption_usizeZ *obj = (LDKCOption_usizeZ*)untag_ptr(ptr);
8945 assert(obj->tag == LDKCOption_usizeZ_Some);
8946 uint32_t some_conv = obj->some;
8949 static inline struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
8950 LDKShutdownScript ret = *owner->contents.result;
8951 ret.is_owned = false;
8954 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(uint64_t owner) {
8955 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
8956 LDKShutdownScript ret_var = CResult_ShutdownScriptDecodeErrorZ_get_ok(owner_conv);
8957 uint64_t ret_ref = 0;
8958 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8959 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8963 static inline struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
8964 CHECK(!owner->result_ok);
8965 return DecodeError_clone(&*owner->contents.err);
8967 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_err(uint64_t owner) {
8968 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(owner);
8969 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
8970 *ret_copy = CResult_ShutdownScriptDecodeErrorZ_get_err(owner_conv);
8971 uint64_t ret_ref = tag_ptr(ret_copy, true);
8975 static inline struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
8976 LDKShutdownScript ret = *owner->contents.result;
8977 ret.is_owned = false;
8980 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint64_t owner) {
8981 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
8982 LDKShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner_conv);
8983 uint64_t ret_ref = 0;
8984 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8985 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
8989 static inline struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
8990 LDKInvalidShutdownScript ret = *owner->contents.err;
8991 ret.is_owned = false;
8994 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(uint64_t owner) {
8995 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(owner);
8996 LDKInvalidShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner_conv);
8997 uint64_t ret_ref = 0;
8998 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8999 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9003 uint32_t __attribute__((export_name("TS_LDKPaymentPurpose_ty_from_ptr"))) TS_LDKPaymentPurpose_ty_from_ptr(uint64_t ptr) {
9004 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
9006 case LDKPaymentPurpose_InvoicePayment: return 0;
9007 case LDKPaymentPurpose_SpontaneousPayment: return 1;
9011 uint64_t __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(uint64_t ptr) {
9012 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
9013 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
9014 uint64_t payment_preimage_ref = tag_ptr(&obj->invoice_payment.payment_preimage, false);
9015 return payment_preimage_ref;
9017 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(uint64_t ptr) {
9018 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
9019 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
9020 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
9021 memcpy(payment_secret_arr->elems, obj->invoice_payment.payment_secret.data, 32);
9022 return payment_secret_arr;
9024 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment"))) TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(uint64_t ptr) {
9025 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)untag_ptr(ptr);
9026 assert(obj->tag == LDKPaymentPurpose_SpontaneousPayment);
9027 int8_tArray spontaneous_payment_arr = init_int8_tArray(32, __LINE__);
9028 memcpy(spontaneous_payment_arr->elems, obj->spontaneous_payment.data, 32);
9029 return spontaneous_payment_arr;
9031 static inline struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
9032 CHECK(owner->result_ok);
9033 return PaymentPurpose_clone(&*owner->contents.result);
9035 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(uint64_t owner) {
9036 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
9037 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
9038 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_ok(owner_conv);
9039 uint64_t ret_ref = tag_ptr(ret_copy, true);
9043 static inline struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
9044 CHECK(!owner->result_ok);
9045 return DecodeError_clone(&*owner->contents.err);
9047 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_err(uint64_t owner) {
9048 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(owner);
9049 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9050 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_err(owner_conv);
9051 uint64_t ret_ref = tag_ptr(ret_copy, true);
9055 static inline struct LDKClaimedHTLC CResult_ClaimedHTLCDecodeErrorZ_get_ok(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner){
9056 LDKClaimedHTLC ret = *owner->contents.result;
9057 ret.is_owned = false;
9060 uint64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok"))) TS_CResult_ClaimedHTLCDecodeErrorZ_get_ok(uint64_t owner) {
9061 LDKCResult_ClaimedHTLCDecodeErrorZ* owner_conv = (LDKCResult_ClaimedHTLCDecodeErrorZ*)untag_ptr(owner);
9062 LDKClaimedHTLC ret_var = CResult_ClaimedHTLCDecodeErrorZ_get_ok(owner_conv);
9063 uint64_t ret_ref = 0;
9064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
9065 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
9069 static inline struct LDKDecodeError CResult_ClaimedHTLCDecodeErrorZ_get_err(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR owner){
9070 CHECK(!owner->result_ok);
9071 return DecodeError_clone(&*owner->contents.err);
9073 uint64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_get_err"))) TS_CResult_ClaimedHTLCDecodeErrorZ_get_err(uint64_t owner) {
9074 LDKCResult_ClaimedHTLCDecodeErrorZ* owner_conv = (LDKCResult_ClaimedHTLCDecodeErrorZ*)untag_ptr(owner);
9075 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9076 *ret_copy = CResult_ClaimedHTLCDecodeErrorZ_get_err(owner_conv);
9077 uint64_t ret_ref = tag_ptr(ret_copy, true);
9081 uint32_t __attribute__((export_name("TS_LDKPathFailure_ty_from_ptr"))) TS_LDKPathFailure_ty_from_ptr(uint64_t ptr) {
9082 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
9084 case LDKPathFailure_InitialSend: return 0;
9085 case LDKPathFailure_OnPath: return 1;
9089 uint64_t __attribute__((export_name("TS_LDKPathFailure_InitialSend_get_err"))) TS_LDKPathFailure_InitialSend_get_err(uint64_t ptr) {
9090 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
9091 assert(obj->tag == LDKPathFailure_InitialSend);
9092 uint64_t err_ref = tag_ptr(&obj->initial_send.err, false);
9095 uint64_t __attribute__((export_name("TS_LDKPathFailure_OnPath_get_network_update"))) TS_LDKPathFailure_OnPath_get_network_update(uint64_t ptr) {
9096 LDKPathFailure *obj = (LDKPathFailure*)untag_ptr(ptr);
9097 assert(obj->tag == LDKPathFailure_OnPath);
9098 uint64_t network_update_ref = tag_ptr(&obj->on_path.network_update, false);
9099 return network_update_ref;
9101 uint32_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_ty_from_ptr"))) TS_LDKCOption_PathFailureZ_ty_from_ptr(uint64_t ptr) {
9102 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
9104 case LDKCOption_PathFailureZ_Some: return 0;
9105 case LDKCOption_PathFailureZ_None: return 1;
9109 uint64_t __attribute__((export_name("TS_LDKCOption_PathFailureZ_Some_get_some"))) TS_LDKCOption_PathFailureZ_Some_get_some(uint64_t ptr) {
9110 LDKCOption_PathFailureZ *obj = (LDKCOption_PathFailureZ*)untag_ptr(ptr);
9111 assert(obj->tag == LDKCOption_PathFailureZ_Some);
9112 uint64_t some_ref = tag_ptr(&obj->some, false);
9115 static inline struct LDKCOption_PathFailureZ CResult_COption_PathFailureZDecodeErrorZ_get_ok(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
9116 CHECK(owner->result_ok);
9117 return COption_PathFailureZ_clone(&*owner->contents.result);
9119 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_ok(uint64_t owner) {
9120 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
9121 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
9122 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_ok(owner_conv);
9123 uint64_t ret_ref = tag_ptr(ret_copy, true);
9127 static inline struct LDKDecodeError CResult_COption_PathFailureZDecodeErrorZ_get_err(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR owner){
9128 CHECK(!owner->result_ok);
9129 return DecodeError_clone(&*owner->contents.err);
9131 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_get_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_get_err(uint64_t owner) {
9132 LDKCResult_COption_PathFailureZDecodeErrorZ* owner_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(owner);
9133 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9134 *ret_copy = CResult_COption_PathFailureZDecodeErrorZ_get_err(owner_conv);
9135 uint64_t ret_ref = tag_ptr(ret_copy, true);
9139 uint32_t __attribute__((export_name("TS_LDKClosureReason_ty_from_ptr"))) TS_LDKClosureReason_ty_from_ptr(uint64_t ptr) {
9140 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
9142 case LDKClosureReason_CounterpartyForceClosed: return 0;
9143 case LDKClosureReason_HolderForceClosed: return 1;
9144 case LDKClosureReason_CooperativeClosure: return 2;
9145 case LDKClosureReason_CommitmentTxConfirmed: return 3;
9146 case LDKClosureReason_FundingTimedOut: return 4;
9147 case LDKClosureReason_ProcessingError: return 5;
9148 case LDKClosureReason_DisconnectedPeer: return 6;
9149 case LDKClosureReason_OutdatedChannelManager: return 7;
9150 case LDKClosureReason_CounterpartyCoopClosedUnfundedChannel: return 8;
9151 case LDKClosureReason_FundingBatchClosure: return 9;
9155 uint64_t __attribute__((export_name("TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg"))) TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(uint64_t ptr) {
9156 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
9157 assert(obj->tag == LDKClosureReason_CounterpartyForceClosed);
9158 LDKUntrustedString peer_msg_var = obj->counterparty_force_closed.peer_msg;
9159 uint64_t peer_msg_ref = 0;
9160 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_var);
9161 peer_msg_ref = tag_ptr(peer_msg_var.inner, false);
9162 return peer_msg_ref;
9164 jstring __attribute__((export_name("TS_LDKClosureReason_ProcessingError_get_err"))) TS_LDKClosureReason_ProcessingError_get_err(uint64_t ptr) {
9165 LDKClosureReason *obj = (LDKClosureReason*)untag_ptr(ptr);
9166 assert(obj->tag == LDKClosureReason_ProcessingError);
9167 LDKStr err_str = obj->processing_error.err;
9168 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
9171 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_ty_from_ptr"))) TS_LDKCOption_ClosureReasonZ_ty_from_ptr(uint64_t ptr) {
9172 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
9174 case LDKCOption_ClosureReasonZ_Some: return 0;
9175 case LDKCOption_ClosureReasonZ_None: return 1;
9179 uint64_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_Some_get_some"))) TS_LDKCOption_ClosureReasonZ_Some_get_some(uint64_t ptr) {
9180 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)untag_ptr(ptr);
9181 assert(obj->tag == LDKCOption_ClosureReasonZ_Some);
9182 uint64_t some_ref = tag_ptr(&obj->some, false);
9185 static inline struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
9186 CHECK(owner->result_ok);
9187 return COption_ClosureReasonZ_clone(&*owner->contents.result);
9189 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint64_t owner) {
9190 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
9191 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
9192 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner_conv);
9193 uint64_t ret_ref = tag_ptr(ret_copy, true);
9197 static inline struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
9198 CHECK(!owner->result_ok);
9199 return DecodeError_clone(&*owner->contents.err);
9201 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint64_t owner) {
9202 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(owner);
9203 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9204 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner_conv);
9205 uint64_t ret_ref = tag_ptr(ret_copy, true);
9209 uint32_t __attribute__((export_name("TS_LDKHTLCDestination_ty_from_ptr"))) TS_LDKHTLCDestination_ty_from_ptr(uint64_t ptr) {
9210 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9212 case LDKHTLCDestination_NextHopChannel: return 0;
9213 case LDKHTLCDestination_UnknownNextHop: return 1;
9214 case LDKHTLCDestination_InvalidForward: return 2;
9215 case LDKHTLCDestination_FailedPayment: return 3;
9219 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_node_id"))) TS_LDKHTLCDestination_NextHopChannel_get_node_id(uint64_t ptr) {
9220 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9221 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
9222 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
9223 memcpy(node_id_arr->elems, obj->next_hop_channel.node_id.compressed_form, 33);
9226 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_channel_id"))) TS_LDKHTLCDestination_NextHopChannel_get_channel_id(uint64_t ptr) {
9227 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9228 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
9229 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
9230 memcpy(channel_id_arr->elems, obj->next_hop_channel.channel_id.data, 32);
9231 return channel_id_arr;
9233 int64_t __attribute__((export_name("TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid"))) TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(uint64_t ptr) {
9234 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9235 assert(obj->tag == LDKHTLCDestination_UnknownNextHop);
9236 int64_t requested_forward_scid_conv = obj->unknown_next_hop.requested_forward_scid;
9237 return requested_forward_scid_conv;
9239 int64_t __attribute__((export_name("TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid"))) TS_LDKHTLCDestination_InvalidForward_get_requested_forward_scid(uint64_t ptr) {
9240 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9241 assert(obj->tag == LDKHTLCDestination_InvalidForward);
9242 int64_t requested_forward_scid_conv = obj->invalid_forward.requested_forward_scid;
9243 return requested_forward_scid_conv;
9245 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_FailedPayment_get_payment_hash"))) TS_LDKHTLCDestination_FailedPayment_get_payment_hash(uint64_t ptr) {
9246 LDKHTLCDestination *obj = (LDKHTLCDestination*)untag_ptr(ptr);
9247 assert(obj->tag == LDKHTLCDestination_FailedPayment);
9248 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9249 memcpy(payment_hash_arr->elems, obj->failed_payment.payment_hash.data, 32);
9250 return payment_hash_arr;
9252 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_ty_from_ptr"))) TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(uint64_t ptr) {
9253 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
9255 case LDKCOption_HTLCDestinationZ_Some: return 0;
9256 case LDKCOption_HTLCDestinationZ_None: return 1;
9260 uint64_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_Some_get_some"))) TS_LDKCOption_HTLCDestinationZ_Some_get_some(uint64_t ptr) {
9261 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)untag_ptr(ptr);
9262 assert(obj->tag == LDKCOption_HTLCDestinationZ_Some);
9263 uint64_t some_ref = tag_ptr(&obj->some, false);
9266 static inline struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
9267 CHECK(owner->result_ok);
9268 return COption_HTLCDestinationZ_clone(&*owner->contents.result);
9270 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(uint64_t owner) {
9271 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
9272 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
9273 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner_conv);
9274 uint64_t ret_ref = tag_ptr(ret_copy, true);
9278 static inline struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
9279 CHECK(!owner->result_ok);
9280 return DecodeError_clone(&*owner->contents.err);
9282 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(uint64_t owner) {
9283 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(owner);
9284 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9285 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner_conv);
9286 uint64_t ret_ref = tag_ptr(ret_copy, true);
9290 static inline enum LDKPaymentFailureReason CResult_PaymentFailureReasonDecodeErrorZ_get_ok(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
9291 CHECK(owner->result_ok);
9292 return PaymentFailureReason_clone(&*owner->contents.result);
9294 uint32_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_ok(uint64_t owner) {
9295 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
9296 uint32_t ret_conv = LDKPaymentFailureReason_to_js(CResult_PaymentFailureReasonDecodeErrorZ_get_ok(owner_conv));
9300 static inline struct LDKDecodeError CResult_PaymentFailureReasonDecodeErrorZ_get_err(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR owner){
9301 CHECK(!owner->result_ok);
9302 return DecodeError_clone(&*owner->contents.err);
9304 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_get_err(uint64_t owner) {
9305 LDKCResult_PaymentFailureReasonDecodeErrorZ* owner_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(owner);
9306 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
9307 *ret_copy = CResult_PaymentFailureReasonDecodeErrorZ_get_err(owner_conv);
9308 uint64_t ret_ref = tag_ptr(ret_copy, true);
9312 uint32_t __attribute__((export_name("TS_LDKCOption_U128Z_ty_from_ptr"))) TS_LDKCOption_U128Z_ty_from_ptr(uint64_t ptr) {
9313 LDKCOption_U128Z *obj = (LDKCOption_U128Z*)untag_ptr(ptr);
9315 case LDKCOption_U128Z_Some: return 0;
9316 case LDKCOption_U128Z_None: return 1;
9320 int8_tArray __attribute__((export_name("TS_LDKCOption_U128Z_Some_get_some"))) TS_LDKCOption_U128Z_Some_get_some(uint64_t ptr) {
9321 LDKCOption_U128Z *obj = (LDKCOption_U128Z*)untag_ptr(ptr);
9322 assert(obj->tag == LDKCOption_U128Z_Some);
9323 int8_tArray some_arr = init_int8_tArray(16, __LINE__);
9324 memcpy(some_arr->elems, obj->some.le_bytes, 16);
9327 static inline LDKCVec_ClaimedHTLCZ CVec_ClaimedHTLCZ_clone(const LDKCVec_ClaimedHTLCZ *orig) {
9328 LDKCVec_ClaimedHTLCZ ret = { .data = MALLOC(sizeof(LDKClaimedHTLC) * orig->datalen, "LDKCVec_ClaimedHTLCZ clone bytes"), .datalen = orig->datalen };
9329 for (size_t i = 0; i < ret.datalen; i++) {
9330 ret.data[i] = ClaimedHTLC_clone(&orig->data[i]);
9334 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr"))) TS_LDKCOption_PaymentFailureReasonZ_ty_from_ptr(uint64_t ptr) {
9335 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
9337 case LDKCOption_PaymentFailureReasonZ_Some: return 0;
9338 case LDKCOption_PaymentFailureReasonZ_None: return 1;
9342 uint32_t __attribute__((export_name("TS_LDKCOption_PaymentFailureReasonZ_Some_get_some"))) TS_LDKCOption_PaymentFailureReasonZ_Some_get_some(uint64_t ptr) {
9343 LDKCOption_PaymentFailureReasonZ *obj = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(ptr);
9344 assert(obj->tag == LDKCOption_PaymentFailureReasonZ_Some);
9345 uint32_t some_conv = LDKPaymentFailureReason_to_js(obj->some);
9348 uint32_t __attribute__((export_name("TS_LDKBumpTransactionEvent_ty_from_ptr"))) TS_LDKBumpTransactionEvent_ty_from_ptr(uint64_t ptr) {
9349 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9351 case LDKBumpTransactionEvent_ChannelClose: return 0;
9352 case LDKBumpTransactionEvent_HTLCResolution: return 1;
9356 int8_tArray __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id"))) TS_LDKBumpTransactionEvent_ChannelClose_get_claim_id(uint64_t ptr) {
9357 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9358 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9359 int8_tArray claim_id_arr = init_int8_tArray(32, __LINE__);
9360 memcpy(claim_id_arr->elems, obj->channel_close.claim_id.data, 32);
9361 return claim_id_arr;
9363 int32_t __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight"))) TS_LDKBumpTransactionEvent_ChannelClose_get_package_target_feerate_sat_per_1000_weight(uint64_t ptr) {
9364 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9365 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9366 int32_t package_target_feerate_sat_per_1000_weight_conv = obj->channel_close.package_target_feerate_sat_per_1000_weight;
9367 return package_target_feerate_sat_per_1000_weight_conv;
9369 int8_tArray __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx"))) TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx(uint64_t ptr) {
9370 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9371 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9372 LDKTransaction commitment_tx_var = obj->channel_close.commitment_tx;
9373 int8_tArray commitment_tx_arr = init_int8_tArray(commitment_tx_var.datalen, __LINE__);
9374 memcpy(commitment_tx_arr->elems, commitment_tx_var.data, commitment_tx_var.datalen);
9375 return commitment_tx_arr;
9377 int64_t __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis"))) TS_LDKBumpTransactionEvent_ChannelClose_get_commitment_tx_fee_satoshis(uint64_t ptr) {
9378 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9379 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9380 int64_t commitment_tx_fee_satoshis_conv = obj->channel_close.commitment_tx_fee_satoshis;
9381 return commitment_tx_fee_satoshis_conv;
9383 uint64_t __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor"))) TS_LDKBumpTransactionEvent_ChannelClose_get_anchor_descriptor(uint64_t ptr) {
9384 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9385 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9386 LDKAnchorDescriptor anchor_descriptor_var = obj->channel_close.anchor_descriptor;
9387 uint64_t anchor_descriptor_ref = 0;
9388 CHECK_INNER_FIELD_ACCESS_OR_NULL(anchor_descriptor_var);
9389 anchor_descriptor_ref = tag_ptr(anchor_descriptor_var.inner, false);
9390 return anchor_descriptor_ref;
9392 uint64_tArray __attribute__((export_name("TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs"))) TS_LDKBumpTransactionEvent_ChannelClose_get_pending_htlcs(uint64_t ptr) {
9393 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9394 assert(obj->tag == LDKBumpTransactionEvent_ChannelClose);
9395 LDKCVec_HTLCOutputInCommitmentZ pending_htlcs_var = obj->channel_close.pending_htlcs;
9396 uint64_tArray pending_htlcs_arr = NULL;
9397 pending_htlcs_arr = init_uint64_tArray(pending_htlcs_var.datalen, __LINE__);
9398 uint64_t *pending_htlcs_arr_ptr = (uint64_t*)(((uint8_t*)pending_htlcs_arr) + 8);
9399 for (size_t y = 0; y < pending_htlcs_var.datalen; y++) {
9400 LDKHTLCOutputInCommitment pending_htlcs_conv_24_var = pending_htlcs_var.data[y];
9401 uint64_t pending_htlcs_conv_24_ref = 0;
9402 CHECK_INNER_FIELD_ACCESS_OR_NULL(pending_htlcs_conv_24_var);
9403 pending_htlcs_conv_24_ref = tag_ptr(pending_htlcs_conv_24_var.inner, false);
9404 pending_htlcs_arr_ptr[y] = pending_htlcs_conv_24_ref;
9407 return pending_htlcs_arr;
9409 int8_tArray __attribute__((export_name("TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id"))) TS_LDKBumpTransactionEvent_HTLCResolution_get_claim_id(uint64_t ptr) {
9410 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9411 assert(obj->tag == LDKBumpTransactionEvent_HTLCResolution);
9412 int8_tArray claim_id_arr = init_int8_tArray(32, __LINE__);
9413 memcpy(claim_id_arr->elems, obj->htlc_resolution.claim_id.data, 32);
9414 return claim_id_arr;
9416 int32_t __attribute__((export_name("TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight"))) TS_LDKBumpTransactionEvent_HTLCResolution_get_target_feerate_sat_per_1000_weight(uint64_t ptr) {
9417 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9418 assert(obj->tag == LDKBumpTransactionEvent_HTLCResolution);
9419 int32_t target_feerate_sat_per_1000_weight_conv = obj->htlc_resolution.target_feerate_sat_per_1000_weight;
9420 return target_feerate_sat_per_1000_weight_conv;
9422 uint64_tArray __attribute__((export_name("TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors"))) TS_LDKBumpTransactionEvent_HTLCResolution_get_htlc_descriptors(uint64_t ptr) {
9423 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9424 assert(obj->tag == LDKBumpTransactionEvent_HTLCResolution);
9425 LDKCVec_HTLCDescriptorZ htlc_descriptors_var = obj->htlc_resolution.htlc_descriptors;
9426 uint64_tArray htlc_descriptors_arr = NULL;
9427 htlc_descriptors_arr = init_uint64_tArray(htlc_descriptors_var.datalen, __LINE__);
9428 uint64_t *htlc_descriptors_arr_ptr = (uint64_t*)(((uint8_t*)htlc_descriptors_arr) + 8);
9429 for (size_t q = 0; q < htlc_descriptors_var.datalen; q++) {
9430 LDKHTLCDescriptor htlc_descriptors_conv_16_var = htlc_descriptors_var.data[q];
9431 uint64_t htlc_descriptors_conv_16_ref = 0;
9432 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_descriptors_conv_16_var);
9433 htlc_descriptors_conv_16_ref = tag_ptr(htlc_descriptors_conv_16_var.inner, false);
9434 htlc_descriptors_arr_ptr[q] = htlc_descriptors_conv_16_ref;
9437 return htlc_descriptors_arr;
9439 int32_t __attribute__((export_name("TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time"))) TS_LDKBumpTransactionEvent_HTLCResolution_get_tx_lock_time(uint64_t ptr) {
9440 LDKBumpTransactionEvent *obj = (LDKBumpTransactionEvent*)untag_ptr(ptr);
9441 assert(obj->tag == LDKBumpTransactionEvent_HTLCResolution);
9442 int32_t tx_lock_time_conv = obj->htlc_resolution.tx_lock_time;
9443 return tx_lock_time_conv;
9445 uint32_t __attribute__((export_name("TS_LDKEvent_ty_from_ptr"))) TS_LDKEvent_ty_from_ptr(uint64_t ptr) {
9446 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9448 case LDKEvent_FundingGenerationReady: return 0;
9449 case LDKEvent_PaymentClaimable: return 1;
9450 case LDKEvent_PaymentClaimed: return 2;
9451 case LDKEvent_PaymentSent: return 3;
9452 case LDKEvent_PaymentFailed: return 4;
9453 case LDKEvent_PaymentPathSuccessful: return 5;
9454 case LDKEvent_PaymentPathFailed: return 6;
9455 case LDKEvent_ProbeSuccessful: return 7;
9456 case LDKEvent_ProbeFailed: return 8;
9457 case LDKEvent_PendingHTLCsForwardable: return 9;
9458 case LDKEvent_HTLCIntercepted: return 10;
9459 case LDKEvent_SpendableOutputs: return 11;
9460 case LDKEvent_PaymentForwarded: return 12;
9461 case LDKEvent_ChannelPending: return 13;
9462 case LDKEvent_ChannelReady: return 14;
9463 case LDKEvent_ChannelClosed: return 15;
9464 case LDKEvent_DiscardFunding: return 16;
9465 case LDKEvent_OpenChannelRequest: return 17;
9466 case LDKEvent_HTLCHandlingFailed: return 18;
9467 case LDKEvent_BumpTransaction: return 19;
9471 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(uint64_t ptr) {
9472 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9473 assert(obj->tag == LDKEvent_FundingGenerationReady);
9474 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
9475 memcpy(temporary_channel_id_arr->elems, obj->funding_generation_ready.temporary_channel_id.data, 32);
9476 return temporary_channel_id_arr;
9478 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id"))) TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(uint64_t ptr) {
9479 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9480 assert(obj->tag == LDKEvent_FundingGenerationReady);
9481 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
9482 memcpy(counterparty_node_id_arr->elems, obj->funding_generation_ready.counterparty_node_id.compressed_form, 33);
9483 return counterparty_node_id_arr;
9485 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis"))) TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(uint64_t ptr) {
9486 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9487 assert(obj->tag == LDKEvent_FundingGenerationReady);
9488 int64_t channel_value_satoshis_conv = obj->funding_generation_ready.channel_value_satoshis;
9489 return channel_value_satoshis_conv;
9491 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_output_script"))) TS_LDKEvent_FundingGenerationReady_get_output_script(uint64_t ptr) {
9492 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9493 assert(obj->tag == LDKEvent_FundingGenerationReady);
9494 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
9495 int8_tArray output_script_arr = init_int8_tArray(output_script_var.datalen, __LINE__);
9496 memcpy(output_script_arr->elems, output_script_var.data, output_script_var.datalen);
9497 return output_script_arr;
9499 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_user_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_user_channel_id(uint64_t ptr) {
9500 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9501 assert(obj->tag == LDKEvent_FundingGenerationReady);
9502 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
9503 memcpy(user_channel_id_arr->elems, obj->funding_generation_ready.user_channel_id.le_bytes, 16);
9504 return user_channel_id_arr;
9506 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimable_get_receiver_node_id(uint64_t ptr) {
9507 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9508 assert(obj->tag == LDKEvent_PaymentClaimable);
9509 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
9510 memcpy(receiver_node_id_arr->elems, obj->payment_claimable.receiver_node_id.compressed_form, 33);
9511 return receiver_node_id_arr;
9513 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_payment_hash"))) TS_LDKEvent_PaymentClaimable_get_payment_hash(uint64_t ptr) {
9514 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9515 assert(obj->tag == LDKEvent_PaymentClaimable);
9516 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9517 memcpy(payment_hash_arr->elems, obj->payment_claimable.payment_hash.data, 32);
9518 return payment_hash_arr;
9520 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_onion_fields"))) TS_LDKEvent_PaymentClaimable_get_onion_fields(uint64_t ptr) {
9521 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9522 assert(obj->tag == LDKEvent_PaymentClaimable);
9523 LDKRecipientOnionFields onion_fields_var = obj->payment_claimable.onion_fields;
9524 uint64_t onion_fields_ref = 0;
9525 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_var);
9526 onion_fields_ref = tag_ptr(onion_fields_var.inner, false);
9527 return onion_fields_ref;
9529 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_amount_msat"))) TS_LDKEvent_PaymentClaimable_get_amount_msat(uint64_t ptr) {
9530 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9531 assert(obj->tag == LDKEvent_PaymentClaimable);
9532 int64_t amount_msat_conv = obj->payment_claimable.amount_msat;
9533 return amount_msat_conv;
9535 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat"))) TS_LDKEvent_PaymentClaimable_get_counterparty_skimmed_fee_msat(uint64_t ptr) {
9536 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9537 assert(obj->tag == LDKEvent_PaymentClaimable);
9538 int64_t counterparty_skimmed_fee_msat_conv = obj->payment_claimable.counterparty_skimmed_fee_msat;
9539 return counterparty_skimmed_fee_msat_conv;
9541 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_purpose"))) TS_LDKEvent_PaymentClaimable_get_purpose(uint64_t ptr) {
9542 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9543 assert(obj->tag == LDKEvent_PaymentClaimable);
9544 uint64_t purpose_ref = tag_ptr(&obj->payment_claimable.purpose, false);
9547 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_channel_id(uint64_t ptr) {
9548 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9549 assert(obj->tag == LDKEvent_PaymentClaimable);
9550 uint64_t via_channel_id_ref = tag_ptr(&obj->payment_claimable.via_channel_id, false);
9551 return via_channel_id_ref;
9553 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_via_user_channel_id"))) TS_LDKEvent_PaymentClaimable_get_via_user_channel_id(uint64_t ptr) {
9554 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9555 assert(obj->tag == LDKEvent_PaymentClaimable);
9556 uint64_t via_user_channel_id_ref = tag_ptr(&obj->payment_claimable.via_user_channel_id, false);
9557 return via_user_channel_id_ref;
9559 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimable_get_claim_deadline"))) TS_LDKEvent_PaymentClaimable_get_claim_deadline(uint64_t ptr) {
9560 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9561 assert(obj->tag == LDKEvent_PaymentClaimable);
9562 uint64_t claim_deadline_ref = tag_ptr(&obj->payment_claimable.claim_deadline, false);
9563 return claim_deadline_ref;
9565 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_receiver_node_id"))) TS_LDKEvent_PaymentClaimed_get_receiver_node_id(uint64_t ptr) {
9566 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9567 assert(obj->tag == LDKEvent_PaymentClaimed);
9568 int8_tArray receiver_node_id_arr = init_int8_tArray(33, __LINE__);
9569 memcpy(receiver_node_id_arr->elems, obj->payment_claimed.receiver_node_id.compressed_form, 33);
9570 return receiver_node_id_arr;
9572 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_payment_hash"))) TS_LDKEvent_PaymentClaimed_get_payment_hash(uint64_t ptr) {
9573 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9574 assert(obj->tag == LDKEvent_PaymentClaimed);
9575 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9576 memcpy(payment_hash_arr->elems, obj->payment_claimed.payment_hash.data, 32);
9577 return payment_hash_arr;
9579 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_amount_msat"))) TS_LDKEvent_PaymentClaimed_get_amount_msat(uint64_t ptr) {
9580 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9581 assert(obj->tag == LDKEvent_PaymentClaimed);
9582 int64_t amount_msat_conv = obj->payment_claimed.amount_msat;
9583 return amount_msat_conv;
9585 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_purpose"))) TS_LDKEvent_PaymentClaimed_get_purpose(uint64_t ptr) {
9586 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9587 assert(obj->tag == LDKEvent_PaymentClaimed);
9588 uint64_t purpose_ref = tag_ptr(&obj->payment_claimed.purpose, false);
9591 uint64_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_htlcs"))) TS_LDKEvent_PaymentClaimed_get_htlcs(uint64_t ptr) {
9592 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9593 assert(obj->tag == LDKEvent_PaymentClaimed);
9594 LDKCVec_ClaimedHTLCZ htlcs_var = obj->payment_claimed.htlcs;
9595 uint64_tArray htlcs_arr = NULL;
9596 htlcs_arr = init_uint64_tArray(htlcs_var.datalen, __LINE__);
9597 uint64_t *htlcs_arr_ptr = (uint64_t*)(((uint8_t*)htlcs_arr) + 8);
9598 for (size_t n = 0; n < htlcs_var.datalen; n++) {
9599 LDKClaimedHTLC htlcs_conv_13_var = htlcs_var.data[n];
9600 uint64_t htlcs_conv_13_ref = 0;
9601 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlcs_conv_13_var);
9602 htlcs_conv_13_ref = tag_ptr(htlcs_conv_13_var.inner, false);
9603 htlcs_arr_ptr[n] = htlcs_conv_13_ref;
9608 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat"))) TS_LDKEvent_PaymentClaimed_get_sender_intended_total_msat(uint64_t ptr) {
9609 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9610 assert(obj->tag == LDKEvent_PaymentClaimed);
9611 uint64_t sender_intended_total_msat_ref = tag_ptr(&obj->payment_claimed.sender_intended_total_msat, false);
9612 return sender_intended_total_msat_ref;
9614 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_id"))) TS_LDKEvent_PaymentSent_get_payment_id(uint64_t ptr) {
9615 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9616 assert(obj->tag == LDKEvent_PaymentSent);
9617 uint64_t payment_id_ref = tag_ptr(&obj->payment_sent.payment_id, false);
9618 return payment_id_ref;
9620 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_preimage"))) TS_LDKEvent_PaymentSent_get_payment_preimage(uint64_t ptr) {
9621 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9622 assert(obj->tag == LDKEvent_PaymentSent);
9623 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
9624 memcpy(payment_preimage_arr->elems, obj->payment_sent.payment_preimage.data, 32);
9625 return payment_preimage_arr;
9627 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_hash"))) TS_LDKEvent_PaymentSent_get_payment_hash(uint64_t ptr) {
9628 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9629 assert(obj->tag == LDKEvent_PaymentSent);
9630 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9631 memcpy(payment_hash_arr->elems, obj->payment_sent.payment_hash.data, 32);
9632 return payment_hash_arr;
9634 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_fee_paid_msat"))) TS_LDKEvent_PaymentSent_get_fee_paid_msat(uint64_t ptr) {
9635 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9636 assert(obj->tag == LDKEvent_PaymentSent);
9637 uint64_t fee_paid_msat_ref = tag_ptr(&obj->payment_sent.fee_paid_msat, false);
9638 return fee_paid_msat_ref;
9640 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_id"))) TS_LDKEvent_PaymentFailed_get_payment_id(uint64_t ptr) {
9641 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9642 assert(obj->tag == LDKEvent_PaymentFailed);
9643 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
9644 memcpy(payment_id_arr->elems, obj->payment_failed.payment_id.data, 32);
9645 return payment_id_arr;
9647 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_hash"))) TS_LDKEvent_PaymentFailed_get_payment_hash(uint64_t ptr) {
9648 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9649 assert(obj->tag == LDKEvent_PaymentFailed);
9650 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9651 memcpy(payment_hash_arr->elems, obj->payment_failed.payment_hash.data, 32);
9652 return payment_hash_arr;
9654 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_reason"))) TS_LDKEvent_PaymentFailed_get_reason(uint64_t ptr) {
9655 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9656 assert(obj->tag == LDKEvent_PaymentFailed);
9657 uint64_t reason_ref = tag_ptr(&obj->payment_failed.reason, false);
9660 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_id"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_id(uint64_t ptr) {
9661 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9662 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
9663 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
9664 memcpy(payment_id_arr->elems, obj->payment_path_successful.payment_id.data, 32);
9665 return payment_id_arr;
9667 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_hash"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(uint64_t ptr) {
9668 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9669 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
9670 uint64_t payment_hash_ref = tag_ptr(&obj->payment_path_successful.payment_hash, false);
9671 return payment_hash_ref;
9673 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_path"))) TS_LDKEvent_PaymentPathSuccessful_get_path(uint64_t ptr) {
9674 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9675 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
9676 LDKPath path_var = obj->payment_path_successful.path;
9677 uint64_t path_ref = 0;
9678 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9679 path_ref = tag_ptr(path_var.inner, false);
9682 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_id"))) TS_LDKEvent_PaymentPathFailed_get_payment_id(uint64_t ptr) {
9683 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9684 assert(obj->tag == LDKEvent_PaymentPathFailed);
9685 uint64_t payment_id_ref = tag_ptr(&obj->payment_path_failed.payment_id, false);
9686 return payment_id_ref;
9688 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_hash"))) TS_LDKEvent_PaymentPathFailed_get_payment_hash(uint64_t ptr) {
9689 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9690 assert(obj->tag == LDKEvent_PaymentPathFailed);
9691 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9692 memcpy(payment_hash_arr->elems, obj->payment_path_failed.payment_hash.data, 32);
9693 return payment_hash_arr;
9695 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently"))) TS_LDKEvent_PaymentPathFailed_get_payment_failed_permanently(uint64_t ptr) {
9696 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9697 assert(obj->tag == LDKEvent_PaymentPathFailed);
9698 jboolean payment_failed_permanently_conv = obj->payment_path_failed.payment_failed_permanently;
9699 return payment_failed_permanently_conv;
9701 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_failure"))) TS_LDKEvent_PaymentPathFailed_get_failure(uint64_t ptr) {
9702 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9703 assert(obj->tag == LDKEvent_PaymentPathFailed);
9704 uint64_t failure_ref = tag_ptr(&obj->payment_path_failed.failure, false);
9707 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_path"))) TS_LDKEvent_PaymentPathFailed_get_path(uint64_t ptr) {
9708 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9709 assert(obj->tag == LDKEvent_PaymentPathFailed);
9710 LDKPath path_var = obj->payment_path_failed.path;
9711 uint64_t path_ref = 0;
9712 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9713 path_ref = tag_ptr(path_var.inner, false);
9716 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_short_channel_id"))) TS_LDKEvent_PaymentPathFailed_get_short_channel_id(uint64_t ptr) {
9717 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9718 assert(obj->tag == LDKEvent_PaymentPathFailed);
9719 uint64_t short_channel_id_ref = tag_ptr(&obj->payment_path_failed.short_channel_id, false);
9720 return short_channel_id_ref;
9722 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_id"))) TS_LDKEvent_ProbeSuccessful_get_payment_id(uint64_t ptr) {
9723 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9724 assert(obj->tag == LDKEvent_ProbeSuccessful);
9725 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
9726 memcpy(payment_id_arr->elems, obj->probe_successful.payment_id.data, 32);
9727 return payment_id_arr;
9729 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_hash"))) TS_LDKEvent_ProbeSuccessful_get_payment_hash(uint64_t ptr) {
9730 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9731 assert(obj->tag == LDKEvent_ProbeSuccessful);
9732 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9733 memcpy(payment_hash_arr->elems, obj->probe_successful.payment_hash.data, 32);
9734 return payment_hash_arr;
9736 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_path"))) TS_LDKEvent_ProbeSuccessful_get_path(uint64_t ptr) {
9737 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9738 assert(obj->tag == LDKEvent_ProbeSuccessful);
9739 LDKPath path_var = obj->probe_successful.path;
9740 uint64_t path_ref = 0;
9741 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9742 path_ref = tag_ptr(path_var.inner, false);
9745 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_id"))) TS_LDKEvent_ProbeFailed_get_payment_id(uint64_t ptr) {
9746 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9747 assert(obj->tag == LDKEvent_ProbeFailed);
9748 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
9749 memcpy(payment_id_arr->elems, obj->probe_failed.payment_id.data, 32);
9750 return payment_id_arr;
9752 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_hash"))) TS_LDKEvent_ProbeFailed_get_payment_hash(uint64_t ptr) {
9753 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9754 assert(obj->tag == LDKEvent_ProbeFailed);
9755 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9756 memcpy(payment_hash_arr->elems, obj->probe_failed.payment_hash.data, 32);
9757 return payment_hash_arr;
9759 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_path"))) TS_LDKEvent_ProbeFailed_get_path(uint64_t ptr) {
9760 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9761 assert(obj->tag == LDKEvent_ProbeFailed);
9762 LDKPath path_var = obj->probe_failed.path;
9763 uint64_t path_ref = 0;
9764 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
9765 path_ref = tag_ptr(path_var.inner, false);
9768 uint64_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_short_channel_id"))) TS_LDKEvent_ProbeFailed_get_short_channel_id(uint64_t ptr) {
9769 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9770 assert(obj->tag == LDKEvent_ProbeFailed);
9771 uint64_t short_channel_id_ref = tag_ptr(&obj->probe_failed.short_channel_id, false);
9772 return short_channel_id_ref;
9774 int64_t __attribute__((export_name("TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable"))) TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(uint64_t ptr) {
9775 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9776 assert(obj->tag == LDKEvent_PendingHTLCsForwardable);
9777 int64_t time_forwardable_conv = obj->pending_htl_cs_forwardable.time_forwardable;
9778 return time_forwardable_conv;
9780 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_intercept_id"))) TS_LDKEvent_HTLCIntercepted_get_intercept_id(uint64_t ptr) {
9781 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9782 assert(obj->tag == LDKEvent_HTLCIntercepted);
9783 int8_tArray intercept_id_arr = init_int8_tArray(32, __LINE__);
9784 memcpy(intercept_id_arr->elems, obj->htlc_intercepted.intercept_id.data, 32);
9785 return intercept_id_arr;
9787 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid"))) TS_LDKEvent_HTLCIntercepted_get_requested_next_hop_scid(uint64_t ptr) {
9788 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9789 assert(obj->tag == LDKEvent_HTLCIntercepted);
9790 int64_t requested_next_hop_scid_conv = obj->htlc_intercepted.requested_next_hop_scid;
9791 return requested_next_hop_scid_conv;
9793 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_payment_hash"))) TS_LDKEvent_HTLCIntercepted_get_payment_hash(uint64_t ptr) {
9794 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9795 assert(obj->tag == LDKEvent_HTLCIntercepted);
9796 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
9797 memcpy(payment_hash_arr->elems, obj->htlc_intercepted.payment_hash.data, 32);
9798 return payment_hash_arr;
9800 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_inbound_amount_msat(uint64_t ptr) {
9801 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9802 assert(obj->tag == LDKEvent_HTLCIntercepted);
9803 int64_t inbound_amount_msat_conv = obj->htlc_intercepted.inbound_amount_msat;
9804 return inbound_amount_msat_conv;
9806 int64_t __attribute__((export_name("TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat"))) TS_LDKEvent_HTLCIntercepted_get_expected_outbound_amount_msat(uint64_t ptr) {
9807 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9808 assert(obj->tag == LDKEvent_HTLCIntercepted);
9809 int64_t expected_outbound_amount_msat_conv = obj->htlc_intercepted.expected_outbound_amount_msat;
9810 return expected_outbound_amount_msat_conv;
9812 uint64_tArray __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_outputs"))) TS_LDKEvent_SpendableOutputs_get_outputs(uint64_t ptr) {
9813 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9814 assert(obj->tag == LDKEvent_SpendableOutputs);
9815 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
9816 uint64_tArray outputs_arr = NULL;
9817 outputs_arr = init_uint64_tArray(outputs_var.datalen, __LINE__);
9818 uint64_t *outputs_arr_ptr = (uint64_t*)(((uint8_t*)outputs_arr) + 8);
9819 for (size_t b = 0; b < outputs_var.datalen; b++) {
9820 uint64_t outputs_conv_27_ref = tag_ptr(&outputs_var.data[b], false);
9821 outputs_arr_ptr[b] = outputs_conv_27_ref;
9826 uint64_t __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_channel_id"))) TS_LDKEvent_SpendableOutputs_get_channel_id(uint64_t ptr) {
9827 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9828 assert(obj->tag == LDKEvent_SpendableOutputs);
9829 uint64_t channel_id_ref = tag_ptr(&obj->spendable_outputs.channel_id, false);
9830 return channel_id_ref;
9832 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_prev_channel_id"))) TS_LDKEvent_PaymentForwarded_get_prev_channel_id(uint64_t ptr) {
9833 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9834 assert(obj->tag == LDKEvent_PaymentForwarded);
9835 uint64_t prev_channel_id_ref = tag_ptr(&obj->payment_forwarded.prev_channel_id, false);
9836 return prev_channel_id_ref;
9838 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_next_channel_id"))) TS_LDKEvent_PaymentForwarded_get_next_channel_id(uint64_t ptr) {
9839 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9840 assert(obj->tag == LDKEvent_PaymentForwarded);
9841 uint64_t next_channel_id_ref = tag_ptr(&obj->payment_forwarded.next_channel_id, false);
9842 return next_channel_id_ref;
9844 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_fee_earned_msat"))) TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(uint64_t ptr) {
9845 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9846 assert(obj->tag == LDKEvent_PaymentForwarded);
9847 uint64_t fee_earned_msat_ref = tag_ptr(&obj->payment_forwarded.fee_earned_msat, false);
9848 return fee_earned_msat_ref;
9850 jboolean __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx"))) TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(uint64_t ptr) {
9851 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9852 assert(obj->tag == LDKEvent_PaymentForwarded);
9853 jboolean claim_from_onchain_tx_conv = obj->payment_forwarded.claim_from_onchain_tx;
9854 return claim_from_onchain_tx_conv;
9856 uint64_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat"))) TS_LDKEvent_PaymentForwarded_get_outbound_amount_forwarded_msat(uint64_t ptr) {
9857 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9858 assert(obj->tag == LDKEvent_PaymentForwarded);
9859 uint64_t outbound_amount_forwarded_msat_ref = tag_ptr(&obj->payment_forwarded.outbound_amount_forwarded_msat, false);
9860 return outbound_amount_forwarded_msat_ref;
9862 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_channel_id"))) TS_LDKEvent_ChannelPending_get_channel_id(uint64_t ptr) {
9863 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9864 assert(obj->tag == LDKEvent_ChannelPending);
9865 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
9866 memcpy(channel_id_arr->elems, obj->channel_pending.channel_id.data, 32);
9867 return channel_id_arr;
9869 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_user_channel_id"))) TS_LDKEvent_ChannelPending_get_user_channel_id(uint64_t ptr) {
9870 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9871 assert(obj->tag == LDKEvent_ChannelPending);
9872 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
9873 memcpy(user_channel_id_arr->elems, obj->channel_pending.user_channel_id.le_bytes, 16);
9874 return user_channel_id_arr;
9876 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelPending_get_former_temporary_channel_id"))) TS_LDKEvent_ChannelPending_get_former_temporary_channel_id(uint64_t ptr) {
9877 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9878 assert(obj->tag == LDKEvent_ChannelPending);
9879 uint64_t former_temporary_channel_id_ref = tag_ptr(&obj->channel_pending.former_temporary_channel_id, false);
9880 return former_temporary_channel_id_ref;
9882 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelPending_get_counterparty_node_id"))) TS_LDKEvent_ChannelPending_get_counterparty_node_id(uint64_t ptr) {
9883 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9884 assert(obj->tag == LDKEvent_ChannelPending);
9885 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
9886 memcpy(counterparty_node_id_arr->elems, obj->channel_pending.counterparty_node_id.compressed_form, 33);
9887 return counterparty_node_id_arr;
9889 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelPending_get_funding_txo"))) TS_LDKEvent_ChannelPending_get_funding_txo(uint64_t ptr) {
9890 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9891 assert(obj->tag == LDKEvent_ChannelPending);
9892 LDKOutPoint funding_txo_var = obj->channel_pending.funding_txo;
9893 uint64_t funding_txo_ref = 0;
9894 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
9895 funding_txo_ref = tag_ptr(funding_txo_var.inner, false);
9896 return funding_txo_ref;
9898 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_id"))) TS_LDKEvent_ChannelReady_get_channel_id(uint64_t ptr) {
9899 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9900 assert(obj->tag == LDKEvent_ChannelReady);
9901 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
9902 memcpy(channel_id_arr->elems, obj->channel_ready.channel_id.data, 32);
9903 return channel_id_arr;
9905 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_user_channel_id"))) TS_LDKEvent_ChannelReady_get_user_channel_id(uint64_t ptr) {
9906 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9907 assert(obj->tag == LDKEvent_ChannelReady);
9908 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
9909 memcpy(user_channel_id_arr->elems, obj->channel_ready.user_channel_id.le_bytes, 16);
9910 return user_channel_id_arr;
9912 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelReady_get_counterparty_node_id"))) TS_LDKEvent_ChannelReady_get_counterparty_node_id(uint64_t ptr) {
9913 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9914 assert(obj->tag == LDKEvent_ChannelReady);
9915 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
9916 memcpy(counterparty_node_id_arr->elems, obj->channel_ready.counterparty_node_id.compressed_form, 33);
9917 return counterparty_node_id_arr;
9919 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelReady_get_channel_type"))) TS_LDKEvent_ChannelReady_get_channel_type(uint64_t ptr) {
9920 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9921 assert(obj->tag == LDKEvent_ChannelReady);
9922 LDKChannelTypeFeatures channel_type_var = obj->channel_ready.channel_type;
9923 uint64_t channel_type_ref = 0;
9924 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
9925 channel_type_ref = tag_ptr(channel_type_var.inner, false);
9926 return channel_type_ref;
9928 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_id"))) TS_LDKEvent_ChannelClosed_get_channel_id(uint64_t ptr) {
9929 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9930 assert(obj->tag == LDKEvent_ChannelClosed);
9931 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
9932 memcpy(channel_id_arr->elems, obj->channel_closed.channel_id.data, 32);
9933 return channel_id_arr;
9935 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_user_channel_id"))) TS_LDKEvent_ChannelClosed_get_user_channel_id(uint64_t ptr) {
9936 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9937 assert(obj->tag == LDKEvent_ChannelClosed);
9938 int8_tArray user_channel_id_arr = init_int8_tArray(16, __LINE__);
9939 memcpy(user_channel_id_arr->elems, obj->channel_closed.user_channel_id.le_bytes, 16);
9940 return user_channel_id_arr;
9942 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_reason"))) TS_LDKEvent_ChannelClosed_get_reason(uint64_t ptr) {
9943 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9944 assert(obj->tag == LDKEvent_ChannelClosed);
9945 uint64_t reason_ref = tag_ptr(&obj->channel_closed.reason, false);
9948 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_counterparty_node_id"))) TS_LDKEvent_ChannelClosed_get_counterparty_node_id(uint64_t ptr) {
9949 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9950 assert(obj->tag == LDKEvent_ChannelClosed);
9951 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
9952 memcpy(counterparty_node_id_arr->elems, obj->channel_closed.counterparty_node_id.compressed_form, 33);
9953 return counterparty_node_id_arr;
9955 uint64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_capacity_sats"))) TS_LDKEvent_ChannelClosed_get_channel_capacity_sats(uint64_t ptr) {
9956 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9957 assert(obj->tag == LDKEvent_ChannelClosed);
9958 uint64_t channel_capacity_sats_ref = tag_ptr(&obj->channel_closed.channel_capacity_sats, false);
9959 return channel_capacity_sats_ref;
9961 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_channel_id"))) TS_LDKEvent_DiscardFunding_get_channel_id(uint64_t ptr) {
9962 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9963 assert(obj->tag == LDKEvent_DiscardFunding);
9964 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
9965 memcpy(channel_id_arr->elems, obj->discard_funding.channel_id.data, 32);
9966 return channel_id_arr;
9968 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_transaction"))) TS_LDKEvent_DiscardFunding_get_transaction(uint64_t ptr) {
9969 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9970 assert(obj->tag == LDKEvent_DiscardFunding);
9971 LDKTransaction transaction_var = obj->discard_funding.transaction;
9972 int8_tArray transaction_arr = init_int8_tArray(transaction_var.datalen, __LINE__);
9973 memcpy(transaction_arr->elems, transaction_var.data, transaction_var.datalen);
9974 return transaction_arr;
9976 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id"))) TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(uint64_t ptr) {
9977 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9978 assert(obj->tag == LDKEvent_OpenChannelRequest);
9979 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
9980 memcpy(temporary_channel_id_arr->elems, obj->open_channel_request.temporary_channel_id.data, 32);
9981 return temporary_channel_id_arr;
9983 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id"))) TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(uint64_t ptr) {
9984 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9985 assert(obj->tag == LDKEvent_OpenChannelRequest);
9986 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
9987 memcpy(counterparty_node_id_arr->elems, obj->open_channel_request.counterparty_node_id.compressed_form, 33);
9988 return counterparty_node_id_arr;
9990 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_funding_satoshis"))) TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(uint64_t ptr) {
9991 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9992 assert(obj->tag == LDKEvent_OpenChannelRequest);
9993 int64_t funding_satoshis_conv = obj->open_channel_request.funding_satoshis;
9994 return funding_satoshis_conv;
9996 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_push_msat"))) TS_LDKEvent_OpenChannelRequest_get_push_msat(uint64_t ptr) {
9997 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
9998 assert(obj->tag == LDKEvent_OpenChannelRequest);
9999 int64_t push_msat_conv = obj->open_channel_request.push_msat;
10000 return push_msat_conv;
10002 uint64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_channel_type"))) TS_LDKEvent_OpenChannelRequest_get_channel_type(uint64_t ptr) {
10003 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
10004 assert(obj->tag == LDKEvent_OpenChannelRequest);
10005 LDKChannelTypeFeatures channel_type_var = obj->open_channel_request.channel_type;
10006 uint64_t channel_type_ref = 0;
10007 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
10008 channel_type_ref = tag_ptr(channel_type_var.inner, false);
10009 return channel_type_ref;
10011 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id"))) TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(uint64_t ptr) {
10012 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
10013 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
10014 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
10015 memcpy(prev_channel_id_arr->elems, obj->htlc_handling_failed.prev_channel_id.data, 32);
10016 return prev_channel_id_arr;
10018 uint64_t __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination"))) TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(uint64_t ptr) {
10019 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
10020 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
10021 uint64_t failed_next_destination_ref = tag_ptr(&obj->htlc_handling_failed.failed_next_destination, false);
10022 return failed_next_destination_ref;
10024 uint64_t __attribute__((export_name("TS_LDKEvent_BumpTransaction_get_bump_transaction"))) TS_LDKEvent_BumpTransaction_get_bump_transaction(uint64_t ptr) {
10025 LDKEvent *obj = (LDKEvent*)untag_ptr(ptr);
10026 assert(obj->tag == LDKEvent_BumpTransaction);
10027 uint64_t bump_transaction_ref = tag_ptr(&obj->bump_transaction, false);
10028 return bump_transaction_ref;
10030 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_ty_from_ptr"))) TS_LDKCOption_EventZ_ty_from_ptr(uint64_t ptr) {
10031 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
10033 case LDKCOption_EventZ_Some: return 0;
10034 case LDKCOption_EventZ_None: return 1;
10038 uint64_t __attribute__((export_name("TS_LDKCOption_EventZ_Some_get_some"))) TS_LDKCOption_EventZ_Some_get_some(uint64_t ptr) {
10039 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)untag_ptr(ptr);
10040 assert(obj->tag == LDKCOption_EventZ_Some);
10041 uint64_t some_ref = tag_ptr(&obj->some, false);
10044 static inline struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
10045 CHECK(owner->result_ok);
10046 return COption_EventZ_clone(&*owner->contents.result);
10048 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_ok"))) TS_CResult_COption_EventZDecodeErrorZ_get_ok(uint64_t owner) {
10049 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
10050 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
10051 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_ok(owner_conv);
10052 uint64_t ret_ref = tag_ptr(ret_copy, true);
10056 static inline struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
10057 CHECK(!owner->result_ok);
10058 return DecodeError_clone(&*owner->contents.err);
10060 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_err"))) TS_CResult_COption_EventZDecodeErrorZ_get_err(uint64_t owner) {
10061 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(owner);
10062 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10063 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_err(owner_conv);
10064 uint64_t ret_ref = tag_ptr(ret_copy, true);
10068 uint32_t __attribute__((export_name("TS_LDKBolt11ParseError_ty_from_ptr"))) TS_LDKBolt11ParseError_ty_from_ptr(uint64_t ptr) {
10069 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10071 case LDKBolt11ParseError_Bech32Error: return 0;
10072 case LDKBolt11ParseError_ParseAmountError: return 1;
10073 case LDKBolt11ParseError_MalformedSignature: return 2;
10074 case LDKBolt11ParseError_BadPrefix: return 3;
10075 case LDKBolt11ParseError_UnknownCurrency: return 4;
10076 case LDKBolt11ParseError_UnknownSiPrefix: return 5;
10077 case LDKBolt11ParseError_MalformedHRP: return 6;
10078 case LDKBolt11ParseError_TooShortDataPart: return 7;
10079 case LDKBolt11ParseError_UnexpectedEndOfTaggedFields: return 8;
10080 case LDKBolt11ParseError_DescriptionDecodeError: return 9;
10081 case LDKBolt11ParseError_PaddingError: return 10;
10082 case LDKBolt11ParseError_IntegerOverflowError: return 11;
10083 case LDKBolt11ParseError_InvalidSegWitProgramLength: return 12;
10084 case LDKBolt11ParseError_InvalidPubKeyHashLength: return 13;
10085 case LDKBolt11ParseError_InvalidScriptHashLength: return 14;
10086 case LDKBolt11ParseError_InvalidRecoveryId: return 15;
10087 case LDKBolt11ParseError_InvalidSliceLength: return 16;
10088 case LDKBolt11ParseError_Skip: return 17;
10092 uint64_t __attribute__((export_name("TS_LDKBolt11ParseError_Bech32Error_get_bech32_error"))) TS_LDKBolt11ParseError_Bech32Error_get_bech32_error(uint64_t ptr) {
10093 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10094 assert(obj->tag == LDKBolt11ParseError_Bech32Error);
10095 uint64_t bech32_error_ref = tag_ptr(&obj->bech32_error, false);
10096 return bech32_error_ref;
10098 int32_t __attribute__((export_name("TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error"))) TS_LDKBolt11ParseError_ParseAmountError_get_parse_amount_error(uint64_t ptr) {
10099 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10100 assert(obj->tag == LDKBolt11ParseError_ParseAmountError);
10101 /*obj->parse_amount_error*/
10104 uint32_t __attribute__((export_name("TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature"))) TS_LDKBolt11ParseError_MalformedSignature_get_malformed_signature(uint64_t ptr) {
10105 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10106 assert(obj->tag == LDKBolt11ParseError_MalformedSignature);
10107 uint32_t malformed_signature_conv = LDKSecp256k1Error_to_js(obj->malformed_signature);
10108 return malformed_signature_conv;
10110 int32_t __attribute__((export_name("TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error"))) TS_LDKBolt11ParseError_DescriptionDecodeError_get_description_decode_error(uint64_t ptr) {
10111 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10112 assert(obj->tag == LDKBolt11ParseError_DescriptionDecodeError);
10113 /*obj->description_decode_error*/
10116 jstring __attribute__((export_name("TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length"))) TS_LDKBolt11ParseError_InvalidSliceLength_get_invalid_slice_length(uint64_t ptr) {
10117 LDKBolt11ParseError *obj = (LDKBolt11ParseError*)untag_ptr(ptr);
10118 assert(obj->tag == LDKBolt11ParseError_InvalidSliceLength);
10119 LDKStr invalid_slice_length_str = obj->invalid_slice_length;
10120 jstring invalid_slice_length_conv = str_ref_to_ts(invalid_slice_length_str.chars, invalid_slice_length_str.len);
10121 return invalid_slice_length_conv;
10123 static inline enum LDKSiPrefix CResult_SiPrefixBolt11ParseErrorZ_get_ok(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner){
10124 CHECK(owner->result_ok);
10125 return SiPrefix_clone(&*owner->contents.result);
10127 uint32_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok"))) TS_CResult_SiPrefixBolt11ParseErrorZ_get_ok(uint64_t owner) {
10128 LDKCResult_SiPrefixBolt11ParseErrorZ* owner_conv = (LDKCResult_SiPrefixBolt11ParseErrorZ*)untag_ptr(owner);
10129 uint32_t ret_conv = LDKSiPrefix_to_js(CResult_SiPrefixBolt11ParseErrorZ_get_ok(owner_conv));
10133 static inline struct LDKBolt11ParseError CResult_SiPrefixBolt11ParseErrorZ_get_err(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR owner){
10134 CHECK(!owner->result_ok);
10135 return Bolt11ParseError_clone(&*owner->contents.err);
10137 uint64_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_get_err"))) TS_CResult_SiPrefixBolt11ParseErrorZ_get_err(uint64_t owner) {
10138 LDKCResult_SiPrefixBolt11ParseErrorZ* owner_conv = (LDKCResult_SiPrefixBolt11ParseErrorZ*)untag_ptr(owner);
10139 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
10140 *ret_copy = CResult_SiPrefixBolt11ParseErrorZ_get_err(owner_conv);
10141 uint64_t ret_ref = tag_ptr(ret_copy, true);
10145 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ty_from_ptr"))) TS_LDKParseOrSemanticError_ty_from_ptr(uint64_t ptr) {
10146 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
10148 case LDKParseOrSemanticError_ParseError: return 0;
10149 case LDKParseOrSemanticError_SemanticError: return 1;
10153 uint64_t __attribute__((export_name("TS_LDKParseOrSemanticError_ParseError_get_parse_error"))) TS_LDKParseOrSemanticError_ParseError_get_parse_error(uint64_t ptr) {
10154 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
10155 assert(obj->tag == LDKParseOrSemanticError_ParseError);
10156 uint64_t parse_error_ref = tag_ptr(&obj->parse_error, false);
10157 return parse_error_ref;
10159 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_SemanticError_get_semantic_error"))) TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(uint64_t ptr) {
10160 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)untag_ptr(ptr);
10161 assert(obj->tag == LDKParseOrSemanticError_SemanticError);
10162 uint32_t semantic_error_conv = LDKBolt11SemanticError_to_js(obj->semantic_error);
10163 return semantic_error_conv;
10165 static inline struct LDKBolt11Invoice CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
10166 LDKBolt11Invoice ret = *owner->contents.result;
10167 ret.is_owned = false;
10170 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(uint64_t owner) {
10171 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
10172 LDKBolt11Invoice ret_var = CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_ok(owner_conv);
10173 uint64_t ret_ref = 0;
10174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10175 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10179 static inline struct LDKParseOrSemanticError CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
10180 CHECK(!owner->result_ok);
10181 return ParseOrSemanticError_clone(&*owner->contents.err);
10183 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(uint64_t owner) {
10184 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)untag_ptr(owner);
10185 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
10186 *ret_copy = CResult_Bolt11InvoiceParseOrSemanticErrorZ_get_err(owner_conv);
10187 uint64_t ret_ref = tag_ptr(ret_copy, true);
10191 static inline struct LDKSignedRawBolt11Invoice CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner){
10192 LDKSignedRawBolt11Invoice ret = *owner->contents.result;
10193 ret.is_owned = false;
10196 uint64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(uint64_t owner) {
10197 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* owner_conv = (LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)untag_ptr(owner);
10198 LDKSignedRawBolt11Invoice ret_var = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_ok(owner_conv);
10199 uint64_t ret_ref = 0;
10200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10205 static inline struct LDKBolt11ParseError CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR owner){
10206 CHECK(!owner->result_ok);
10207 return Bolt11ParseError_clone(&*owner->contents.err);
10209 uint64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(uint64_t owner) {
10210 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* owner_conv = (LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)untag_ptr(owner);
10211 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
10212 *ret_copy = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_get_err(owner_conv);
10213 uint64_t ret_ref = tag_ptr(ret_copy, true);
10217 static inline struct LDKRawBolt11Invoice C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner){
10218 LDKRawBolt11Invoice ret = owner->a;
10219 ret.is_owned = false;
10222 uint64_t __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(uint64_t owner) {
10223 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)untag_ptr(owner);
10224 LDKRawBolt11Invoice ret_var = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_a(owner_conv);
10225 uint64_t ret_ref = 0;
10226 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10227 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10231 static inline struct LDKThirtyTwoBytes C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner){
10232 return ThirtyTwoBytes_clone(&owner->b);
10234 int8_tArray __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(uint64_t owner) {
10235 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)untag_ptr(owner);
10236 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
10237 memcpy(ret_arr->elems, C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_b(owner_conv).data, 32);
10241 static inline struct LDKBolt11InvoiceSignature C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR owner){
10242 LDKBolt11InvoiceSignature ret = owner->c;
10243 ret.is_owned = false;
10246 uint64_t __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(uint64_t owner) {
10247 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)untag_ptr(owner);
10248 LDKBolt11InvoiceSignature ret_var = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_get_c(owner_conv);
10249 uint64_t ret_ref = 0;
10250 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10251 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10255 static inline struct LDKPayeePubKey CResult_PayeePubKeySecp256k1ErrorZ_get_ok(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner){
10256 LDKPayeePubKey ret = *owner->contents.result;
10257 ret.is_owned = false;
10260 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_get_ok(uint64_t owner) {
10261 LDKCResult_PayeePubKeySecp256k1ErrorZ* owner_conv = (LDKCResult_PayeePubKeySecp256k1ErrorZ*)untag_ptr(owner);
10262 LDKPayeePubKey ret_var = CResult_PayeePubKeySecp256k1ErrorZ_get_ok(owner_conv);
10263 uint64_t ret_ref = 0;
10264 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10265 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10269 static inline enum LDKSecp256k1Error CResult_PayeePubKeySecp256k1ErrorZ_get_err(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR owner){
10270 CHECK(!owner->result_ok);
10271 return *owner->contents.err;
10273 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_get_err(uint64_t owner) {
10274 LDKCResult_PayeePubKeySecp256k1ErrorZ* owner_conv = (LDKCResult_PayeePubKeySecp256k1ErrorZ*)untag_ptr(owner);
10275 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PayeePubKeySecp256k1ErrorZ_get_err(owner_conv));
10279 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
10280 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
10281 for (size_t i = 0; i < ret.datalen; i++) {
10282 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
10286 static inline struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
10287 LDKPositiveTimestamp ret = *owner->contents.result;
10288 ret.is_owned = false;
10291 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_get_ok(uint64_t owner) {
10292 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
10293 LDKPositiveTimestamp ret_var = CResult_PositiveTimestampCreationErrorZ_get_ok(owner_conv);
10294 uint64_t ret_ref = 0;
10295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10296 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10300 static inline enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
10301 CHECK(!owner->result_ok);
10302 return CreationError_clone(&*owner->contents.err);
10304 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_err"))) TS_CResult_PositiveTimestampCreationErrorZ_get_err(uint64_t owner) {
10305 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(owner);
10306 uint32_t ret_conv = LDKCreationError_to_js(CResult_PositiveTimestampCreationErrorZ_get_err(owner_conv));
10310 static inline void CResult_NoneBolt11SemanticErrorZ_get_ok(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner){
10311 CHECK(owner->result_ok);
10312 return *owner->contents.result;
10314 void __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_get_ok"))) TS_CResult_NoneBolt11SemanticErrorZ_get_ok(uint64_t owner) {
10315 LDKCResult_NoneBolt11SemanticErrorZ* owner_conv = (LDKCResult_NoneBolt11SemanticErrorZ*)untag_ptr(owner);
10316 CResult_NoneBolt11SemanticErrorZ_get_ok(owner_conv);
10319 static inline enum LDKBolt11SemanticError CResult_NoneBolt11SemanticErrorZ_get_err(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR owner){
10320 CHECK(!owner->result_ok);
10321 return Bolt11SemanticError_clone(&*owner->contents.err);
10323 uint32_t __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_get_err"))) TS_CResult_NoneBolt11SemanticErrorZ_get_err(uint64_t owner) {
10324 LDKCResult_NoneBolt11SemanticErrorZ* owner_conv = (LDKCResult_NoneBolt11SemanticErrorZ*)untag_ptr(owner);
10325 uint32_t ret_conv = LDKBolt11SemanticError_to_js(CResult_NoneBolt11SemanticErrorZ_get_err(owner_conv));
10329 static inline struct LDKBolt11Invoice CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner){
10330 LDKBolt11Invoice ret = *owner->contents.result;
10331 ret.is_owned = false;
10334 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(uint64_t owner) {
10335 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)untag_ptr(owner);
10336 LDKBolt11Invoice ret_var = CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_ok(owner_conv);
10337 uint64_t ret_ref = 0;
10338 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10339 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10343 static inline enum LDKBolt11SemanticError CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR owner){
10344 CHECK(!owner->result_ok);
10345 return Bolt11SemanticError_clone(&*owner->contents.err);
10347 uint32_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(uint64_t owner) {
10348 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* owner_conv = (LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)untag_ptr(owner);
10349 uint32_t ret_conv = LDKBolt11SemanticError_to_js(CResult_Bolt11InvoiceBolt11SemanticErrorZ_get_err(owner_conv));
10353 static inline struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
10354 LDKDescription ret = *owner->contents.result;
10355 ret.is_owned = false;
10358 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_ok"))) TS_CResult_DescriptionCreationErrorZ_get_ok(uint64_t owner) {
10359 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
10360 LDKDescription ret_var = CResult_DescriptionCreationErrorZ_get_ok(owner_conv);
10361 uint64_t ret_ref = 0;
10362 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10363 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10367 static inline enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
10368 CHECK(!owner->result_ok);
10369 return CreationError_clone(&*owner->contents.err);
10371 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_err"))) TS_CResult_DescriptionCreationErrorZ_get_err(uint64_t owner) {
10372 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(owner);
10373 uint32_t ret_conv = LDKCreationError_to_js(CResult_DescriptionCreationErrorZ_get_err(owner_conv));
10377 static inline struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
10378 LDKPrivateRoute ret = *owner->contents.result;
10379 ret.is_owned = false;
10382 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_ok"))) TS_CResult_PrivateRouteCreationErrorZ_get_ok(uint64_t owner) {
10383 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
10384 LDKPrivateRoute ret_var = CResult_PrivateRouteCreationErrorZ_get_ok(owner_conv);
10385 uint64_t ret_ref = 0;
10386 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10387 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10391 static inline enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
10392 CHECK(!owner->result_ok);
10393 return CreationError_clone(&*owner->contents.err);
10395 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_err"))) TS_CResult_PrivateRouteCreationErrorZ_get_err(uint64_t owner) {
10396 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(owner);
10397 uint32_t ret_conv = LDKCreationError_to_js(CResult_PrivateRouteCreationErrorZ_get_err(owner_conv));
10401 static inline struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
10402 LDKOutPoint ret = *owner->contents.result;
10403 ret.is_owned = false;
10406 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_ok"))) TS_CResult_OutPointDecodeErrorZ_get_ok(uint64_t owner) {
10407 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
10408 LDKOutPoint ret_var = CResult_OutPointDecodeErrorZ_get_ok(owner_conv);
10409 uint64_t ret_ref = 0;
10410 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10411 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10415 static inline struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
10416 CHECK(!owner->result_ok);
10417 return DecodeError_clone(&*owner->contents.err);
10419 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_err"))) TS_CResult_OutPointDecodeErrorZ_get_err(uint64_t owner) {
10420 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(owner);
10421 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10422 *ret_copy = CResult_OutPointDecodeErrorZ_get_err(owner_conv);
10423 uint64_t ret_ref = tag_ptr(ret_copy, true);
10427 static inline struct LDKBigSize CResult_BigSizeDecodeErrorZ_get_ok(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner){
10428 LDKBigSize ret = *owner->contents.result;
10429 ret.is_owned = false;
10432 uint64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_get_ok"))) TS_CResult_BigSizeDecodeErrorZ_get_ok(uint64_t owner) {
10433 LDKCResult_BigSizeDecodeErrorZ* owner_conv = (LDKCResult_BigSizeDecodeErrorZ*)untag_ptr(owner);
10434 LDKBigSize ret_var = CResult_BigSizeDecodeErrorZ_get_ok(owner_conv);
10435 uint64_t ret_ref = 0;
10436 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10437 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10441 static inline struct LDKDecodeError CResult_BigSizeDecodeErrorZ_get_err(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR owner){
10442 CHECK(!owner->result_ok);
10443 return DecodeError_clone(&*owner->contents.err);
10445 uint64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_get_err"))) TS_CResult_BigSizeDecodeErrorZ_get_err(uint64_t owner) {
10446 LDKCResult_BigSizeDecodeErrorZ* owner_conv = (LDKCResult_BigSizeDecodeErrorZ*)untag_ptr(owner);
10447 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10448 *ret_copy = CResult_BigSizeDecodeErrorZ_get_err(owner_conv);
10449 uint64_t ret_ref = tag_ptr(ret_copy, true);
10453 static inline struct LDKHostname CResult_HostnameDecodeErrorZ_get_ok(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner){
10454 LDKHostname ret = *owner->contents.result;
10455 ret.is_owned = false;
10458 uint64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_get_ok"))) TS_CResult_HostnameDecodeErrorZ_get_ok(uint64_t owner) {
10459 LDKCResult_HostnameDecodeErrorZ* owner_conv = (LDKCResult_HostnameDecodeErrorZ*)untag_ptr(owner);
10460 LDKHostname ret_var = CResult_HostnameDecodeErrorZ_get_ok(owner_conv);
10461 uint64_t ret_ref = 0;
10462 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10463 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10467 static inline struct LDKDecodeError CResult_HostnameDecodeErrorZ_get_err(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR owner){
10468 CHECK(!owner->result_ok);
10469 return DecodeError_clone(&*owner->contents.err);
10471 uint64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_get_err"))) TS_CResult_HostnameDecodeErrorZ_get_err(uint64_t owner) {
10472 LDKCResult_HostnameDecodeErrorZ* owner_conv = (LDKCResult_HostnameDecodeErrorZ*)untag_ptr(owner);
10473 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10474 *ret_copy = CResult_HostnameDecodeErrorZ_get_err(owner_conv);
10475 uint64_t ret_ref = tag_ptr(ret_copy, true);
10479 static inline struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedNoneZ_get_ok(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner){
10480 LDKTransactionU16LenLimited ret = *owner->contents.result;
10481 ret.is_owned = false;
10484 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_get_ok"))) TS_CResult_TransactionU16LenLimitedNoneZ_get_ok(uint64_t owner) {
10485 LDKCResult_TransactionU16LenLimitedNoneZ* owner_conv = (LDKCResult_TransactionU16LenLimitedNoneZ*)untag_ptr(owner);
10486 LDKTransactionU16LenLimited ret_var = CResult_TransactionU16LenLimitedNoneZ_get_ok(owner_conv);
10487 uint64_t ret_ref = 0;
10488 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10489 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10493 static inline void CResult_TransactionU16LenLimitedNoneZ_get_err(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR owner){
10494 CHECK(!owner->result_ok);
10495 return *owner->contents.err;
10497 void __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_get_err"))) TS_CResult_TransactionU16LenLimitedNoneZ_get_err(uint64_t owner) {
10498 LDKCResult_TransactionU16LenLimitedNoneZ* owner_conv = (LDKCResult_TransactionU16LenLimitedNoneZ*)untag_ptr(owner);
10499 CResult_TransactionU16LenLimitedNoneZ_get_err(owner_conv);
10502 static inline struct LDKTransactionU16LenLimited CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner){
10503 LDKTransactionU16LenLimited ret = *owner->contents.result;
10504 ret.is_owned = false;
10507 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(uint64_t owner) {
10508 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* owner_conv = (LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)untag_ptr(owner);
10509 LDKTransactionU16LenLimited ret_var = CResult_TransactionU16LenLimitedDecodeErrorZ_get_ok(owner_conv);
10510 uint64_t ret_ref = 0;
10511 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10512 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10516 static inline struct LDKDecodeError CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR owner){
10517 CHECK(!owner->result_ok);
10518 return DecodeError_clone(&*owner->contents.err);
10520 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(uint64_t owner) {
10521 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* owner_conv = (LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)untag_ptr(owner);
10522 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10523 *ret_copy = CResult_TransactionU16LenLimitedDecodeErrorZ_get_err(owner_conv);
10524 uint64_t ret_ref = tag_ptr(ret_copy, true);
10528 static inline struct LDKUntrustedString CResult_UntrustedStringDecodeErrorZ_get_ok(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
10529 LDKUntrustedString ret = *owner->contents.result;
10530 ret.is_owned = false;
10533 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_get_ok(uint64_t owner) {
10534 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
10535 LDKUntrustedString ret_var = CResult_UntrustedStringDecodeErrorZ_get_ok(owner_conv);
10536 uint64_t ret_ref = 0;
10537 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10538 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10542 static inline struct LDKDecodeError CResult_UntrustedStringDecodeErrorZ_get_err(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR owner){
10543 CHECK(!owner->result_ok);
10544 return DecodeError_clone(&*owner->contents.err);
10546 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_get_err"))) TS_CResult_UntrustedStringDecodeErrorZ_get_err(uint64_t owner) {
10547 LDKCResult_UntrustedStringDecodeErrorZ* owner_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(owner);
10548 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10549 *ret_copy = CResult_UntrustedStringDecodeErrorZ_get_err(owner_conv);
10550 uint64_t ret_ref = tag_ptr(ret_copy, true);
10554 static inline struct LDKReceiveTlvs CResult_ReceiveTlvsDecodeErrorZ_get_ok(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner){
10555 LDKReceiveTlvs ret = *owner->contents.result;
10556 ret.is_owned = false;
10559 uint64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_get_ok"))) TS_CResult_ReceiveTlvsDecodeErrorZ_get_ok(uint64_t owner) {
10560 LDKCResult_ReceiveTlvsDecodeErrorZ* owner_conv = (LDKCResult_ReceiveTlvsDecodeErrorZ*)untag_ptr(owner);
10561 LDKReceiveTlvs ret_var = CResult_ReceiveTlvsDecodeErrorZ_get_ok(owner_conv);
10562 uint64_t ret_ref = 0;
10563 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10564 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10568 static inline struct LDKDecodeError CResult_ReceiveTlvsDecodeErrorZ_get_err(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR owner){
10569 CHECK(!owner->result_ok);
10570 return DecodeError_clone(&*owner->contents.err);
10572 uint64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_get_err"))) TS_CResult_ReceiveTlvsDecodeErrorZ_get_err(uint64_t owner) {
10573 LDKCResult_ReceiveTlvsDecodeErrorZ* owner_conv = (LDKCResult_ReceiveTlvsDecodeErrorZ*)untag_ptr(owner);
10574 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10575 *ret_copy = CResult_ReceiveTlvsDecodeErrorZ_get_err(owner_conv);
10576 uint64_t ret_ref = tag_ptr(ret_copy, true);
10580 static inline struct LDKPaymentRelay CResult_PaymentRelayDecodeErrorZ_get_ok(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner){
10581 LDKPaymentRelay ret = *owner->contents.result;
10582 ret.is_owned = false;
10585 uint64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_get_ok"))) TS_CResult_PaymentRelayDecodeErrorZ_get_ok(uint64_t owner) {
10586 LDKCResult_PaymentRelayDecodeErrorZ* owner_conv = (LDKCResult_PaymentRelayDecodeErrorZ*)untag_ptr(owner);
10587 LDKPaymentRelay ret_var = CResult_PaymentRelayDecodeErrorZ_get_ok(owner_conv);
10588 uint64_t ret_ref = 0;
10589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10594 static inline struct LDKDecodeError CResult_PaymentRelayDecodeErrorZ_get_err(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR owner){
10595 CHECK(!owner->result_ok);
10596 return DecodeError_clone(&*owner->contents.err);
10598 uint64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_get_err"))) TS_CResult_PaymentRelayDecodeErrorZ_get_err(uint64_t owner) {
10599 LDKCResult_PaymentRelayDecodeErrorZ* owner_conv = (LDKCResult_PaymentRelayDecodeErrorZ*)untag_ptr(owner);
10600 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10601 *ret_copy = CResult_PaymentRelayDecodeErrorZ_get_err(owner_conv);
10602 uint64_t ret_ref = tag_ptr(ret_copy, true);
10606 static inline struct LDKPaymentConstraints CResult_PaymentConstraintsDecodeErrorZ_get_ok(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner){
10607 LDKPaymentConstraints ret = *owner->contents.result;
10608 ret.is_owned = false;
10611 uint64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok"))) TS_CResult_PaymentConstraintsDecodeErrorZ_get_ok(uint64_t owner) {
10612 LDKCResult_PaymentConstraintsDecodeErrorZ* owner_conv = (LDKCResult_PaymentConstraintsDecodeErrorZ*)untag_ptr(owner);
10613 LDKPaymentConstraints ret_var = CResult_PaymentConstraintsDecodeErrorZ_get_ok(owner_conv);
10614 uint64_t ret_ref = 0;
10615 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10616 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10620 static inline struct LDKDecodeError CResult_PaymentConstraintsDecodeErrorZ_get_err(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR owner){
10621 CHECK(!owner->result_ok);
10622 return DecodeError_clone(&*owner->contents.err);
10624 uint64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_get_err"))) TS_CResult_PaymentConstraintsDecodeErrorZ_get_err(uint64_t owner) {
10625 LDKCResult_PaymentConstraintsDecodeErrorZ* owner_conv = (LDKCResult_PaymentConstraintsDecodeErrorZ*)untag_ptr(owner);
10626 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10627 *ret_copy = CResult_PaymentConstraintsDecodeErrorZ_get_err(owner_conv);
10628 uint64_t ret_ref = tag_ptr(ret_copy, true);
10632 uint32_t __attribute__((export_name("TS_LDKPaymentError_ty_from_ptr"))) TS_LDKPaymentError_ty_from_ptr(uint64_t ptr) {
10633 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
10635 case LDKPaymentError_Invoice: return 0;
10636 case LDKPaymentError_Sending: return 1;
10640 jstring __attribute__((export_name("TS_LDKPaymentError_Invoice_get_invoice"))) TS_LDKPaymentError_Invoice_get_invoice(uint64_t ptr) {
10641 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
10642 assert(obj->tag == LDKPaymentError_Invoice);
10643 LDKStr invoice_str = obj->invoice;
10644 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
10645 return invoice_conv;
10647 uint32_t __attribute__((export_name("TS_LDKPaymentError_Sending_get_sending"))) TS_LDKPaymentError_Sending_get_sending(uint64_t ptr) {
10648 LDKPaymentError *obj = (LDKPaymentError*)untag_ptr(ptr);
10649 assert(obj->tag == LDKPaymentError_Sending);
10650 uint32_t sending_conv = LDKRetryableSendFailure_to_js(obj->sending);
10651 return sending_conv;
10653 static inline struct LDKThirtyTwoBytes CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner){
10654 CHECK(owner->result_ok);
10655 return ThirtyTwoBytes_clone(&*owner->contents.result);
10657 int8_tArray __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_ok"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(uint64_t owner) {
10658 LDKCResult_ThirtyTwoBytesPaymentErrorZ* owner_conv = (LDKCResult_ThirtyTwoBytesPaymentErrorZ*)untag_ptr(owner);
10659 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
10660 memcpy(ret_arr->elems, CResult_ThirtyTwoBytesPaymentErrorZ_get_ok(owner_conv).data, 32);
10664 static inline struct LDKPaymentError CResult_ThirtyTwoBytesPaymentErrorZ_get_err(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR owner){
10665 CHECK(!owner->result_ok);
10666 return PaymentError_clone(&*owner->contents.err);
10668 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_err"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_get_err(uint64_t owner) {
10669 LDKCResult_ThirtyTwoBytesPaymentErrorZ* owner_conv = (LDKCResult_ThirtyTwoBytesPaymentErrorZ*)untag_ptr(owner);
10670 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
10671 *ret_copy = CResult_ThirtyTwoBytesPaymentErrorZ_get_err(owner_conv);
10672 uint64_t ret_ref = tag_ptr(ret_copy, true);
10676 static inline void CResult_NonePaymentErrorZ_get_ok(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
10677 CHECK(owner->result_ok);
10678 return *owner->contents.result;
10680 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_ok"))) TS_CResult_NonePaymentErrorZ_get_ok(uint64_t owner) {
10681 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
10682 CResult_NonePaymentErrorZ_get_ok(owner_conv);
10685 static inline struct LDKPaymentError CResult_NonePaymentErrorZ_get_err(LDKCResult_NonePaymentErrorZ *NONNULL_PTR owner){
10686 CHECK(!owner->result_ok);
10687 return PaymentError_clone(&*owner->contents.err);
10689 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_get_err"))) TS_CResult_NonePaymentErrorZ_get_err(uint64_t owner) {
10690 LDKCResult_NonePaymentErrorZ* owner_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(owner);
10691 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
10692 *ret_copy = CResult_NonePaymentErrorZ_get_err(owner_conv);
10693 uint64_t ret_ref = tag_ptr(ret_copy, true);
10697 uint32_t __attribute__((export_name("TS_LDKProbingError_ty_from_ptr"))) TS_LDKProbingError_ty_from_ptr(uint64_t ptr) {
10698 LDKProbingError *obj = (LDKProbingError*)untag_ptr(ptr);
10700 case LDKProbingError_Invoice: return 0;
10701 case LDKProbingError_Sending: return 1;
10705 jstring __attribute__((export_name("TS_LDKProbingError_Invoice_get_invoice"))) TS_LDKProbingError_Invoice_get_invoice(uint64_t ptr) {
10706 LDKProbingError *obj = (LDKProbingError*)untag_ptr(ptr);
10707 assert(obj->tag == LDKProbingError_Invoice);
10708 LDKStr invoice_str = obj->invoice;
10709 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
10710 return invoice_conv;
10712 uint64_t __attribute__((export_name("TS_LDKProbingError_Sending_get_sending"))) TS_LDKProbingError_Sending_get_sending(uint64_t ptr) {
10713 LDKProbingError *obj = (LDKProbingError*)untag_ptr(ptr);
10714 assert(obj->tag == LDKProbingError_Sending);
10715 uint64_t sending_ref = tag_ptr(&obj->sending, false);
10716 return sending_ref;
10718 static inline struct LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner){
10719 CHECK(owner->result_ok);
10720 return CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_clone(&*owner->contents.result);
10722 uint64_tArray __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(uint64_t owner) {
10723 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)untag_ptr(owner);
10724 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ ret_var = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_ok(owner_conv);
10725 uint64_tArray ret_arr = NULL;
10726 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
10727 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
10728 for (size_t o = 0; o < ret_var.datalen; o++) {
10729 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
10730 *ret_conv_40_conv = ret_var.data[o];
10731 ret_arr_ptr[o] = tag_ptr(ret_conv_40_conv, true);
10734 FREE(ret_var.data);
10738 static inline struct LDKProbingError CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR owner){
10739 CHECK(!owner->result_ok);
10740 return ProbingError_clone(&*owner->contents.err);
10742 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(uint64_t owner) {
10743 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* owner_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)untag_ptr(owner);
10744 LDKProbingError *ret_copy = MALLOC(sizeof(LDKProbingError), "LDKProbingError");
10745 *ret_copy = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_get_err(owner_conv);
10746 uint64_t ret_ref = tag_ptr(ret_copy, true);
10750 static inline struct LDKStr CResult_StrSecp256k1ErrorZ_get_ok(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner){
10751 CHECK(owner->result_ok);
10752 return *owner->contents.result;
10754 jstring __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_get_ok"))) TS_CResult_StrSecp256k1ErrorZ_get_ok(uint64_t owner) {
10755 LDKCResult_StrSecp256k1ErrorZ* owner_conv = (LDKCResult_StrSecp256k1ErrorZ*)untag_ptr(owner);
10756 LDKStr ret_str = CResult_StrSecp256k1ErrorZ_get_ok(owner_conv);
10757 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
10761 static inline enum LDKSecp256k1Error CResult_StrSecp256k1ErrorZ_get_err(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR owner){
10762 CHECK(!owner->result_ok);
10763 return *owner->contents.err;
10765 uint32_t __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_get_err"))) TS_CResult_StrSecp256k1ErrorZ_get_err(uint64_t owner) {
10766 LDKCResult_StrSecp256k1ErrorZ* owner_conv = (LDKCResult_StrSecp256k1ErrorZ*)untag_ptr(owner);
10767 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_StrSecp256k1ErrorZ_get_err(owner_conv));
10771 static inline struct LDKOnionMessagePath CResult_OnionMessagePathNoneZ_get_ok(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner){
10772 LDKOnionMessagePath ret = *owner->contents.result;
10773 ret.is_owned = false;
10776 uint64_t __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_get_ok"))) TS_CResult_OnionMessagePathNoneZ_get_ok(uint64_t owner) {
10777 LDKCResult_OnionMessagePathNoneZ* owner_conv = (LDKCResult_OnionMessagePathNoneZ*)untag_ptr(owner);
10778 LDKOnionMessagePath ret_var = CResult_OnionMessagePathNoneZ_get_ok(owner_conv);
10779 uint64_t ret_ref = 0;
10780 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10781 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10785 static inline void CResult_OnionMessagePathNoneZ_get_err(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR owner){
10786 CHECK(!owner->result_ok);
10787 return *owner->contents.err;
10789 void __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_get_err"))) TS_CResult_OnionMessagePathNoneZ_get_err(uint64_t owner) {
10790 LDKCResult_OnionMessagePathNoneZ* owner_conv = (LDKCResult_OnionMessagePathNoneZ*)untag_ptr(owner);
10791 CResult_OnionMessagePathNoneZ_get_err(owner_conv);
10794 static inline struct LDKPublicKey C2Tuple_PublicKeyOnionMessageZ_get_a(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner){
10797 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_get_a"))) TS_C2Tuple_PublicKeyOnionMessageZ_get_a(uint64_t owner) {
10798 LDKC2Tuple_PublicKeyOnionMessageZ* owner_conv = (LDKC2Tuple_PublicKeyOnionMessageZ*)untag_ptr(owner);
10799 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
10800 memcpy(ret_arr->elems, C2Tuple_PublicKeyOnionMessageZ_get_a(owner_conv).compressed_form, 33);
10804 static inline struct LDKOnionMessage C2Tuple_PublicKeyOnionMessageZ_get_b(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR owner){
10805 LDKOnionMessage ret = owner->b;
10806 ret.is_owned = false;
10809 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_get_b"))) TS_C2Tuple_PublicKeyOnionMessageZ_get_b(uint64_t owner) {
10810 LDKC2Tuple_PublicKeyOnionMessageZ* owner_conv = (LDKC2Tuple_PublicKeyOnionMessageZ*)untag_ptr(owner);
10811 LDKOnionMessage ret_var = C2Tuple_PublicKeyOnionMessageZ_get_b(owner_conv);
10812 uint64_t ret_ref = 0;
10813 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10814 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10818 uint32_t __attribute__((export_name("TS_LDKSendError_ty_from_ptr"))) TS_LDKSendError_ty_from_ptr(uint64_t ptr) {
10819 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
10821 case LDKSendError_Secp256k1: return 0;
10822 case LDKSendError_TooBigPacket: return 1;
10823 case LDKSendError_TooFewBlindedHops: return 2;
10824 case LDKSendError_InvalidFirstHop: return 3;
10825 case LDKSendError_InvalidMessage: return 4;
10826 case LDKSendError_BufferFull: return 5;
10827 case LDKSendError_GetNodeIdFailed: return 6;
10828 case LDKSendError_BlindedPathAdvanceFailed: return 7;
10832 uint32_t __attribute__((export_name("TS_LDKSendError_Secp256k1_get_secp256k1"))) TS_LDKSendError_Secp256k1_get_secp256k1(uint64_t ptr) {
10833 LDKSendError *obj = (LDKSendError*)untag_ptr(ptr);
10834 assert(obj->tag == LDKSendError_Secp256k1);
10835 uint32_t secp256k1_conv = LDKSecp256k1Error_to_js(obj->secp256k1);
10836 return secp256k1_conv;
10838 static inline struct LDKC2Tuple_PublicKeyOnionMessageZ CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner){
10839 CHECK(owner->result_ok);
10840 return C2Tuple_PublicKeyOnionMessageZ_clone(&*owner->contents.result);
10842 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(uint64_t owner) {
10843 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* owner_conv = (LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ*)untag_ptr(owner);
10844 LDKC2Tuple_PublicKeyOnionMessageZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyOnionMessageZ), "LDKC2Tuple_PublicKeyOnionMessageZ");
10845 *ret_conv = CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_ok(owner_conv);
10846 return tag_ptr(ret_conv, true);
10849 static inline struct LDKSendError CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ *NONNULL_PTR owner){
10850 CHECK(!owner->result_ok);
10851 return SendError_clone(&*owner->contents.err);
10853 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(uint64_t owner) {
10854 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* owner_conv = (LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ*)untag_ptr(owner);
10855 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
10856 *ret_copy = CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_get_err(owner_conv);
10857 uint64_t ret_ref = tag_ptr(ret_copy, true);
10861 static inline void CResult_NoneSendErrorZ_get_ok(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
10862 CHECK(owner->result_ok);
10863 return *owner->contents.result;
10865 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_ok"))) TS_CResult_NoneSendErrorZ_get_ok(uint64_t owner) {
10866 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
10867 CResult_NoneSendErrorZ_get_ok(owner_conv);
10870 static inline struct LDKSendError CResult_NoneSendErrorZ_get_err(LDKCResult_NoneSendErrorZ *NONNULL_PTR owner){
10871 CHECK(!owner->result_ok);
10872 return SendError_clone(&*owner->contents.err);
10874 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_get_err"))) TS_CResult_NoneSendErrorZ_get_err(uint64_t owner) {
10875 LDKCResult_NoneSendErrorZ* owner_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(owner);
10876 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
10877 *ret_copy = CResult_NoneSendErrorZ_get_err(owner_conv);
10878 uint64_t ret_ref = tag_ptr(ret_copy, true);
10882 static inline struct LDKBlindedPath CResult_BlindedPathNoneZ_get_ok(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
10883 LDKBlindedPath ret = *owner->contents.result;
10884 ret.is_owned = false;
10887 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_ok"))) TS_CResult_BlindedPathNoneZ_get_ok(uint64_t owner) {
10888 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
10889 LDKBlindedPath ret_var = CResult_BlindedPathNoneZ_get_ok(owner_conv);
10890 uint64_t ret_ref = 0;
10891 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10892 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10896 static inline void CResult_BlindedPathNoneZ_get_err(LDKCResult_BlindedPathNoneZ *NONNULL_PTR owner){
10897 CHECK(!owner->result_ok);
10898 return *owner->contents.err;
10900 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_get_err"))) TS_CResult_BlindedPathNoneZ_get_err(uint64_t owner) {
10901 LDKCResult_BlindedPathNoneZ* owner_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(owner);
10902 CResult_BlindedPathNoneZ_get_err(owner_conv);
10905 static inline struct LDKC2Tuple_BlindedPayInfoBlindedPathZ CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner){
10906 CHECK(owner->result_ok);
10907 return C2Tuple_BlindedPayInfoBlindedPathZ_clone(&*owner->contents.result);
10909 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(uint64_t owner) {
10910 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* owner_conv = (LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)untag_ptr(owner);
10911 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
10912 *ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_ok(owner_conv);
10913 return tag_ptr(ret_conv, true);
10916 static inline void CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR owner){
10917 CHECK(!owner->result_ok);
10918 return *owner->contents.err;
10920 void __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(uint64_t owner) {
10921 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* owner_conv = (LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)untag_ptr(owner);
10922 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_get_err(owner_conv);
10925 static inline struct LDKBlindedPath CResult_BlindedPathDecodeErrorZ_get_ok(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
10926 LDKBlindedPath ret = *owner->contents.result;
10927 ret.is_owned = false;
10930 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_ok"))) TS_CResult_BlindedPathDecodeErrorZ_get_ok(uint64_t owner) {
10931 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
10932 LDKBlindedPath ret_var = CResult_BlindedPathDecodeErrorZ_get_ok(owner_conv);
10933 uint64_t ret_ref = 0;
10934 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10935 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10939 static inline struct LDKDecodeError CResult_BlindedPathDecodeErrorZ_get_err(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR owner){
10940 CHECK(!owner->result_ok);
10941 return DecodeError_clone(&*owner->contents.err);
10943 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_get_err"))) TS_CResult_BlindedPathDecodeErrorZ_get_err(uint64_t owner) {
10944 LDKCResult_BlindedPathDecodeErrorZ* owner_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(owner);
10945 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10946 *ret_copy = CResult_BlindedPathDecodeErrorZ_get_err(owner_conv);
10947 uint64_t ret_ref = tag_ptr(ret_copy, true);
10951 static inline struct LDKBlindedHop CResult_BlindedHopDecodeErrorZ_get_ok(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
10952 LDKBlindedHop ret = *owner->contents.result;
10953 ret.is_owned = false;
10956 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_ok"))) TS_CResult_BlindedHopDecodeErrorZ_get_ok(uint64_t owner) {
10957 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
10958 LDKBlindedHop ret_var = CResult_BlindedHopDecodeErrorZ_get_ok(owner_conv);
10959 uint64_t ret_ref = 0;
10960 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10961 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10965 static inline struct LDKDecodeError CResult_BlindedHopDecodeErrorZ_get_err(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR owner){
10966 CHECK(!owner->result_ok);
10967 return DecodeError_clone(&*owner->contents.err);
10969 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_get_err"))) TS_CResult_BlindedHopDecodeErrorZ_get_err(uint64_t owner) {
10970 LDKCResult_BlindedHopDecodeErrorZ* owner_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(owner);
10971 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10972 *ret_copy = CResult_BlindedHopDecodeErrorZ_get_err(owner_conv);
10973 uint64_t ret_ref = tag_ptr(ret_copy, true);
10977 static inline struct LDKInvoiceError CResult_InvoiceErrorDecodeErrorZ_get_ok(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner){
10978 LDKInvoiceError ret = *owner->contents.result;
10979 ret.is_owned = false;
10982 uint64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_get_ok"))) TS_CResult_InvoiceErrorDecodeErrorZ_get_ok(uint64_t owner) {
10983 LDKCResult_InvoiceErrorDecodeErrorZ* owner_conv = (LDKCResult_InvoiceErrorDecodeErrorZ*)untag_ptr(owner);
10984 LDKInvoiceError ret_var = CResult_InvoiceErrorDecodeErrorZ_get_ok(owner_conv);
10985 uint64_t ret_ref = 0;
10986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
10987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
10991 static inline struct LDKDecodeError CResult_InvoiceErrorDecodeErrorZ_get_err(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR owner){
10992 CHECK(!owner->result_ok);
10993 return DecodeError_clone(&*owner->contents.err);
10995 uint64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_get_err"))) TS_CResult_InvoiceErrorDecodeErrorZ_get_err(uint64_t owner) {
10996 LDKCResult_InvoiceErrorDecodeErrorZ* owner_conv = (LDKCResult_InvoiceErrorDecodeErrorZ*)untag_ptr(owner);
10997 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
10998 *ret_copy = CResult_InvoiceErrorDecodeErrorZ_get_err(owner_conv);
10999 uint64_t ret_ref = tag_ptr(ret_copy, true);
11003 typedef struct LDKFilter_JCalls {
11004 atomic_size_t refcnt;
11005 uint32_t instance_ptr;
11006 } LDKFilter_JCalls;
11007 static void LDKFilter_JCalls_free(void* this_arg) {
11008 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
11009 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11013 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
11014 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
11015 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
11016 memcpy(txid_arr->elems, *txid, 32);
11017 LDKu8slice script_pubkey_var = script_pubkey;
11018 int8_tArray script_pubkey_arr = init_int8_tArray(script_pubkey_var.datalen, __LINE__);
11019 memcpy(script_pubkey_arr->elems, script_pubkey_var.data, script_pubkey_var.datalen);
11020 js_invoke_function_uuuuuu(j_calls->instance_ptr, 43, (uint32_t)txid_arr, (uint32_t)script_pubkey_arr, 0, 0, 0, 0);
11022 void register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
11023 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
11024 LDKWatchedOutput output_var = output;
11025 uint64_t output_ref = 0;
11026 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
11027 output_ref = tag_ptr(output_var.inner, output_var.is_owned);
11028 js_invoke_function_buuuuu(j_calls->instance_ptr, 44, output_ref, 0, 0, 0, 0, 0);
11030 static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
11031 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
11032 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11034 static inline LDKFilter LDKFilter_init (JSValue o) {
11035 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
11036 atomic_init(&calls->refcnt, 1);
11037 calls->instance_ptr = o;
11040 .this_arg = (void*) calls,
11041 .register_tx = register_tx_LDKFilter_jcall,
11042 .register_output = register_output_LDKFilter_jcall,
11043 .free = LDKFilter_JCalls_free,
11047 uint64_t __attribute__((export_name("TS_LDKFilter_new"))) TS_LDKFilter_new(JSValue o) {
11048 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
11049 *res_ptr = LDKFilter_init(o);
11050 return tag_ptr(res_ptr, true);
11052 void __attribute__((export_name("TS_Filter_register_tx"))) TS_Filter_register_tx(uint64_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
11053 void* this_arg_ptr = untag_ptr(this_arg);
11054 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11055 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
11056 uint8_t txid_arr[32];
11057 CHECK(txid->arr_len == 32);
11058 memcpy(txid_arr, txid->elems, 32); FREE(txid);
11059 uint8_t (*txid_ref)[32] = &txid_arr;
11060 LDKu8slice script_pubkey_ref;
11061 script_pubkey_ref.datalen = script_pubkey->arr_len;
11062 script_pubkey_ref.data = script_pubkey->elems;
11063 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
11064 FREE(script_pubkey);
11067 void __attribute__((export_name("TS_Filter_register_output"))) TS_Filter_register_output(uint64_t this_arg, uint64_t output) {
11068 void* this_arg_ptr = untag_ptr(this_arg);
11069 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11070 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
11071 LDKWatchedOutput output_conv;
11072 output_conv.inner = untag_ptr(output);
11073 output_conv.is_owned = ptr_is_owned(output);
11074 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
11075 output_conv = WatchedOutput_clone(&output_conv);
11076 (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
11079 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_ty_from_ptr"))) TS_LDKCOption_FilterZ_ty_from_ptr(uint64_t ptr) {
11080 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
11082 case LDKCOption_FilterZ_Some: return 0;
11083 case LDKCOption_FilterZ_None: return 1;
11087 uint64_t __attribute__((export_name("TS_LDKCOption_FilterZ_Some_get_some"))) TS_LDKCOption_FilterZ_Some_get_some(uint64_t ptr) {
11088 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)untag_ptr(ptr);
11089 assert(obj->tag == LDKCOption_FilterZ_Some);
11090 LDKFilter* some_ret = MALLOC(sizeof(LDKFilter), "LDKFilter");
11091 *some_ret = obj->some;
11092 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
11093 if ((*some_ret).free == LDKFilter_JCalls_free) {
11094 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11095 LDKFilter_JCalls_cloned(&(*some_ret));
11097 return tag_ptr(some_ret, true);
11099 static inline struct LDKLockedChannelMonitor CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
11100 LDKLockedChannelMonitor ret = *owner->contents.result;
11101 ret.is_owned = false;
11104 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_ok"))) TS_CResult_LockedChannelMonitorNoneZ_get_ok(uint64_t owner) {
11105 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
11106 LDKLockedChannelMonitor ret_var = CResult_LockedChannelMonitorNoneZ_get_ok(owner_conv);
11107 uint64_t ret_ref = 0;
11108 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11109 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11113 static inline void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
11114 CHECK(!owner->result_ok);
11115 return *owner->contents.err;
11117 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_err"))) TS_CResult_LockedChannelMonitorNoneZ_get_err(uint64_t owner) {
11118 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(owner);
11119 CResult_LockedChannelMonitorNoneZ_get_err(owner_conv);
11122 static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
11123 LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
11124 for (size_t i = 0; i < ret.datalen; i++) {
11125 ret.data[i] = OutPoint_clone(&orig->data[i]);
11129 static inline LDKCVec_MonitorUpdateIdZ CVec_MonitorUpdateIdZ_clone(const LDKCVec_MonitorUpdateIdZ *orig) {
11130 LDKCVec_MonitorUpdateIdZ ret = { .data = MALLOC(sizeof(LDKMonitorUpdateId) * orig->datalen, "LDKCVec_MonitorUpdateIdZ clone bytes"), .datalen = orig->datalen };
11131 for (size_t i = 0; i < ret.datalen; i++) {
11132 ret.data[i] = MonitorUpdateId_clone(&orig->data[i]);
11136 static inline struct LDKOutPoint C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
11137 LDKOutPoint ret = owner->a;
11138 ret.is_owned = false;
11141 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(uint64_t owner) {
11142 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
11143 LDKOutPoint ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_a(owner_conv);
11144 uint64_t ret_ref = 0;
11145 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
11146 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
11150 static inline struct LDKCVec_MonitorUpdateIdZ C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR owner){
11151 return CVec_MonitorUpdateIdZ_clone(&owner->b);
11153 uint64_tArray __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(uint64_t owner) {
11154 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* owner_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(owner);
11155 LDKCVec_MonitorUpdateIdZ ret_var = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_get_b(owner_conv);
11156 uint64_tArray ret_arr = NULL;
11157 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
11158 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
11159 for (size_t r = 0; r < ret_var.datalen; r++) {
11160 LDKMonitorUpdateId ret_conv_17_var = ret_var.data[r];
11161 uint64_t ret_conv_17_ref = 0;
11162 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_17_var);
11163 ret_conv_17_ref = tag_ptr(ret_conv_17_var.inner, ret_conv_17_var.is_owned);
11164 ret_arr_ptr[r] = ret_conv_17_ref;
11167 FREE(ret_var.data);
11171 static inline LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_clone(const LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ *orig) {
11172 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ) * orig->datalen, "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ clone bytes"), .datalen = orig->datalen };
11173 for (size_t i = 0; i < ret.datalen; i++) {
11174 ret.data[i] = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(&orig->data[i]);
11178 typedef struct LDKKVStore_JCalls {
11179 atomic_size_t refcnt;
11180 uint32_t instance_ptr;
11181 } LDKKVStore_JCalls;
11182 static void LDKKVStore_JCalls_free(void* this_arg) {
11183 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) this_arg;
11184 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11188 LDKCResult_CVec_u8ZIOErrorZ read_LDKKVStore_jcall(const void* this_arg, LDKStr primary_namespace, LDKStr secondary_namespace, LDKStr key) {
11189 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) this_arg;
11190 LDKStr primary_namespace_str = primary_namespace;
11191 jstring primary_namespace_conv = str_ref_to_ts(primary_namespace_str.chars, primary_namespace_str.len);
11192 Str_free(primary_namespace_str);
11193 LDKStr secondary_namespace_str = secondary_namespace;
11194 jstring secondary_namespace_conv = str_ref_to_ts(secondary_namespace_str.chars, secondary_namespace_str.len);
11195 Str_free(secondary_namespace_str);
11196 LDKStr key_str = key;
11197 jstring key_conv = str_ref_to_ts(key_str.chars, key_str.len);
11199 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 45, primary_namespace_conv, secondary_namespace_conv, key_conv, 0, 0, 0);
11200 void* ret_ptr = untag_ptr(ret);
11201 CHECK_ACCESS(ret_ptr);
11202 LDKCResult_CVec_u8ZIOErrorZ ret_conv = *(LDKCResult_CVec_u8ZIOErrorZ*)(ret_ptr);
11203 FREE(untag_ptr(ret));
11206 LDKCResult_NoneIOErrorZ write_LDKKVStore_jcall(const void* this_arg, LDKStr primary_namespace, LDKStr secondary_namespace, LDKStr key, LDKu8slice buf) {
11207 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) this_arg;
11208 LDKStr primary_namespace_str = primary_namespace;
11209 jstring primary_namespace_conv = str_ref_to_ts(primary_namespace_str.chars, primary_namespace_str.len);
11210 Str_free(primary_namespace_str);
11211 LDKStr secondary_namespace_str = secondary_namespace;
11212 jstring secondary_namespace_conv = str_ref_to_ts(secondary_namespace_str.chars, secondary_namespace_str.len);
11213 Str_free(secondary_namespace_str);
11214 LDKStr key_str = key;
11215 jstring key_conv = str_ref_to_ts(key_str.chars, key_str.len);
11217 LDKu8slice buf_var = buf;
11218 int8_tArray buf_arr = init_int8_tArray(buf_var.datalen, __LINE__);
11219 memcpy(buf_arr->elems, buf_var.data, buf_var.datalen);
11220 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 46, primary_namespace_conv, secondary_namespace_conv, key_conv, (uint32_t)buf_arr, 0, 0);
11221 void* ret_ptr = untag_ptr(ret);
11222 CHECK_ACCESS(ret_ptr);
11223 LDKCResult_NoneIOErrorZ ret_conv = *(LDKCResult_NoneIOErrorZ*)(ret_ptr);
11224 FREE(untag_ptr(ret));
11227 LDKCResult_NoneIOErrorZ remove_LDKKVStore_jcall(const void* this_arg, LDKStr primary_namespace, LDKStr secondary_namespace, LDKStr key, bool lazy) {
11228 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) this_arg;
11229 LDKStr primary_namespace_str = primary_namespace;
11230 jstring primary_namespace_conv = str_ref_to_ts(primary_namespace_str.chars, primary_namespace_str.len);
11231 Str_free(primary_namespace_str);
11232 LDKStr secondary_namespace_str = secondary_namespace;
11233 jstring secondary_namespace_conv = str_ref_to_ts(secondary_namespace_str.chars, secondary_namespace_str.len);
11234 Str_free(secondary_namespace_str);
11235 LDKStr key_str = key;
11236 jstring key_conv = str_ref_to_ts(key_str.chars, key_str.len);
11238 jboolean lazy_conv = lazy;
11239 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 47, primary_namespace_conv, secondary_namespace_conv, key_conv, lazy_conv, 0, 0);
11240 void* ret_ptr = untag_ptr(ret);
11241 CHECK_ACCESS(ret_ptr);
11242 LDKCResult_NoneIOErrorZ ret_conv = *(LDKCResult_NoneIOErrorZ*)(ret_ptr);
11243 FREE(untag_ptr(ret));
11246 LDKCResult_CVec_StrZIOErrorZ list_LDKKVStore_jcall(const void* this_arg, LDKStr primary_namespace, LDKStr secondary_namespace) {
11247 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) this_arg;
11248 LDKStr primary_namespace_str = primary_namespace;
11249 jstring primary_namespace_conv = str_ref_to_ts(primary_namespace_str.chars, primary_namespace_str.len);
11250 Str_free(primary_namespace_str);
11251 LDKStr secondary_namespace_str = secondary_namespace;
11252 jstring secondary_namespace_conv = str_ref_to_ts(secondary_namespace_str.chars, secondary_namespace_str.len);
11253 Str_free(secondary_namespace_str);
11254 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 48, primary_namespace_conv, secondary_namespace_conv, 0, 0, 0, 0);
11255 void* ret_ptr = untag_ptr(ret);
11256 CHECK_ACCESS(ret_ptr);
11257 LDKCResult_CVec_StrZIOErrorZ ret_conv = *(LDKCResult_CVec_StrZIOErrorZ*)(ret_ptr);
11258 FREE(untag_ptr(ret));
11261 static void LDKKVStore_JCalls_cloned(LDKKVStore* new_obj) {
11262 LDKKVStore_JCalls *j_calls = (LDKKVStore_JCalls*) new_obj->this_arg;
11263 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11265 static inline LDKKVStore LDKKVStore_init (JSValue o) {
11266 LDKKVStore_JCalls *calls = MALLOC(sizeof(LDKKVStore_JCalls), "LDKKVStore_JCalls");
11267 atomic_init(&calls->refcnt, 1);
11268 calls->instance_ptr = o;
11271 .this_arg = (void*) calls,
11272 .read = read_LDKKVStore_jcall,
11273 .write = write_LDKKVStore_jcall,
11274 .remove = remove_LDKKVStore_jcall,
11275 .list = list_LDKKVStore_jcall,
11276 .free = LDKKVStore_JCalls_free,
11280 uint64_t __attribute__((export_name("TS_LDKKVStore_new"))) TS_LDKKVStore_new(JSValue o) {
11281 LDKKVStore *res_ptr = MALLOC(sizeof(LDKKVStore), "LDKKVStore");
11282 *res_ptr = LDKKVStore_init(o);
11283 return tag_ptr(res_ptr, true);
11285 uint64_t __attribute__((export_name("TS_KVStore_read"))) TS_KVStore_read(uint64_t this_arg, jstring primary_namespace, jstring secondary_namespace, jstring key) {
11286 void* this_arg_ptr = untag_ptr(this_arg);
11287 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11288 LDKKVStore* this_arg_conv = (LDKKVStore*)this_arg_ptr;
11289 LDKStr primary_namespace_conv = str_ref_to_owned_c(primary_namespace);
11290 LDKStr secondary_namespace_conv = str_ref_to_owned_c(secondary_namespace);
11291 LDKStr key_conv = str_ref_to_owned_c(key);
11292 LDKCResult_CVec_u8ZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZIOErrorZ), "LDKCResult_CVec_u8ZIOErrorZ");
11293 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, primary_namespace_conv, secondary_namespace_conv, key_conv);
11294 return tag_ptr(ret_conv, true);
11297 uint64_t __attribute__((export_name("TS_KVStore_write"))) TS_KVStore_write(uint64_t this_arg, jstring primary_namespace, jstring secondary_namespace, jstring key, int8_tArray buf) {
11298 void* this_arg_ptr = untag_ptr(this_arg);
11299 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11300 LDKKVStore* this_arg_conv = (LDKKVStore*)this_arg_ptr;
11301 LDKStr primary_namespace_conv = str_ref_to_owned_c(primary_namespace);
11302 LDKStr secondary_namespace_conv = str_ref_to_owned_c(secondary_namespace);
11303 LDKStr key_conv = str_ref_to_owned_c(key);
11304 LDKu8slice buf_ref;
11305 buf_ref.datalen = buf->arr_len;
11306 buf_ref.data = buf->elems;
11307 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
11308 *ret_conv = (this_arg_conv->write)(this_arg_conv->this_arg, primary_namespace_conv, secondary_namespace_conv, key_conv, buf_ref);
11310 return tag_ptr(ret_conv, true);
11313 uint64_t __attribute__((export_name("TS_KVStore_remove"))) TS_KVStore_remove(uint64_t this_arg, jstring primary_namespace, jstring secondary_namespace, jstring key, jboolean lazy) {
11314 void* this_arg_ptr = untag_ptr(this_arg);
11315 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11316 LDKKVStore* this_arg_conv = (LDKKVStore*)this_arg_ptr;
11317 LDKStr primary_namespace_conv = str_ref_to_owned_c(primary_namespace);
11318 LDKStr secondary_namespace_conv = str_ref_to_owned_c(secondary_namespace);
11319 LDKStr key_conv = str_ref_to_owned_c(key);
11320 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
11321 *ret_conv = (this_arg_conv->remove)(this_arg_conv->this_arg, primary_namespace_conv, secondary_namespace_conv, key_conv, lazy);
11322 return tag_ptr(ret_conv, true);
11325 uint64_t __attribute__((export_name("TS_KVStore_list"))) TS_KVStore_list(uint64_t this_arg, jstring primary_namespace, jstring secondary_namespace) {
11326 void* this_arg_ptr = untag_ptr(this_arg);
11327 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11328 LDKKVStore* this_arg_conv = (LDKKVStore*)this_arg_ptr;
11329 LDKStr primary_namespace_conv = str_ref_to_owned_c(primary_namespace);
11330 LDKStr secondary_namespace_conv = str_ref_to_owned_c(secondary_namespace);
11331 LDKCResult_CVec_StrZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_StrZIOErrorZ), "LDKCResult_CVec_StrZIOErrorZ");
11332 *ret_conv = (this_arg_conv->list)(this_arg_conv->this_arg, primary_namespace_conv, secondary_namespace_conv);
11333 return tag_ptr(ret_conv, true);
11336 typedef struct LDKScoreLookUp_JCalls {
11337 atomic_size_t refcnt;
11338 uint32_t instance_ptr;
11339 } LDKScoreLookUp_JCalls;
11340 static void LDKScoreLookUp_JCalls_free(void* this_arg) {
11341 LDKScoreLookUp_JCalls *j_calls = (LDKScoreLookUp_JCalls*) this_arg;
11342 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11346 uint64_t channel_penalty_msat_LDKScoreLookUp_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage, const LDKProbabilisticScoringFeeParameters * score_params) {
11347 LDKScoreLookUp_JCalls *j_calls = (LDKScoreLookUp_JCalls*) this_arg;
11348 int64_t short_channel_id_conv = short_channel_id;
11349 LDKNodeId source_var = *source;
11350 uint64_t source_ref = 0;
11351 source_var = NodeId_clone(&source_var);
11352 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
11353 source_ref = tag_ptr(source_var.inner, source_var.is_owned);
11354 LDKNodeId target_var = *target;
11355 uint64_t target_ref = 0;
11356 target_var = NodeId_clone(&target_var);
11357 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
11358 target_ref = tag_ptr(target_var.inner, target_var.is_owned);
11359 LDKChannelUsage usage_var = usage;
11360 uint64_t usage_ref = 0;
11361 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
11362 usage_ref = tag_ptr(usage_var.inner, usage_var.is_owned);
11363 LDKProbabilisticScoringFeeParameters score_params_var = *score_params;
11364 uint64_t score_params_ref = 0;
11365 score_params_var = ProbabilisticScoringFeeParameters_clone(&score_params_var);
11366 CHECK_INNER_FIELD_ACCESS_OR_NULL(score_params_var);
11367 score_params_ref = tag_ptr(score_params_var.inner, score_params_var.is_owned);
11368 return js_invoke_function_bbbbbu(j_calls->instance_ptr, 49, short_channel_id_conv, source_ref, target_ref, usage_ref, score_params_ref, 0);
11370 static void LDKScoreLookUp_JCalls_cloned(LDKScoreLookUp* new_obj) {
11371 LDKScoreLookUp_JCalls *j_calls = (LDKScoreLookUp_JCalls*) new_obj->this_arg;
11372 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11374 static inline LDKScoreLookUp LDKScoreLookUp_init (JSValue o) {
11375 LDKScoreLookUp_JCalls *calls = MALLOC(sizeof(LDKScoreLookUp_JCalls), "LDKScoreLookUp_JCalls");
11376 atomic_init(&calls->refcnt, 1);
11377 calls->instance_ptr = o;
11379 LDKScoreLookUp ret = {
11380 .this_arg = (void*) calls,
11381 .channel_penalty_msat = channel_penalty_msat_LDKScoreLookUp_jcall,
11382 .free = LDKScoreLookUp_JCalls_free,
11386 uint64_t __attribute__((export_name("TS_LDKScoreLookUp_new"))) TS_LDKScoreLookUp_new(JSValue o) {
11387 LDKScoreLookUp *res_ptr = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
11388 *res_ptr = LDKScoreLookUp_init(o);
11389 return tag_ptr(res_ptr, true);
11391 int64_t __attribute__((export_name("TS_ScoreLookUp_channel_penalty_msat"))) TS_ScoreLookUp_channel_penalty_msat(uint64_t this_arg, int64_t short_channel_id, uint64_t source, uint64_t target, uint64_t usage, uint64_t score_params) {
11392 void* this_arg_ptr = untag_ptr(this_arg);
11393 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11394 LDKScoreLookUp* this_arg_conv = (LDKScoreLookUp*)this_arg_ptr;
11395 LDKNodeId source_conv;
11396 source_conv.inner = untag_ptr(source);
11397 source_conv.is_owned = ptr_is_owned(source);
11398 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
11399 source_conv.is_owned = false;
11400 LDKNodeId target_conv;
11401 target_conv.inner = untag_ptr(target);
11402 target_conv.is_owned = ptr_is_owned(target);
11403 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
11404 target_conv.is_owned = false;
11405 LDKChannelUsage usage_conv;
11406 usage_conv.inner = untag_ptr(usage);
11407 usage_conv.is_owned = ptr_is_owned(usage);
11408 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
11409 usage_conv = ChannelUsage_clone(&usage_conv);
11410 LDKProbabilisticScoringFeeParameters score_params_conv;
11411 score_params_conv.inner = untag_ptr(score_params);
11412 score_params_conv.is_owned = ptr_is_owned(score_params);
11413 CHECK_INNER_FIELD_ACCESS_OR_NULL(score_params_conv);
11414 score_params_conv.is_owned = false;
11415 int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv, &score_params_conv);
11419 typedef struct LDKScoreUpdate_JCalls {
11420 atomic_size_t refcnt;
11421 uint32_t instance_ptr;
11422 } LDKScoreUpdate_JCalls;
11423 static void LDKScoreUpdate_JCalls_free(void* this_arg) {
11424 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) this_arg;
11425 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11429 void payment_path_failed_LDKScoreUpdate_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
11430 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) this_arg;
11431 LDKPath path_var = *path;
11432 uint64_t path_ref = 0;
11433 path_var = Path_clone(&path_var);
11434 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
11435 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
11436 int64_t short_channel_id_conv = short_channel_id;
11437 js_invoke_function_bbuuuu(j_calls->instance_ptr, 50, path_ref, short_channel_id_conv, 0, 0, 0, 0);
11439 void payment_path_successful_LDKScoreUpdate_jcall(void* this_arg, const LDKPath * path) {
11440 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) this_arg;
11441 LDKPath path_var = *path;
11442 uint64_t path_ref = 0;
11443 path_var = Path_clone(&path_var);
11444 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
11445 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
11446 js_invoke_function_buuuuu(j_calls->instance_ptr, 51, path_ref, 0, 0, 0, 0, 0);
11448 void probe_failed_LDKScoreUpdate_jcall(void* this_arg, const LDKPath * path, uint64_t short_channel_id) {
11449 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) this_arg;
11450 LDKPath path_var = *path;
11451 uint64_t path_ref = 0;
11452 path_var = Path_clone(&path_var);
11453 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
11454 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
11455 int64_t short_channel_id_conv = short_channel_id;
11456 js_invoke_function_bbuuuu(j_calls->instance_ptr, 52, path_ref, short_channel_id_conv, 0, 0, 0, 0);
11458 void probe_successful_LDKScoreUpdate_jcall(void* this_arg, const LDKPath * path) {
11459 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) this_arg;
11460 LDKPath path_var = *path;
11461 uint64_t path_ref = 0;
11462 path_var = Path_clone(&path_var);
11463 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_var);
11464 path_ref = tag_ptr(path_var.inner, path_var.is_owned);
11465 js_invoke_function_buuuuu(j_calls->instance_ptr, 53, path_ref, 0, 0, 0, 0, 0);
11467 static void LDKScoreUpdate_JCalls_cloned(LDKScoreUpdate* new_obj) {
11468 LDKScoreUpdate_JCalls *j_calls = (LDKScoreUpdate_JCalls*) new_obj->this_arg;
11469 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11471 static inline LDKScoreUpdate LDKScoreUpdate_init (JSValue o) {
11472 LDKScoreUpdate_JCalls *calls = MALLOC(sizeof(LDKScoreUpdate_JCalls), "LDKScoreUpdate_JCalls");
11473 atomic_init(&calls->refcnt, 1);
11474 calls->instance_ptr = o;
11476 LDKScoreUpdate ret = {
11477 .this_arg = (void*) calls,
11478 .payment_path_failed = payment_path_failed_LDKScoreUpdate_jcall,
11479 .payment_path_successful = payment_path_successful_LDKScoreUpdate_jcall,
11480 .probe_failed = probe_failed_LDKScoreUpdate_jcall,
11481 .probe_successful = probe_successful_LDKScoreUpdate_jcall,
11482 .free = LDKScoreUpdate_JCalls_free,
11486 uint64_t __attribute__((export_name("TS_LDKScoreUpdate_new"))) TS_LDKScoreUpdate_new(JSValue o) {
11487 LDKScoreUpdate *res_ptr = MALLOC(sizeof(LDKScoreUpdate), "LDKScoreUpdate");
11488 *res_ptr = LDKScoreUpdate_init(o);
11489 return tag_ptr(res_ptr, true);
11491 void __attribute__((export_name("TS_ScoreUpdate_payment_path_failed"))) TS_ScoreUpdate_payment_path_failed(uint64_t this_arg, uint64_t path, int64_t short_channel_id) {
11492 void* this_arg_ptr = untag_ptr(this_arg);
11493 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11494 LDKScoreUpdate* this_arg_conv = (LDKScoreUpdate*)this_arg_ptr;
11496 path_conv.inner = untag_ptr(path);
11497 path_conv.is_owned = ptr_is_owned(path);
11498 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
11499 path_conv.is_owned = false;
11500 (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
11503 void __attribute__((export_name("TS_ScoreUpdate_payment_path_successful"))) TS_ScoreUpdate_payment_path_successful(uint64_t this_arg, uint64_t path) {
11504 void* this_arg_ptr = untag_ptr(this_arg);
11505 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11506 LDKScoreUpdate* this_arg_conv = (LDKScoreUpdate*)this_arg_ptr;
11508 path_conv.inner = untag_ptr(path);
11509 path_conv.is_owned = ptr_is_owned(path);
11510 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
11511 path_conv.is_owned = false;
11512 (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, &path_conv);
11515 void __attribute__((export_name("TS_ScoreUpdate_probe_failed"))) TS_ScoreUpdate_probe_failed(uint64_t this_arg, uint64_t path, int64_t short_channel_id) {
11516 void* this_arg_ptr = untag_ptr(this_arg);
11517 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11518 LDKScoreUpdate* this_arg_conv = (LDKScoreUpdate*)this_arg_ptr;
11520 path_conv.inner = untag_ptr(path);
11521 path_conv.is_owned = ptr_is_owned(path);
11522 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
11523 path_conv.is_owned = false;
11524 (this_arg_conv->probe_failed)(this_arg_conv->this_arg, &path_conv, short_channel_id);
11527 void __attribute__((export_name("TS_ScoreUpdate_probe_successful"))) TS_ScoreUpdate_probe_successful(uint64_t this_arg, uint64_t path) {
11528 void* this_arg_ptr = untag_ptr(this_arg);
11529 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11530 LDKScoreUpdate* this_arg_conv = (LDKScoreUpdate*)this_arg_ptr;
11532 path_conv.inner = untag_ptr(path);
11533 path_conv.is_owned = ptr_is_owned(path);
11534 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
11535 path_conv.is_owned = false;
11536 (this_arg_conv->probe_successful)(this_arg_conv->this_arg, &path_conv);
11539 typedef struct LDKLockableScore_JCalls {
11540 atomic_size_t refcnt;
11541 uint32_t instance_ptr;
11542 } LDKLockableScore_JCalls;
11543 static void LDKLockableScore_JCalls_free(void* this_arg) {
11544 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
11545 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11549 LDKScoreLookUp read_lock_LDKLockableScore_jcall(const void* this_arg) {
11550 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
11551 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 54, 0, 0, 0, 0, 0, 0);
11552 void* ret_ptr = untag_ptr(ret);
11553 CHECK_ACCESS(ret_ptr);
11554 LDKScoreLookUp ret_conv = *(LDKScoreLookUp*)(ret_ptr);
11555 if (ret_conv.free == LDKScoreLookUp_JCalls_free) {
11556 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11557 LDKScoreLookUp_JCalls_cloned(&ret_conv);
11558 }// WARNING: we may need a move here but no clone is available for LDKScoreLookUp
11562 LDKScoreUpdate write_lock_LDKLockableScore_jcall(const void* this_arg) {
11563 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
11564 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 55, 0, 0, 0, 0, 0, 0);
11565 void* ret_ptr = untag_ptr(ret);
11566 CHECK_ACCESS(ret_ptr);
11567 LDKScoreUpdate ret_conv = *(LDKScoreUpdate*)(ret_ptr);
11568 if (ret_conv.free == LDKScoreUpdate_JCalls_free) {
11569 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
11570 LDKScoreUpdate_JCalls_cloned(&ret_conv);
11571 }// WARNING: we may need a move here but no clone is available for LDKScoreUpdate
11575 static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
11576 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
11577 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11579 static inline LDKLockableScore LDKLockableScore_init (JSValue o) {
11580 LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
11581 atomic_init(&calls->refcnt, 1);
11582 calls->instance_ptr = o;
11584 LDKLockableScore ret = {
11585 .this_arg = (void*) calls,
11586 .read_lock = read_lock_LDKLockableScore_jcall,
11587 .write_lock = write_lock_LDKLockableScore_jcall,
11588 .free = LDKLockableScore_JCalls_free,
11592 uint64_t __attribute__((export_name("TS_LDKLockableScore_new"))) TS_LDKLockableScore_new(JSValue o) {
11593 LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
11594 *res_ptr = LDKLockableScore_init(o);
11595 return tag_ptr(res_ptr, true);
11597 uint64_t __attribute__((export_name("TS_LockableScore_read_lock"))) TS_LockableScore_read_lock(uint64_t this_arg) {
11598 void* this_arg_ptr = untag_ptr(this_arg);
11599 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11600 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
11601 LDKScoreLookUp* ret_ret = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
11602 *ret_ret = (this_arg_conv->read_lock)(this_arg_conv->this_arg);
11603 return tag_ptr(ret_ret, true);
11606 uint64_t __attribute__((export_name("TS_LockableScore_write_lock"))) TS_LockableScore_write_lock(uint64_t this_arg) {
11607 void* this_arg_ptr = untag_ptr(this_arg);
11608 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11609 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
11610 LDKScoreUpdate* ret_ret = MALLOC(sizeof(LDKScoreUpdate), "LDKScoreUpdate");
11611 *ret_ret = (this_arg_conv->write_lock)(this_arg_conv->this_arg);
11612 return tag_ptr(ret_ret, true);
11615 typedef struct LDKWriteableScore_JCalls {
11616 atomic_size_t refcnt;
11617 uint32_t instance_ptr;
11618 LDKLockableScore_JCalls* LockableScore;
11619 } LDKWriteableScore_JCalls;
11620 static void LDKWriteableScore_JCalls_free(void* this_arg) {
11621 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
11622 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11626 LDKCVec_u8Z write_LDKWriteableScore_jcall(const void* this_arg) {
11627 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) this_arg;
11628 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 56, 0, 0, 0, 0, 0, 0);
11629 LDKCVec_u8Z ret_ref;
11630 ret_ref.datalen = ret->arr_len;
11631 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
11632 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
11635 static void LDKWriteableScore_JCalls_cloned(LDKWriteableScore* new_obj) {
11636 LDKWriteableScore_JCalls *j_calls = (LDKWriteableScore_JCalls*) new_obj->this_arg;
11637 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11638 atomic_fetch_add_explicit(&j_calls->LockableScore->refcnt, 1, memory_order_release);
11640 static inline LDKWriteableScore LDKWriteableScore_init (JSValue o, JSValue LockableScore) {
11641 LDKWriteableScore_JCalls *calls = MALLOC(sizeof(LDKWriteableScore_JCalls), "LDKWriteableScore_JCalls");
11642 atomic_init(&calls->refcnt, 1);
11643 calls->instance_ptr = o;
11645 LDKWriteableScore ret = {
11646 .this_arg = (void*) calls,
11647 .write = write_LDKWriteableScore_jcall,
11648 .free = LDKWriteableScore_JCalls_free,
11649 .LockableScore = LDKLockableScore_init(LockableScore),
11651 calls->LockableScore = ret.LockableScore.this_arg;
11654 uint64_t __attribute__((export_name("TS_LDKWriteableScore_new"))) TS_LDKWriteableScore_new(JSValue o, JSValue LockableScore) {
11655 LDKWriteableScore *res_ptr = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
11656 *res_ptr = LDKWriteableScore_init(o, LockableScore);
11657 return tag_ptr(res_ptr, true);
11659 int8_tArray __attribute__((export_name("TS_WriteableScore_write"))) TS_WriteableScore_write(uint64_t this_arg) {
11660 void* this_arg_ptr = untag_ptr(this_arg);
11661 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11662 LDKWriteableScore* this_arg_conv = (LDKWriteableScore*)this_arg_ptr;
11663 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
11664 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
11665 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
11666 CVec_u8Z_free(ret_var);
11670 typedef struct LDKPersister_JCalls {
11671 atomic_size_t refcnt;
11672 uint32_t instance_ptr;
11673 } LDKPersister_JCalls;
11674 static void LDKPersister_JCalls_free(void* this_arg) {
11675 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
11676 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11680 LDKCResult_NoneIOErrorZ persist_manager_LDKPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
11681 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
11682 LDKChannelManager channel_manager_var = *channel_manager;
11683 uint64_t channel_manager_ref = 0;
11684 // WARNING: we may need a move here but no clone is available for LDKChannelManager
11685 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
11686 channel_manager_ref = tag_ptr(channel_manager_var.inner, channel_manager_var.is_owned);
11687 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 57, channel_manager_ref, 0, 0, 0, 0, 0);
11688 void* ret_ptr = untag_ptr(ret);
11689 CHECK_ACCESS(ret_ptr);
11690 LDKCResult_NoneIOErrorZ ret_conv = *(LDKCResult_NoneIOErrorZ*)(ret_ptr);
11691 FREE(untag_ptr(ret));
11694 LDKCResult_NoneIOErrorZ persist_graph_LDKPersister_jcall(const void* this_arg, const LDKNetworkGraph * network_graph) {
11695 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
11696 LDKNetworkGraph network_graph_var = *network_graph;
11697 uint64_t network_graph_ref = 0;
11698 // WARNING: we may need a move here but no clone is available for LDKNetworkGraph
11699 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_var);
11700 network_graph_ref = tag_ptr(network_graph_var.inner, network_graph_var.is_owned);
11701 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 58, network_graph_ref, 0, 0, 0, 0, 0);
11702 void* ret_ptr = untag_ptr(ret);
11703 CHECK_ACCESS(ret_ptr);
11704 LDKCResult_NoneIOErrorZ ret_conv = *(LDKCResult_NoneIOErrorZ*)(ret_ptr);
11705 FREE(untag_ptr(ret));
11708 LDKCResult_NoneIOErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKWriteableScore * scorer) {
11709 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
11710 // WARNING: This object doesn't live past this scope, needs clone!
11711 uint64_t ret_scorer = tag_ptr(scorer, false);
11712 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 59, ret_scorer, 0, 0, 0, 0, 0);
11713 void* ret_ptr = untag_ptr(ret);
11714 CHECK_ACCESS(ret_ptr);
11715 LDKCResult_NoneIOErrorZ ret_conv = *(LDKCResult_NoneIOErrorZ*)(ret_ptr);
11716 FREE(untag_ptr(ret));
11719 static void LDKPersister_JCalls_cloned(LDKPersister* new_obj) {
11720 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) new_obj->this_arg;
11721 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11723 static inline LDKPersister LDKPersister_init (JSValue o) {
11724 LDKPersister_JCalls *calls = MALLOC(sizeof(LDKPersister_JCalls), "LDKPersister_JCalls");
11725 atomic_init(&calls->refcnt, 1);
11726 calls->instance_ptr = o;
11728 LDKPersister ret = {
11729 .this_arg = (void*) calls,
11730 .persist_manager = persist_manager_LDKPersister_jcall,
11731 .persist_graph = persist_graph_LDKPersister_jcall,
11732 .persist_scorer = persist_scorer_LDKPersister_jcall,
11733 .free = LDKPersister_JCalls_free,
11737 uint64_t __attribute__((export_name("TS_LDKPersister_new"))) TS_LDKPersister_new(JSValue o) {
11738 LDKPersister *res_ptr = MALLOC(sizeof(LDKPersister), "LDKPersister");
11739 *res_ptr = LDKPersister_init(o);
11740 return tag_ptr(res_ptr, true);
11742 uint64_t __attribute__((export_name("TS_Persister_persist_manager"))) TS_Persister_persist_manager(uint64_t this_arg, uint64_t channel_manager) {
11743 void* this_arg_ptr = untag_ptr(this_arg);
11744 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11745 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
11746 LDKChannelManager channel_manager_conv;
11747 channel_manager_conv.inner = untag_ptr(channel_manager);
11748 channel_manager_conv.is_owned = ptr_is_owned(channel_manager);
11749 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
11750 channel_manager_conv.is_owned = false;
11751 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
11752 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
11753 return tag_ptr(ret_conv, true);
11756 uint64_t __attribute__((export_name("TS_Persister_persist_graph"))) TS_Persister_persist_graph(uint64_t this_arg, uint64_t network_graph) {
11757 void* this_arg_ptr = untag_ptr(this_arg);
11758 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11759 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
11760 LDKNetworkGraph network_graph_conv;
11761 network_graph_conv.inner = untag_ptr(network_graph);
11762 network_graph_conv.is_owned = ptr_is_owned(network_graph);
11763 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
11764 network_graph_conv.is_owned = false;
11765 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
11766 *ret_conv = (this_arg_conv->persist_graph)(this_arg_conv->this_arg, &network_graph_conv);
11767 return tag_ptr(ret_conv, true);
11770 uint64_t __attribute__((export_name("TS_Persister_persist_scorer"))) TS_Persister_persist_scorer(uint64_t this_arg, uint64_t scorer) {
11771 void* this_arg_ptr = untag_ptr(this_arg);
11772 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11773 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
11774 void* scorer_ptr = untag_ptr(scorer);
11775 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
11776 LDKWriteableScore* scorer_conv = (LDKWriteableScore*)scorer_ptr;
11777 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
11778 *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, scorer_conv);
11779 return tag_ptr(ret_conv, true);
11782 typedef struct LDKPersist_JCalls {
11783 atomic_size_t refcnt;
11784 uint32_t instance_ptr;
11785 } LDKPersist_JCalls;
11786 static void LDKPersist_JCalls_free(void* this_arg) {
11787 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
11788 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11792 LDKChannelMonitorUpdateStatus persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
11793 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
11794 LDKOutPoint channel_id_var = channel_id;
11795 uint64_t channel_id_ref = 0;
11796 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
11797 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
11798 LDKChannelMonitor data_var = *data;
11799 uint64_t data_ref = 0;
11800 data_var = ChannelMonitor_clone(&data_var);
11801 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
11802 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
11803 LDKMonitorUpdateId update_id_var = update_id;
11804 uint64_t update_id_ref = 0;
11805 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
11806 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
11807 uint64_t ret = js_invoke_function_bbbuuu(j_calls->instance_ptr, 60, channel_id_ref, data_ref, update_id_ref, 0, 0, 0);
11808 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
11811 LDKChannelMonitorUpdateStatus update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, LDKChannelMonitorUpdate update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
11812 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
11813 LDKOutPoint channel_id_var = channel_id;
11814 uint64_t channel_id_ref = 0;
11815 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
11816 channel_id_ref = tag_ptr(channel_id_var.inner, channel_id_var.is_owned);
11817 LDKChannelMonitorUpdate update_var = update;
11818 uint64_t update_ref = 0;
11819 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
11820 update_ref = tag_ptr(update_var.inner, update_var.is_owned);
11821 LDKChannelMonitor data_var = *data;
11822 uint64_t data_ref = 0;
11823 data_var = ChannelMonitor_clone(&data_var);
11824 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
11825 data_ref = tag_ptr(data_var.inner, data_var.is_owned);
11826 LDKMonitorUpdateId update_id_var = update_id;
11827 uint64_t update_id_ref = 0;
11828 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
11829 update_id_ref = tag_ptr(update_id_var.inner, update_id_var.is_owned);
11830 uint64_t ret = js_invoke_function_bbbbuu(j_calls->instance_ptr, 61, channel_id_ref, update_ref, data_ref, update_id_ref, 0, 0);
11831 LDKChannelMonitorUpdateStatus ret_conv = LDKChannelMonitorUpdateStatus_from_js(ret);
11834 static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
11835 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) new_obj->this_arg;
11836 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11838 static inline LDKPersist LDKPersist_init (JSValue o) {
11839 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
11840 atomic_init(&calls->refcnt, 1);
11841 calls->instance_ptr = o;
11844 .this_arg = (void*) calls,
11845 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
11846 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
11847 .free = LDKPersist_JCalls_free,
11851 uint64_t __attribute__((export_name("TS_LDKPersist_new"))) TS_LDKPersist_new(JSValue o) {
11852 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
11853 *res_ptr = LDKPersist_init(o);
11854 return tag_ptr(res_ptr, true);
11856 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) {
11857 void* this_arg_ptr = untag_ptr(this_arg);
11858 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11859 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
11860 LDKOutPoint channel_id_conv;
11861 channel_id_conv.inner = untag_ptr(channel_id);
11862 channel_id_conv.is_owned = ptr_is_owned(channel_id);
11863 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
11864 channel_id_conv = OutPoint_clone(&channel_id_conv);
11865 LDKChannelMonitor data_conv;
11866 data_conv.inner = untag_ptr(data);
11867 data_conv.is_owned = ptr_is_owned(data);
11868 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
11869 data_conv.is_owned = false;
11870 LDKMonitorUpdateId update_id_conv;
11871 update_id_conv.inner = untag_ptr(update_id);
11872 update_id_conv.is_owned = ptr_is_owned(update_id);
11873 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
11874 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
11875 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));
11879 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) {
11880 void* this_arg_ptr = untag_ptr(this_arg);
11881 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11882 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
11883 LDKOutPoint channel_id_conv;
11884 channel_id_conv.inner = untag_ptr(channel_id);
11885 channel_id_conv.is_owned = ptr_is_owned(channel_id);
11886 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
11887 channel_id_conv = OutPoint_clone(&channel_id_conv);
11888 LDKChannelMonitorUpdate update_conv;
11889 update_conv.inner = untag_ptr(update);
11890 update_conv.is_owned = ptr_is_owned(update);
11891 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
11892 update_conv = ChannelMonitorUpdate_clone(&update_conv);
11893 LDKChannelMonitor data_conv;
11894 data_conv.inner = untag_ptr(data);
11895 data_conv.is_owned = ptr_is_owned(data);
11896 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
11897 data_conv.is_owned = false;
11898 LDKMonitorUpdateId update_id_conv;
11899 update_id_conv.inner = untag_ptr(update_id);
11900 update_id_conv.is_owned = ptr_is_owned(update_id);
11901 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
11902 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
11903 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));
11907 typedef struct LDKFutureCallback_JCalls {
11908 atomic_size_t refcnt;
11909 uint32_t instance_ptr;
11910 } LDKFutureCallback_JCalls;
11911 static void LDKFutureCallback_JCalls_free(void* this_arg) {
11912 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
11913 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11917 void call_LDKFutureCallback_jcall(const void* this_arg) {
11918 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) this_arg;
11919 js_invoke_function_uuuuuu(j_calls->instance_ptr, 62, 0, 0, 0, 0, 0, 0);
11921 static void LDKFutureCallback_JCalls_cloned(LDKFutureCallback* new_obj) {
11922 LDKFutureCallback_JCalls *j_calls = (LDKFutureCallback_JCalls*) new_obj->this_arg;
11923 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11925 static inline LDKFutureCallback LDKFutureCallback_init (JSValue o) {
11926 LDKFutureCallback_JCalls *calls = MALLOC(sizeof(LDKFutureCallback_JCalls), "LDKFutureCallback_JCalls");
11927 atomic_init(&calls->refcnt, 1);
11928 calls->instance_ptr = o;
11930 LDKFutureCallback ret = {
11931 .this_arg = (void*) calls,
11932 .call = call_LDKFutureCallback_jcall,
11933 .free = LDKFutureCallback_JCalls_free,
11937 uint64_t __attribute__((export_name("TS_LDKFutureCallback_new"))) TS_LDKFutureCallback_new(JSValue o) {
11938 LDKFutureCallback *res_ptr = MALLOC(sizeof(LDKFutureCallback), "LDKFutureCallback");
11939 *res_ptr = LDKFutureCallback_init(o);
11940 return tag_ptr(res_ptr, true);
11942 void __attribute__((export_name("TS_FutureCallback_call"))) TS_FutureCallback_call(uint64_t this_arg) {
11943 void* this_arg_ptr = untag_ptr(this_arg);
11944 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
11945 LDKFutureCallback* this_arg_conv = (LDKFutureCallback*)this_arg_ptr;
11946 (this_arg_conv->call)(this_arg_conv->this_arg);
11949 typedef struct LDKListen_JCalls {
11950 atomic_size_t refcnt;
11951 uint32_t instance_ptr;
11952 } LDKListen_JCalls;
11953 static void LDKListen_JCalls_free(void* this_arg) {
11954 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
11955 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11959 void filtered_block_connected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
11960 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
11961 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
11962 memcpy(header_arr->elems, *header, 80);
11963 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
11964 uint64_tArray txdata_arr = NULL;
11965 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
11966 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
11967 for (size_t c = 0; c < txdata_var.datalen; c++) {
11968 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
11969 *txdata_conv_28_conv = txdata_var.data[c];
11970 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
11973 FREE(txdata_var.data);
11974 int32_t height_conv = height;
11975 js_invoke_function_uuuuuu(j_calls->instance_ptr, 63, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
11977 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
11978 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
11979 LDKu8slice block_var = block;
11980 int8_tArray block_arr = init_int8_tArray(block_var.datalen, __LINE__);
11981 memcpy(block_arr->elems, block_var.data, block_var.datalen);
11982 int32_t height_conv = height;
11983 js_invoke_function_uuuuuu(j_calls->instance_ptr, 64, (uint32_t)block_arr, height_conv, 0, 0, 0, 0);
11985 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
11986 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
11987 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
11988 memcpy(header_arr->elems, *header, 80);
11989 int32_t height_conv = height;
11990 js_invoke_function_uuuuuu(j_calls->instance_ptr, 65, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
11992 static void LDKListen_JCalls_cloned(LDKListen* new_obj) {
11993 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) new_obj->this_arg;
11994 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11996 static inline LDKListen LDKListen_init (JSValue o) {
11997 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
11998 atomic_init(&calls->refcnt, 1);
11999 calls->instance_ptr = o;
12002 .this_arg = (void*) calls,
12003 .filtered_block_connected = filtered_block_connected_LDKListen_jcall,
12004 .block_connected = block_connected_LDKListen_jcall,
12005 .block_disconnected = block_disconnected_LDKListen_jcall,
12006 .free = LDKListen_JCalls_free,
12010 uint64_t __attribute__((export_name("TS_LDKListen_new"))) TS_LDKListen_new(JSValue o) {
12011 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
12012 *res_ptr = LDKListen_init(o);
12013 return tag_ptr(res_ptr, true);
12015 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) {
12016 void* this_arg_ptr = untag_ptr(this_arg);
12017 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12018 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
12019 uint8_t header_arr[80];
12020 CHECK(header->arr_len == 80);
12021 memcpy(header_arr, header->elems, 80); FREE(header);
12022 uint8_t (*header_ref)[80] = &header_arr;
12023 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
12024 txdata_constr.datalen = txdata->arr_len;
12025 if (txdata_constr.datalen > 0)
12026 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
12028 txdata_constr.data = NULL;
12029 uint64_t* txdata_vals = txdata->elems;
12030 for (size_t c = 0; c < txdata_constr.datalen; c++) {
12031 uint64_t txdata_conv_28 = txdata_vals[c];
12032 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
12033 CHECK_ACCESS(txdata_conv_28_ptr);
12034 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
12035 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
12036 txdata_constr.data[c] = txdata_conv_28_conv;
12039 (this_arg_conv->filtered_block_connected)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
12042 void __attribute__((export_name("TS_Listen_block_connected"))) TS_Listen_block_connected(uint64_t this_arg, int8_tArray block, int32_t height) {
12043 void* this_arg_ptr = untag_ptr(this_arg);
12044 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12045 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
12046 LDKu8slice block_ref;
12047 block_ref.datalen = block->arr_len;
12048 block_ref.data = block->elems;
12049 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
12053 void __attribute__((export_name("TS_Listen_block_disconnected"))) TS_Listen_block_disconnected(uint64_t this_arg, int8_tArray header, int32_t height) {
12054 void* this_arg_ptr = untag_ptr(this_arg);
12055 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12056 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
12057 uint8_t header_arr[80];
12058 CHECK(header->arr_len == 80);
12059 memcpy(header_arr, header->elems, 80); FREE(header);
12060 uint8_t (*header_ref)[80] = &header_arr;
12061 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
12064 typedef struct LDKConfirm_JCalls {
12065 atomic_size_t refcnt;
12066 uint32_t instance_ptr;
12067 } LDKConfirm_JCalls;
12068 static void LDKConfirm_JCalls_free(void* this_arg) {
12069 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
12070 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
12074 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
12075 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
12076 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
12077 memcpy(header_arr->elems, *header, 80);
12078 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
12079 uint64_tArray txdata_arr = NULL;
12080 txdata_arr = init_uint64_tArray(txdata_var.datalen, __LINE__);
12081 uint64_t *txdata_arr_ptr = (uint64_t*)(((uint8_t*)txdata_arr) + 8);
12082 for (size_t c = 0; c < txdata_var.datalen; c++) {
12083 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
12084 *txdata_conv_28_conv = txdata_var.data[c];
12085 txdata_arr_ptr[c] = tag_ptr(txdata_conv_28_conv, true);
12088 FREE(txdata_var.data);
12089 int32_t height_conv = height;
12090 js_invoke_function_uuuuuu(j_calls->instance_ptr, 66, (uint32_t)header_arr, (uint32_t)txdata_arr, height_conv, 0, 0, 0);
12092 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
12093 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
12094 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
12095 memcpy(txid_arr->elems, *txid, 32);
12096 js_invoke_function_uuuuuu(j_calls->instance_ptr, 67, (uint32_t)txid_arr, 0, 0, 0, 0, 0);
12098 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
12099 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
12100 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
12101 memcpy(header_arr->elems, *header, 80);
12102 int32_t height_conv = height;
12103 js_invoke_function_uuuuuu(j_calls->instance_ptr, 68, (uint32_t)header_arr, height_conv, 0, 0, 0, 0);
12105 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
12106 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
12107 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 69, 0, 0, 0, 0, 0, 0);
12108 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret_constr;
12109 ret_constr.datalen = ret->arr_len;
12110 if (ret_constr.datalen > 0)
12111 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Elements");
12113 ret_constr.data = NULL;
12114 uint64_t* ret_vals = ret->elems;
12115 for (size_t x = 0; x < ret_constr.datalen; x++) {
12116 uint64_t ret_conv_49 = ret_vals[x];
12117 void* ret_conv_49_ptr = untag_ptr(ret_conv_49);
12118 CHECK_ACCESS(ret_conv_49_ptr);
12119 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ ret_conv_49_conv = *(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)(ret_conv_49_ptr);
12120 FREE(untag_ptr(ret_conv_49));
12121 ret_constr.data[x] = ret_conv_49_conv;
12126 static void LDKConfirm_JCalls_cloned(LDKConfirm* new_obj) {
12127 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) new_obj->this_arg;
12128 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
12130 static inline LDKConfirm LDKConfirm_init (JSValue o) {
12131 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
12132 atomic_init(&calls->refcnt, 1);
12133 calls->instance_ptr = o;
12136 .this_arg = (void*) calls,
12137 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
12138 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
12139 .best_block_updated = best_block_updated_LDKConfirm_jcall,
12140 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
12141 .free = LDKConfirm_JCalls_free,
12145 uint64_t __attribute__((export_name("TS_LDKConfirm_new"))) TS_LDKConfirm_new(JSValue o) {
12146 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
12147 *res_ptr = LDKConfirm_init(o);
12148 return tag_ptr(res_ptr, true);
12150 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) {
12151 void* this_arg_ptr = untag_ptr(this_arg);
12152 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12153 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
12154 uint8_t header_arr[80];
12155 CHECK(header->arr_len == 80);
12156 memcpy(header_arr, header->elems, 80); FREE(header);
12157 uint8_t (*header_ref)[80] = &header_arr;
12158 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
12159 txdata_constr.datalen = txdata->arr_len;
12160 if (txdata_constr.datalen > 0)
12161 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
12163 txdata_constr.data = NULL;
12164 uint64_t* txdata_vals = txdata->elems;
12165 for (size_t c = 0; c < txdata_constr.datalen; c++) {
12166 uint64_t txdata_conv_28 = txdata_vals[c];
12167 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
12168 CHECK_ACCESS(txdata_conv_28_ptr);
12169 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
12170 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
12171 txdata_constr.data[c] = txdata_conv_28_conv;
12174 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
12177 void __attribute__((export_name("TS_Confirm_transaction_unconfirmed"))) TS_Confirm_transaction_unconfirmed(uint64_t this_arg, int8_tArray txid) {
12178 void* this_arg_ptr = untag_ptr(this_arg);
12179 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12180 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
12181 uint8_t txid_arr[32];
12182 CHECK(txid->arr_len == 32);
12183 memcpy(txid_arr, txid->elems, 32); FREE(txid);
12184 uint8_t (*txid_ref)[32] = &txid_arr;
12185 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
12188 void __attribute__((export_name("TS_Confirm_best_block_updated"))) TS_Confirm_best_block_updated(uint64_t this_arg, int8_tArray header, int32_t height) {
12189 void* this_arg_ptr = untag_ptr(this_arg);
12190 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12191 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
12192 uint8_t header_arr[80];
12193 CHECK(header->arr_len == 80);
12194 memcpy(header_arr, header->elems, 80); FREE(header);
12195 uint8_t (*header_ref)[80] = &header_arr;
12196 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
12199 uint64_tArray __attribute__((export_name("TS_Confirm_get_relevant_txids"))) TS_Confirm_get_relevant_txids(uint64_t this_arg) {
12200 void* this_arg_ptr = untag_ptr(this_arg);
12201 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12202 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
12203 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
12204 uint64_tArray ret_arr = NULL;
12205 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
12206 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
12207 for (size_t x = 0; x < ret_var.datalen; x++) {
12208 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* ret_conv_49_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ");
12209 *ret_conv_49_conv = ret_var.data[x];
12210 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
12213 FREE(ret_var.data);
12217 typedef struct LDKEventHandler_JCalls {
12218 atomic_size_t refcnt;
12219 uint32_t instance_ptr;
12220 } LDKEventHandler_JCalls;
12221 static void LDKEventHandler_JCalls_free(void* this_arg) {
12222 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
12223 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
12227 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
12228 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
12229 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
12230 *event_copy = event;
12231 uint64_t event_ref = tag_ptr(event_copy, true);
12232 js_invoke_function_buuuuu(j_calls->instance_ptr, 70, event_ref, 0, 0, 0, 0, 0);
12234 static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) {
12235 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg;
12236 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
12238 static inline LDKEventHandler LDKEventHandler_init (JSValue o) {
12239 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
12240 atomic_init(&calls->refcnt, 1);
12241 calls->instance_ptr = o;
12243 LDKEventHandler ret = {
12244 .this_arg = (void*) calls,
12245 .handle_event = handle_event_LDKEventHandler_jcall,
12246 .free = LDKEventHandler_JCalls_free,
12250 uint64_t __attribute__((export_name("TS_LDKEventHandler_new"))) TS_LDKEventHandler_new(JSValue o) {
12251 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
12252 *res_ptr = LDKEventHandler_init(o);
12253 return tag_ptr(res_ptr, true);
12255 void __attribute__((export_name("TS_EventHandler_handle_event"))) TS_EventHandler_handle_event(uint64_t this_arg, uint64_t event) {
12256 void* this_arg_ptr = untag_ptr(this_arg);
12257 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12258 LDKEventHandler* this_arg_conv = (LDKEventHandler*)this_arg_ptr;
12259 void* event_ptr = untag_ptr(event);
12260 CHECK_ACCESS(event_ptr);
12261 LDKEvent event_conv = *(LDKEvent*)(event_ptr);
12262 event_conv = Event_clone((LDKEvent*)untag_ptr(event));
12263 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
12266 typedef struct LDKEventsProvider_JCalls {
12267 atomic_size_t refcnt;
12268 uint32_t instance_ptr;
12269 } LDKEventsProvider_JCalls;
12270 static void LDKEventsProvider_JCalls_free(void* this_arg) {
12271 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
12272 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
12276 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
12277 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
12278 LDKEventHandler* handler_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
12279 *handler_ret = handler;
12280 js_invoke_function_buuuuu(j_calls->instance_ptr, 71, tag_ptr(handler_ret, true), 0, 0, 0, 0, 0);
12282 static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) {
12283 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg;
12284 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
12286 static inline LDKEventsProvider LDKEventsProvider_init (JSValue o) {
12287 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
12288 atomic_init(&calls->refcnt, 1);
12289 calls->instance_ptr = o;
12291 LDKEventsProvider ret = {
12292 .this_arg = (void*) calls,
12293 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
12294 .free = LDKEventsProvider_JCalls_free,
12298 uint64_t __attribute__((export_name("TS_LDKEventsProvider_new"))) TS_LDKEventsProvider_new(JSValue o) {
12299 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
12300 *res_ptr = LDKEventsProvider_init(o);
12301 return tag_ptr(res_ptr, true);
12303 void __attribute__((export_name("TS_EventsProvider_process_pending_events"))) TS_EventsProvider_process_pending_events(uint64_t this_arg, uint64_t handler) {
12304 void* this_arg_ptr = untag_ptr(this_arg);
12305 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12306 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)this_arg_ptr;
12307 void* handler_ptr = untag_ptr(handler);
12308 CHECK_ACCESS(handler_ptr);
12309 LDKEventHandler handler_conv = *(LDKEventHandler*)(handler_ptr);
12310 if (handler_conv.free == LDKEventHandler_JCalls_free) {
12311 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
12312 LDKEventHandler_JCalls_cloned(&handler_conv);
12314 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
12317 uint32_t __attribute__((export_name("TS_LDKFailureCode_ty_from_ptr"))) TS_LDKFailureCode_ty_from_ptr(uint64_t ptr) {
12318 LDKFailureCode *obj = (LDKFailureCode*)untag_ptr(ptr);
12320 case LDKFailureCode_TemporaryNodeFailure: return 0;
12321 case LDKFailureCode_RequiredNodeFeatureMissing: return 1;
12322 case LDKFailureCode_IncorrectOrUnknownPaymentDetails: return 2;
12323 case LDKFailureCode_InvalidOnionPayload: return 3;
12327 uint64_t __attribute__((export_name("TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload"))) TS_LDKFailureCode_InvalidOnionPayload_get_invalid_onion_payload(uint64_t ptr) {
12328 LDKFailureCode *obj = (LDKFailureCode*)untag_ptr(ptr);
12329 assert(obj->tag == LDKFailureCode_InvalidOnionPayload);
12330 uint64_t invalid_onion_payload_ref = tag_ptr(&obj->invalid_onion_payload, false);
12331 return invalid_onion_payload_ref;
12333 typedef struct LDKMessageSendEventsProvider_JCalls {
12334 atomic_size_t refcnt;
12335 uint32_t instance_ptr;
12336 } LDKMessageSendEventsProvider_JCalls;
12337 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
12338 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
12339 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
12343 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
12344 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
12345 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 72, 0, 0, 0, 0, 0, 0);
12346 LDKCVec_MessageSendEventZ ret_constr;
12347 ret_constr.datalen = ret->arr_len;
12348 if (ret_constr.datalen > 0)
12349 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
12351 ret_constr.data = NULL;
12352 uint64_t* ret_vals = ret->elems;
12353 for (size_t s = 0; s < ret_constr.datalen; s++) {
12354 uint64_t ret_conv_18 = ret_vals[s];
12355 void* ret_conv_18_ptr = untag_ptr(ret_conv_18);
12356 CHECK_ACCESS(ret_conv_18_ptr);
12357 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
12358 FREE(untag_ptr(ret_conv_18));
12359 ret_constr.data[s] = ret_conv_18_conv;
12364 static void LDKMessageSendEventsProvider_JCalls_cloned(LDKMessageSendEventsProvider* new_obj) {
12365 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) new_obj->this_arg;
12366 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
12368 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JSValue o) {
12369 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
12370 atomic_init(&calls->refcnt, 1);
12371 calls->instance_ptr = o;
12373 LDKMessageSendEventsProvider ret = {
12374 .this_arg = (void*) calls,
12375 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
12376 .free = LDKMessageSendEventsProvider_JCalls_free,
12380 uint64_t __attribute__((export_name("TS_LDKMessageSendEventsProvider_new"))) TS_LDKMessageSendEventsProvider_new(JSValue o) {
12381 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
12382 *res_ptr = LDKMessageSendEventsProvider_init(o);
12383 return tag_ptr(res_ptr, true);
12385 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) {
12386 void* this_arg_ptr = untag_ptr(this_arg);
12387 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12388 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)this_arg_ptr;
12389 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
12390 uint64_tArray ret_arr = NULL;
12391 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
12392 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
12393 for (size_t s = 0; s < ret_var.datalen; s++) {
12394 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
12395 *ret_conv_18_copy = ret_var.data[s];
12396 uint64_t ret_conv_18_ref = tag_ptr(ret_conv_18_copy, true);
12397 ret_arr_ptr[s] = ret_conv_18_ref;
12400 FREE(ret_var.data);
12404 typedef struct LDKChannelMessageHandler_JCalls {
12405 atomic_size_t refcnt;
12406 uint32_t instance_ptr;
12407 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
12408 } LDKChannelMessageHandler_JCalls;
12409 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
12410 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12411 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
12415 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKOpenChannel * msg) {
12416 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12417 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12418 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12419 LDKOpenChannel msg_var = *msg;
12420 uint64_t msg_ref = 0;
12421 msg_var = OpenChannel_clone(&msg_var);
12422 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12423 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12424 js_invoke_function_ubuuuu(j_calls->instance_ptr, 73, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12426 void handle_open_channel_v2_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKOpenChannelV2 * msg) {
12427 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12428 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12429 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12430 LDKOpenChannelV2 msg_var = *msg;
12431 uint64_t msg_ref = 0;
12432 msg_var = OpenChannelV2_clone(&msg_var);
12433 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12434 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12435 js_invoke_function_ubuuuu(j_calls->instance_ptr, 74, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12437 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAcceptChannel * msg) {
12438 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12439 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12440 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12441 LDKAcceptChannel msg_var = *msg;
12442 uint64_t msg_ref = 0;
12443 msg_var = AcceptChannel_clone(&msg_var);
12444 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12445 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12446 js_invoke_function_ubuuuu(j_calls->instance_ptr, 75, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12448 void handle_accept_channel_v2_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAcceptChannelV2 * msg) {
12449 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12450 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12451 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12452 LDKAcceptChannelV2 msg_var = *msg;
12453 uint64_t msg_ref = 0;
12454 msg_var = AcceptChannelV2_clone(&msg_var);
12455 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12456 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12457 js_invoke_function_ubuuuu(j_calls->instance_ptr, 76, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12459 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
12460 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12461 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12462 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12463 LDKFundingCreated msg_var = *msg;
12464 uint64_t msg_ref = 0;
12465 msg_var = FundingCreated_clone(&msg_var);
12466 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12467 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12468 js_invoke_function_ubuuuu(j_calls->instance_ptr, 77, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12470 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
12471 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12472 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12473 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12474 LDKFundingSigned msg_var = *msg;
12475 uint64_t msg_ref = 0;
12476 msg_var = FundingSigned_clone(&msg_var);
12477 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12478 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12479 js_invoke_function_ubuuuu(j_calls->instance_ptr, 78, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12481 void handle_channel_ready_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReady * msg) {
12482 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12483 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12484 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12485 LDKChannelReady msg_var = *msg;
12486 uint64_t msg_ref = 0;
12487 msg_var = ChannelReady_clone(&msg_var);
12488 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12489 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12490 js_invoke_function_ubuuuu(j_calls->instance_ptr, 79, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12492 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKShutdown * msg) {
12493 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12494 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12495 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12496 LDKShutdown msg_var = *msg;
12497 uint64_t msg_ref = 0;
12498 msg_var = Shutdown_clone(&msg_var);
12499 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12500 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12501 js_invoke_function_ubuuuu(j_calls->instance_ptr, 80, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12503 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
12504 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12505 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12506 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12507 LDKClosingSigned msg_var = *msg;
12508 uint64_t msg_ref = 0;
12509 msg_var = ClosingSigned_clone(&msg_var);
12510 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12511 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12512 js_invoke_function_ubuuuu(j_calls->instance_ptr, 81, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12514 void handle_tx_add_input_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxAddInput * msg) {
12515 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12516 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12517 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12518 LDKTxAddInput msg_var = *msg;
12519 uint64_t msg_ref = 0;
12520 msg_var = TxAddInput_clone(&msg_var);
12521 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12522 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12523 js_invoke_function_ubuuuu(j_calls->instance_ptr, 82, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12525 void handle_tx_add_output_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxAddOutput * msg) {
12526 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12527 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12528 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12529 LDKTxAddOutput msg_var = *msg;
12530 uint64_t msg_ref = 0;
12531 msg_var = TxAddOutput_clone(&msg_var);
12532 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12533 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12534 js_invoke_function_ubuuuu(j_calls->instance_ptr, 83, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12536 void handle_tx_remove_input_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxRemoveInput * msg) {
12537 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12538 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12539 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12540 LDKTxRemoveInput msg_var = *msg;
12541 uint64_t msg_ref = 0;
12542 msg_var = TxRemoveInput_clone(&msg_var);
12543 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12544 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12545 js_invoke_function_ubuuuu(j_calls->instance_ptr, 84, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12547 void handle_tx_remove_output_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxRemoveOutput * msg) {
12548 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12549 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12550 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12551 LDKTxRemoveOutput msg_var = *msg;
12552 uint64_t msg_ref = 0;
12553 msg_var = TxRemoveOutput_clone(&msg_var);
12554 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12555 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12556 js_invoke_function_ubuuuu(j_calls->instance_ptr, 85, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12558 void handle_tx_complete_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxComplete * msg) {
12559 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12560 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12561 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12562 LDKTxComplete msg_var = *msg;
12563 uint64_t msg_ref = 0;
12564 msg_var = TxComplete_clone(&msg_var);
12565 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12566 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12567 js_invoke_function_ubuuuu(j_calls->instance_ptr, 86, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12569 void handle_tx_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxSignatures * msg) {
12570 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12571 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12572 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12573 LDKTxSignatures msg_var = *msg;
12574 uint64_t msg_ref = 0;
12575 msg_var = TxSignatures_clone(&msg_var);
12576 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12577 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12578 js_invoke_function_ubuuuu(j_calls->instance_ptr, 87, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12580 void handle_tx_init_rbf_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxInitRbf * msg) {
12581 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12582 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12583 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12584 LDKTxInitRbf msg_var = *msg;
12585 uint64_t msg_ref = 0;
12586 msg_var = TxInitRbf_clone(&msg_var);
12587 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12588 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12589 js_invoke_function_ubuuuu(j_calls->instance_ptr, 88, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12591 void handle_tx_ack_rbf_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxAckRbf * msg) {
12592 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12593 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12594 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12595 LDKTxAckRbf msg_var = *msg;
12596 uint64_t msg_ref = 0;
12597 msg_var = TxAckRbf_clone(&msg_var);
12598 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12599 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12600 js_invoke_function_ubuuuu(j_calls->instance_ptr, 89, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12602 void handle_tx_abort_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKTxAbort * msg) {
12603 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12604 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12605 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12606 LDKTxAbort msg_var = *msg;
12607 uint64_t msg_ref = 0;
12608 msg_var = TxAbort_clone(&msg_var);
12609 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12610 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12611 js_invoke_function_ubuuuu(j_calls->instance_ptr, 90, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12613 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
12614 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12615 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12616 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12617 LDKUpdateAddHTLC msg_var = *msg;
12618 uint64_t msg_ref = 0;
12619 msg_var = UpdateAddHTLC_clone(&msg_var);
12620 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12621 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12622 js_invoke_function_ubuuuu(j_calls->instance_ptr, 91, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12624 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
12625 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12626 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12627 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12628 LDKUpdateFulfillHTLC msg_var = *msg;
12629 uint64_t msg_ref = 0;
12630 msg_var = UpdateFulfillHTLC_clone(&msg_var);
12631 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12632 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12633 js_invoke_function_ubuuuu(j_calls->instance_ptr, 92, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12635 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
12636 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12637 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12638 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12639 LDKUpdateFailHTLC msg_var = *msg;
12640 uint64_t msg_ref = 0;
12641 msg_var = UpdateFailHTLC_clone(&msg_var);
12642 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12643 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12644 js_invoke_function_ubuuuu(j_calls->instance_ptr, 93, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12646 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
12647 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12648 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12649 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12650 LDKUpdateFailMalformedHTLC msg_var = *msg;
12651 uint64_t msg_ref = 0;
12652 msg_var = UpdateFailMalformedHTLC_clone(&msg_var);
12653 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12654 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12655 js_invoke_function_ubuuuu(j_calls->instance_ptr, 94, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12657 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
12658 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12659 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12660 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12661 LDKCommitmentSigned msg_var = *msg;
12662 uint64_t msg_ref = 0;
12663 msg_var = CommitmentSigned_clone(&msg_var);
12664 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12665 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12666 js_invoke_function_ubuuuu(j_calls->instance_ptr, 95, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12668 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
12669 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12670 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12671 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12672 LDKRevokeAndACK msg_var = *msg;
12673 uint64_t msg_ref = 0;
12674 msg_var = RevokeAndACK_clone(&msg_var);
12675 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12676 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12677 js_invoke_function_ubuuuu(j_calls->instance_ptr, 96, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12679 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
12680 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12681 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12682 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12683 LDKUpdateFee msg_var = *msg;
12684 uint64_t msg_ref = 0;
12685 msg_var = UpdateFee_clone(&msg_var);
12686 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12687 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12688 js_invoke_function_ubuuuu(j_calls->instance_ptr, 97, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12690 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
12691 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12692 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12693 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12694 LDKAnnouncementSignatures msg_var = *msg;
12695 uint64_t msg_ref = 0;
12696 msg_var = AnnouncementSignatures_clone(&msg_var);
12697 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12698 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12699 js_invoke_function_ubuuuu(j_calls->instance_ptr, 98, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12701 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
12702 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12703 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12704 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12705 js_invoke_function_uuuuuu(j_calls->instance_ptr, 99, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
12707 LDKCResult_NoneNoneZ peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg, bool inbound) {
12708 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12709 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12710 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12711 LDKInit msg_var = *msg;
12712 uint64_t msg_ref = 0;
12713 msg_var = Init_clone(&msg_var);
12714 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12715 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12716 jboolean inbound_conv = inbound;
12717 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 100, (uint32_t)their_node_id_arr, msg_ref, inbound_conv, 0, 0, 0);
12718 void* ret_ptr = untag_ptr(ret);
12719 CHECK_ACCESS(ret_ptr);
12720 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
12721 FREE(untag_ptr(ret));
12724 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
12725 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12726 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12727 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12728 LDKChannelReestablish msg_var = *msg;
12729 uint64_t msg_ref = 0;
12730 msg_var = ChannelReestablish_clone(&msg_var);
12731 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12732 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12733 js_invoke_function_ubuuuu(j_calls->instance_ptr, 101, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12735 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
12736 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12737 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12738 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12739 LDKChannelUpdate msg_var = *msg;
12740 uint64_t msg_ref = 0;
12741 msg_var = ChannelUpdate_clone(&msg_var);
12742 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12743 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12744 js_invoke_function_ubuuuu(j_calls->instance_ptr, 102, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12746 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
12747 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12748 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12749 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12750 LDKErrorMessage msg_var = *msg;
12751 uint64_t msg_ref = 0;
12752 msg_var = ErrorMessage_clone(&msg_var);
12753 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
12754 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
12755 js_invoke_function_ubuuuu(j_calls->instance_ptr, 103, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
12757 LDKNodeFeatures provided_node_features_LDKChannelMessageHandler_jcall(const void* this_arg) {
12758 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12759 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 104, 0, 0, 0, 0, 0, 0);
12760 LDKNodeFeatures ret_conv;
12761 ret_conv.inner = untag_ptr(ret);
12762 ret_conv.is_owned = ptr_is_owned(ret);
12763 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
12766 LDKInitFeatures provided_init_features_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
12767 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12768 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
12769 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
12770 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 105, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
12771 LDKInitFeatures ret_conv;
12772 ret_conv.inner = untag_ptr(ret);
12773 ret_conv.is_owned = ptr_is_owned(ret);
12774 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
12777 LDKCOption_CVec_ThirtyTwoBytesZZ get_genesis_hashes_LDKChannelMessageHandler_jcall(const void* this_arg) {
12778 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
12779 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 106, 0, 0, 0, 0, 0, 0);
12780 void* ret_ptr = untag_ptr(ret);
12781 CHECK_ACCESS(ret_ptr);
12782 LDKCOption_CVec_ThirtyTwoBytesZZ ret_conv = *(LDKCOption_CVec_ThirtyTwoBytesZZ*)(ret_ptr);
12783 FREE(untag_ptr(ret));
12786 static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
12787 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
12788 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
12789 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
12791 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
12792 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
12793 atomic_init(&calls->refcnt, 1);
12794 calls->instance_ptr = o;
12796 LDKChannelMessageHandler ret = {
12797 .this_arg = (void*) calls,
12798 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
12799 .handle_open_channel_v2 = handle_open_channel_v2_LDKChannelMessageHandler_jcall,
12800 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
12801 .handle_accept_channel_v2 = handle_accept_channel_v2_LDKChannelMessageHandler_jcall,
12802 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
12803 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
12804 .handle_channel_ready = handle_channel_ready_LDKChannelMessageHandler_jcall,
12805 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
12806 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
12807 .handle_tx_add_input = handle_tx_add_input_LDKChannelMessageHandler_jcall,
12808 .handle_tx_add_output = handle_tx_add_output_LDKChannelMessageHandler_jcall,
12809 .handle_tx_remove_input = handle_tx_remove_input_LDKChannelMessageHandler_jcall,
12810 .handle_tx_remove_output = handle_tx_remove_output_LDKChannelMessageHandler_jcall,
12811 .handle_tx_complete = handle_tx_complete_LDKChannelMessageHandler_jcall,
12812 .handle_tx_signatures = handle_tx_signatures_LDKChannelMessageHandler_jcall,
12813 .handle_tx_init_rbf = handle_tx_init_rbf_LDKChannelMessageHandler_jcall,
12814 .handle_tx_ack_rbf = handle_tx_ack_rbf_LDKChannelMessageHandler_jcall,
12815 .handle_tx_abort = handle_tx_abort_LDKChannelMessageHandler_jcall,
12816 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
12817 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
12818 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
12819 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
12820 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
12821 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
12822 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
12823 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
12824 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
12825 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
12826 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
12827 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
12828 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
12829 .provided_node_features = provided_node_features_LDKChannelMessageHandler_jcall,
12830 .provided_init_features = provided_init_features_LDKChannelMessageHandler_jcall,
12831 .get_genesis_hashes = get_genesis_hashes_LDKChannelMessageHandler_jcall,
12832 .free = LDKChannelMessageHandler_JCalls_free,
12833 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
12835 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
12838 uint64_t __attribute__((export_name("TS_LDKChannelMessageHandler_new"))) TS_LDKChannelMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
12839 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
12840 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
12841 return tag_ptr(res_ptr, true);
12843 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) {
12844 void* this_arg_ptr = untag_ptr(this_arg);
12845 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12846 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12847 LDKPublicKey their_node_id_ref;
12848 CHECK(their_node_id->arr_len == 33);
12849 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12850 LDKOpenChannel msg_conv;
12851 msg_conv.inner = untag_ptr(msg);
12852 msg_conv.is_owned = ptr_is_owned(msg);
12853 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12854 msg_conv.is_owned = false;
12855 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12858 void __attribute__((export_name("TS_ChannelMessageHandler_handle_open_channel_v2"))) TS_ChannelMessageHandler_handle_open_channel_v2(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
12859 void* this_arg_ptr = untag_ptr(this_arg);
12860 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12861 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12862 LDKPublicKey their_node_id_ref;
12863 CHECK(their_node_id->arr_len == 33);
12864 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12865 LDKOpenChannelV2 msg_conv;
12866 msg_conv.inner = untag_ptr(msg);
12867 msg_conv.is_owned = ptr_is_owned(msg);
12868 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12869 msg_conv.is_owned = false;
12870 (this_arg_conv->handle_open_channel_v2)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12873 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) {
12874 void* this_arg_ptr = untag_ptr(this_arg);
12875 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12876 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12877 LDKPublicKey their_node_id_ref;
12878 CHECK(their_node_id->arr_len == 33);
12879 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12880 LDKAcceptChannel msg_conv;
12881 msg_conv.inner = untag_ptr(msg);
12882 msg_conv.is_owned = ptr_is_owned(msg);
12883 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12884 msg_conv.is_owned = false;
12885 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12888 void __attribute__((export_name("TS_ChannelMessageHandler_handle_accept_channel_v2"))) TS_ChannelMessageHandler_handle_accept_channel_v2(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
12889 void* this_arg_ptr = untag_ptr(this_arg);
12890 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12891 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12892 LDKPublicKey their_node_id_ref;
12893 CHECK(their_node_id->arr_len == 33);
12894 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12895 LDKAcceptChannelV2 msg_conv;
12896 msg_conv.inner = untag_ptr(msg);
12897 msg_conv.is_owned = ptr_is_owned(msg);
12898 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12899 msg_conv.is_owned = false;
12900 (this_arg_conv->handle_accept_channel_v2)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12903 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) {
12904 void* this_arg_ptr = untag_ptr(this_arg);
12905 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12906 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12907 LDKPublicKey their_node_id_ref;
12908 CHECK(their_node_id->arr_len == 33);
12909 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12910 LDKFundingCreated msg_conv;
12911 msg_conv.inner = untag_ptr(msg);
12912 msg_conv.is_owned = ptr_is_owned(msg);
12913 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12914 msg_conv.is_owned = false;
12915 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12918 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) {
12919 void* this_arg_ptr = untag_ptr(this_arg);
12920 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12921 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12922 LDKPublicKey their_node_id_ref;
12923 CHECK(their_node_id->arr_len == 33);
12924 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12925 LDKFundingSigned msg_conv;
12926 msg_conv.inner = untag_ptr(msg);
12927 msg_conv.is_owned = ptr_is_owned(msg);
12928 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12929 msg_conv.is_owned = false;
12930 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12933 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) {
12934 void* this_arg_ptr = untag_ptr(this_arg);
12935 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12936 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12937 LDKPublicKey their_node_id_ref;
12938 CHECK(their_node_id->arr_len == 33);
12939 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12940 LDKChannelReady msg_conv;
12941 msg_conv.inner = untag_ptr(msg);
12942 msg_conv.is_owned = ptr_is_owned(msg);
12943 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12944 msg_conv.is_owned = false;
12945 (this_arg_conv->handle_channel_ready)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12948 void __attribute__((export_name("TS_ChannelMessageHandler_handle_shutdown"))) TS_ChannelMessageHandler_handle_shutdown(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
12949 void* this_arg_ptr = untag_ptr(this_arg);
12950 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12951 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12952 LDKPublicKey their_node_id_ref;
12953 CHECK(their_node_id->arr_len == 33);
12954 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12955 LDKShutdown msg_conv;
12956 msg_conv.inner = untag_ptr(msg);
12957 msg_conv.is_owned = ptr_is_owned(msg);
12958 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12959 msg_conv.is_owned = false;
12960 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12963 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) {
12964 void* this_arg_ptr = untag_ptr(this_arg);
12965 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12966 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12967 LDKPublicKey their_node_id_ref;
12968 CHECK(their_node_id->arr_len == 33);
12969 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12970 LDKClosingSigned msg_conv;
12971 msg_conv.inner = untag_ptr(msg);
12972 msg_conv.is_owned = ptr_is_owned(msg);
12973 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12974 msg_conv.is_owned = false;
12975 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12978 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_add_input"))) TS_ChannelMessageHandler_handle_tx_add_input(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
12979 void* this_arg_ptr = untag_ptr(this_arg);
12980 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12981 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12982 LDKPublicKey their_node_id_ref;
12983 CHECK(their_node_id->arr_len == 33);
12984 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
12985 LDKTxAddInput msg_conv;
12986 msg_conv.inner = untag_ptr(msg);
12987 msg_conv.is_owned = ptr_is_owned(msg);
12988 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
12989 msg_conv.is_owned = false;
12990 (this_arg_conv->handle_tx_add_input)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
12993 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_add_output"))) TS_ChannelMessageHandler_handle_tx_add_output(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
12994 void* this_arg_ptr = untag_ptr(this_arg);
12995 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
12996 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
12997 LDKPublicKey their_node_id_ref;
12998 CHECK(their_node_id->arr_len == 33);
12999 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13000 LDKTxAddOutput msg_conv;
13001 msg_conv.inner = untag_ptr(msg);
13002 msg_conv.is_owned = ptr_is_owned(msg);
13003 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13004 msg_conv.is_owned = false;
13005 (this_arg_conv->handle_tx_add_output)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13008 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_remove_input"))) TS_ChannelMessageHandler_handle_tx_remove_input(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13009 void* this_arg_ptr = untag_ptr(this_arg);
13010 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13011 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13012 LDKPublicKey their_node_id_ref;
13013 CHECK(their_node_id->arr_len == 33);
13014 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13015 LDKTxRemoveInput msg_conv;
13016 msg_conv.inner = untag_ptr(msg);
13017 msg_conv.is_owned = ptr_is_owned(msg);
13018 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13019 msg_conv.is_owned = false;
13020 (this_arg_conv->handle_tx_remove_input)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13023 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_remove_output"))) TS_ChannelMessageHandler_handle_tx_remove_output(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13024 void* this_arg_ptr = untag_ptr(this_arg);
13025 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13026 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13027 LDKPublicKey their_node_id_ref;
13028 CHECK(their_node_id->arr_len == 33);
13029 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13030 LDKTxRemoveOutput msg_conv;
13031 msg_conv.inner = untag_ptr(msg);
13032 msg_conv.is_owned = ptr_is_owned(msg);
13033 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13034 msg_conv.is_owned = false;
13035 (this_arg_conv->handle_tx_remove_output)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13038 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_complete"))) TS_ChannelMessageHandler_handle_tx_complete(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13039 void* this_arg_ptr = untag_ptr(this_arg);
13040 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13041 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13042 LDKPublicKey their_node_id_ref;
13043 CHECK(their_node_id->arr_len == 33);
13044 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13045 LDKTxComplete msg_conv;
13046 msg_conv.inner = untag_ptr(msg);
13047 msg_conv.is_owned = ptr_is_owned(msg);
13048 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13049 msg_conv.is_owned = false;
13050 (this_arg_conv->handle_tx_complete)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13053 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_signatures"))) TS_ChannelMessageHandler_handle_tx_signatures(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13054 void* this_arg_ptr = untag_ptr(this_arg);
13055 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13056 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13057 LDKPublicKey their_node_id_ref;
13058 CHECK(their_node_id->arr_len == 33);
13059 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13060 LDKTxSignatures msg_conv;
13061 msg_conv.inner = untag_ptr(msg);
13062 msg_conv.is_owned = ptr_is_owned(msg);
13063 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13064 msg_conv.is_owned = false;
13065 (this_arg_conv->handle_tx_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13068 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_init_rbf"))) TS_ChannelMessageHandler_handle_tx_init_rbf(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13069 void* this_arg_ptr = untag_ptr(this_arg);
13070 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13071 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13072 LDKPublicKey their_node_id_ref;
13073 CHECK(their_node_id->arr_len == 33);
13074 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13075 LDKTxInitRbf msg_conv;
13076 msg_conv.inner = untag_ptr(msg);
13077 msg_conv.is_owned = ptr_is_owned(msg);
13078 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13079 msg_conv.is_owned = false;
13080 (this_arg_conv->handle_tx_init_rbf)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13083 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_ack_rbf"))) TS_ChannelMessageHandler_handle_tx_ack_rbf(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13084 void* this_arg_ptr = untag_ptr(this_arg);
13085 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13086 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13087 LDKPublicKey their_node_id_ref;
13088 CHECK(their_node_id->arr_len == 33);
13089 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13090 LDKTxAckRbf msg_conv;
13091 msg_conv.inner = untag_ptr(msg);
13092 msg_conv.is_owned = ptr_is_owned(msg);
13093 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13094 msg_conv.is_owned = false;
13095 (this_arg_conv->handle_tx_ack_rbf)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13098 void __attribute__((export_name("TS_ChannelMessageHandler_handle_tx_abort"))) TS_ChannelMessageHandler_handle_tx_abort(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13099 void* this_arg_ptr = untag_ptr(this_arg);
13100 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13101 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13102 LDKPublicKey their_node_id_ref;
13103 CHECK(their_node_id->arr_len == 33);
13104 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13105 LDKTxAbort msg_conv;
13106 msg_conv.inner = untag_ptr(msg);
13107 msg_conv.is_owned = ptr_is_owned(msg);
13108 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13109 msg_conv.is_owned = false;
13110 (this_arg_conv->handle_tx_abort)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13113 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) {
13114 void* this_arg_ptr = untag_ptr(this_arg);
13115 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13116 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13117 LDKPublicKey their_node_id_ref;
13118 CHECK(their_node_id->arr_len == 33);
13119 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13120 LDKUpdateAddHTLC msg_conv;
13121 msg_conv.inner = untag_ptr(msg);
13122 msg_conv.is_owned = ptr_is_owned(msg);
13123 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13124 msg_conv.is_owned = false;
13125 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13128 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) {
13129 void* this_arg_ptr = untag_ptr(this_arg);
13130 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13131 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13132 LDKPublicKey their_node_id_ref;
13133 CHECK(their_node_id->arr_len == 33);
13134 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13135 LDKUpdateFulfillHTLC msg_conv;
13136 msg_conv.inner = untag_ptr(msg);
13137 msg_conv.is_owned = ptr_is_owned(msg);
13138 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13139 msg_conv.is_owned = false;
13140 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13143 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) {
13144 void* this_arg_ptr = untag_ptr(this_arg);
13145 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13146 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13147 LDKPublicKey their_node_id_ref;
13148 CHECK(their_node_id->arr_len == 33);
13149 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13150 LDKUpdateFailHTLC msg_conv;
13151 msg_conv.inner = untag_ptr(msg);
13152 msg_conv.is_owned = ptr_is_owned(msg);
13153 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13154 msg_conv.is_owned = false;
13155 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13158 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) {
13159 void* this_arg_ptr = untag_ptr(this_arg);
13160 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13161 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13162 LDKPublicKey their_node_id_ref;
13163 CHECK(their_node_id->arr_len == 33);
13164 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13165 LDKUpdateFailMalformedHTLC msg_conv;
13166 msg_conv.inner = untag_ptr(msg);
13167 msg_conv.is_owned = ptr_is_owned(msg);
13168 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13169 msg_conv.is_owned = false;
13170 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13173 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) {
13174 void* this_arg_ptr = untag_ptr(this_arg);
13175 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13176 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13177 LDKPublicKey their_node_id_ref;
13178 CHECK(their_node_id->arr_len == 33);
13179 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13180 LDKCommitmentSigned msg_conv;
13181 msg_conv.inner = untag_ptr(msg);
13182 msg_conv.is_owned = ptr_is_owned(msg);
13183 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13184 msg_conv.is_owned = false;
13185 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13188 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) {
13189 void* this_arg_ptr = untag_ptr(this_arg);
13190 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13191 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13192 LDKPublicKey their_node_id_ref;
13193 CHECK(their_node_id->arr_len == 33);
13194 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13195 LDKRevokeAndACK msg_conv;
13196 msg_conv.inner = untag_ptr(msg);
13197 msg_conv.is_owned = ptr_is_owned(msg);
13198 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13199 msg_conv.is_owned = false;
13200 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13203 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) {
13204 void* this_arg_ptr = untag_ptr(this_arg);
13205 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13206 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13207 LDKPublicKey their_node_id_ref;
13208 CHECK(their_node_id->arr_len == 33);
13209 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13210 LDKUpdateFee msg_conv;
13211 msg_conv.inner = untag_ptr(msg);
13212 msg_conv.is_owned = ptr_is_owned(msg);
13213 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13214 msg_conv.is_owned = false;
13215 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13218 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) {
13219 void* this_arg_ptr = untag_ptr(this_arg);
13220 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13221 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13222 LDKPublicKey their_node_id_ref;
13223 CHECK(their_node_id->arr_len == 33);
13224 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13225 LDKAnnouncementSignatures msg_conv;
13226 msg_conv.inner = untag_ptr(msg);
13227 msg_conv.is_owned = ptr_is_owned(msg);
13228 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13229 msg_conv.is_owned = false;
13230 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13233 void __attribute__((export_name("TS_ChannelMessageHandler_peer_disconnected"))) TS_ChannelMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
13234 void* this_arg_ptr = untag_ptr(this_arg);
13235 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13236 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13237 LDKPublicKey their_node_id_ref;
13238 CHECK(their_node_id->arr_len == 33);
13239 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13240 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
13243 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) {
13244 void* this_arg_ptr = untag_ptr(this_arg);
13245 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13246 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13247 LDKPublicKey their_node_id_ref;
13248 CHECK(their_node_id->arr_len == 33);
13249 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13251 msg_conv.inner = untag_ptr(msg);
13252 msg_conv.is_owned = ptr_is_owned(msg);
13253 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13254 msg_conv.is_owned = false;
13255 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
13256 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv, inbound);
13257 return tag_ptr(ret_conv, true);
13260 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) {
13261 void* this_arg_ptr = untag_ptr(this_arg);
13262 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13263 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13264 LDKPublicKey their_node_id_ref;
13265 CHECK(their_node_id->arr_len == 33);
13266 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13267 LDKChannelReestablish msg_conv;
13268 msg_conv.inner = untag_ptr(msg);
13269 msg_conv.is_owned = ptr_is_owned(msg);
13270 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13271 msg_conv.is_owned = false;
13272 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13275 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) {
13276 void* this_arg_ptr = untag_ptr(this_arg);
13277 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13278 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13279 LDKPublicKey their_node_id_ref;
13280 CHECK(their_node_id->arr_len == 33);
13281 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13282 LDKChannelUpdate msg_conv;
13283 msg_conv.inner = untag_ptr(msg);
13284 msg_conv.is_owned = ptr_is_owned(msg);
13285 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13286 msg_conv.is_owned = false;
13287 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13290 void __attribute__((export_name("TS_ChannelMessageHandler_handle_error"))) TS_ChannelMessageHandler_handle_error(uint64_t this_arg, int8_tArray their_node_id, uint64_t msg) {
13291 void* this_arg_ptr = untag_ptr(this_arg);
13292 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13293 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13294 LDKPublicKey their_node_id_ref;
13295 CHECK(their_node_id->arr_len == 33);
13296 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13297 LDKErrorMessage msg_conv;
13298 msg_conv.inner = untag_ptr(msg);
13299 msg_conv.is_owned = ptr_is_owned(msg);
13300 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13301 msg_conv.is_owned = false;
13302 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
13305 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_node_features"))) TS_ChannelMessageHandler_provided_node_features(uint64_t this_arg) {
13306 void* this_arg_ptr = untag_ptr(this_arg);
13307 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13308 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13309 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
13310 uint64_t ret_ref = 0;
13311 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13312 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13316 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_provided_init_features"))) TS_ChannelMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
13317 void* this_arg_ptr = untag_ptr(this_arg);
13318 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13319 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13320 LDKPublicKey their_node_id_ref;
13321 CHECK(their_node_id->arr_len == 33);
13322 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13323 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
13324 uint64_t ret_ref = 0;
13325 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13326 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13330 uint64_t __attribute__((export_name("TS_ChannelMessageHandler_get_genesis_hashes"))) TS_ChannelMessageHandler_get_genesis_hashes(uint64_t this_arg) {
13331 void* this_arg_ptr = untag_ptr(this_arg);
13332 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13333 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
13334 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
13335 *ret_copy = (this_arg_conv->get_genesis_hashes)(this_arg_conv->this_arg);
13336 uint64_t ret_ref = tag_ptr(ret_copy, true);
13340 typedef struct LDKRoutingMessageHandler_JCalls {
13341 atomic_size_t refcnt;
13342 uint32_t instance_ptr;
13343 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
13344 } LDKRoutingMessageHandler_JCalls;
13345 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
13346 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13347 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
13351 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
13352 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13353 LDKNodeAnnouncement msg_var = *msg;
13354 uint64_t msg_ref = 0;
13355 msg_var = NodeAnnouncement_clone(&msg_var);
13356 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13357 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13358 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 107, msg_ref, 0, 0, 0, 0, 0);
13359 void* ret_ptr = untag_ptr(ret);
13360 CHECK_ACCESS(ret_ptr);
13361 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
13362 FREE(untag_ptr(ret));
13365 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
13366 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13367 LDKChannelAnnouncement msg_var = *msg;
13368 uint64_t msg_ref = 0;
13369 msg_var = ChannelAnnouncement_clone(&msg_var);
13370 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13371 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13372 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 108, msg_ref, 0, 0, 0, 0, 0);
13373 void* ret_ptr = untag_ptr(ret);
13374 CHECK_ACCESS(ret_ptr);
13375 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
13376 FREE(untag_ptr(ret));
13379 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
13380 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13381 LDKChannelUpdate msg_var = *msg;
13382 uint64_t msg_ref = 0;
13383 msg_var = ChannelUpdate_clone(&msg_var);
13384 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13385 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13386 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 109, msg_ref, 0, 0, 0, 0, 0);
13387 void* ret_ptr = untag_ptr(ret);
13388 CHECK_ACCESS(ret_ptr);
13389 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
13390 FREE(untag_ptr(ret));
13393 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point) {
13394 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13395 int64_t starting_point_conv = starting_point;
13396 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 110, starting_point_conv, 0, 0, 0, 0, 0);
13397 void* ret_ptr = untag_ptr(ret);
13398 CHECK_ACCESS(ret_ptr);
13399 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(ret_ptr);
13400 FREE(untag_ptr(ret));
13403 LDKNodeAnnouncement get_next_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKNodeId starting_point) {
13404 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13405 LDKNodeId starting_point_var = starting_point;
13406 uint64_t starting_point_ref = 0;
13407 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_var);
13408 starting_point_ref = tag_ptr(starting_point_var.inner, starting_point_var.is_owned);
13409 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 111, starting_point_ref, 0, 0, 0, 0, 0);
13410 LDKNodeAnnouncement ret_conv;
13411 ret_conv.inner = untag_ptr(ret);
13412 ret_conv.is_owned = ptr_is_owned(ret);
13413 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13416 LDKCResult_NoneNoneZ peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
13417 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13418 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13419 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13420 LDKInit init_var = *init;
13421 uint64_t init_ref = 0;
13422 init_var = Init_clone(&init_var);
13423 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
13424 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
13425 jboolean inbound_conv = inbound;
13426 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 112, (uint32_t)their_node_id_arr, init_ref, inbound_conv, 0, 0, 0);
13427 void* ret_ptr = untag_ptr(ret);
13428 CHECK_ACCESS(ret_ptr);
13429 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
13430 FREE(untag_ptr(ret));
13433 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
13434 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13435 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13436 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13437 LDKReplyChannelRange msg_var = msg;
13438 uint64_t msg_ref = 0;
13439 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13440 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13441 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 113, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
13442 void* ret_ptr = untag_ptr(ret);
13443 CHECK_ACCESS(ret_ptr);
13444 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
13445 FREE(untag_ptr(ret));
13448 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
13449 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13450 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13451 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13452 LDKReplyShortChannelIdsEnd msg_var = msg;
13453 uint64_t msg_ref = 0;
13454 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13455 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13456 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 114, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
13457 void* ret_ptr = untag_ptr(ret);
13458 CHECK_ACCESS(ret_ptr);
13459 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
13460 FREE(untag_ptr(ret));
13463 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
13464 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13465 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13466 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13467 LDKQueryChannelRange msg_var = msg;
13468 uint64_t msg_ref = 0;
13469 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13470 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13471 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 115, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
13472 void* ret_ptr = untag_ptr(ret);
13473 CHECK_ACCESS(ret_ptr);
13474 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
13475 FREE(untag_ptr(ret));
13478 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
13479 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13480 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13481 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13482 LDKQueryShortChannelIds msg_var = msg;
13483 uint64_t msg_ref = 0;
13484 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13485 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13486 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 116, (uint32_t)their_node_id_arr, msg_ref, 0, 0, 0, 0);
13487 void* ret_ptr = untag_ptr(ret);
13488 CHECK_ACCESS(ret_ptr);
13489 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
13490 FREE(untag_ptr(ret));
13493 bool processing_queue_high_LDKRoutingMessageHandler_jcall(const void* this_arg) {
13494 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13495 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 117, 0, 0, 0, 0, 0, 0);
13497 LDKNodeFeatures provided_node_features_LDKRoutingMessageHandler_jcall(const void* this_arg) {
13498 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13499 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 118, 0, 0, 0, 0, 0, 0);
13500 LDKNodeFeatures ret_conv;
13501 ret_conv.inner = untag_ptr(ret);
13502 ret_conv.is_owned = ptr_is_owned(ret);
13503 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13506 LDKInitFeatures provided_init_features_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
13507 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
13508 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13509 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13510 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 119, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
13511 LDKInitFeatures ret_conv;
13512 ret_conv.inner = untag_ptr(ret);
13513 ret_conv.is_owned = ptr_is_owned(ret);
13514 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13517 static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
13518 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
13519 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
13520 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
13522 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
13523 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
13524 atomic_init(&calls->refcnt, 1);
13525 calls->instance_ptr = o;
13527 LDKRoutingMessageHandler ret = {
13528 .this_arg = (void*) calls,
13529 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
13530 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
13531 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
13532 .get_next_channel_announcement = get_next_channel_announcement_LDKRoutingMessageHandler_jcall,
13533 .get_next_node_announcement = get_next_node_announcement_LDKRoutingMessageHandler_jcall,
13534 .peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
13535 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
13536 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
13537 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
13538 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
13539 .processing_queue_high = processing_queue_high_LDKRoutingMessageHandler_jcall,
13540 .provided_node_features = provided_node_features_LDKRoutingMessageHandler_jcall,
13541 .provided_init_features = provided_init_features_LDKRoutingMessageHandler_jcall,
13542 .free = LDKRoutingMessageHandler_JCalls_free,
13543 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
13545 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
13548 uint64_t __attribute__((export_name("TS_LDKRoutingMessageHandler_new"))) TS_LDKRoutingMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
13549 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
13550 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
13551 return tag_ptr(res_ptr, true);
13553 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_node_announcement"))) TS_RoutingMessageHandler_handle_node_announcement(uint64_t this_arg, uint64_t msg) {
13554 void* this_arg_ptr = untag_ptr(this_arg);
13555 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13556 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13557 LDKNodeAnnouncement msg_conv;
13558 msg_conv.inner = untag_ptr(msg);
13559 msg_conv.is_owned = ptr_is_owned(msg);
13560 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13561 msg_conv.is_owned = false;
13562 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
13563 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
13564 return tag_ptr(ret_conv, true);
13567 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_announcement"))) TS_RoutingMessageHandler_handle_channel_announcement(uint64_t this_arg, uint64_t msg) {
13568 void* this_arg_ptr = untag_ptr(this_arg);
13569 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13570 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13571 LDKChannelAnnouncement msg_conv;
13572 msg_conv.inner = untag_ptr(msg);
13573 msg_conv.is_owned = ptr_is_owned(msg);
13574 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13575 msg_conv.is_owned = false;
13576 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
13577 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
13578 return tag_ptr(ret_conv, true);
13581 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_update"))) TS_RoutingMessageHandler_handle_channel_update(uint64_t this_arg, uint64_t msg) {
13582 void* this_arg_ptr = untag_ptr(this_arg);
13583 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13584 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13585 LDKChannelUpdate msg_conv;
13586 msg_conv.inner = untag_ptr(msg);
13587 msg_conv.is_owned = ptr_is_owned(msg);
13588 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13589 msg_conv.is_owned = false;
13590 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
13591 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
13592 return tag_ptr(ret_conv, true);
13595 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) {
13596 void* this_arg_ptr = untag_ptr(this_arg);
13597 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13598 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13599 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
13600 *ret_copy = (this_arg_conv->get_next_channel_announcement)(this_arg_conv->this_arg, starting_point);
13601 uint64_t ret_ref = tag_ptr(ret_copy, true);
13605 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) {
13606 void* this_arg_ptr = untag_ptr(this_arg);
13607 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13608 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13609 LDKNodeId starting_point_conv;
13610 starting_point_conv.inner = untag_ptr(starting_point);
13611 starting_point_conv.is_owned = ptr_is_owned(starting_point);
13612 CHECK_INNER_FIELD_ACCESS_OR_NULL(starting_point_conv);
13613 starting_point_conv = NodeId_clone(&starting_point_conv);
13614 LDKNodeAnnouncement ret_var = (this_arg_conv->get_next_node_announcement)(this_arg_conv->this_arg, starting_point_conv);
13615 uint64_t ret_ref = 0;
13616 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13617 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13621 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) {
13622 void* this_arg_ptr = untag_ptr(this_arg);
13623 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13624 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13625 LDKPublicKey their_node_id_ref;
13626 CHECK(their_node_id->arr_len == 33);
13627 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13629 init_conv.inner = untag_ptr(init);
13630 init_conv.is_owned = ptr_is_owned(init);
13631 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
13632 init_conv.is_owned = false;
13633 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
13634 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
13635 return tag_ptr(ret_conv, true);
13638 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) {
13639 void* this_arg_ptr = untag_ptr(this_arg);
13640 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13641 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13642 LDKPublicKey their_node_id_ref;
13643 CHECK(their_node_id->arr_len == 33);
13644 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13645 LDKReplyChannelRange msg_conv;
13646 msg_conv.inner = untag_ptr(msg);
13647 msg_conv.is_owned = ptr_is_owned(msg);
13648 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13649 msg_conv = ReplyChannelRange_clone(&msg_conv);
13650 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
13651 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
13652 return tag_ptr(ret_conv, true);
13655 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) {
13656 void* this_arg_ptr = untag_ptr(this_arg);
13657 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13658 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13659 LDKPublicKey their_node_id_ref;
13660 CHECK(their_node_id->arr_len == 33);
13661 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13662 LDKReplyShortChannelIdsEnd msg_conv;
13663 msg_conv.inner = untag_ptr(msg);
13664 msg_conv.is_owned = ptr_is_owned(msg);
13665 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13666 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
13667 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
13668 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
13669 return tag_ptr(ret_conv, true);
13672 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) {
13673 void* this_arg_ptr = untag_ptr(this_arg);
13674 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13675 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13676 LDKPublicKey their_node_id_ref;
13677 CHECK(their_node_id->arr_len == 33);
13678 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13679 LDKQueryChannelRange msg_conv;
13680 msg_conv.inner = untag_ptr(msg);
13681 msg_conv.is_owned = ptr_is_owned(msg);
13682 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13683 msg_conv = QueryChannelRange_clone(&msg_conv);
13684 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
13685 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
13686 return tag_ptr(ret_conv, true);
13689 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) {
13690 void* this_arg_ptr = untag_ptr(this_arg);
13691 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13692 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13693 LDKPublicKey their_node_id_ref;
13694 CHECK(their_node_id->arr_len == 33);
13695 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13696 LDKQueryShortChannelIds msg_conv;
13697 msg_conv.inner = untag_ptr(msg);
13698 msg_conv.is_owned = ptr_is_owned(msg);
13699 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13700 msg_conv = QueryShortChannelIds_clone(&msg_conv);
13701 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
13702 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
13703 return tag_ptr(ret_conv, true);
13706 jboolean __attribute__((export_name("TS_RoutingMessageHandler_processing_queue_high"))) TS_RoutingMessageHandler_processing_queue_high(uint64_t this_arg) {
13707 void* this_arg_ptr = untag_ptr(this_arg);
13708 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13709 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13710 jboolean ret_conv = (this_arg_conv->processing_queue_high)(this_arg_conv->this_arg);
13714 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_node_features"))) TS_RoutingMessageHandler_provided_node_features(uint64_t this_arg) {
13715 void* this_arg_ptr = untag_ptr(this_arg);
13716 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13717 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13718 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
13719 uint64_t ret_ref = 0;
13720 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13721 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13725 uint64_t __attribute__((export_name("TS_RoutingMessageHandler_provided_init_features"))) TS_RoutingMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
13726 void* this_arg_ptr = untag_ptr(this_arg);
13727 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13728 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
13729 LDKPublicKey their_node_id_ref;
13730 CHECK(their_node_id->arr_len == 33);
13731 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13732 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
13733 uint64_t ret_ref = 0;
13734 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13735 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13739 typedef struct LDKOnionMessageProvider_JCalls {
13740 atomic_size_t refcnt;
13741 uint32_t instance_ptr;
13742 } LDKOnionMessageProvider_JCalls;
13743 static void LDKOnionMessageProvider_JCalls_free(void* this_arg) {
13744 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
13745 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
13749 LDKOnionMessage next_onion_message_for_peer_LDKOnionMessageProvider_jcall(const void* this_arg, LDKPublicKey peer_node_id) {
13750 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) this_arg;
13751 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
13752 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
13753 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 120, (uint32_t)peer_node_id_arr, 0, 0, 0, 0, 0);
13754 LDKOnionMessage ret_conv;
13755 ret_conv.inner = untag_ptr(ret);
13756 ret_conv.is_owned = ptr_is_owned(ret);
13757 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13760 static void LDKOnionMessageProvider_JCalls_cloned(LDKOnionMessageProvider* new_obj) {
13761 LDKOnionMessageProvider_JCalls *j_calls = (LDKOnionMessageProvider_JCalls*) new_obj->this_arg;
13762 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
13764 static inline LDKOnionMessageProvider LDKOnionMessageProvider_init (JSValue o) {
13765 LDKOnionMessageProvider_JCalls *calls = MALLOC(sizeof(LDKOnionMessageProvider_JCalls), "LDKOnionMessageProvider_JCalls");
13766 atomic_init(&calls->refcnt, 1);
13767 calls->instance_ptr = o;
13769 LDKOnionMessageProvider ret = {
13770 .this_arg = (void*) calls,
13771 .next_onion_message_for_peer = next_onion_message_for_peer_LDKOnionMessageProvider_jcall,
13772 .free = LDKOnionMessageProvider_JCalls_free,
13776 uint64_t __attribute__((export_name("TS_LDKOnionMessageProvider_new"))) TS_LDKOnionMessageProvider_new(JSValue o) {
13777 LDKOnionMessageProvider *res_ptr = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
13778 *res_ptr = LDKOnionMessageProvider_init(o);
13779 return tag_ptr(res_ptr, true);
13781 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) {
13782 void* this_arg_ptr = untag_ptr(this_arg);
13783 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13784 LDKOnionMessageProvider* this_arg_conv = (LDKOnionMessageProvider*)this_arg_ptr;
13785 LDKPublicKey peer_node_id_ref;
13786 CHECK(peer_node_id->arr_len == 33);
13787 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
13788 LDKOnionMessage ret_var = (this_arg_conv->next_onion_message_for_peer)(this_arg_conv->this_arg, peer_node_id_ref);
13789 uint64_t ret_ref = 0;
13790 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13791 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13795 typedef struct LDKOnionMessageHandler_JCalls {
13796 atomic_size_t refcnt;
13797 uint32_t instance_ptr;
13798 LDKOnionMessageProvider_JCalls* OnionMessageProvider;
13799 } LDKOnionMessageHandler_JCalls;
13800 static void LDKOnionMessageHandler_JCalls_free(void* this_arg) {
13801 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13802 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
13806 void handle_onion_message_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey peer_node_id, const LDKOnionMessage * msg) {
13807 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13808 int8_tArray peer_node_id_arr = init_int8_tArray(33, __LINE__);
13809 memcpy(peer_node_id_arr->elems, peer_node_id.compressed_form, 33);
13810 LDKOnionMessage msg_var = *msg;
13811 uint64_t msg_ref = 0;
13812 msg_var = OnionMessage_clone(&msg_var);
13813 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
13814 msg_ref = tag_ptr(msg_var.inner, msg_var.is_owned);
13815 js_invoke_function_ubuuuu(j_calls->instance_ptr, 121, (uint32_t)peer_node_id_arr, msg_ref, 0, 0, 0, 0);
13817 LDKCResult_NoneNoneZ peer_connected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init, bool inbound) {
13818 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13819 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13820 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13821 LDKInit init_var = *init;
13822 uint64_t init_ref = 0;
13823 init_var = Init_clone(&init_var);
13824 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
13825 init_ref = tag_ptr(init_var.inner, init_var.is_owned);
13826 jboolean inbound_conv = inbound;
13827 uint64_t ret = js_invoke_function_ubuuuu(j_calls->instance_ptr, 122, (uint32_t)their_node_id_arr, init_ref, inbound_conv, 0, 0, 0);
13828 void* ret_ptr = untag_ptr(ret);
13829 CHECK_ACCESS(ret_ptr);
13830 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
13831 FREE(untag_ptr(ret));
13834 void peer_disconnected_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
13835 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13836 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13837 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13838 js_invoke_function_uuuuuu(j_calls->instance_ptr, 123, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
13840 LDKNodeFeatures provided_node_features_LDKOnionMessageHandler_jcall(const void* this_arg) {
13841 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13842 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 124, 0, 0, 0, 0, 0, 0);
13843 LDKNodeFeatures ret_conv;
13844 ret_conv.inner = untag_ptr(ret);
13845 ret_conv.is_owned = ptr_is_owned(ret);
13846 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13849 LDKInitFeatures provided_init_features_LDKOnionMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
13850 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) this_arg;
13851 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
13852 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
13853 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 125, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
13854 LDKInitFeatures ret_conv;
13855 ret_conv.inner = untag_ptr(ret);
13856 ret_conv.is_owned = ptr_is_owned(ret);
13857 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
13860 static void LDKOnionMessageHandler_JCalls_cloned(LDKOnionMessageHandler* new_obj) {
13861 LDKOnionMessageHandler_JCalls *j_calls = (LDKOnionMessageHandler_JCalls*) new_obj->this_arg;
13862 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
13863 atomic_fetch_add_explicit(&j_calls->OnionMessageProvider->refcnt, 1, memory_order_release);
13865 static inline LDKOnionMessageHandler LDKOnionMessageHandler_init (JSValue o, JSValue OnionMessageProvider) {
13866 LDKOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOnionMessageHandler_JCalls), "LDKOnionMessageHandler_JCalls");
13867 atomic_init(&calls->refcnt, 1);
13868 calls->instance_ptr = o;
13870 LDKOnionMessageHandler ret = {
13871 .this_arg = (void*) calls,
13872 .handle_onion_message = handle_onion_message_LDKOnionMessageHandler_jcall,
13873 .peer_connected = peer_connected_LDKOnionMessageHandler_jcall,
13874 .peer_disconnected = peer_disconnected_LDKOnionMessageHandler_jcall,
13875 .provided_node_features = provided_node_features_LDKOnionMessageHandler_jcall,
13876 .provided_init_features = provided_init_features_LDKOnionMessageHandler_jcall,
13877 .free = LDKOnionMessageHandler_JCalls_free,
13878 .OnionMessageProvider = LDKOnionMessageProvider_init(OnionMessageProvider),
13880 calls->OnionMessageProvider = ret.OnionMessageProvider.this_arg;
13883 uint64_t __attribute__((export_name("TS_LDKOnionMessageHandler_new"))) TS_LDKOnionMessageHandler_new(JSValue o, JSValue OnionMessageProvider) {
13884 LDKOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
13885 *res_ptr = LDKOnionMessageHandler_init(o, OnionMessageProvider);
13886 return tag_ptr(res_ptr, true);
13888 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) {
13889 void* this_arg_ptr = untag_ptr(this_arg);
13890 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13891 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
13892 LDKPublicKey peer_node_id_ref;
13893 CHECK(peer_node_id->arr_len == 33);
13894 memcpy(peer_node_id_ref.compressed_form, peer_node_id->elems, 33); FREE(peer_node_id);
13895 LDKOnionMessage msg_conv;
13896 msg_conv.inner = untag_ptr(msg);
13897 msg_conv.is_owned = ptr_is_owned(msg);
13898 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
13899 msg_conv.is_owned = false;
13900 (this_arg_conv->handle_onion_message)(this_arg_conv->this_arg, peer_node_id_ref, &msg_conv);
13903 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) {
13904 void* this_arg_ptr = untag_ptr(this_arg);
13905 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13906 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
13907 LDKPublicKey their_node_id_ref;
13908 CHECK(their_node_id->arr_len == 33);
13909 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13911 init_conv.inner = untag_ptr(init);
13912 init_conv.is_owned = ptr_is_owned(init);
13913 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
13914 init_conv.is_owned = false;
13915 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
13916 *ret_conv = (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv, inbound);
13917 return tag_ptr(ret_conv, true);
13920 void __attribute__((export_name("TS_OnionMessageHandler_peer_disconnected"))) TS_OnionMessageHandler_peer_disconnected(uint64_t this_arg, int8_tArray their_node_id) {
13921 void* this_arg_ptr = untag_ptr(this_arg);
13922 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13923 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
13924 LDKPublicKey their_node_id_ref;
13925 CHECK(their_node_id->arr_len == 33);
13926 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13927 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref);
13930 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_node_features"))) TS_OnionMessageHandler_provided_node_features(uint64_t this_arg) {
13931 void* this_arg_ptr = untag_ptr(this_arg);
13932 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13933 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
13934 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
13935 uint64_t ret_ref = 0;
13936 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13937 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13941 uint64_t __attribute__((export_name("TS_OnionMessageHandler_provided_init_features"))) TS_OnionMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
13942 void* this_arg_ptr = untag_ptr(this_arg);
13943 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
13944 LDKOnionMessageHandler* this_arg_conv = (LDKOnionMessageHandler*)this_arg_ptr;
13945 LDKPublicKey their_node_id_ref;
13946 CHECK(their_node_id->arr_len == 33);
13947 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
13948 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
13949 uint64_t ret_ref = 0;
13950 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
13951 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
13955 typedef struct LDKCustomMessageReader_JCalls {
13956 atomic_size_t refcnt;
13957 uint32_t instance_ptr;
13958 } LDKCustomMessageReader_JCalls;
13959 static void LDKCustomMessageReader_JCalls_free(void* this_arg) {
13960 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
13961 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
13965 LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) {
13966 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
13967 int16_t message_type_conv = message_type;
13968 LDKu8slice buffer_var = buffer;
13969 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
13970 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
13971 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 126, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
13972 void* ret_ptr = untag_ptr(ret);
13973 CHECK_ACCESS(ret_ptr);
13974 LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
13975 FREE(untag_ptr(ret));
13978 static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
13979 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg;
13980 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
13982 static inline LDKCustomMessageReader LDKCustomMessageReader_init (JSValue o) {
13983 LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls");
13984 atomic_init(&calls->refcnt, 1);
13985 calls->instance_ptr = o;
13987 LDKCustomMessageReader ret = {
13988 .this_arg = (void*) calls,
13989 .read = read_LDKCustomMessageReader_jcall,
13990 .free = LDKCustomMessageReader_JCalls_free,
13994 uint64_t __attribute__((export_name("TS_LDKCustomMessageReader_new"))) TS_LDKCustomMessageReader_new(JSValue o) {
13995 LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
13996 *res_ptr = LDKCustomMessageReader_init(o);
13997 return tag_ptr(res_ptr, true);
13999 uint64_t __attribute__((export_name("TS_CustomMessageReader_read"))) TS_CustomMessageReader_read(uint64_t this_arg, int16_t message_type, int8_tArray buffer) {
14000 void* this_arg_ptr = untag_ptr(this_arg);
14001 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14002 LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)this_arg_ptr;
14003 LDKu8slice buffer_ref;
14004 buffer_ref.datalen = buffer->arr_len;
14005 buffer_ref.data = buffer->elems;
14006 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
14007 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref);
14009 return tag_ptr(ret_conv, true);
14012 typedef struct LDKCustomMessageHandler_JCalls {
14013 atomic_size_t refcnt;
14014 uint32_t instance_ptr;
14015 LDKCustomMessageReader_JCalls* CustomMessageReader;
14016 } LDKCustomMessageHandler_JCalls;
14017 static void LDKCustomMessageHandler_JCalls_free(void* this_arg) {
14018 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
14019 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14023 LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) {
14024 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
14025 LDKType* msg_ret = MALLOC(sizeof(LDKType), "LDKType");
14027 int8_tArray sender_node_id_arr = init_int8_tArray(33, __LINE__);
14028 memcpy(sender_node_id_arr->elems, sender_node_id.compressed_form, 33);
14029 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 127, tag_ptr(msg_ret, true), (uint32_t)sender_node_id_arr, 0, 0, 0, 0);
14030 void* ret_ptr = untag_ptr(ret);
14031 CHECK_ACCESS(ret_ptr);
14032 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
14033 FREE(untag_ptr(ret));
14036 LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
14037 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
14038 uint64_tArray ret = (uint64_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 128, 0, 0, 0, 0, 0, 0);
14039 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr;
14040 ret_constr.datalen = ret->arr_len;
14041 if (ret_constr.datalen > 0)
14042 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
14044 ret_constr.data = NULL;
14045 uint64_t* ret_vals = ret->elems;
14046 for (size_t z = 0; z < ret_constr.datalen; z++) {
14047 uint64_t ret_conv_25 = ret_vals[z];
14048 void* ret_conv_25_ptr = untag_ptr(ret_conv_25);
14049 CHECK_ACCESS(ret_conv_25_ptr);
14050 LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
14051 FREE(untag_ptr(ret_conv_25));
14052 ret_constr.data[z] = ret_conv_25_conv;
14057 LDKNodeFeatures provided_node_features_LDKCustomMessageHandler_jcall(const void* this_arg) {
14058 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
14059 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 129, 0, 0, 0, 0, 0, 0);
14060 LDKNodeFeatures ret_conv;
14061 ret_conv.inner = untag_ptr(ret);
14062 ret_conv.is_owned = ptr_is_owned(ret);
14063 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
14066 LDKInitFeatures provided_init_features_LDKCustomMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id) {
14067 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
14068 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
14069 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
14070 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 130, (uint32_t)their_node_id_arr, 0, 0, 0, 0, 0);
14071 LDKInitFeatures ret_conv;
14072 ret_conv.inner = untag_ptr(ret);
14073 ret_conv.is_owned = ptr_is_owned(ret);
14074 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
14077 static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) {
14078 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg;
14079 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14080 atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release);
14082 static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (JSValue o, JSValue CustomMessageReader) {
14083 LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls");
14084 atomic_init(&calls->refcnt, 1);
14085 calls->instance_ptr = o;
14087 LDKCustomMessageHandler ret = {
14088 .this_arg = (void*) calls,
14089 .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall,
14090 .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall,
14091 .provided_node_features = provided_node_features_LDKCustomMessageHandler_jcall,
14092 .provided_init_features = provided_init_features_LDKCustomMessageHandler_jcall,
14093 .free = LDKCustomMessageHandler_JCalls_free,
14094 .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader),
14096 calls->CustomMessageReader = ret.CustomMessageReader.this_arg;
14099 uint64_t __attribute__((export_name("TS_LDKCustomMessageHandler_new"))) TS_LDKCustomMessageHandler_new(JSValue o, JSValue CustomMessageReader) {
14100 LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
14101 *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader);
14102 return tag_ptr(res_ptr, true);
14104 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) {
14105 void* this_arg_ptr = untag_ptr(this_arg);
14106 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14107 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
14108 void* msg_ptr = untag_ptr(msg);
14109 CHECK_ACCESS(msg_ptr);
14110 LDKType msg_conv = *(LDKType*)(msg_ptr);
14111 if (msg_conv.free == LDKType_JCalls_free) {
14112 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14113 LDKType_JCalls_cloned(&msg_conv);
14115 LDKPublicKey sender_node_id_ref;
14116 CHECK(sender_node_id->arr_len == 33);
14117 memcpy(sender_node_id_ref.compressed_form, sender_node_id->elems, 33); FREE(sender_node_id);
14118 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14119 *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref);
14120 return tag_ptr(ret_conv, true);
14123 uint64_tArray __attribute__((export_name("TS_CustomMessageHandler_get_and_clear_pending_msg"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint64_t this_arg) {
14124 void* this_arg_ptr = untag_ptr(this_arg);
14125 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14126 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
14127 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg);
14128 uint64_tArray ret_arr = NULL;
14129 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
14130 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
14131 for (size_t z = 0; z < ret_var.datalen; z++) {
14132 LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
14133 *ret_conv_25_conv = ret_var.data[z];
14134 ret_arr_ptr[z] = tag_ptr(ret_conv_25_conv, true);
14137 FREE(ret_var.data);
14141 uint64_t __attribute__((export_name("TS_CustomMessageHandler_provided_node_features"))) TS_CustomMessageHandler_provided_node_features(uint64_t this_arg) {
14142 void* this_arg_ptr = untag_ptr(this_arg);
14143 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14144 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
14145 LDKNodeFeatures ret_var = (this_arg_conv->provided_node_features)(this_arg_conv->this_arg);
14146 uint64_t ret_ref = 0;
14147 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
14148 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
14152 uint64_t __attribute__((export_name("TS_CustomMessageHandler_provided_init_features"))) TS_CustomMessageHandler_provided_init_features(uint64_t this_arg, int8_tArray their_node_id) {
14153 void* this_arg_ptr = untag_ptr(this_arg);
14154 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14155 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
14156 LDKPublicKey their_node_id_ref;
14157 CHECK(their_node_id->arr_len == 33);
14158 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
14159 LDKInitFeatures ret_var = (this_arg_conv->provided_init_features)(this_arg_conv->this_arg, their_node_id_ref);
14160 uint64_t ret_ref = 0;
14161 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
14162 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
14166 typedef struct LDKOffersMessageHandler_JCalls {
14167 atomic_size_t refcnt;
14168 uint32_t instance_ptr;
14169 } LDKOffersMessageHandler_JCalls;
14170 static void LDKOffersMessageHandler_JCalls_free(void* this_arg) {
14171 LDKOffersMessageHandler_JCalls *j_calls = (LDKOffersMessageHandler_JCalls*) this_arg;
14172 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14176 LDKCOption_OffersMessageZ handle_message_LDKOffersMessageHandler_jcall(const void* this_arg, LDKOffersMessage message) {
14177 LDKOffersMessageHandler_JCalls *j_calls = (LDKOffersMessageHandler_JCalls*) this_arg;
14178 LDKOffersMessage *message_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
14179 *message_copy = message;
14180 uint64_t message_ref = tag_ptr(message_copy, true);
14181 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 131, message_ref, 0, 0, 0, 0, 0);
14182 void* ret_ptr = untag_ptr(ret);
14183 CHECK_ACCESS(ret_ptr);
14184 LDKCOption_OffersMessageZ ret_conv = *(LDKCOption_OffersMessageZ*)(ret_ptr);
14185 FREE(untag_ptr(ret));
14188 static void LDKOffersMessageHandler_JCalls_cloned(LDKOffersMessageHandler* new_obj) {
14189 LDKOffersMessageHandler_JCalls *j_calls = (LDKOffersMessageHandler_JCalls*) new_obj->this_arg;
14190 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14192 static inline LDKOffersMessageHandler LDKOffersMessageHandler_init (JSValue o) {
14193 LDKOffersMessageHandler_JCalls *calls = MALLOC(sizeof(LDKOffersMessageHandler_JCalls), "LDKOffersMessageHandler_JCalls");
14194 atomic_init(&calls->refcnt, 1);
14195 calls->instance_ptr = o;
14197 LDKOffersMessageHandler ret = {
14198 .this_arg = (void*) calls,
14199 .handle_message = handle_message_LDKOffersMessageHandler_jcall,
14200 .free = LDKOffersMessageHandler_JCalls_free,
14204 uint64_t __attribute__((export_name("TS_LDKOffersMessageHandler_new"))) TS_LDKOffersMessageHandler_new(JSValue o) {
14205 LDKOffersMessageHandler *res_ptr = MALLOC(sizeof(LDKOffersMessageHandler), "LDKOffersMessageHandler");
14206 *res_ptr = LDKOffersMessageHandler_init(o);
14207 return tag_ptr(res_ptr, true);
14209 uint64_t __attribute__((export_name("TS_OffersMessageHandler_handle_message"))) TS_OffersMessageHandler_handle_message(uint64_t this_arg, uint64_t message) {
14210 void* this_arg_ptr = untag_ptr(this_arg);
14211 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14212 LDKOffersMessageHandler* this_arg_conv = (LDKOffersMessageHandler*)this_arg_ptr;
14213 void* message_ptr = untag_ptr(message);
14214 CHECK_ACCESS(message_ptr);
14215 LDKOffersMessage message_conv = *(LDKOffersMessage*)(message_ptr);
14216 message_conv = OffersMessage_clone((LDKOffersMessage*)untag_ptr(message));
14217 LDKCOption_OffersMessageZ *ret_copy = MALLOC(sizeof(LDKCOption_OffersMessageZ), "LDKCOption_OffersMessageZ");
14218 *ret_copy = (this_arg_conv->handle_message)(this_arg_conv->this_arg, message_conv);
14219 uint64_t ret_ref = tag_ptr(ret_copy, true);
14223 typedef struct LDKCustomOnionMessageHandler_JCalls {
14224 atomic_size_t refcnt;
14225 uint32_t instance_ptr;
14226 } LDKCustomOnionMessageHandler_JCalls;
14227 static void LDKCustomOnionMessageHandler_JCalls_free(void* this_arg) {
14228 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
14229 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14233 LDKCOption_CustomOnionMessageContentsZ handle_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, LDKCustomOnionMessageContents msg) {
14234 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
14235 LDKCustomOnionMessageContents* msg_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
14237 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 132, tag_ptr(msg_ret, true), 0, 0, 0, 0, 0);
14238 void* ret_ptr = untag_ptr(ret);
14239 CHECK_ACCESS(ret_ptr);
14240 LDKCOption_CustomOnionMessageContentsZ ret_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(ret_ptr);
14241 FREE(untag_ptr(ret));
14244 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ read_custom_message_LDKCustomOnionMessageHandler_jcall(const void* this_arg, uint64_t message_type, LDKu8slice buffer) {
14245 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) this_arg;
14246 int64_t message_type_conv = message_type;
14247 LDKu8slice buffer_var = buffer;
14248 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
14249 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
14250 uint64_t ret = js_invoke_function_buuuuu(j_calls->instance_ptr, 133, message_type_conv, (uint32_t)buffer_arr, 0, 0, 0, 0);
14251 void* ret_ptr = untag_ptr(ret);
14252 CHECK_ACCESS(ret_ptr);
14253 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ ret_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(ret_ptr);
14254 FREE(untag_ptr(ret));
14257 static void LDKCustomOnionMessageHandler_JCalls_cloned(LDKCustomOnionMessageHandler* new_obj) {
14258 LDKCustomOnionMessageHandler_JCalls *j_calls = (LDKCustomOnionMessageHandler_JCalls*) new_obj->this_arg;
14259 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14261 static inline LDKCustomOnionMessageHandler LDKCustomOnionMessageHandler_init (JSValue o) {
14262 LDKCustomOnionMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomOnionMessageHandler_JCalls), "LDKCustomOnionMessageHandler_JCalls");
14263 atomic_init(&calls->refcnt, 1);
14264 calls->instance_ptr = o;
14266 LDKCustomOnionMessageHandler ret = {
14267 .this_arg = (void*) calls,
14268 .handle_custom_message = handle_custom_message_LDKCustomOnionMessageHandler_jcall,
14269 .read_custom_message = read_custom_message_LDKCustomOnionMessageHandler_jcall,
14270 .free = LDKCustomOnionMessageHandler_JCalls_free,
14274 uint64_t __attribute__((export_name("TS_LDKCustomOnionMessageHandler_new"))) TS_LDKCustomOnionMessageHandler_new(JSValue o) {
14275 LDKCustomOnionMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
14276 *res_ptr = LDKCustomOnionMessageHandler_init(o);
14277 return tag_ptr(res_ptr, true);
14279 uint64_t __attribute__((export_name("TS_CustomOnionMessageHandler_handle_custom_message"))) TS_CustomOnionMessageHandler_handle_custom_message(uint64_t this_arg, uint64_t msg) {
14280 void* this_arg_ptr = untag_ptr(this_arg);
14281 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14282 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
14283 void* msg_ptr = untag_ptr(msg);
14284 CHECK_ACCESS(msg_ptr);
14285 LDKCustomOnionMessageContents msg_conv = *(LDKCustomOnionMessageContents*)(msg_ptr);
14286 if (msg_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
14287 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14288 LDKCustomOnionMessageContents_JCalls_cloned(&msg_conv);
14290 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
14291 *ret_copy = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv);
14292 uint64_t ret_ref = tag_ptr(ret_copy, true);
14296 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) {
14297 void* this_arg_ptr = untag_ptr(this_arg);
14298 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14299 LDKCustomOnionMessageHandler* this_arg_conv = (LDKCustomOnionMessageHandler*)this_arg_ptr;
14300 LDKu8slice buffer_ref;
14301 buffer_ref.datalen = buffer->arr_len;
14302 buffer_ref.data = buffer->elems;
14303 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
14304 *ret_conv = (this_arg_conv->read_custom_message)(this_arg_conv->this_arg, message_type, buffer_ref);
14306 return tag_ptr(ret_conv, true);
14309 typedef struct LDKSocketDescriptor_JCalls {
14310 atomic_size_t refcnt;
14311 uint32_t instance_ptr;
14312 } LDKSocketDescriptor_JCalls;
14313 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
14314 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
14315 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14319 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
14320 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
14321 LDKu8slice data_var = data;
14322 int8_tArray data_arr = init_int8_tArray(data_var.datalen, __LINE__);
14323 memcpy(data_arr->elems, data_var.data, data_var.datalen);
14324 jboolean resume_read_conv = resume_read;
14325 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 134, (uint32_t)data_arr, resume_read_conv, 0, 0, 0, 0);
14327 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
14328 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
14329 js_invoke_function_uuuuuu(j_calls->instance_ptr, 135, 0, 0, 0, 0, 0, 0);
14331 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
14332 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
14333 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
14334 *other_arg_clone = SocketDescriptor_clone(other_arg);
14335 return js_invoke_function_buuuuu(j_calls->instance_ptr, 136, tag_ptr(other_arg_clone, true), 0, 0, 0, 0, 0);
14337 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
14338 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
14339 return js_invoke_function_uuuuuu(j_calls->instance_ptr, 137, 0, 0, 0, 0, 0, 0);
14341 static void LDKSocketDescriptor_JCalls_cloned(LDKSocketDescriptor* new_obj) {
14342 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) new_obj->this_arg;
14343 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14345 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JSValue o) {
14346 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
14347 atomic_init(&calls->refcnt, 1);
14348 calls->instance_ptr = o;
14350 LDKSocketDescriptor ret = {
14351 .this_arg = (void*) calls,
14352 .send_data = send_data_LDKSocketDescriptor_jcall,
14353 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
14354 .eq = eq_LDKSocketDescriptor_jcall,
14355 .hash = hash_LDKSocketDescriptor_jcall,
14356 .cloned = LDKSocketDescriptor_JCalls_cloned,
14357 .free = LDKSocketDescriptor_JCalls_free,
14361 uint64_t __attribute__((export_name("TS_LDKSocketDescriptor_new"))) TS_LDKSocketDescriptor_new(JSValue o) {
14362 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
14363 *res_ptr = LDKSocketDescriptor_init(o);
14364 return tag_ptr(res_ptr, true);
14366 uint32_t __attribute__((export_name("TS_SocketDescriptor_send_data"))) TS_SocketDescriptor_send_data(uint64_t this_arg, int8_tArray data, jboolean resume_read) {
14367 void* this_arg_ptr = untag_ptr(this_arg);
14368 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14369 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
14370 LDKu8slice data_ref;
14371 data_ref.datalen = data->arr_len;
14372 data_ref.data = data->elems;
14373 uint32_t ret_conv = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
14378 void __attribute__((export_name("TS_SocketDescriptor_disconnect_socket"))) TS_SocketDescriptor_disconnect_socket(uint64_t this_arg) {
14379 void* this_arg_ptr = untag_ptr(this_arg);
14380 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14381 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
14382 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
14385 int64_t __attribute__((export_name("TS_SocketDescriptor_hash"))) TS_SocketDescriptor_hash(uint64_t this_arg) {
14386 void* this_arg_ptr = untag_ptr(this_arg);
14387 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14388 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
14389 int64_t ret_conv = (this_arg_conv->hash)(this_arg_conv->this_arg);
14393 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_ty_from_ptr"))) TS_LDKEffectiveCapacity_ty_from_ptr(uint64_t ptr) {
14394 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14396 case LDKEffectiveCapacity_ExactLiquidity: return 0;
14397 case LDKEffectiveCapacity_AdvertisedMaxHTLC: return 1;
14398 case LDKEffectiveCapacity_Total: return 2;
14399 case LDKEffectiveCapacity_Infinite: return 3;
14400 case LDKEffectiveCapacity_HintMaxHTLC: return 4;
14401 case LDKEffectiveCapacity_Unknown: return 5;
14405 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat"))) TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(uint64_t ptr) {
14406 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14407 assert(obj->tag == LDKEffectiveCapacity_ExactLiquidity);
14408 int64_t liquidity_msat_conv = obj->exact_liquidity.liquidity_msat;
14409 return liquidity_msat_conv;
14411 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_AdvertisedMaxHTLC_get_amount_msat(uint64_t ptr) {
14412 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14413 assert(obj->tag == LDKEffectiveCapacity_AdvertisedMaxHTLC);
14414 int64_t amount_msat_conv = obj->advertised_max_htlc.amount_msat;
14415 return amount_msat_conv;
14417 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_capacity_msat"))) TS_LDKEffectiveCapacity_Total_get_capacity_msat(uint64_t ptr) {
14418 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14419 assert(obj->tag == LDKEffectiveCapacity_Total);
14420 int64_t capacity_msat_conv = obj->total.capacity_msat;
14421 return capacity_msat_conv;
14423 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat"))) TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(uint64_t ptr) {
14424 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14425 assert(obj->tag == LDKEffectiveCapacity_Total);
14426 int64_t htlc_maximum_msat_conv = obj->total.htlc_maximum_msat;
14427 return htlc_maximum_msat_conv;
14429 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_HintMaxHTLC_get_amount_msat(uint64_t ptr) {
14430 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)untag_ptr(ptr);
14431 assert(obj->tag == LDKEffectiveCapacity_HintMaxHTLC);
14432 int64_t amount_msat_conv = obj->hint_max_htlc.amount_msat;
14433 return amount_msat_conv;
14435 uint32_t __attribute__((export_name("TS_LDKPayee_ty_from_ptr"))) TS_LDKPayee_ty_from_ptr(uint64_t ptr) {
14436 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14438 case LDKPayee_Blinded: return 0;
14439 case LDKPayee_Clear: return 1;
14443 uint64_tArray __attribute__((export_name("TS_LDKPayee_Blinded_get_route_hints"))) TS_LDKPayee_Blinded_get_route_hints(uint64_t ptr) {
14444 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14445 assert(obj->tag == LDKPayee_Blinded);
14446 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints_var = obj->blinded.route_hints;
14447 uint64_tArray route_hints_arr = NULL;
14448 route_hints_arr = init_uint64_tArray(route_hints_var.datalen, __LINE__);
14449 uint64_t *route_hints_arr_ptr = (uint64_t*)(((uint8_t*)route_hints_arr) + 8);
14450 for (size_t l = 0; l < route_hints_var.datalen; l++) {
14451 LDKC2Tuple_BlindedPayInfoBlindedPathZ* route_hints_conv_37_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
14452 *route_hints_conv_37_conv = route_hints_var.data[l];
14453 *route_hints_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(route_hints_conv_37_conv);
14454 route_hints_arr_ptr[l] = tag_ptr(route_hints_conv_37_conv, true);
14457 return route_hints_arr;
14459 uint64_t __attribute__((export_name("TS_LDKPayee_Blinded_get_features"))) TS_LDKPayee_Blinded_get_features(uint64_t ptr) {
14460 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14461 assert(obj->tag == LDKPayee_Blinded);
14462 LDKBolt12InvoiceFeatures features_var = obj->blinded.features;
14463 uint64_t features_ref = 0;
14464 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_var);
14465 features_ref = tag_ptr(features_var.inner, false);
14466 return features_ref;
14468 int8_tArray __attribute__((export_name("TS_LDKPayee_Clear_get_node_id"))) TS_LDKPayee_Clear_get_node_id(uint64_t ptr) {
14469 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14470 assert(obj->tag == LDKPayee_Clear);
14471 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
14472 memcpy(node_id_arr->elems, obj->clear.node_id.compressed_form, 33);
14473 return node_id_arr;
14475 uint64_tArray __attribute__((export_name("TS_LDKPayee_Clear_get_route_hints"))) TS_LDKPayee_Clear_get_route_hints(uint64_t ptr) {
14476 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14477 assert(obj->tag == LDKPayee_Clear);
14478 LDKCVec_RouteHintZ route_hints_var = obj->clear.route_hints;
14479 uint64_tArray route_hints_arr = NULL;
14480 route_hints_arr = init_uint64_tArray(route_hints_var.datalen, __LINE__);
14481 uint64_t *route_hints_arr_ptr = (uint64_t*)(((uint8_t*)route_hints_arr) + 8);
14482 for (size_t l = 0; l < route_hints_var.datalen; l++) {
14483 LDKRouteHint route_hints_conv_11_var = route_hints_var.data[l];
14484 uint64_t route_hints_conv_11_ref = 0;
14485 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_conv_11_var);
14486 route_hints_conv_11_ref = tag_ptr(route_hints_conv_11_var.inner, false);
14487 route_hints_arr_ptr[l] = route_hints_conv_11_ref;
14490 return route_hints_arr;
14492 uint64_t __attribute__((export_name("TS_LDKPayee_Clear_get_features"))) TS_LDKPayee_Clear_get_features(uint64_t ptr) {
14493 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14494 assert(obj->tag == LDKPayee_Clear);
14495 LDKBolt11InvoiceFeatures features_var = obj->clear.features;
14496 uint64_t features_ref = 0;
14497 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_var);
14498 features_ref = tag_ptr(features_var.inner, false);
14499 return features_ref;
14501 int32_t __attribute__((export_name("TS_LDKPayee_Clear_get_final_cltv_expiry_delta"))) TS_LDKPayee_Clear_get_final_cltv_expiry_delta(uint64_t ptr) {
14502 LDKPayee *obj = (LDKPayee*)untag_ptr(ptr);
14503 assert(obj->tag == LDKPayee_Clear);
14504 int32_t final_cltv_expiry_delta_conv = obj->clear.final_cltv_expiry_delta;
14505 return final_cltv_expiry_delta_conv;
14507 typedef struct LDKScore_JCalls {
14508 atomic_size_t refcnt;
14509 uint32_t instance_ptr;
14510 LDKScoreLookUp_JCalls* ScoreLookUp;
14511 LDKScoreUpdate_JCalls* ScoreUpdate;
14513 static void LDKScore_JCalls_free(void* this_arg) {
14514 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
14515 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14519 LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
14520 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
14521 int8_tArray ret = (int8_tArray)js_invoke_function_uuuuuu(j_calls->instance_ptr, 138, 0, 0, 0, 0, 0, 0);
14522 LDKCVec_u8Z ret_ref;
14523 ret_ref.datalen = ret->arr_len;
14524 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
14525 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
14528 static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
14529 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
14530 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14531 atomic_fetch_add_explicit(&j_calls->ScoreLookUp->refcnt, 1, memory_order_release);
14532 atomic_fetch_add_explicit(&j_calls->ScoreUpdate->refcnt, 1, memory_order_release);
14534 static inline LDKScore LDKScore_init (JSValue o, JSValue ScoreLookUp, JSValue ScoreUpdate) {
14535 LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
14536 atomic_init(&calls->refcnt, 1);
14537 calls->instance_ptr = o;
14540 .this_arg = (void*) calls,
14541 .write = write_LDKScore_jcall,
14542 .free = LDKScore_JCalls_free,
14543 .ScoreLookUp = LDKScoreLookUp_init(ScoreLookUp),
14544 .ScoreUpdate = LDKScoreUpdate_init(ScoreUpdate),
14546 calls->ScoreLookUp = ret.ScoreLookUp.this_arg;
14547 calls->ScoreUpdate = ret.ScoreUpdate.this_arg;
14550 uint64_t __attribute__((export_name("TS_LDKScore_new"))) TS_LDKScore_new(JSValue o, JSValue ScoreLookUp, JSValue ScoreUpdate) {
14551 LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
14552 *res_ptr = LDKScore_init(o, ScoreLookUp, ScoreUpdate);
14553 return tag_ptr(res_ptr, true);
14555 int8_tArray __attribute__((export_name("TS_Score_write"))) TS_Score_write(uint64_t this_arg) {
14556 void* this_arg_ptr = untag_ptr(this_arg);
14557 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14558 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
14559 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
14560 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
14561 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
14562 CVec_u8Z_free(ret_var);
14566 uint32_t __attribute__((export_name("TS_LDKDestination_ty_from_ptr"))) TS_LDKDestination_ty_from_ptr(uint64_t ptr) {
14567 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
14569 case LDKDestination_Node: return 0;
14570 case LDKDestination_BlindedPath: return 1;
14574 int8_tArray __attribute__((export_name("TS_LDKDestination_Node_get_node"))) TS_LDKDestination_Node_get_node(uint64_t ptr) {
14575 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
14576 assert(obj->tag == LDKDestination_Node);
14577 int8_tArray node_arr = init_int8_tArray(33, __LINE__);
14578 memcpy(node_arr->elems, obj->node.compressed_form, 33);
14581 uint64_t __attribute__((export_name("TS_LDKDestination_BlindedPath_get_blinded_path"))) TS_LDKDestination_BlindedPath_get_blinded_path(uint64_t ptr) {
14582 LDKDestination *obj = (LDKDestination*)untag_ptr(ptr);
14583 assert(obj->tag == LDKDestination_BlindedPath);
14584 LDKBlindedPath blinded_path_var = obj->blinded_path;
14585 uint64_t blinded_path_ref = 0;
14586 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_path_var);
14587 blinded_path_ref = tag_ptr(blinded_path_var.inner, false);
14588 return blinded_path_ref;
14590 typedef struct LDKMessageRouter_JCalls {
14591 atomic_size_t refcnt;
14592 uint32_t instance_ptr;
14593 } LDKMessageRouter_JCalls;
14594 static void LDKMessageRouter_JCalls_free(void* this_arg) {
14595 LDKMessageRouter_JCalls *j_calls = (LDKMessageRouter_JCalls*) this_arg;
14596 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14600 LDKCResult_OnionMessagePathNoneZ find_path_LDKMessageRouter_jcall(const void* this_arg, LDKPublicKey sender, LDKCVec_PublicKeyZ peers, LDKDestination destination) {
14601 LDKMessageRouter_JCalls *j_calls = (LDKMessageRouter_JCalls*) this_arg;
14602 int8_tArray sender_arr = init_int8_tArray(33, __LINE__);
14603 memcpy(sender_arr->elems, sender.compressed_form, 33);
14604 LDKCVec_PublicKeyZ peers_var = peers;
14605 ptrArray peers_arr = NULL;
14606 peers_arr = init_ptrArray(peers_var.datalen, __LINE__);
14607 int8_tArray *peers_arr_ptr = (int8_tArray*)(((uint8_t*)peers_arr) + 8);
14608 for (size_t m = 0; m < peers_var.datalen; m++) {
14609 int8_tArray peers_conv_12_arr = init_int8_tArray(33, __LINE__);
14610 memcpy(peers_conv_12_arr->elems, peers_var.data[m].compressed_form, 33);
14611 peers_arr_ptr[m] = peers_conv_12_arr;
14614 FREE(peers_var.data);
14615 LDKDestination *destination_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
14616 *destination_copy = destination;
14617 uint64_t destination_ref = tag_ptr(destination_copy, true);
14618 uint64_t ret = js_invoke_function_uubuuu(j_calls->instance_ptr, 139, (uint32_t)sender_arr, (uint32_t)peers_arr, destination_ref, 0, 0, 0);
14619 void* ret_ptr = untag_ptr(ret);
14620 CHECK_ACCESS(ret_ptr);
14621 LDKCResult_OnionMessagePathNoneZ ret_conv = *(LDKCResult_OnionMessagePathNoneZ*)(ret_ptr);
14622 FREE(untag_ptr(ret));
14625 static void LDKMessageRouter_JCalls_cloned(LDKMessageRouter* new_obj) {
14626 LDKMessageRouter_JCalls *j_calls = (LDKMessageRouter_JCalls*) new_obj->this_arg;
14627 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14629 static inline LDKMessageRouter LDKMessageRouter_init (JSValue o) {
14630 LDKMessageRouter_JCalls *calls = MALLOC(sizeof(LDKMessageRouter_JCalls), "LDKMessageRouter_JCalls");
14631 atomic_init(&calls->refcnt, 1);
14632 calls->instance_ptr = o;
14634 LDKMessageRouter ret = {
14635 .this_arg = (void*) calls,
14636 .find_path = find_path_LDKMessageRouter_jcall,
14637 .free = LDKMessageRouter_JCalls_free,
14641 uint64_t __attribute__((export_name("TS_LDKMessageRouter_new"))) TS_LDKMessageRouter_new(JSValue o) {
14642 LDKMessageRouter *res_ptr = MALLOC(sizeof(LDKMessageRouter), "LDKMessageRouter");
14643 *res_ptr = LDKMessageRouter_init(o);
14644 return tag_ptr(res_ptr, true);
14646 uint64_t __attribute__((export_name("TS_MessageRouter_find_path"))) TS_MessageRouter_find_path(uint64_t this_arg, int8_tArray sender, ptrArray peers, uint64_t destination) {
14647 void* this_arg_ptr = untag_ptr(this_arg);
14648 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14649 LDKMessageRouter* this_arg_conv = (LDKMessageRouter*)this_arg_ptr;
14650 LDKPublicKey sender_ref;
14651 CHECK(sender->arr_len == 33);
14652 memcpy(sender_ref.compressed_form, sender->elems, 33); FREE(sender);
14653 LDKCVec_PublicKeyZ peers_constr;
14654 peers_constr.datalen = peers->arr_len;
14655 if (peers_constr.datalen > 0)
14656 peers_constr.data = MALLOC(peers_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
14658 peers_constr.data = NULL;
14659 int8_tArray* peers_vals = (void*) peers->elems;
14660 for (size_t m = 0; m < peers_constr.datalen; m++) {
14661 int8_tArray peers_conv_12 = peers_vals[m];
14662 LDKPublicKey peers_conv_12_ref;
14663 CHECK(peers_conv_12->arr_len == 33);
14664 memcpy(peers_conv_12_ref.compressed_form, peers_conv_12->elems, 33); FREE(peers_conv_12);
14665 peers_constr.data[m] = peers_conv_12_ref;
14668 void* destination_ptr = untag_ptr(destination);
14669 CHECK_ACCESS(destination_ptr);
14670 LDKDestination destination_conv = *(LDKDestination*)(destination_ptr);
14671 destination_conv = Destination_clone((LDKDestination*)untag_ptr(destination));
14672 LDKCResult_OnionMessagePathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessagePathNoneZ), "LDKCResult_OnionMessagePathNoneZ");
14673 *ret_conv = (this_arg_conv->find_path)(this_arg_conv->this_arg, sender_ref, peers_constr, destination_conv);
14674 return tag_ptr(ret_conv, true);
14677 uint32_t __attribute__((export_name("TS_LDKOnionMessageContents_ty_from_ptr"))) TS_LDKOnionMessageContents_ty_from_ptr(uint64_t ptr) {
14678 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
14680 case LDKOnionMessageContents_Offers: return 0;
14681 case LDKOnionMessageContents_Custom: return 1;
14685 uint64_t __attribute__((export_name("TS_LDKOnionMessageContents_Offers_get_offers"))) TS_LDKOnionMessageContents_Offers_get_offers(uint64_t ptr) {
14686 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
14687 assert(obj->tag == LDKOnionMessageContents_Offers);
14688 uint64_t offers_ref = tag_ptr(&obj->offers, false);
14691 uint64_t __attribute__((export_name("TS_LDKOnionMessageContents_Custom_get_custom"))) TS_LDKOnionMessageContents_Custom_get_custom(uint64_t ptr) {
14692 LDKOnionMessageContents *obj = (LDKOnionMessageContents*)untag_ptr(ptr);
14693 assert(obj->tag == LDKOnionMessageContents_Custom);
14694 LDKCustomOnionMessageContents* custom_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
14695 *custom_ret = CustomOnionMessageContents_clone(&obj->custom);
14696 return tag_ptr(custom_ret, true);
14698 typedef struct LDKCoinSelectionSource_JCalls {
14699 atomic_size_t refcnt;
14700 uint32_t instance_ptr;
14701 } LDKCoinSelectionSource_JCalls;
14702 static void LDKCoinSelectionSource_JCalls_free(void* this_arg) {
14703 LDKCoinSelectionSource_JCalls *j_calls = (LDKCoinSelectionSource_JCalls*) this_arg;
14704 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14708 LDKCResult_CoinSelectionNoneZ select_confirmed_utxos_LDKCoinSelectionSource_jcall(const void* this_arg, LDKThirtyTwoBytes claim_id, LDKCVec_InputZ must_spend, LDKCVec_TxOutZ must_pay_to, uint32_t target_feerate_sat_per_1000_weight) {
14709 LDKCoinSelectionSource_JCalls *j_calls = (LDKCoinSelectionSource_JCalls*) this_arg;
14710 int8_tArray claim_id_arr = init_int8_tArray(32, __LINE__);
14711 memcpy(claim_id_arr->elems, claim_id.data, 32);
14712 LDKCVec_InputZ must_spend_var = must_spend;
14713 uint64_tArray must_spend_arr = NULL;
14714 must_spend_arr = init_uint64_tArray(must_spend_var.datalen, __LINE__);
14715 uint64_t *must_spend_arr_ptr = (uint64_t*)(((uint8_t*)must_spend_arr) + 8);
14716 for (size_t h = 0; h < must_spend_var.datalen; h++) {
14717 LDKInput must_spend_conv_7_var = must_spend_var.data[h];
14718 uint64_t must_spend_conv_7_ref = 0;
14719 CHECK_INNER_FIELD_ACCESS_OR_NULL(must_spend_conv_7_var);
14720 must_spend_conv_7_ref = tag_ptr(must_spend_conv_7_var.inner, must_spend_conv_7_var.is_owned);
14721 must_spend_arr_ptr[h] = must_spend_conv_7_ref;
14724 FREE(must_spend_var.data);
14725 LDKCVec_TxOutZ must_pay_to_var = must_pay_to;
14726 uint64_tArray must_pay_to_arr = NULL;
14727 must_pay_to_arr = init_uint64_tArray(must_pay_to_var.datalen, __LINE__);
14728 uint64_t *must_pay_to_arr_ptr = (uint64_t*)(((uint8_t*)must_pay_to_arr) + 8);
14729 for (size_t h = 0; h < must_pay_to_var.datalen; h++) {
14730 LDKTxOut* must_pay_to_conv_7_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
14731 *must_pay_to_conv_7_ref = must_pay_to_var.data[h];
14732 must_pay_to_arr_ptr[h] = tag_ptr(must_pay_to_conv_7_ref, true);
14735 FREE(must_pay_to_var.data);
14736 int32_t target_feerate_sat_per_1000_weight_conv = target_feerate_sat_per_1000_weight;
14737 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 140, (uint32_t)claim_id_arr, (uint32_t)must_spend_arr, (uint32_t)must_pay_to_arr, target_feerate_sat_per_1000_weight_conv, 0, 0);
14738 void* ret_ptr = untag_ptr(ret);
14739 CHECK_ACCESS(ret_ptr);
14740 LDKCResult_CoinSelectionNoneZ ret_conv = *(LDKCResult_CoinSelectionNoneZ*)(ret_ptr);
14741 FREE(untag_ptr(ret));
14744 LDKCResult_TransactionNoneZ sign_tx_LDKCoinSelectionSource_jcall(const void* this_arg, LDKTransaction tx) {
14745 LDKCoinSelectionSource_JCalls *j_calls = (LDKCoinSelectionSource_JCalls*) this_arg;
14746 LDKTransaction tx_var = tx;
14747 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
14748 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
14749 Transaction_free(tx_var);
14750 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 141, (uint32_t)tx_arr, 0, 0, 0, 0, 0);
14751 void* ret_ptr = untag_ptr(ret);
14752 CHECK_ACCESS(ret_ptr);
14753 LDKCResult_TransactionNoneZ ret_conv = *(LDKCResult_TransactionNoneZ*)(ret_ptr);
14754 FREE(untag_ptr(ret));
14757 static void LDKCoinSelectionSource_JCalls_cloned(LDKCoinSelectionSource* new_obj) {
14758 LDKCoinSelectionSource_JCalls *j_calls = (LDKCoinSelectionSource_JCalls*) new_obj->this_arg;
14759 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14761 static inline LDKCoinSelectionSource LDKCoinSelectionSource_init (JSValue o) {
14762 LDKCoinSelectionSource_JCalls *calls = MALLOC(sizeof(LDKCoinSelectionSource_JCalls), "LDKCoinSelectionSource_JCalls");
14763 atomic_init(&calls->refcnt, 1);
14764 calls->instance_ptr = o;
14766 LDKCoinSelectionSource ret = {
14767 .this_arg = (void*) calls,
14768 .select_confirmed_utxos = select_confirmed_utxos_LDKCoinSelectionSource_jcall,
14769 .sign_tx = sign_tx_LDKCoinSelectionSource_jcall,
14770 .free = LDKCoinSelectionSource_JCalls_free,
14774 uint64_t __attribute__((export_name("TS_LDKCoinSelectionSource_new"))) TS_LDKCoinSelectionSource_new(JSValue o) {
14775 LDKCoinSelectionSource *res_ptr = MALLOC(sizeof(LDKCoinSelectionSource), "LDKCoinSelectionSource");
14776 *res_ptr = LDKCoinSelectionSource_init(o);
14777 return tag_ptr(res_ptr, true);
14779 uint64_t __attribute__((export_name("TS_CoinSelectionSource_select_confirmed_utxos"))) TS_CoinSelectionSource_select_confirmed_utxos(uint64_t this_arg, int8_tArray claim_id, uint64_tArray must_spend, uint64_tArray must_pay_to, int32_t target_feerate_sat_per_1000_weight) {
14780 void* this_arg_ptr = untag_ptr(this_arg);
14781 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14782 LDKCoinSelectionSource* this_arg_conv = (LDKCoinSelectionSource*)this_arg_ptr;
14783 LDKThirtyTwoBytes claim_id_ref;
14784 CHECK(claim_id->arr_len == 32);
14785 memcpy(claim_id_ref.data, claim_id->elems, 32); FREE(claim_id);
14786 LDKCVec_InputZ must_spend_constr;
14787 must_spend_constr.datalen = must_spend->arr_len;
14788 if (must_spend_constr.datalen > 0)
14789 must_spend_constr.data = MALLOC(must_spend_constr.datalen * sizeof(LDKInput), "LDKCVec_InputZ Elements");
14791 must_spend_constr.data = NULL;
14792 uint64_t* must_spend_vals = must_spend->elems;
14793 for (size_t h = 0; h < must_spend_constr.datalen; h++) {
14794 uint64_t must_spend_conv_7 = must_spend_vals[h];
14795 LDKInput must_spend_conv_7_conv;
14796 must_spend_conv_7_conv.inner = untag_ptr(must_spend_conv_7);
14797 must_spend_conv_7_conv.is_owned = ptr_is_owned(must_spend_conv_7);
14798 CHECK_INNER_FIELD_ACCESS_OR_NULL(must_spend_conv_7_conv);
14799 must_spend_conv_7_conv = Input_clone(&must_spend_conv_7_conv);
14800 must_spend_constr.data[h] = must_spend_conv_7_conv;
14803 LDKCVec_TxOutZ must_pay_to_constr;
14804 must_pay_to_constr.datalen = must_pay_to->arr_len;
14805 if (must_pay_to_constr.datalen > 0)
14806 must_pay_to_constr.data = MALLOC(must_pay_to_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
14808 must_pay_to_constr.data = NULL;
14809 uint64_t* must_pay_to_vals = must_pay_to->elems;
14810 for (size_t h = 0; h < must_pay_to_constr.datalen; h++) {
14811 uint64_t must_pay_to_conv_7 = must_pay_to_vals[h];
14812 void* must_pay_to_conv_7_ptr = untag_ptr(must_pay_to_conv_7);
14813 CHECK_ACCESS(must_pay_to_conv_7_ptr);
14814 LDKTxOut must_pay_to_conv_7_conv = *(LDKTxOut*)(must_pay_to_conv_7_ptr);
14815 must_pay_to_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(must_pay_to_conv_7));
14816 must_pay_to_constr.data[h] = must_pay_to_conv_7_conv;
14819 LDKCResult_CoinSelectionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CoinSelectionNoneZ), "LDKCResult_CoinSelectionNoneZ");
14820 *ret_conv = (this_arg_conv->select_confirmed_utxos)(this_arg_conv->this_arg, claim_id_ref, must_spend_constr, must_pay_to_constr, target_feerate_sat_per_1000_weight);
14821 return tag_ptr(ret_conv, true);
14824 uint64_t __attribute__((export_name("TS_CoinSelectionSource_sign_tx"))) TS_CoinSelectionSource_sign_tx(uint64_t this_arg, int8_tArray tx) {
14825 void* this_arg_ptr = untag_ptr(this_arg);
14826 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14827 LDKCoinSelectionSource* this_arg_conv = (LDKCoinSelectionSource*)this_arg_ptr;
14828 LDKTransaction tx_ref;
14829 tx_ref.datalen = tx->arr_len;
14830 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
14831 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
14832 tx_ref.data_is_owned = true;
14833 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
14834 *ret_conv = (this_arg_conv->sign_tx)(this_arg_conv->this_arg, tx_ref);
14835 return tag_ptr(ret_conv, true);
14838 typedef struct LDKWalletSource_JCalls {
14839 atomic_size_t refcnt;
14840 uint32_t instance_ptr;
14841 } LDKWalletSource_JCalls;
14842 static void LDKWalletSource_JCalls_free(void* this_arg) {
14843 LDKWalletSource_JCalls *j_calls = (LDKWalletSource_JCalls*) this_arg;
14844 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
14848 LDKCResult_CVec_UtxoZNoneZ list_confirmed_utxos_LDKWalletSource_jcall(const void* this_arg) {
14849 LDKWalletSource_JCalls *j_calls = (LDKWalletSource_JCalls*) this_arg;
14850 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 142, 0, 0, 0, 0, 0, 0);
14851 void* ret_ptr = untag_ptr(ret);
14852 CHECK_ACCESS(ret_ptr);
14853 LDKCResult_CVec_UtxoZNoneZ ret_conv = *(LDKCResult_CVec_UtxoZNoneZ*)(ret_ptr);
14854 FREE(untag_ptr(ret));
14857 LDKCResult_CVec_u8ZNoneZ get_change_script_LDKWalletSource_jcall(const void* this_arg) {
14858 LDKWalletSource_JCalls *j_calls = (LDKWalletSource_JCalls*) this_arg;
14859 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 143, 0, 0, 0, 0, 0, 0);
14860 void* ret_ptr = untag_ptr(ret);
14861 CHECK_ACCESS(ret_ptr);
14862 LDKCResult_CVec_u8ZNoneZ ret_conv = *(LDKCResult_CVec_u8ZNoneZ*)(ret_ptr);
14863 FREE(untag_ptr(ret));
14866 LDKCResult_TransactionNoneZ sign_tx_LDKWalletSource_jcall(const void* this_arg, LDKTransaction tx) {
14867 LDKWalletSource_JCalls *j_calls = (LDKWalletSource_JCalls*) this_arg;
14868 LDKTransaction tx_var = tx;
14869 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
14870 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
14871 Transaction_free(tx_var);
14872 uint64_t ret = js_invoke_function_uuuuuu(j_calls->instance_ptr, 144, (uint32_t)tx_arr, 0, 0, 0, 0, 0);
14873 void* ret_ptr = untag_ptr(ret);
14874 CHECK_ACCESS(ret_ptr);
14875 LDKCResult_TransactionNoneZ ret_conv = *(LDKCResult_TransactionNoneZ*)(ret_ptr);
14876 FREE(untag_ptr(ret));
14879 static void LDKWalletSource_JCalls_cloned(LDKWalletSource* new_obj) {
14880 LDKWalletSource_JCalls *j_calls = (LDKWalletSource_JCalls*) new_obj->this_arg;
14881 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
14883 static inline LDKWalletSource LDKWalletSource_init (JSValue o) {
14884 LDKWalletSource_JCalls *calls = MALLOC(sizeof(LDKWalletSource_JCalls), "LDKWalletSource_JCalls");
14885 atomic_init(&calls->refcnt, 1);
14886 calls->instance_ptr = o;
14888 LDKWalletSource ret = {
14889 .this_arg = (void*) calls,
14890 .list_confirmed_utxos = list_confirmed_utxos_LDKWalletSource_jcall,
14891 .get_change_script = get_change_script_LDKWalletSource_jcall,
14892 .sign_tx = sign_tx_LDKWalletSource_jcall,
14893 .free = LDKWalletSource_JCalls_free,
14897 uint64_t __attribute__((export_name("TS_LDKWalletSource_new"))) TS_LDKWalletSource_new(JSValue o) {
14898 LDKWalletSource *res_ptr = MALLOC(sizeof(LDKWalletSource), "LDKWalletSource");
14899 *res_ptr = LDKWalletSource_init(o);
14900 return tag_ptr(res_ptr, true);
14902 uint64_t __attribute__((export_name("TS_WalletSource_list_confirmed_utxos"))) TS_WalletSource_list_confirmed_utxos(uint64_t this_arg) {
14903 void* this_arg_ptr = untag_ptr(this_arg);
14904 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14905 LDKWalletSource* this_arg_conv = (LDKWalletSource*)this_arg_ptr;
14906 LDKCResult_CVec_UtxoZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_UtxoZNoneZ), "LDKCResult_CVec_UtxoZNoneZ");
14907 *ret_conv = (this_arg_conv->list_confirmed_utxos)(this_arg_conv->this_arg);
14908 return tag_ptr(ret_conv, true);
14911 uint64_t __attribute__((export_name("TS_WalletSource_get_change_script"))) TS_WalletSource_get_change_script(uint64_t this_arg) {
14912 void* this_arg_ptr = untag_ptr(this_arg);
14913 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14914 LDKWalletSource* this_arg_conv = (LDKWalletSource*)this_arg_ptr;
14915 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
14916 *ret_conv = (this_arg_conv->get_change_script)(this_arg_conv->this_arg);
14917 return tag_ptr(ret_conv, true);
14920 uint64_t __attribute__((export_name("TS_WalletSource_sign_tx"))) TS_WalletSource_sign_tx(uint64_t this_arg, int8_tArray tx) {
14921 void* this_arg_ptr = untag_ptr(this_arg);
14922 if (ptr_is_owned(this_arg)) { CHECK_ACCESS(this_arg_ptr); }
14923 LDKWalletSource* this_arg_conv = (LDKWalletSource*)this_arg_ptr;
14924 LDKTransaction tx_ref;
14925 tx_ref.datalen = tx->arr_len;
14926 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
14927 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
14928 tx_ref.data_is_owned = true;
14929 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
14930 *ret_conv = (this_arg_conv->sign_tx)(this_arg_conv->this_arg, tx_ref);
14931 return tag_ptr(ret_conv, true);
14934 uint32_t __attribute__((export_name("TS_LDKGossipSync_ty_from_ptr"))) TS_LDKGossipSync_ty_from_ptr(uint64_t ptr) {
14935 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
14937 case LDKGossipSync_P2P: return 0;
14938 case LDKGossipSync_Rapid: return 1;
14939 case LDKGossipSync_None: return 2;
14943 uint64_t __attribute__((export_name("TS_LDKGossipSync_P2P_get_p2p"))) TS_LDKGossipSync_P2P_get_p2p(uint64_t ptr) {
14944 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
14945 assert(obj->tag == LDKGossipSync_P2P);
14946 LDKP2PGossipSync p2p_var = obj->p2p;
14947 uint64_t p2p_ref = 0;
14948 CHECK_INNER_FIELD_ACCESS_OR_NULL(p2p_var);
14949 p2p_ref = tag_ptr(p2p_var.inner, false);
14952 uint64_t __attribute__((export_name("TS_LDKGossipSync_Rapid_get_rapid"))) TS_LDKGossipSync_Rapid_get_rapid(uint64_t ptr) {
14953 LDKGossipSync *obj = (LDKGossipSync*)untag_ptr(ptr);
14954 assert(obj->tag == LDKGossipSync_Rapid);
14955 LDKRapidGossipSync rapid_var = obj->rapid;
14956 uint64_t rapid_ref = 0;
14957 CHECK_INNER_FIELD_ACCESS_OR_NULL(rapid_var);
14958 rapid_ref = tag_ptr(rapid_var.inner, false);
14961 uint32_t __attribute__((export_name("TS_LDKFallback_ty_from_ptr"))) TS_LDKFallback_ty_from_ptr(uint64_t ptr) {
14962 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
14964 case LDKFallback_SegWitProgram: return 0;
14965 case LDKFallback_PubKeyHash: return 1;
14966 case LDKFallback_ScriptHash: return 2;
14970 int8_t __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_version"))) TS_LDKFallback_SegWitProgram_get_version(uint64_t ptr) {
14971 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
14972 assert(obj->tag == LDKFallback_SegWitProgram);
14973 uint8_t version_val = obj->seg_wit_program.version._0;
14974 return version_val;
14976 int8_tArray __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_program"))) TS_LDKFallback_SegWitProgram_get_program(uint64_t ptr) {
14977 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
14978 assert(obj->tag == LDKFallback_SegWitProgram);
14979 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
14980 int8_tArray program_arr = init_int8_tArray(program_var.datalen, __LINE__);
14981 memcpy(program_arr->elems, program_var.data, program_var.datalen);
14982 return program_arr;
14984 int8_tArray __attribute__((export_name("TS_LDKFallback_PubKeyHash_get_pub_key_hash"))) TS_LDKFallback_PubKeyHash_get_pub_key_hash(uint64_t ptr) {
14985 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
14986 assert(obj->tag == LDKFallback_PubKeyHash);
14987 int8_tArray pub_key_hash_arr = init_int8_tArray(20, __LINE__);
14988 memcpy(pub_key_hash_arr->elems, obj->pub_key_hash.data, 20);
14989 return pub_key_hash_arr;
14991 int8_tArray __attribute__((export_name("TS_LDKFallback_ScriptHash_get_script_hash"))) TS_LDKFallback_ScriptHash_get_script_hash(uint64_t ptr) {
14992 LDKFallback *obj = (LDKFallback*)untag_ptr(ptr);
14993 assert(obj->tag == LDKFallback_ScriptHash);
14994 int8_tArray script_hash_arr = init_int8_tArray(20, __LINE__);
14995 memcpy(script_hash_arr->elems, obj->script_hash.data, 20);
14996 return script_hash_arr;
14998 jstring __attribute__((export_name("TS__ldk_get_compiled_version"))) TS__ldk_get_compiled_version() {
14999 LDKStr ret_str = _ldk_get_compiled_version();
15000 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
15005 jstring __attribute__((export_name("TS__ldk_c_bindings_get_compiled_version"))) TS__ldk_c_bindings_get_compiled_version() {
15006 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
15007 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
15012 int8_tArray __attribute__((export_name("TS_U128_le_bytes"))) TS_U128_le_bytes(int8_tArray val) {
15014 CHECK(val->arr_len == 16);
15015 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
15016 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
15017 memcpy(ret_arr->elems, U128_le_bytes(val_ref).data, 16);
15021 int8_tArray __attribute__((export_name("TS_U128_new"))) TS_U128_new(int8_tArray le_bytes) {
15022 LDKSixteenBytes le_bytes_ref;
15023 CHECK(le_bytes->arr_len == 16);
15024 memcpy(le_bytes_ref.data, le_bytes->elems, 16); FREE(le_bytes);
15025 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
15026 memcpy(ret_arr->elems, U128_new(le_bytes_ref).le_bytes, 16);
15030 uint64_t __attribute__((export_name("TS_BigEndianScalar_new"))) TS_BigEndianScalar_new(int8_tArray big_endian_bytes) {
15031 LDKThirtyTwoBytes big_endian_bytes_ref;
15032 CHECK(big_endian_bytes->arr_len == 32);
15033 memcpy(big_endian_bytes_ref.data, big_endian_bytes->elems, 32); FREE(big_endian_bytes);
15034 LDKBigEndianScalar* ret_ref = MALLOC(sizeof(LDKBigEndianScalar), "LDKBigEndianScalar");
15035 *ret_ref = BigEndianScalar_new(big_endian_bytes_ref);
15036 return tag_ptr(ret_ref, true);
15039 static inline uint64_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
15040 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
15041 *ret_copy = Bech32Error_clone(arg);
15042 uint64_t ret_ref = tag_ptr(ret_copy, true);
15045 int64_t __attribute__((export_name("TS_Bech32Error_clone_ptr"))) TS_Bech32Error_clone_ptr(uint64_t arg) {
15046 LDKBech32Error* arg_conv = (LDKBech32Error*)untag_ptr(arg);
15047 int64_t ret_conv = Bech32Error_clone_ptr(arg_conv);
15051 uint64_t __attribute__((export_name("TS_Bech32Error_clone"))) TS_Bech32Error_clone(uint64_t orig) {
15052 LDKBech32Error* orig_conv = (LDKBech32Error*)untag_ptr(orig);
15053 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
15054 *ret_copy = Bech32Error_clone(orig_conv);
15055 uint64_t ret_ref = tag_ptr(ret_copy, true);
15059 void __attribute__((export_name("TS_Bech32Error_free"))) TS_Bech32Error_free(uint64_t o) {
15060 if (!ptr_is_owned(o)) return;
15061 void* o_ptr = untag_ptr(o);
15062 CHECK_ACCESS(o_ptr);
15063 LDKBech32Error o_conv = *(LDKBech32Error*)(o_ptr);
15064 FREE(untag_ptr(o));
15065 Bech32Error_free(o_conv);
15068 void __attribute__((export_name("TS_Transaction_free"))) TS_Transaction_free(int8_tArray _res) {
15069 LDKTransaction _res_ref;
15070 _res_ref.datalen = _res->arr_len;
15071 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
15072 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
15073 _res_ref.data_is_owned = true;
15074 Transaction_free(_res_ref);
15077 void __attribute__((export_name("TS_Witness_free"))) TS_Witness_free(int8_tArray _res) {
15078 LDKWitness _res_ref;
15079 _res_ref.datalen = _res->arr_len;
15080 _res_ref.data = MALLOC(_res_ref.datalen, "LDKWitness Bytes");
15081 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
15082 _res_ref.data_is_owned = true;
15083 Witness_free(_res_ref);
15086 void __attribute__((export_name("TS_TxIn_free"))) TS_TxIn_free(uint64_t _res) {
15087 if (!ptr_is_owned(_res)) return;
15088 void* _res_ptr = untag_ptr(_res);
15089 CHECK_ACCESS(_res_ptr);
15090 LDKTxIn _res_conv = *(LDKTxIn*)(_res_ptr);
15091 FREE(untag_ptr(_res));
15092 TxIn_free(_res_conv);
15095 uint64_t __attribute__((export_name("TS_TxIn_new"))) TS_TxIn_new(int8_tArray witness, int8_tArray script_sig, int32_t sequence, int8_tArray previous_txid, int32_t previous_vout) {
15096 LDKWitness witness_ref;
15097 witness_ref.datalen = witness->arr_len;
15098 witness_ref.data = MALLOC(witness_ref.datalen, "LDKWitness Bytes");
15099 memcpy(witness_ref.data, witness->elems, witness_ref.datalen); FREE(witness);
15100 witness_ref.data_is_owned = true;
15101 LDKCVec_u8Z script_sig_ref;
15102 script_sig_ref.datalen = script_sig->arr_len;
15103 script_sig_ref.data = MALLOC(script_sig_ref.datalen, "LDKCVec_u8Z Bytes");
15104 memcpy(script_sig_ref.data, script_sig->elems, script_sig_ref.datalen); FREE(script_sig);
15105 LDKThirtyTwoBytes previous_txid_ref;
15106 CHECK(previous_txid->arr_len == 32);
15107 memcpy(previous_txid_ref.data, previous_txid->elems, 32); FREE(previous_txid);
15108 LDKTxIn* ret_ref = MALLOC(sizeof(LDKTxIn), "LDKTxIn");
15109 *ret_ref = TxIn_new(witness_ref, script_sig_ref, sequence, previous_txid_ref, previous_vout);
15110 return tag_ptr(ret_ref, true);
15113 uint64_t __attribute__((export_name("TS_TxOut_new"))) TS_TxOut_new(int8_tArray script_pubkey, int64_t value) {
15114 LDKCVec_u8Z script_pubkey_ref;
15115 script_pubkey_ref.datalen = script_pubkey->arr_len;
15116 script_pubkey_ref.data = MALLOC(script_pubkey_ref.datalen, "LDKCVec_u8Z Bytes");
15117 memcpy(script_pubkey_ref.data, script_pubkey->elems, script_pubkey_ref.datalen); FREE(script_pubkey);
15118 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
15119 *ret_ref = TxOut_new(script_pubkey_ref, value);
15120 return tag_ptr(ret_ref, true);
15123 void __attribute__((export_name("TS_TxOut_free"))) TS_TxOut_free(uint64_t _res) {
15124 if (!ptr_is_owned(_res)) return;
15125 void* _res_ptr = untag_ptr(_res);
15126 CHECK_ACCESS(_res_ptr);
15127 LDKTxOut _res_conv = *(LDKTxOut*)(_res_ptr);
15128 FREE(untag_ptr(_res));
15129 TxOut_free(_res_conv);
15132 static inline uint64_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
15133 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
15134 *ret_ref = TxOut_clone(arg);
15135 return tag_ptr(ret_ref, true);
15137 int64_t __attribute__((export_name("TS_TxOut_clone_ptr"))) TS_TxOut_clone_ptr(uint64_t arg) {
15138 LDKTxOut* arg_conv = (LDKTxOut*)untag_ptr(arg);
15139 int64_t ret_conv = TxOut_clone_ptr(arg_conv);
15143 uint64_t __attribute__((export_name("TS_TxOut_clone"))) TS_TxOut_clone(uint64_t orig) {
15144 LDKTxOut* orig_conv = (LDKTxOut*)untag_ptr(orig);
15145 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
15146 *ret_ref = TxOut_clone(orig_conv);
15147 return tag_ptr(ret_ref, true);
15150 void __attribute__((export_name("TS_Str_free"))) TS_Str_free(jstring _res) {
15151 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
15155 uint64_t __attribute__((export_name("TS_COption_u64Z_some"))) TS_COption_u64Z_some(int64_t o) {
15156 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15157 *ret_copy = COption_u64Z_some(o);
15158 uint64_t ret_ref = tag_ptr(ret_copy, true);
15162 uint64_t __attribute__((export_name("TS_COption_u64Z_none"))) TS_COption_u64Z_none() {
15163 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15164 *ret_copy = COption_u64Z_none();
15165 uint64_t ret_ref = tag_ptr(ret_copy, true);
15169 void __attribute__((export_name("TS_COption_u64Z_free"))) TS_COption_u64Z_free(uint64_t _res) {
15170 if (!ptr_is_owned(_res)) return;
15171 void* _res_ptr = untag_ptr(_res);
15172 CHECK_ACCESS(_res_ptr);
15173 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(_res_ptr);
15174 FREE(untag_ptr(_res));
15175 COption_u64Z_free(_res_conv);
15178 static inline uint64_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
15179 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15180 *ret_copy = COption_u64Z_clone(arg);
15181 uint64_t ret_ref = tag_ptr(ret_copy, true);
15184 int64_t __attribute__((export_name("TS_COption_u64Z_clone_ptr"))) TS_COption_u64Z_clone_ptr(uint64_t arg) {
15185 LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)untag_ptr(arg);
15186 int64_t ret_conv = COption_u64Z_clone_ptr(arg_conv);
15190 uint64_t __attribute__((export_name("TS_COption_u64Z_clone"))) TS_COption_u64Z_clone(uint64_t orig) {
15191 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)untag_ptr(orig);
15192 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
15193 *ret_copy = COption_u64Z_clone(orig_conv);
15194 uint64_t ret_ref = tag_ptr(ret_copy, true);
15198 void __attribute__((export_name("TS_CVec_BlindedPathZ_free"))) TS_CVec_BlindedPathZ_free(uint64_tArray _res) {
15199 LDKCVec_BlindedPathZ _res_constr;
15200 _res_constr.datalen = _res->arr_len;
15201 if (_res_constr.datalen > 0)
15202 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedPath), "LDKCVec_BlindedPathZ Elements");
15204 _res_constr.data = NULL;
15205 uint64_t* _res_vals = _res->elems;
15206 for (size_t n = 0; n < _res_constr.datalen; n++) {
15207 uint64_t _res_conv_13 = _res_vals[n];
15208 LDKBlindedPath _res_conv_13_conv;
15209 _res_conv_13_conv.inner = untag_ptr(_res_conv_13);
15210 _res_conv_13_conv.is_owned = ptr_is_owned(_res_conv_13);
15211 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_13_conv);
15212 _res_constr.data[n] = _res_conv_13_conv;
15215 CVec_BlindedPathZ_free(_res_constr);
15218 uint64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_ok"))) TS_CResult_RefundBolt12ParseErrorZ_ok(uint64_t o) {
15220 o_conv.inner = untag_ptr(o);
15221 o_conv.is_owned = ptr_is_owned(o);
15222 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15223 o_conv = Refund_clone(&o_conv);
15224 LDKCResult_RefundBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RefundBolt12ParseErrorZ), "LDKCResult_RefundBolt12ParseErrorZ");
15225 *ret_conv = CResult_RefundBolt12ParseErrorZ_ok(o_conv);
15226 return tag_ptr(ret_conv, true);
15229 uint64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_err"))) TS_CResult_RefundBolt12ParseErrorZ_err(uint64_t e) {
15230 LDKBolt12ParseError e_conv;
15231 e_conv.inner = untag_ptr(e);
15232 e_conv.is_owned = ptr_is_owned(e);
15233 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15234 e_conv = Bolt12ParseError_clone(&e_conv);
15235 LDKCResult_RefundBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RefundBolt12ParseErrorZ), "LDKCResult_RefundBolt12ParseErrorZ");
15236 *ret_conv = CResult_RefundBolt12ParseErrorZ_err(e_conv);
15237 return tag_ptr(ret_conv, true);
15240 jboolean __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_is_ok"))) TS_CResult_RefundBolt12ParseErrorZ_is_ok(uint64_t o) {
15241 LDKCResult_RefundBolt12ParseErrorZ* o_conv = (LDKCResult_RefundBolt12ParseErrorZ*)untag_ptr(o);
15242 jboolean ret_conv = CResult_RefundBolt12ParseErrorZ_is_ok(o_conv);
15246 void __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_free"))) TS_CResult_RefundBolt12ParseErrorZ_free(uint64_t _res) {
15247 if (!ptr_is_owned(_res)) return;
15248 void* _res_ptr = untag_ptr(_res);
15249 CHECK_ACCESS(_res_ptr);
15250 LDKCResult_RefundBolt12ParseErrorZ _res_conv = *(LDKCResult_RefundBolt12ParseErrorZ*)(_res_ptr);
15251 FREE(untag_ptr(_res));
15252 CResult_RefundBolt12ParseErrorZ_free(_res_conv);
15255 static inline uint64_t CResult_RefundBolt12ParseErrorZ_clone_ptr(LDKCResult_RefundBolt12ParseErrorZ *NONNULL_PTR arg) {
15256 LDKCResult_RefundBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RefundBolt12ParseErrorZ), "LDKCResult_RefundBolt12ParseErrorZ");
15257 *ret_conv = CResult_RefundBolt12ParseErrorZ_clone(arg);
15258 return tag_ptr(ret_conv, true);
15260 int64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_clone_ptr"))) TS_CResult_RefundBolt12ParseErrorZ_clone_ptr(uint64_t arg) {
15261 LDKCResult_RefundBolt12ParseErrorZ* arg_conv = (LDKCResult_RefundBolt12ParseErrorZ*)untag_ptr(arg);
15262 int64_t ret_conv = CResult_RefundBolt12ParseErrorZ_clone_ptr(arg_conv);
15266 uint64_t __attribute__((export_name("TS_CResult_RefundBolt12ParseErrorZ_clone"))) TS_CResult_RefundBolt12ParseErrorZ_clone(uint64_t orig) {
15267 LDKCResult_RefundBolt12ParseErrorZ* orig_conv = (LDKCResult_RefundBolt12ParseErrorZ*)untag_ptr(orig);
15268 LDKCResult_RefundBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RefundBolt12ParseErrorZ), "LDKCResult_RefundBolt12ParseErrorZ");
15269 *ret_conv = CResult_RefundBolt12ParseErrorZ_clone(orig_conv);
15270 return tag_ptr(ret_conv, true);
15273 uint64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_ok"))) TS_CResult_RetryDecodeErrorZ_ok(uint64_t o) {
15274 void* o_ptr = untag_ptr(o);
15275 CHECK_ACCESS(o_ptr);
15276 LDKRetry o_conv = *(LDKRetry*)(o_ptr);
15277 o_conv = Retry_clone((LDKRetry*)untag_ptr(o));
15278 LDKCResult_RetryDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RetryDecodeErrorZ), "LDKCResult_RetryDecodeErrorZ");
15279 *ret_conv = CResult_RetryDecodeErrorZ_ok(o_conv);
15280 return tag_ptr(ret_conv, true);
15283 uint64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_err"))) TS_CResult_RetryDecodeErrorZ_err(uint64_t e) {
15284 void* e_ptr = untag_ptr(e);
15285 CHECK_ACCESS(e_ptr);
15286 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15287 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15288 LDKCResult_RetryDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RetryDecodeErrorZ), "LDKCResult_RetryDecodeErrorZ");
15289 *ret_conv = CResult_RetryDecodeErrorZ_err(e_conv);
15290 return tag_ptr(ret_conv, true);
15293 jboolean __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_is_ok"))) TS_CResult_RetryDecodeErrorZ_is_ok(uint64_t o) {
15294 LDKCResult_RetryDecodeErrorZ* o_conv = (LDKCResult_RetryDecodeErrorZ*)untag_ptr(o);
15295 jboolean ret_conv = CResult_RetryDecodeErrorZ_is_ok(o_conv);
15299 void __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_free"))) TS_CResult_RetryDecodeErrorZ_free(uint64_t _res) {
15300 if (!ptr_is_owned(_res)) return;
15301 void* _res_ptr = untag_ptr(_res);
15302 CHECK_ACCESS(_res_ptr);
15303 LDKCResult_RetryDecodeErrorZ _res_conv = *(LDKCResult_RetryDecodeErrorZ*)(_res_ptr);
15304 FREE(untag_ptr(_res));
15305 CResult_RetryDecodeErrorZ_free(_res_conv);
15308 static inline uint64_t CResult_RetryDecodeErrorZ_clone_ptr(LDKCResult_RetryDecodeErrorZ *NONNULL_PTR arg) {
15309 LDKCResult_RetryDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RetryDecodeErrorZ), "LDKCResult_RetryDecodeErrorZ");
15310 *ret_conv = CResult_RetryDecodeErrorZ_clone(arg);
15311 return tag_ptr(ret_conv, true);
15313 int64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_clone_ptr"))) TS_CResult_RetryDecodeErrorZ_clone_ptr(uint64_t arg) {
15314 LDKCResult_RetryDecodeErrorZ* arg_conv = (LDKCResult_RetryDecodeErrorZ*)untag_ptr(arg);
15315 int64_t ret_conv = CResult_RetryDecodeErrorZ_clone_ptr(arg_conv);
15319 uint64_t __attribute__((export_name("TS_CResult_RetryDecodeErrorZ_clone"))) TS_CResult_RetryDecodeErrorZ_clone(uint64_t orig) {
15320 LDKCResult_RetryDecodeErrorZ* orig_conv = (LDKCResult_RetryDecodeErrorZ*)untag_ptr(orig);
15321 LDKCResult_RetryDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RetryDecodeErrorZ), "LDKCResult_RetryDecodeErrorZ");
15322 *ret_conv = CResult_RetryDecodeErrorZ_clone(orig_conv);
15323 return tag_ptr(ret_conv, true);
15326 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_ok"))) TS_CResult_NoneAPIErrorZ_ok() {
15327 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15328 *ret_conv = CResult_NoneAPIErrorZ_ok();
15329 return tag_ptr(ret_conv, true);
15332 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_err"))) TS_CResult_NoneAPIErrorZ_err(uint64_t e) {
15333 void* e_ptr = untag_ptr(e);
15334 CHECK_ACCESS(e_ptr);
15335 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
15336 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
15337 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15338 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
15339 return tag_ptr(ret_conv, true);
15342 jboolean __attribute__((export_name("TS_CResult_NoneAPIErrorZ_is_ok"))) TS_CResult_NoneAPIErrorZ_is_ok(uint64_t o) {
15343 LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(o);
15344 jboolean ret_conv = CResult_NoneAPIErrorZ_is_ok(o_conv);
15348 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_free"))) TS_CResult_NoneAPIErrorZ_free(uint64_t _res) {
15349 if (!ptr_is_owned(_res)) return;
15350 void* _res_ptr = untag_ptr(_res);
15351 CHECK_ACCESS(_res_ptr);
15352 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
15353 FREE(untag_ptr(_res));
15354 CResult_NoneAPIErrorZ_free(_res_conv);
15357 static inline uint64_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
15358 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15359 *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
15360 return tag_ptr(ret_conv, true);
15362 int64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone_ptr"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint64_t arg) {
15363 LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(arg);
15364 int64_t ret_conv = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
15368 uint64_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone"))) TS_CResult_NoneAPIErrorZ_clone(uint64_t orig) {
15369 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)untag_ptr(orig);
15370 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15371 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
15372 return tag_ptr(ret_conv, true);
15375 void __attribute__((export_name("TS_CVec_CResult_NoneAPIErrorZZ_free"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint64_tArray _res) {
15376 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
15377 _res_constr.datalen = _res->arr_len;
15378 if (_res_constr.datalen > 0)
15379 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
15381 _res_constr.data = NULL;
15382 uint64_t* _res_vals = _res->elems;
15383 for (size_t w = 0; w < _res_constr.datalen; w++) {
15384 uint64_t _res_conv_22 = _res_vals[w];
15385 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
15386 CHECK_ACCESS(_res_conv_22_ptr);
15387 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
15388 FREE(untag_ptr(_res_conv_22));
15389 _res_constr.data[w] = _res_conv_22_conv;
15392 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
15395 void __attribute__((export_name("TS_CVec_APIErrorZ_free"))) TS_CVec_APIErrorZ_free(uint64_tArray _res) {
15396 LDKCVec_APIErrorZ _res_constr;
15397 _res_constr.datalen = _res->arr_len;
15398 if (_res_constr.datalen > 0)
15399 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
15401 _res_constr.data = NULL;
15402 uint64_t* _res_vals = _res->elems;
15403 for (size_t k = 0; k < _res_constr.datalen; k++) {
15404 uint64_t _res_conv_10 = _res_vals[k];
15405 void* _res_conv_10_ptr = untag_ptr(_res_conv_10);
15406 CHECK_ACCESS(_res_conv_10_ptr);
15407 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
15408 FREE(untag_ptr(_res_conv_10));
15409 _res_constr.data[k] = _res_conv_10_conv;
15412 CVec_APIErrorZ_free(_res_constr);
15415 uint64_t __attribute__((export_name("TS_COption_ThirtyTwoBytesZ_some"))) TS_COption_ThirtyTwoBytesZ_some(int8_tArray o) {
15416 LDKThirtyTwoBytes o_ref;
15417 CHECK(o->arr_len == 32);
15418 memcpy(o_ref.data, o->elems, 32); FREE(o);
15419 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
15420 *ret_copy = COption_ThirtyTwoBytesZ_some(o_ref);
15421 uint64_t ret_ref = tag_ptr(ret_copy, true);
15425 uint64_t __attribute__((export_name("TS_COption_ThirtyTwoBytesZ_none"))) TS_COption_ThirtyTwoBytesZ_none() {
15426 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
15427 *ret_copy = COption_ThirtyTwoBytesZ_none();
15428 uint64_t ret_ref = tag_ptr(ret_copy, true);
15432 void __attribute__((export_name("TS_COption_ThirtyTwoBytesZ_free"))) TS_COption_ThirtyTwoBytesZ_free(uint64_t _res) {
15433 if (!ptr_is_owned(_res)) return;
15434 void* _res_ptr = untag_ptr(_res);
15435 CHECK_ACCESS(_res_ptr);
15436 LDKCOption_ThirtyTwoBytesZ _res_conv = *(LDKCOption_ThirtyTwoBytesZ*)(_res_ptr);
15437 FREE(untag_ptr(_res));
15438 COption_ThirtyTwoBytesZ_free(_res_conv);
15441 static inline uint64_t COption_ThirtyTwoBytesZ_clone_ptr(LDKCOption_ThirtyTwoBytesZ *NONNULL_PTR arg) {
15442 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
15443 *ret_copy = COption_ThirtyTwoBytesZ_clone(arg);
15444 uint64_t ret_ref = tag_ptr(ret_copy, true);
15447 int64_t __attribute__((export_name("TS_COption_ThirtyTwoBytesZ_clone_ptr"))) TS_COption_ThirtyTwoBytesZ_clone_ptr(uint64_t arg) {
15448 LDKCOption_ThirtyTwoBytesZ* arg_conv = (LDKCOption_ThirtyTwoBytesZ*)untag_ptr(arg);
15449 int64_t ret_conv = COption_ThirtyTwoBytesZ_clone_ptr(arg_conv);
15453 uint64_t __attribute__((export_name("TS_COption_ThirtyTwoBytesZ_clone"))) TS_COption_ThirtyTwoBytesZ_clone(uint64_t orig) {
15454 LDKCOption_ThirtyTwoBytesZ* orig_conv = (LDKCOption_ThirtyTwoBytesZ*)untag_ptr(orig);
15455 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
15456 *ret_copy = COption_ThirtyTwoBytesZ_clone(orig_conv);
15457 uint64_t ret_ref = tag_ptr(ret_copy, true);
15461 void __attribute__((export_name("TS_CVec_u8Z_free"))) TS_CVec_u8Z_free(int8_tArray _res) {
15462 LDKCVec_u8Z _res_ref;
15463 _res_ref.datalen = _res->arr_len;
15464 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
15465 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
15466 CVec_u8Z_free(_res_ref);
15469 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_some"))) TS_COption_CVec_u8ZZ_some(int8_tArray o) {
15471 o_ref.datalen = o->arr_len;
15472 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
15473 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
15474 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
15475 *ret_copy = COption_CVec_u8ZZ_some(o_ref);
15476 uint64_t ret_ref = tag_ptr(ret_copy, true);
15480 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_none"))) TS_COption_CVec_u8ZZ_none() {
15481 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
15482 *ret_copy = COption_CVec_u8ZZ_none();
15483 uint64_t ret_ref = tag_ptr(ret_copy, true);
15487 void __attribute__((export_name("TS_COption_CVec_u8ZZ_free"))) TS_COption_CVec_u8ZZ_free(uint64_t _res) {
15488 if (!ptr_is_owned(_res)) return;
15489 void* _res_ptr = untag_ptr(_res);
15490 CHECK_ACCESS(_res_ptr);
15491 LDKCOption_CVec_u8ZZ _res_conv = *(LDKCOption_CVec_u8ZZ*)(_res_ptr);
15492 FREE(untag_ptr(_res));
15493 COption_CVec_u8ZZ_free(_res_conv);
15496 static inline uint64_t COption_CVec_u8ZZ_clone_ptr(LDKCOption_CVec_u8ZZ *NONNULL_PTR arg) {
15497 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
15498 *ret_copy = COption_CVec_u8ZZ_clone(arg);
15499 uint64_t ret_ref = tag_ptr(ret_copy, true);
15502 int64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone_ptr"))) TS_COption_CVec_u8ZZ_clone_ptr(uint64_t arg) {
15503 LDKCOption_CVec_u8ZZ* arg_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(arg);
15504 int64_t ret_conv = COption_CVec_u8ZZ_clone_ptr(arg_conv);
15508 uint64_t __attribute__((export_name("TS_COption_CVec_u8ZZ_clone"))) TS_COption_CVec_u8ZZ_clone(uint64_t orig) {
15509 LDKCOption_CVec_u8ZZ* orig_conv = (LDKCOption_CVec_u8ZZ*)untag_ptr(orig);
15510 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
15511 *ret_copy = COption_CVec_u8ZZ_clone(orig_conv);
15512 uint64_t ret_ref = tag_ptr(ret_copy, true);
15516 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_ok(uint64_t o) {
15517 LDKRecipientOnionFields o_conv;
15518 o_conv.inner = untag_ptr(o);
15519 o_conv.is_owned = ptr_is_owned(o);
15520 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15521 o_conv = RecipientOnionFields_clone(&o_conv);
15522 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
15523 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_ok(o_conv);
15524 return tag_ptr(ret_conv, true);
15527 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_err"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_err(uint64_t e) {
15528 void* e_ptr = untag_ptr(e);
15529 CHECK_ACCESS(e_ptr);
15530 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15531 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15532 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
15533 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_err(e_conv);
15534 return tag_ptr(ret_conv, true);
15537 jboolean __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(uint64_t o) {
15538 LDKCResult_RecipientOnionFieldsDecodeErrorZ* o_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(o);
15539 jboolean ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_is_ok(o_conv);
15543 void __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_free"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_free(uint64_t _res) {
15544 if (!ptr_is_owned(_res)) return;
15545 void* _res_ptr = untag_ptr(_res);
15546 CHECK_ACCESS(_res_ptr);
15547 LDKCResult_RecipientOnionFieldsDecodeErrorZ _res_conv = *(LDKCResult_RecipientOnionFieldsDecodeErrorZ*)(_res_ptr);
15548 FREE(untag_ptr(_res));
15549 CResult_RecipientOnionFieldsDecodeErrorZ_free(_res_conv);
15552 static inline uint64_t CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(LDKCResult_RecipientOnionFieldsDecodeErrorZ *NONNULL_PTR arg) {
15553 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
15554 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(arg);
15555 return tag_ptr(ret_conv, true);
15557 int64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(uint64_t arg) {
15558 LDKCResult_RecipientOnionFieldsDecodeErrorZ* arg_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(arg);
15559 int64_t ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone_ptr(arg_conv);
15563 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone"))) TS_CResult_RecipientOnionFieldsDecodeErrorZ_clone(uint64_t orig) {
15564 LDKCResult_RecipientOnionFieldsDecodeErrorZ* orig_conv = (LDKCResult_RecipientOnionFieldsDecodeErrorZ*)untag_ptr(orig);
15565 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
15566 *ret_conv = CResult_RecipientOnionFieldsDecodeErrorZ_clone(orig_conv);
15567 return tag_ptr(ret_conv, true);
15570 static inline uint64_t C2Tuple_u64CVec_u8ZZ_clone_ptr(LDKC2Tuple_u64CVec_u8ZZ *NONNULL_PTR arg) {
15571 LDKC2Tuple_u64CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKC2Tuple_u64CVec_u8ZZ");
15572 *ret_conv = C2Tuple_u64CVec_u8ZZ_clone(arg);
15573 return tag_ptr(ret_conv, true);
15575 int64_t __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_clone_ptr"))) TS_C2Tuple_u64CVec_u8ZZ_clone_ptr(uint64_t arg) {
15576 LDKC2Tuple_u64CVec_u8ZZ* arg_conv = (LDKC2Tuple_u64CVec_u8ZZ*)untag_ptr(arg);
15577 int64_t ret_conv = C2Tuple_u64CVec_u8ZZ_clone_ptr(arg_conv);
15581 uint64_t __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_clone"))) TS_C2Tuple_u64CVec_u8ZZ_clone(uint64_t orig) {
15582 LDKC2Tuple_u64CVec_u8ZZ* orig_conv = (LDKC2Tuple_u64CVec_u8ZZ*)untag_ptr(orig);
15583 LDKC2Tuple_u64CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKC2Tuple_u64CVec_u8ZZ");
15584 *ret_conv = C2Tuple_u64CVec_u8ZZ_clone(orig_conv);
15585 return tag_ptr(ret_conv, true);
15588 uint64_t __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_new"))) TS_C2Tuple_u64CVec_u8ZZ_new(int64_t a, int8_tArray b) {
15590 b_ref.datalen = b->arr_len;
15591 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
15592 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
15593 LDKC2Tuple_u64CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKC2Tuple_u64CVec_u8ZZ");
15594 *ret_conv = C2Tuple_u64CVec_u8ZZ_new(a, b_ref);
15595 return tag_ptr(ret_conv, true);
15598 void __attribute__((export_name("TS_C2Tuple_u64CVec_u8ZZ_free"))) TS_C2Tuple_u64CVec_u8ZZ_free(uint64_t _res) {
15599 if (!ptr_is_owned(_res)) return;
15600 void* _res_ptr = untag_ptr(_res);
15601 CHECK_ACCESS(_res_ptr);
15602 LDKC2Tuple_u64CVec_u8ZZ _res_conv = *(LDKC2Tuple_u64CVec_u8ZZ*)(_res_ptr);
15603 FREE(untag_ptr(_res));
15604 C2Tuple_u64CVec_u8ZZ_free(_res_conv);
15607 void __attribute__((export_name("TS_CVec_C2Tuple_u64CVec_u8ZZZ_free"))) TS_CVec_C2Tuple_u64CVec_u8ZZZ_free(uint64_tArray _res) {
15608 LDKCVec_C2Tuple_u64CVec_u8ZZZ _res_constr;
15609 _res_constr.datalen = _res->arr_len;
15610 if (_res_constr.datalen > 0)
15611 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKCVec_C2Tuple_u64CVec_u8ZZZ Elements");
15613 _res_constr.data = NULL;
15614 uint64_t* _res_vals = _res->elems;
15615 for (size_t x = 0; x < _res_constr.datalen; x++) {
15616 uint64_t _res_conv_23 = _res_vals[x];
15617 void* _res_conv_23_ptr = untag_ptr(_res_conv_23);
15618 CHECK_ACCESS(_res_conv_23_ptr);
15619 LDKC2Tuple_u64CVec_u8ZZ _res_conv_23_conv = *(LDKC2Tuple_u64CVec_u8ZZ*)(_res_conv_23_ptr);
15620 FREE(untag_ptr(_res_conv_23));
15621 _res_constr.data[x] = _res_conv_23_conv;
15624 CVec_C2Tuple_u64CVec_u8ZZZ_free(_res_constr);
15627 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_ok"))) TS_CResult_RecipientOnionFieldsNoneZ_ok(uint64_t o) {
15628 LDKRecipientOnionFields o_conv;
15629 o_conv.inner = untag_ptr(o);
15630 o_conv.is_owned = ptr_is_owned(o);
15631 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15632 o_conv = RecipientOnionFields_clone(&o_conv);
15633 LDKCResult_RecipientOnionFieldsNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsNoneZ), "LDKCResult_RecipientOnionFieldsNoneZ");
15634 *ret_conv = CResult_RecipientOnionFieldsNoneZ_ok(o_conv);
15635 return tag_ptr(ret_conv, true);
15638 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_err"))) TS_CResult_RecipientOnionFieldsNoneZ_err() {
15639 LDKCResult_RecipientOnionFieldsNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsNoneZ), "LDKCResult_RecipientOnionFieldsNoneZ");
15640 *ret_conv = CResult_RecipientOnionFieldsNoneZ_err();
15641 return tag_ptr(ret_conv, true);
15644 jboolean __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_is_ok"))) TS_CResult_RecipientOnionFieldsNoneZ_is_ok(uint64_t o) {
15645 LDKCResult_RecipientOnionFieldsNoneZ* o_conv = (LDKCResult_RecipientOnionFieldsNoneZ*)untag_ptr(o);
15646 jboolean ret_conv = CResult_RecipientOnionFieldsNoneZ_is_ok(o_conv);
15650 void __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_free"))) TS_CResult_RecipientOnionFieldsNoneZ_free(uint64_t _res) {
15651 if (!ptr_is_owned(_res)) return;
15652 void* _res_ptr = untag_ptr(_res);
15653 CHECK_ACCESS(_res_ptr);
15654 LDKCResult_RecipientOnionFieldsNoneZ _res_conv = *(LDKCResult_RecipientOnionFieldsNoneZ*)(_res_ptr);
15655 FREE(untag_ptr(_res));
15656 CResult_RecipientOnionFieldsNoneZ_free(_res_conv);
15659 static inline uint64_t CResult_RecipientOnionFieldsNoneZ_clone_ptr(LDKCResult_RecipientOnionFieldsNoneZ *NONNULL_PTR arg) {
15660 LDKCResult_RecipientOnionFieldsNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsNoneZ), "LDKCResult_RecipientOnionFieldsNoneZ");
15661 *ret_conv = CResult_RecipientOnionFieldsNoneZ_clone(arg);
15662 return tag_ptr(ret_conv, true);
15664 int64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr"))) TS_CResult_RecipientOnionFieldsNoneZ_clone_ptr(uint64_t arg) {
15665 LDKCResult_RecipientOnionFieldsNoneZ* arg_conv = (LDKCResult_RecipientOnionFieldsNoneZ*)untag_ptr(arg);
15666 int64_t ret_conv = CResult_RecipientOnionFieldsNoneZ_clone_ptr(arg_conv);
15670 uint64_t __attribute__((export_name("TS_CResult_RecipientOnionFieldsNoneZ_clone"))) TS_CResult_RecipientOnionFieldsNoneZ_clone(uint64_t orig) {
15671 LDKCResult_RecipientOnionFieldsNoneZ* orig_conv = (LDKCResult_RecipientOnionFieldsNoneZ*)untag_ptr(orig);
15672 LDKCResult_RecipientOnionFieldsNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsNoneZ), "LDKCResult_RecipientOnionFieldsNoneZ");
15673 *ret_conv = CResult_RecipientOnionFieldsNoneZ_clone(orig_conv);
15674 return tag_ptr(ret_conv, true);
15677 void __attribute__((export_name("TS_CVec_ThirtyTwoBytesZ_free"))) TS_CVec_ThirtyTwoBytesZ_free(ptrArray _res) {
15678 LDKCVec_ThirtyTwoBytesZ _res_constr;
15679 _res_constr.datalen = _res->arr_len;
15680 if (_res_constr.datalen > 0)
15681 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
15683 _res_constr.data = NULL;
15684 int8_tArray* _res_vals = (void*) _res->elems;
15685 for (size_t m = 0; m < _res_constr.datalen; m++) {
15686 int8_tArray _res_conv_12 = _res_vals[m];
15687 LDKThirtyTwoBytes _res_conv_12_ref;
15688 CHECK(_res_conv_12->arr_len == 32);
15689 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
15690 _res_constr.data[m] = _res_conv_12_ref;
15693 CVec_ThirtyTwoBytesZ_free(_res_constr);
15696 uint64_t __attribute__((export_name("TS_COption_CVec_ThirtyTwoBytesZZ_some"))) TS_COption_CVec_ThirtyTwoBytesZZ_some(ptrArray o) {
15697 LDKCVec_ThirtyTwoBytesZ o_constr;
15698 o_constr.datalen = o->arr_len;
15699 if (o_constr.datalen > 0)
15700 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
15702 o_constr.data = NULL;
15703 int8_tArray* o_vals = (void*) o->elems;
15704 for (size_t m = 0; m < o_constr.datalen; m++) {
15705 int8_tArray o_conv_12 = o_vals[m];
15706 LDKThirtyTwoBytes o_conv_12_ref;
15707 CHECK(o_conv_12->arr_len == 32);
15708 memcpy(o_conv_12_ref.data, o_conv_12->elems, 32); FREE(o_conv_12);
15709 o_constr.data[m] = o_conv_12_ref;
15712 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
15713 *ret_copy = COption_CVec_ThirtyTwoBytesZZ_some(o_constr);
15714 uint64_t ret_ref = tag_ptr(ret_copy, true);
15718 uint64_t __attribute__((export_name("TS_COption_CVec_ThirtyTwoBytesZZ_none"))) TS_COption_CVec_ThirtyTwoBytesZZ_none() {
15719 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
15720 *ret_copy = COption_CVec_ThirtyTwoBytesZZ_none();
15721 uint64_t ret_ref = tag_ptr(ret_copy, true);
15725 void __attribute__((export_name("TS_COption_CVec_ThirtyTwoBytesZZ_free"))) TS_COption_CVec_ThirtyTwoBytesZZ_free(uint64_t _res) {
15726 if (!ptr_is_owned(_res)) return;
15727 void* _res_ptr = untag_ptr(_res);
15728 CHECK_ACCESS(_res_ptr);
15729 LDKCOption_CVec_ThirtyTwoBytesZZ _res_conv = *(LDKCOption_CVec_ThirtyTwoBytesZZ*)(_res_ptr);
15730 FREE(untag_ptr(_res));
15731 COption_CVec_ThirtyTwoBytesZZ_free(_res_conv);
15734 static inline uint64_t COption_CVec_ThirtyTwoBytesZZ_clone_ptr(LDKCOption_CVec_ThirtyTwoBytesZZ *NONNULL_PTR arg) {
15735 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
15736 *ret_copy = COption_CVec_ThirtyTwoBytesZZ_clone(arg);
15737 uint64_t ret_ref = tag_ptr(ret_copy, true);
15740 int64_t __attribute__((export_name("TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr"))) TS_COption_CVec_ThirtyTwoBytesZZ_clone_ptr(uint64_t arg) {
15741 LDKCOption_CVec_ThirtyTwoBytesZZ* arg_conv = (LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(arg);
15742 int64_t ret_conv = COption_CVec_ThirtyTwoBytesZZ_clone_ptr(arg_conv);
15746 uint64_t __attribute__((export_name("TS_COption_CVec_ThirtyTwoBytesZZ_clone"))) TS_COption_CVec_ThirtyTwoBytesZZ_clone(uint64_t orig) {
15747 LDKCOption_CVec_ThirtyTwoBytesZZ* orig_conv = (LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(orig);
15748 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
15749 *ret_copy = COption_CVec_ThirtyTwoBytesZZ_clone(orig_conv);
15750 uint64_t ret_ref = tag_ptr(ret_copy, true);
15754 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_ok"))) TS_CResult_ThirtyTwoBytesNoneZ_ok(int8_tArray o) {
15755 LDKThirtyTwoBytes o_ref;
15756 CHECK(o->arr_len == 32);
15757 memcpy(o_ref.data, o->elems, 32); FREE(o);
15758 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
15759 *ret_conv = CResult_ThirtyTwoBytesNoneZ_ok(o_ref);
15760 return tag_ptr(ret_conv, true);
15763 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_err"))) TS_CResult_ThirtyTwoBytesNoneZ_err() {
15764 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
15765 *ret_conv = CResult_ThirtyTwoBytesNoneZ_err();
15766 return tag_ptr(ret_conv, true);
15769 jboolean __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_is_ok"))) TS_CResult_ThirtyTwoBytesNoneZ_is_ok(uint64_t o) {
15770 LDKCResult_ThirtyTwoBytesNoneZ* o_conv = (LDKCResult_ThirtyTwoBytesNoneZ*)untag_ptr(o);
15771 jboolean ret_conv = CResult_ThirtyTwoBytesNoneZ_is_ok(o_conv);
15775 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_free"))) TS_CResult_ThirtyTwoBytesNoneZ_free(uint64_t _res) {
15776 if (!ptr_is_owned(_res)) return;
15777 void* _res_ptr = untag_ptr(_res);
15778 CHECK_ACCESS(_res_ptr);
15779 LDKCResult_ThirtyTwoBytesNoneZ _res_conv = *(LDKCResult_ThirtyTwoBytesNoneZ*)(_res_ptr);
15780 FREE(untag_ptr(_res));
15781 CResult_ThirtyTwoBytesNoneZ_free(_res_conv);
15784 static inline uint64_t CResult_ThirtyTwoBytesNoneZ_clone_ptr(LDKCResult_ThirtyTwoBytesNoneZ *NONNULL_PTR arg) {
15785 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
15786 *ret_conv = CResult_ThirtyTwoBytesNoneZ_clone(arg);
15787 return tag_ptr(ret_conv, true);
15789 int64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr"))) TS_CResult_ThirtyTwoBytesNoneZ_clone_ptr(uint64_t arg) {
15790 LDKCResult_ThirtyTwoBytesNoneZ* arg_conv = (LDKCResult_ThirtyTwoBytesNoneZ*)untag_ptr(arg);
15791 int64_t ret_conv = CResult_ThirtyTwoBytesNoneZ_clone_ptr(arg_conv);
15795 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesNoneZ_clone"))) TS_CResult_ThirtyTwoBytesNoneZ_clone(uint64_t orig) {
15796 LDKCResult_ThirtyTwoBytesNoneZ* orig_conv = (LDKCResult_ThirtyTwoBytesNoneZ*)untag_ptr(orig);
15797 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
15798 *ret_conv = CResult_ThirtyTwoBytesNoneZ_clone(orig_conv);
15799 return tag_ptr(ret_conv, true);
15802 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_ok(uint64_t o) {
15803 LDKBlindedPayInfo o_conv;
15804 o_conv.inner = untag_ptr(o);
15805 o_conv.is_owned = ptr_is_owned(o);
15806 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15807 o_conv = BlindedPayInfo_clone(&o_conv);
15808 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
15809 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_ok(o_conv);
15810 return tag_ptr(ret_conv, true);
15813 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_err"))) TS_CResult_BlindedPayInfoDecodeErrorZ_err(uint64_t e) {
15814 void* e_ptr = untag_ptr(e);
15815 CHECK_ACCESS(e_ptr);
15816 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15817 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15818 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
15819 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_err(e_conv);
15820 return tag_ptr(ret_conv, true);
15823 jboolean __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok"))) TS_CResult_BlindedPayInfoDecodeErrorZ_is_ok(uint64_t o) {
15824 LDKCResult_BlindedPayInfoDecodeErrorZ* o_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(o);
15825 jboolean ret_conv = CResult_BlindedPayInfoDecodeErrorZ_is_ok(o_conv);
15829 void __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_free"))) TS_CResult_BlindedPayInfoDecodeErrorZ_free(uint64_t _res) {
15830 if (!ptr_is_owned(_res)) return;
15831 void* _res_ptr = untag_ptr(_res);
15832 CHECK_ACCESS(_res_ptr);
15833 LDKCResult_BlindedPayInfoDecodeErrorZ _res_conv = *(LDKCResult_BlindedPayInfoDecodeErrorZ*)(_res_ptr);
15834 FREE(untag_ptr(_res));
15835 CResult_BlindedPayInfoDecodeErrorZ_free(_res_conv);
15838 static inline uint64_t CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(LDKCResult_BlindedPayInfoDecodeErrorZ *NONNULL_PTR arg) {
15839 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
15840 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(arg);
15841 return tag_ptr(ret_conv, true);
15843 int64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
15844 LDKCResult_BlindedPayInfoDecodeErrorZ* arg_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(arg);
15845 int64_t ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone_ptr(arg_conv);
15849 uint64_t __attribute__((export_name("TS_CResult_BlindedPayInfoDecodeErrorZ_clone"))) TS_CResult_BlindedPayInfoDecodeErrorZ_clone(uint64_t orig) {
15850 LDKCResult_BlindedPayInfoDecodeErrorZ* orig_conv = (LDKCResult_BlindedPayInfoDecodeErrorZ*)untag_ptr(orig);
15851 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
15852 *ret_conv = CResult_BlindedPayInfoDecodeErrorZ_clone(orig_conv);
15853 return tag_ptr(ret_conv, true);
15856 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15857 LDKDelayedPaymentOutputDescriptor o_conv;
15858 o_conv.inner = untag_ptr(o);
15859 o_conv.is_owned = ptr_is_owned(o);
15860 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15861 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
15862 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15863 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
15864 return tag_ptr(ret_conv, true);
15867 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
15868 void* e_ptr = untag_ptr(e);
15869 CHECK_ACCESS(e_ptr);
15870 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15871 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15872 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15873 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
15874 return tag_ptr(ret_conv, true);
15877 jboolean __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15878 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15879 jboolean ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15883 void __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
15884 if (!ptr_is_owned(_res)) return;
15885 void* _res_ptr = untag_ptr(_res);
15886 CHECK_ACCESS(_res_ptr);
15887 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
15888 FREE(untag_ptr(_res));
15889 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
15892 static inline uint64_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15893 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15894 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
15895 return tag_ptr(ret_conv, true);
15897 int64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
15898 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
15899 int64_t ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15903 uint64_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
15904 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
15905 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15906 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15907 return tag_ptr(ret_conv, true);
15910 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15911 LDKStaticPaymentOutputDescriptor o_conv;
15912 o_conv.inner = untag_ptr(o);
15913 o_conv.is_owned = ptr_is_owned(o);
15914 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15915 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
15916 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15917 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
15918 return tag_ptr(ret_conv, true);
15921 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint64_t e) {
15922 void* e_ptr = untag_ptr(e);
15923 CHECK_ACCESS(e_ptr);
15924 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
15925 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
15926 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15927 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
15928 return tag_ptr(ret_conv, true);
15931 jboolean __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15932 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15933 jboolean ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15937 void __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint64_t _res) {
15938 if (!ptr_is_owned(_res)) return;
15939 void* _res_ptr = untag_ptr(_res);
15940 CHECK_ACCESS(_res_ptr);
15941 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
15942 FREE(untag_ptr(_res));
15943 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
15946 static inline uint64_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15947 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15948 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
15949 return tag_ptr(ret_conv, true);
15951 int64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
15952 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
15953 int64_t ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15957 uint64_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
15958 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
15959 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15960 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15961 return tag_ptr(ret_conv, true);
15964 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint64_t o) {
15965 void* o_ptr = untag_ptr(o);
15966 CHECK_ACCESS(o_ptr);
15967 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
15968 o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(o));
15969 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15970 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
15971 return tag_ptr(ret_conv, true);
15974 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_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_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15980 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
15981 return tag_ptr(ret_conv, true);
15984 jboolean __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint64_t o) {
15985 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(o);
15986 jboolean ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15990 void __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_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_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
15995 FREE(untag_ptr(_res));
15996 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
15999 static inline uint64_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
16000 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16001 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
16002 return tag_ptr(ret_conv, true);
16004 int64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
16005 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(arg);
16006 int64_t ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
16010 uint64_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint64_t orig) {
16011 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)untag_ptr(orig);
16012 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
16013 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
16014 return tag_ptr(ret_conv, true);
16017 void __attribute__((export_name("TS_CVec_SpendableOutputDescriptorZ_free"))) TS_CVec_SpendableOutputDescriptorZ_free(uint64_tArray _res) {
16018 LDKCVec_SpendableOutputDescriptorZ _res_constr;
16019 _res_constr.datalen = _res->arr_len;
16020 if (_res_constr.datalen > 0)
16021 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
16023 _res_constr.data = NULL;
16024 uint64_t* _res_vals = _res->elems;
16025 for (size_t b = 0; b < _res_constr.datalen; b++) {
16026 uint64_t _res_conv_27 = _res_vals[b];
16027 void* _res_conv_27_ptr = untag_ptr(_res_conv_27);
16028 CHECK_ACCESS(_res_conv_27_ptr);
16029 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
16030 FREE(untag_ptr(_res_conv_27));
16031 _res_constr.data[b] = _res_conv_27_conv;
16034 CVec_SpendableOutputDescriptorZ_free(_res_constr);
16037 void __attribute__((export_name("TS_CVec_TxOutZ_free"))) TS_CVec_TxOutZ_free(uint64_tArray _res) {
16038 LDKCVec_TxOutZ _res_constr;
16039 _res_constr.datalen = _res->arr_len;
16040 if (_res_constr.datalen > 0)
16041 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
16043 _res_constr.data = NULL;
16044 uint64_t* _res_vals = _res->elems;
16045 for (size_t h = 0; h < _res_constr.datalen; h++) {
16046 uint64_t _res_conv_7 = _res_vals[h];
16047 void* _res_conv_7_ptr = untag_ptr(_res_conv_7);
16048 CHECK_ACCESS(_res_conv_7_ptr);
16049 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
16050 FREE(untag_ptr(_res_conv_7));
16051 _res_constr.data[h] = _res_conv_7_conv;
16054 CVec_TxOutZ_free(_res_constr);
16057 uint64_t __attribute__((export_name("TS_COption_u32Z_some"))) TS_COption_u32Z_some(int32_t o) {
16058 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
16059 *ret_copy = COption_u32Z_some(o);
16060 uint64_t ret_ref = tag_ptr(ret_copy, true);
16064 uint64_t __attribute__((export_name("TS_COption_u32Z_none"))) TS_COption_u32Z_none() {
16065 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
16066 *ret_copy = COption_u32Z_none();
16067 uint64_t ret_ref = tag_ptr(ret_copy, true);
16071 void __attribute__((export_name("TS_COption_u32Z_free"))) TS_COption_u32Z_free(uint64_t _res) {
16072 if (!ptr_is_owned(_res)) return;
16073 void* _res_ptr = untag_ptr(_res);
16074 CHECK_ACCESS(_res_ptr);
16075 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(_res_ptr);
16076 FREE(untag_ptr(_res));
16077 COption_u32Z_free(_res_conv);
16080 static inline uint64_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
16081 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
16082 *ret_copy = COption_u32Z_clone(arg);
16083 uint64_t ret_ref = tag_ptr(ret_copy, true);
16086 int64_t __attribute__((export_name("TS_COption_u32Z_clone_ptr"))) TS_COption_u32Z_clone_ptr(uint64_t arg) {
16087 LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)untag_ptr(arg);
16088 int64_t ret_conv = COption_u32Z_clone_ptr(arg_conv);
16092 uint64_t __attribute__((export_name("TS_COption_u32Z_clone"))) TS_COption_u32Z_clone(uint64_t orig) {
16093 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)untag_ptr(orig);
16094 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
16095 *ret_copy = COption_u32Z_clone(orig_conv);
16096 uint64_t ret_ref = tag_ptr(ret_copy, true);
16100 static inline uint64_t C2Tuple_CVec_u8ZusizeZ_clone_ptr(LDKC2Tuple_CVec_u8ZusizeZ *NONNULL_PTR arg) {
16101 LDKC2Tuple_CVec_u8ZusizeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_CVec_u8ZusizeZ), "LDKC2Tuple_CVec_u8ZusizeZ");
16102 *ret_conv = C2Tuple_CVec_u8ZusizeZ_clone(arg);
16103 return tag_ptr(ret_conv, true);
16105 int64_t __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_clone_ptr"))) TS_C2Tuple_CVec_u8ZusizeZ_clone_ptr(uint64_t arg) {
16106 LDKC2Tuple_CVec_u8ZusizeZ* arg_conv = (LDKC2Tuple_CVec_u8ZusizeZ*)untag_ptr(arg);
16107 int64_t ret_conv = C2Tuple_CVec_u8ZusizeZ_clone_ptr(arg_conv);
16111 uint64_t __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_clone"))) TS_C2Tuple_CVec_u8ZusizeZ_clone(uint64_t orig) {
16112 LDKC2Tuple_CVec_u8ZusizeZ* orig_conv = (LDKC2Tuple_CVec_u8ZusizeZ*)untag_ptr(orig);
16113 LDKC2Tuple_CVec_u8ZusizeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_CVec_u8ZusizeZ), "LDKC2Tuple_CVec_u8ZusizeZ");
16114 *ret_conv = C2Tuple_CVec_u8ZusizeZ_clone(orig_conv);
16115 return tag_ptr(ret_conv, true);
16118 uint64_t __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_new"))) TS_C2Tuple_CVec_u8ZusizeZ_new(int8_tArray a, uint32_t b) {
16120 a_ref.datalen = a->arr_len;
16121 a_ref.data = MALLOC(a_ref.datalen, "LDKCVec_u8Z Bytes");
16122 memcpy(a_ref.data, a->elems, a_ref.datalen); FREE(a);
16123 LDKC2Tuple_CVec_u8ZusizeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_CVec_u8ZusizeZ), "LDKC2Tuple_CVec_u8ZusizeZ");
16124 *ret_conv = C2Tuple_CVec_u8ZusizeZ_new(a_ref, b);
16125 return tag_ptr(ret_conv, true);
16128 void __attribute__((export_name("TS_C2Tuple_CVec_u8ZusizeZ_free"))) TS_C2Tuple_CVec_u8ZusizeZ_free(uint64_t _res) {
16129 if (!ptr_is_owned(_res)) return;
16130 void* _res_ptr = untag_ptr(_res);
16131 CHECK_ACCESS(_res_ptr);
16132 LDKC2Tuple_CVec_u8ZusizeZ _res_conv = *(LDKC2Tuple_CVec_u8ZusizeZ*)(_res_ptr);
16133 FREE(untag_ptr(_res));
16134 C2Tuple_CVec_u8ZusizeZ_free(_res_conv);
16137 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(uint64_t o) {
16138 void* o_ptr = untag_ptr(o);
16139 CHECK_ACCESS(o_ptr);
16140 LDKC2Tuple_CVec_u8ZusizeZ o_conv = *(LDKC2Tuple_CVec_u8ZusizeZ*)(o_ptr);
16141 o_conv = C2Tuple_CVec_u8ZusizeZ_clone((LDKC2Tuple_CVec_u8ZusizeZ*)untag_ptr(o));
16142 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ), "LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ");
16143 *ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_ok(o_conv);
16144 return tag_ptr(ret_conv, true);
16147 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err() {
16148 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ), "LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ");
16149 *ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_err();
16150 return tag_ptr(ret_conv, true);
16153 jboolean __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(uint64_t o) {
16154 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* o_conv = (LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)untag_ptr(o);
16155 jboolean ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_is_ok(o_conv);
16159 void __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(uint64_t _res) {
16160 if (!ptr_is_owned(_res)) return;
16161 void* _res_ptr = untag_ptr(_res);
16162 CHECK_ACCESS(_res_ptr);
16163 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ _res_conv = *(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)(_res_ptr);
16164 FREE(untag_ptr(_res));
16165 CResult_C2Tuple_CVec_u8ZusizeZNoneZ_free(_res_conv);
16168 static inline uint64_t CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ *NONNULL_PTR arg) {
16169 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ), "LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ");
16170 *ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(arg);
16171 return tag_ptr(ret_conv, true);
16173 int64_t __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(uint64_t arg) {
16174 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* arg_conv = (LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)untag_ptr(arg);
16175 int64_t ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone_ptr(arg_conv);
16179 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone"))) TS_CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(uint64_t orig) {
16180 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* orig_conv = (LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ*)untag_ptr(orig);
16181 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ), "LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ");
16182 *ret_conv = CResult_C2Tuple_CVec_u8ZusizeZNoneZ_clone(orig_conv);
16183 return tag_ptr(ret_conv, true);
16186 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_ok"))) TS_CResult_NoneNoneZ_ok() {
16187 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
16188 *ret_conv = CResult_NoneNoneZ_ok();
16189 return tag_ptr(ret_conv, true);
16192 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_err"))) TS_CResult_NoneNoneZ_err() {
16193 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
16194 *ret_conv = CResult_NoneNoneZ_err();
16195 return tag_ptr(ret_conv, true);
16198 jboolean __attribute__((export_name("TS_CResult_NoneNoneZ_is_ok"))) TS_CResult_NoneNoneZ_is_ok(uint64_t o) {
16199 LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)untag_ptr(o);
16200 jboolean ret_conv = CResult_NoneNoneZ_is_ok(o_conv);
16204 void __attribute__((export_name("TS_CResult_NoneNoneZ_free"))) TS_CResult_NoneNoneZ_free(uint64_t _res) {
16205 if (!ptr_is_owned(_res)) return;
16206 void* _res_ptr = untag_ptr(_res);
16207 CHECK_ACCESS(_res_ptr);
16208 LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
16209 FREE(untag_ptr(_res));
16210 CResult_NoneNoneZ_free(_res_conv);
16213 static inline uint64_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
16214 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
16215 *ret_conv = CResult_NoneNoneZ_clone(arg);
16216 return tag_ptr(ret_conv, true);
16218 int64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone_ptr"))) TS_CResult_NoneNoneZ_clone_ptr(uint64_t arg) {
16219 LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)untag_ptr(arg);
16220 int64_t ret_conv = CResult_NoneNoneZ_clone_ptr(arg_conv);
16224 uint64_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone"))) TS_CResult_NoneNoneZ_clone(uint64_t orig) {
16225 LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)untag_ptr(orig);
16226 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
16227 *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
16228 return tag_ptr(ret_conv, true);
16231 void __attribute__((export_name("TS_CVec_ECDSASignatureZ_free"))) TS_CVec_ECDSASignatureZ_free(ptrArray _res) {
16232 LDKCVec_ECDSASignatureZ _res_constr;
16233 _res_constr.datalen = _res->arr_len;
16234 if (_res_constr.datalen > 0)
16235 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
16237 _res_constr.data = NULL;
16238 int8_tArray* _res_vals = (void*) _res->elems;
16239 for (size_t m = 0; m < _res_constr.datalen; m++) {
16240 int8_tArray _res_conv_12 = _res_vals[m];
16241 LDKECDSASignature _res_conv_12_ref;
16242 CHECK(_res_conv_12->arr_len == 64);
16243 memcpy(_res_conv_12_ref.compact_form, _res_conv_12->elems, 64); FREE(_res_conv_12);
16244 _res_constr.data[m] = _res_conv_12_ref;
16247 CVec_ECDSASignatureZ_free(_res_constr);
16250 static inline uint64_t C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ *NONNULL_PTR arg) {
16251 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ), "LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ");
16252 *ret_conv = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(arg);
16253 return tag_ptr(ret_conv, true);
16255 int64_t __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(uint64_t arg) {
16256 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* arg_conv = (LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)untag_ptr(arg);
16257 int64_t ret_conv = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone_ptr(arg_conv);
16261 uint64_t __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(uint64_t orig) {
16262 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* orig_conv = (LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)untag_ptr(orig);
16263 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ), "LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ");
16264 *ret_conv = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone(orig_conv);
16265 return tag_ptr(ret_conv, true);
16268 uint64_t __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(int8_tArray a, ptrArray b) {
16269 LDKECDSASignature a_ref;
16270 CHECK(a->arr_len == 64);
16271 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
16272 LDKCVec_ECDSASignatureZ b_constr;
16273 b_constr.datalen = b->arr_len;
16274 if (b_constr.datalen > 0)
16275 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
16277 b_constr.data = NULL;
16278 int8_tArray* b_vals = (void*) b->elems;
16279 for (size_t m = 0; m < b_constr.datalen; m++) {
16280 int8_tArray b_conv_12 = b_vals[m];
16281 LDKECDSASignature b_conv_12_ref;
16282 CHECK(b_conv_12->arr_len == 64);
16283 memcpy(b_conv_12_ref.compact_form, b_conv_12->elems, 64); FREE(b_conv_12);
16284 b_constr.data[m] = b_conv_12_ref;
16287 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ), "LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ");
16288 *ret_conv = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_new(a_ref, b_constr);
16289 return tag_ptr(ret_conv, true);
16292 void __attribute__((export_name("TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free"))) TS_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(uint64_t _res) {
16293 if (!ptr_is_owned(_res)) return;
16294 void* _res_ptr = untag_ptr(_res);
16295 CHECK_ACCESS(_res_ptr);
16296 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ _res_conv = *(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)(_res_ptr);
16297 FREE(untag_ptr(_res));
16298 C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_free(_res_conv);
16301 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(uint64_t o) {
16302 void* o_ptr = untag_ptr(o);
16303 CHECK_ACCESS(o_ptr);
16304 LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ o_conv = *(LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)(o_ptr);
16305 o_conv = C2Tuple_ECDSASignatureCVec_ECDSASignatureZZ_clone((LDKC2Tuple_ECDSASignatureCVec_ECDSASignatureZZ*)untag_ptr(o));
16306 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
16307 *ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_ok(o_conv);
16308 return tag_ptr(ret_conv, true);
16311 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err() {
16312 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
16313 *ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_err();
16314 return tag_ptr(ret_conv, true);
16317 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(uint64_t o) {
16318 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)untag_ptr(o);
16319 jboolean ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_is_ok(o_conv);
16323 void __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(uint64_t _res) {
16324 if (!ptr_is_owned(_res)) return;
16325 void* _res_ptr = untag_ptr(_res);
16326 CHECK_ACCESS(_res_ptr);
16327 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)(_res_ptr);
16328 FREE(untag_ptr(_res));
16329 CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_free(_res_conv);
16332 static inline uint64_t CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ *NONNULL_PTR arg) {
16333 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
16334 *ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(arg);
16335 return tag_ptr(ret_conv, true);
16337 int64_t __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(uint64_t arg) {
16338 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)untag_ptr(arg);
16339 int64_t ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone_ptr(arg_conv);
16343 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone"))) TS_CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(uint64_t orig) {
16344 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ*)untag_ptr(orig);
16345 LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ), "LDKCResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ");
16346 *ret_conv = CResult_C2Tuple_ECDSASignatureCVec_ECDSASignatureZZNoneZ_clone(orig_conv);
16347 return tag_ptr(ret_conv, true);
16350 uint64_t __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_ok"))) TS_CResult_ECDSASignatureNoneZ_ok(int8_tArray o) {
16351 LDKECDSASignature o_ref;
16352 CHECK(o->arr_len == 64);
16353 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
16354 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
16355 *ret_conv = CResult_ECDSASignatureNoneZ_ok(o_ref);
16356 return tag_ptr(ret_conv, true);
16359 uint64_t __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_err"))) TS_CResult_ECDSASignatureNoneZ_err() {
16360 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
16361 *ret_conv = CResult_ECDSASignatureNoneZ_err();
16362 return tag_ptr(ret_conv, true);
16365 jboolean __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_is_ok"))) TS_CResult_ECDSASignatureNoneZ_is_ok(uint64_t o) {
16366 LDKCResult_ECDSASignatureNoneZ* o_conv = (LDKCResult_ECDSASignatureNoneZ*)untag_ptr(o);
16367 jboolean ret_conv = CResult_ECDSASignatureNoneZ_is_ok(o_conv);
16371 void __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_free"))) TS_CResult_ECDSASignatureNoneZ_free(uint64_t _res) {
16372 if (!ptr_is_owned(_res)) return;
16373 void* _res_ptr = untag_ptr(_res);
16374 CHECK_ACCESS(_res_ptr);
16375 LDKCResult_ECDSASignatureNoneZ _res_conv = *(LDKCResult_ECDSASignatureNoneZ*)(_res_ptr);
16376 FREE(untag_ptr(_res));
16377 CResult_ECDSASignatureNoneZ_free(_res_conv);
16380 static inline uint64_t CResult_ECDSASignatureNoneZ_clone_ptr(LDKCResult_ECDSASignatureNoneZ *NONNULL_PTR arg) {
16381 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
16382 *ret_conv = CResult_ECDSASignatureNoneZ_clone(arg);
16383 return tag_ptr(ret_conv, true);
16385 int64_t __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_clone_ptr"))) TS_CResult_ECDSASignatureNoneZ_clone_ptr(uint64_t arg) {
16386 LDKCResult_ECDSASignatureNoneZ* arg_conv = (LDKCResult_ECDSASignatureNoneZ*)untag_ptr(arg);
16387 int64_t ret_conv = CResult_ECDSASignatureNoneZ_clone_ptr(arg_conv);
16391 uint64_t __attribute__((export_name("TS_CResult_ECDSASignatureNoneZ_clone"))) TS_CResult_ECDSASignatureNoneZ_clone(uint64_t orig) {
16392 LDKCResult_ECDSASignatureNoneZ* orig_conv = (LDKCResult_ECDSASignatureNoneZ*)untag_ptr(orig);
16393 LDKCResult_ECDSASignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ECDSASignatureNoneZ), "LDKCResult_ECDSASignatureNoneZ");
16394 *ret_conv = CResult_ECDSASignatureNoneZ_clone(orig_conv);
16395 return tag_ptr(ret_conv, true);
16398 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_ok"))) TS_CResult_PublicKeyNoneZ_ok(int8_tArray o) {
16399 LDKPublicKey o_ref;
16400 CHECK(o->arr_len == 33);
16401 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
16402 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16403 *ret_conv = CResult_PublicKeyNoneZ_ok(o_ref);
16404 return tag_ptr(ret_conv, true);
16407 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_err"))) TS_CResult_PublicKeyNoneZ_err() {
16408 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16409 *ret_conv = CResult_PublicKeyNoneZ_err();
16410 return tag_ptr(ret_conv, true);
16413 jboolean __attribute__((export_name("TS_CResult_PublicKeyNoneZ_is_ok"))) TS_CResult_PublicKeyNoneZ_is_ok(uint64_t o) {
16414 LDKCResult_PublicKeyNoneZ* o_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(o);
16415 jboolean ret_conv = CResult_PublicKeyNoneZ_is_ok(o_conv);
16419 void __attribute__((export_name("TS_CResult_PublicKeyNoneZ_free"))) TS_CResult_PublicKeyNoneZ_free(uint64_t _res) {
16420 if (!ptr_is_owned(_res)) return;
16421 void* _res_ptr = untag_ptr(_res);
16422 CHECK_ACCESS(_res_ptr);
16423 LDKCResult_PublicKeyNoneZ _res_conv = *(LDKCResult_PublicKeyNoneZ*)(_res_ptr);
16424 FREE(untag_ptr(_res));
16425 CResult_PublicKeyNoneZ_free(_res_conv);
16428 static inline uint64_t CResult_PublicKeyNoneZ_clone_ptr(LDKCResult_PublicKeyNoneZ *NONNULL_PTR arg) {
16429 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16430 *ret_conv = CResult_PublicKeyNoneZ_clone(arg);
16431 return tag_ptr(ret_conv, true);
16433 int64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone_ptr"))) TS_CResult_PublicKeyNoneZ_clone_ptr(uint64_t arg) {
16434 LDKCResult_PublicKeyNoneZ* arg_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(arg);
16435 int64_t ret_conv = CResult_PublicKeyNoneZ_clone_ptr(arg_conv);
16439 uint64_t __attribute__((export_name("TS_CResult_PublicKeyNoneZ_clone"))) TS_CResult_PublicKeyNoneZ_clone(uint64_t orig) {
16440 LDKCResult_PublicKeyNoneZ* orig_conv = (LDKCResult_PublicKeyNoneZ*)untag_ptr(orig);
16441 LDKCResult_PublicKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyNoneZ), "LDKCResult_PublicKeyNoneZ");
16442 *ret_conv = CResult_PublicKeyNoneZ_clone(orig_conv);
16443 return tag_ptr(ret_conv, true);
16446 uint64_t __attribute__((export_name("TS_COption_BigEndianScalarZ_some"))) TS_COption_BigEndianScalarZ_some(uint64_t o) {
16447 void* o_ptr = untag_ptr(o);
16448 CHECK_ACCESS(o_ptr);
16449 LDKBigEndianScalar o_conv = *(LDKBigEndianScalar*)(o_ptr);
16450 // WARNING: we may need a move here but no clone is available for LDKBigEndianScalar
16451 LDKCOption_BigEndianScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_BigEndianScalarZ), "LDKCOption_BigEndianScalarZ");
16452 *ret_copy = COption_BigEndianScalarZ_some(o_conv);
16453 uint64_t ret_ref = tag_ptr(ret_copy, true);
16457 uint64_t __attribute__((export_name("TS_COption_BigEndianScalarZ_none"))) TS_COption_BigEndianScalarZ_none() {
16458 LDKCOption_BigEndianScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_BigEndianScalarZ), "LDKCOption_BigEndianScalarZ");
16459 *ret_copy = COption_BigEndianScalarZ_none();
16460 uint64_t ret_ref = tag_ptr(ret_copy, true);
16464 void __attribute__((export_name("TS_COption_BigEndianScalarZ_free"))) TS_COption_BigEndianScalarZ_free(uint64_t _res) {
16465 if (!ptr_is_owned(_res)) return;
16466 void* _res_ptr = untag_ptr(_res);
16467 CHECK_ACCESS(_res_ptr);
16468 LDKCOption_BigEndianScalarZ _res_conv = *(LDKCOption_BigEndianScalarZ*)(_res_ptr);
16469 FREE(untag_ptr(_res));
16470 COption_BigEndianScalarZ_free(_res_conv);
16473 static inline uint64_t COption_BigEndianScalarZ_clone_ptr(LDKCOption_BigEndianScalarZ *NONNULL_PTR arg) {
16474 LDKCOption_BigEndianScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_BigEndianScalarZ), "LDKCOption_BigEndianScalarZ");
16475 *ret_copy = COption_BigEndianScalarZ_clone(arg);
16476 uint64_t ret_ref = tag_ptr(ret_copy, true);
16479 int64_t __attribute__((export_name("TS_COption_BigEndianScalarZ_clone_ptr"))) TS_COption_BigEndianScalarZ_clone_ptr(uint64_t arg) {
16480 LDKCOption_BigEndianScalarZ* arg_conv = (LDKCOption_BigEndianScalarZ*)untag_ptr(arg);
16481 int64_t ret_conv = COption_BigEndianScalarZ_clone_ptr(arg_conv);
16485 uint64_t __attribute__((export_name("TS_COption_BigEndianScalarZ_clone"))) TS_COption_BigEndianScalarZ_clone(uint64_t orig) {
16486 LDKCOption_BigEndianScalarZ* orig_conv = (LDKCOption_BigEndianScalarZ*)untag_ptr(orig);
16487 LDKCOption_BigEndianScalarZ *ret_copy = MALLOC(sizeof(LDKCOption_BigEndianScalarZ), "LDKCOption_BigEndianScalarZ");
16488 *ret_copy = COption_BigEndianScalarZ_clone(orig_conv);
16489 uint64_t ret_ref = tag_ptr(ret_copy, true);
16493 void __attribute__((export_name("TS_CVec_U5Z_free"))) TS_CVec_U5Z_free(ptrArray _res) {
16494 LDKCVec_U5Z _res_constr;
16495 _res_constr.datalen = _res->arr_len;
16496 if (_res_constr.datalen > 0)
16497 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
16499 _res_constr.data = NULL;
16500 int8_t* _res_vals = (void*) _res->elems;
16501 for (size_t h = 0; h < _res_constr.datalen; h++) {
16502 int8_t _res_conv_7 = _res_vals[h];
16504 _res_constr.data[h] = (LDKU5){ ._0 = _res_conv_7 };
16507 CVec_U5Z_free(_res_constr);
16510 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_ok"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray o) {
16511 LDKRecoverableSignature o_ref;
16512 CHECK(o->arr_len == 68);
16513 memcpy(o_ref.serialized_form, o->elems, 68); FREE(o);
16514 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16515 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(o_ref);
16516 return tag_ptr(ret_conv, true);
16519 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_err"))) TS_CResult_RecoverableSignatureNoneZ_err() {
16520 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16521 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
16522 return tag_ptr(ret_conv, true);
16525 jboolean __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_is_ok"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint64_t o) {
16526 LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(o);
16527 jboolean ret_conv = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
16531 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_free"))) TS_CResult_RecoverableSignatureNoneZ_free(uint64_t _res) {
16532 if (!ptr_is_owned(_res)) return;
16533 void* _res_ptr = untag_ptr(_res);
16534 CHECK_ACCESS(_res_ptr);
16535 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
16536 FREE(untag_ptr(_res));
16537 CResult_RecoverableSignatureNoneZ_free(_res_conv);
16540 static inline uint64_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
16541 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16542 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
16543 return tag_ptr(ret_conv, true);
16545 int64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone_ptr"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint64_t arg) {
16546 LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(arg);
16547 int64_t ret_conv = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
16551 uint64_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint64_t orig) {
16552 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)untag_ptr(orig);
16553 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
16554 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
16555 return tag_ptr(ret_conv, true);
16558 uint64_t __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_ok"))) TS_CResult_SchnorrSignatureNoneZ_ok(int8_tArray o) {
16559 LDKSchnorrSignature o_ref;
16560 CHECK(o->arr_len == 64);
16561 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
16562 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
16563 *ret_conv = CResult_SchnorrSignatureNoneZ_ok(o_ref);
16564 return tag_ptr(ret_conv, true);
16567 uint64_t __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_err"))) TS_CResult_SchnorrSignatureNoneZ_err() {
16568 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
16569 *ret_conv = CResult_SchnorrSignatureNoneZ_err();
16570 return tag_ptr(ret_conv, true);
16573 jboolean __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_is_ok"))) TS_CResult_SchnorrSignatureNoneZ_is_ok(uint64_t o) {
16574 LDKCResult_SchnorrSignatureNoneZ* o_conv = (LDKCResult_SchnorrSignatureNoneZ*)untag_ptr(o);
16575 jboolean ret_conv = CResult_SchnorrSignatureNoneZ_is_ok(o_conv);
16579 void __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_free"))) TS_CResult_SchnorrSignatureNoneZ_free(uint64_t _res) {
16580 if (!ptr_is_owned(_res)) return;
16581 void* _res_ptr = untag_ptr(_res);
16582 CHECK_ACCESS(_res_ptr);
16583 LDKCResult_SchnorrSignatureNoneZ _res_conv = *(LDKCResult_SchnorrSignatureNoneZ*)(_res_ptr);
16584 FREE(untag_ptr(_res));
16585 CResult_SchnorrSignatureNoneZ_free(_res_conv);
16588 static inline uint64_t CResult_SchnorrSignatureNoneZ_clone_ptr(LDKCResult_SchnorrSignatureNoneZ *NONNULL_PTR arg) {
16589 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
16590 *ret_conv = CResult_SchnorrSignatureNoneZ_clone(arg);
16591 return tag_ptr(ret_conv, true);
16593 int64_t __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_clone_ptr"))) TS_CResult_SchnorrSignatureNoneZ_clone_ptr(uint64_t arg) {
16594 LDKCResult_SchnorrSignatureNoneZ* arg_conv = (LDKCResult_SchnorrSignatureNoneZ*)untag_ptr(arg);
16595 int64_t ret_conv = CResult_SchnorrSignatureNoneZ_clone_ptr(arg_conv);
16599 uint64_t __attribute__((export_name("TS_CResult_SchnorrSignatureNoneZ_clone"))) TS_CResult_SchnorrSignatureNoneZ_clone(uint64_t orig) {
16600 LDKCResult_SchnorrSignatureNoneZ* orig_conv = (LDKCResult_SchnorrSignatureNoneZ*)untag_ptr(orig);
16601 LDKCResult_SchnorrSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SchnorrSignatureNoneZ), "LDKCResult_SchnorrSignatureNoneZ");
16602 *ret_conv = CResult_SchnorrSignatureNoneZ_clone(orig_conv);
16603 return tag_ptr(ret_conv, true);
16606 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(uint64_t o) {
16607 void* o_ptr = untag_ptr(o);
16608 CHECK_ACCESS(o_ptr);
16609 LDKWriteableEcdsaChannelSigner o_conv = *(LDKWriteableEcdsaChannelSigner*)(o_ptr);
16610 if (o_conv.free == LDKWriteableEcdsaChannelSigner_JCalls_free) {
16611 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16612 LDKWriteableEcdsaChannelSigner_JCalls_cloned(&o_conv);
16614 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16615 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_ok(o_conv);
16616 return tag_ptr(ret_conv, true);
16619 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(uint64_t e) {
16620 void* e_ptr = untag_ptr(e);
16621 CHECK_ACCESS(e_ptr);
16622 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16623 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16624 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16625 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_err(e_conv);
16626 return tag_ptr(ret_conv, true);
16629 jboolean __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(uint64_t o) {
16630 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* o_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(o);
16631 jboolean ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_is_ok(o_conv);
16635 void __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(uint64_t _res) {
16636 if (!ptr_is_owned(_res)) return;
16637 void* _res_ptr = untag_ptr(_res);
16638 CHECK_ACCESS(_res_ptr);
16639 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ _res_conv = *(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)(_res_ptr);
16640 FREE(untag_ptr(_res));
16641 CResult_WriteableEcdsaChannelSignerDecodeErrorZ_free(_res_conv);
16644 static inline uint64_t CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ *NONNULL_PTR arg) {
16645 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16646 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(arg);
16647 return tag_ptr(ret_conv, true);
16649 int64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16650 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* arg_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(arg);
16651 int64_t ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone_ptr(arg_conv);
16655 uint64_t __attribute__((export_name("TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone"))) TS_CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(uint64_t orig) {
16656 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* orig_conv = (LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ*)untag_ptr(orig);
16657 LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ), "LDKCResult_WriteableEcdsaChannelSignerDecodeErrorZ");
16658 *ret_conv = CResult_WriteableEcdsaChannelSignerDecodeErrorZ_clone(orig_conv);
16659 return tag_ptr(ret_conv, true);
16662 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_ok"))) TS_CResult_CVec_u8ZNoneZ_ok(int8_tArray o) {
16664 o_ref.datalen = o->arr_len;
16665 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
16666 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
16667 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
16668 *ret_conv = CResult_CVec_u8ZNoneZ_ok(o_ref);
16669 return tag_ptr(ret_conv, true);
16672 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_err"))) TS_CResult_CVec_u8ZNoneZ_err() {
16673 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
16674 *ret_conv = CResult_CVec_u8ZNoneZ_err();
16675 return tag_ptr(ret_conv, true);
16678 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_is_ok"))) TS_CResult_CVec_u8ZNoneZ_is_ok(uint64_t o) {
16679 LDKCResult_CVec_u8ZNoneZ* o_conv = (LDKCResult_CVec_u8ZNoneZ*)untag_ptr(o);
16680 jboolean ret_conv = CResult_CVec_u8ZNoneZ_is_ok(o_conv);
16684 void __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_free"))) TS_CResult_CVec_u8ZNoneZ_free(uint64_t _res) {
16685 if (!ptr_is_owned(_res)) return;
16686 void* _res_ptr = untag_ptr(_res);
16687 CHECK_ACCESS(_res_ptr);
16688 LDKCResult_CVec_u8ZNoneZ _res_conv = *(LDKCResult_CVec_u8ZNoneZ*)(_res_ptr);
16689 FREE(untag_ptr(_res));
16690 CResult_CVec_u8ZNoneZ_free(_res_conv);
16693 static inline uint64_t CResult_CVec_u8ZNoneZ_clone_ptr(LDKCResult_CVec_u8ZNoneZ *NONNULL_PTR arg) {
16694 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
16695 *ret_conv = CResult_CVec_u8ZNoneZ_clone(arg);
16696 return tag_ptr(ret_conv, true);
16698 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_clone_ptr"))) TS_CResult_CVec_u8ZNoneZ_clone_ptr(uint64_t arg) {
16699 LDKCResult_CVec_u8ZNoneZ* arg_conv = (LDKCResult_CVec_u8ZNoneZ*)untag_ptr(arg);
16700 int64_t ret_conv = CResult_CVec_u8ZNoneZ_clone_ptr(arg_conv);
16704 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZNoneZ_clone"))) TS_CResult_CVec_u8ZNoneZ_clone(uint64_t orig) {
16705 LDKCResult_CVec_u8ZNoneZ* orig_conv = (LDKCResult_CVec_u8ZNoneZ*)untag_ptr(orig);
16706 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
16707 *ret_conv = CResult_CVec_u8ZNoneZ_clone(orig_conv);
16708 return tag_ptr(ret_conv, true);
16711 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_ok"))) TS_CResult_ShutdownScriptNoneZ_ok(uint64_t o) {
16712 LDKShutdownScript o_conv;
16713 o_conv.inner = untag_ptr(o);
16714 o_conv.is_owned = ptr_is_owned(o);
16715 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16716 o_conv = ShutdownScript_clone(&o_conv);
16717 LDKCResult_ShutdownScriptNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptNoneZ), "LDKCResult_ShutdownScriptNoneZ");
16718 *ret_conv = CResult_ShutdownScriptNoneZ_ok(o_conv);
16719 return tag_ptr(ret_conv, true);
16722 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_err"))) TS_CResult_ShutdownScriptNoneZ_err() {
16723 LDKCResult_ShutdownScriptNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptNoneZ), "LDKCResult_ShutdownScriptNoneZ");
16724 *ret_conv = CResult_ShutdownScriptNoneZ_err();
16725 return tag_ptr(ret_conv, true);
16728 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_is_ok"))) TS_CResult_ShutdownScriptNoneZ_is_ok(uint64_t o) {
16729 LDKCResult_ShutdownScriptNoneZ* o_conv = (LDKCResult_ShutdownScriptNoneZ*)untag_ptr(o);
16730 jboolean ret_conv = CResult_ShutdownScriptNoneZ_is_ok(o_conv);
16734 void __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_free"))) TS_CResult_ShutdownScriptNoneZ_free(uint64_t _res) {
16735 if (!ptr_is_owned(_res)) return;
16736 void* _res_ptr = untag_ptr(_res);
16737 CHECK_ACCESS(_res_ptr);
16738 LDKCResult_ShutdownScriptNoneZ _res_conv = *(LDKCResult_ShutdownScriptNoneZ*)(_res_ptr);
16739 FREE(untag_ptr(_res));
16740 CResult_ShutdownScriptNoneZ_free(_res_conv);
16743 static inline uint64_t CResult_ShutdownScriptNoneZ_clone_ptr(LDKCResult_ShutdownScriptNoneZ *NONNULL_PTR arg) {
16744 LDKCResult_ShutdownScriptNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptNoneZ), "LDKCResult_ShutdownScriptNoneZ");
16745 *ret_conv = CResult_ShutdownScriptNoneZ_clone(arg);
16746 return tag_ptr(ret_conv, true);
16748 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_clone_ptr"))) TS_CResult_ShutdownScriptNoneZ_clone_ptr(uint64_t arg) {
16749 LDKCResult_ShutdownScriptNoneZ* arg_conv = (LDKCResult_ShutdownScriptNoneZ*)untag_ptr(arg);
16750 int64_t ret_conv = CResult_ShutdownScriptNoneZ_clone_ptr(arg_conv);
16754 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptNoneZ_clone"))) TS_CResult_ShutdownScriptNoneZ_clone(uint64_t orig) {
16755 LDKCResult_ShutdownScriptNoneZ* orig_conv = (LDKCResult_ShutdownScriptNoneZ*)untag_ptr(orig);
16756 LDKCResult_ShutdownScriptNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptNoneZ), "LDKCResult_ShutdownScriptNoneZ");
16757 *ret_conv = CResult_ShutdownScriptNoneZ_clone(orig_conv);
16758 return tag_ptr(ret_conv, true);
16761 uint64_t __attribute__((export_name("TS_COption_u16Z_some"))) TS_COption_u16Z_some(int16_t o) {
16762 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16763 *ret_copy = COption_u16Z_some(o);
16764 uint64_t ret_ref = tag_ptr(ret_copy, true);
16768 uint64_t __attribute__((export_name("TS_COption_u16Z_none"))) TS_COption_u16Z_none() {
16769 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16770 *ret_copy = COption_u16Z_none();
16771 uint64_t ret_ref = tag_ptr(ret_copy, true);
16775 void __attribute__((export_name("TS_COption_u16Z_free"))) TS_COption_u16Z_free(uint64_t _res) {
16776 if (!ptr_is_owned(_res)) return;
16777 void* _res_ptr = untag_ptr(_res);
16778 CHECK_ACCESS(_res_ptr);
16779 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
16780 FREE(untag_ptr(_res));
16781 COption_u16Z_free(_res_conv);
16784 static inline uint64_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
16785 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16786 *ret_copy = COption_u16Z_clone(arg);
16787 uint64_t ret_ref = tag_ptr(ret_copy, true);
16790 int64_t __attribute__((export_name("TS_COption_u16Z_clone_ptr"))) TS_COption_u16Z_clone_ptr(uint64_t arg) {
16791 LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)untag_ptr(arg);
16792 int64_t ret_conv = COption_u16Z_clone_ptr(arg_conv);
16796 uint64_t __attribute__((export_name("TS_COption_u16Z_clone"))) TS_COption_u16Z_clone(uint64_t orig) {
16797 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)untag_ptr(orig);
16798 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
16799 *ret_copy = COption_u16Z_clone(orig_conv);
16800 uint64_t ret_ref = tag_ptr(ret_copy, true);
16804 uint64_t __attribute__((export_name("TS_COption_boolZ_some"))) TS_COption_boolZ_some(jboolean o) {
16805 LDKCOption_boolZ *ret_copy = MALLOC(sizeof(LDKCOption_boolZ), "LDKCOption_boolZ");
16806 *ret_copy = COption_boolZ_some(o);
16807 uint64_t ret_ref = tag_ptr(ret_copy, true);
16811 uint64_t __attribute__((export_name("TS_COption_boolZ_none"))) TS_COption_boolZ_none() {
16812 LDKCOption_boolZ *ret_copy = MALLOC(sizeof(LDKCOption_boolZ), "LDKCOption_boolZ");
16813 *ret_copy = COption_boolZ_none();
16814 uint64_t ret_ref = tag_ptr(ret_copy, true);
16818 void __attribute__((export_name("TS_COption_boolZ_free"))) TS_COption_boolZ_free(uint64_t _res) {
16819 if (!ptr_is_owned(_res)) return;
16820 void* _res_ptr = untag_ptr(_res);
16821 CHECK_ACCESS(_res_ptr);
16822 LDKCOption_boolZ _res_conv = *(LDKCOption_boolZ*)(_res_ptr);
16823 FREE(untag_ptr(_res));
16824 COption_boolZ_free(_res_conv);
16827 static inline uint64_t COption_boolZ_clone_ptr(LDKCOption_boolZ *NONNULL_PTR arg) {
16828 LDKCOption_boolZ *ret_copy = MALLOC(sizeof(LDKCOption_boolZ), "LDKCOption_boolZ");
16829 *ret_copy = COption_boolZ_clone(arg);
16830 uint64_t ret_ref = tag_ptr(ret_copy, true);
16833 int64_t __attribute__((export_name("TS_COption_boolZ_clone_ptr"))) TS_COption_boolZ_clone_ptr(uint64_t arg) {
16834 LDKCOption_boolZ* arg_conv = (LDKCOption_boolZ*)untag_ptr(arg);
16835 int64_t ret_conv = COption_boolZ_clone_ptr(arg_conv);
16839 uint64_t __attribute__((export_name("TS_COption_boolZ_clone"))) TS_COption_boolZ_clone(uint64_t orig) {
16840 LDKCOption_boolZ* orig_conv = (LDKCOption_boolZ*)untag_ptr(orig);
16841 LDKCOption_boolZ *ret_copy = MALLOC(sizeof(LDKCOption_boolZ), "LDKCOption_boolZ");
16842 *ret_copy = COption_boolZ_clone(orig_conv);
16843 uint64_t ret_ref = tag_ptr(ret_copy, true);
16847 void __attribute__((export_name("TS_CVec_CVec_u8ZZ_free"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
16848 LDKCVec_CVec_u8ZZ _res_constr;
16849 _res_constr.datalen = _res->arr_len;
16850 if (_res_constr.datalen > 0)
16851 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16853 _res_constr.data = NULL;
16854 int8_tArray* _res_vals = (void*) _res->elems;
16855 for (size_t m = 0; m < _res_constr.datalen; m++) {
16856 int8_tArray _res_conv_12 = _res_vals[m];
16857 LDKCVec_u8Z _res_conv_12_ref;
16858 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
16859 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16860 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
16861 _res_constr.data[m] = _res_conv_12_ref;
16864 CVec_CVec_u8ZZ_free(_res_constr);
16867 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
16868 LDKCVec_CVec_u8ZZ o_constr;
16869 o_constr.datalen = o->arr_len;
16870 if (o_constr.datalen > 0)
16871 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
16873 o_constr.data = NULL;
16874 int8_tArray* o_vals = (void*) o->elems;
16875 for (size_t m = 0; m < o_constr.datalen; m++) {
16876 int8_tArray o_conv_12 = o_vals[m];
16877 LDKCVec_u8Z o_conv_12_ref;
16878 o_conv_12_ref.datalen = o_conv_12->arr_len;
16879 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
16880 memcpy(o_conv_12_ref.data, o_conv_12->elems, o_conv_12_ref.datalen); FREE(o_conv_12);
16881 o_constr.data[m] = o_conv_12_ref;
16884 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16885 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
16886 return tag_ptr(ret_conv, true);
16889 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
16890 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16891 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
16892 return tag_ptr(ret_conv, true);
16895 jboolean __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint64_t o) {
16896 LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(o);
16897 jboolean ret_conv = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
16901 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_free"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint64_t _res) {
16902 if (!ptr_is_owned(_res)) return;
16903 void* _res_ptr = untag_ptr(_res);
16904 CHECK_ACCESS(_res_ptr);
16905 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
16906 FREE(untag_ptr(_res));
16907 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
16910 static inline uint64_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
16911 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16912 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
16913 return tag_ptr(ret_conv, true);
16915 int64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint64_t arg) {
16916 LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(arg);
16917 int64_t ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
16921 uint64_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint64_t orig) {
16922 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)untag_ptr(orig);
16923 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
16924 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
16925 return tag_ptr(ret_conv, true);
16928 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint64_t o) {
16929 LDKInMemorySigner o_conv;
16930 o_conv.inner = untag_ptr(o);
16931 o_conv.is_owned = ptr_is_owned(o);
16932 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16933 o_conv = InMemorySigner_clone(&o_conv);
16934 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16935 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
16936 return tag_ptr(ret_conv, true);
16939 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_err"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint64_t e) {
16940 void* e_ptr = untag_ptr(e);
16941 CHECK_ACCESS(e_ptr);
16942 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
16943 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
16944 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16945 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
16946 return tag_ptr(ret_conv, true);
16949 jboolean __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_is_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint64_t o) {
16950 LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(o);
16951 jboolean ret_conv = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
16955 void __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_free"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint64_t _res) {
16956 if (!ptr_is_owned(_res)) return;
16957 void* _res_ptr = untag_ptr(_res);
16958 CHECK_ACCESS(_res_ptr);
16959 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
16960 FREE(untag_ptr(_res));
16961 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
16964 static inline uint64_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
16965 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16966 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
16967 return tag_ptr(ret_conv, true);
16969 int64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint64_t arg) {
16970 LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(arg);
16971 int64_t ret_conv = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
16975 uint64_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint64_t orig) {
16976 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)untag_ptr(orig);
16977 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
16978 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
16979 return tag_ptr(ret_conv, true);
16982 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_ok"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
16983 LDKTransaction o_ref;
16984 o_ref.datalen = o->arr_len;
16985 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
16986 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
16987 o_ref.data_is_owned = true;
16988 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16989 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
16990 return tag_ptr(ret_conv, true);
16993 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_err"))) TS_CResult_TransactionNoneZ_err() {
16994 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
16995 *ret_conv = CResult_TransactionNoneZ_err();
16996 return tag_ptr(ret_conv, true);
16999 jboolean __attribute__((export_name("TS_CResult_TransactionNoneZ_is_ok"))) TS_CResult_TransactionNoneZ_is_ok(uint64_t o) {
17000 LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(o);
17001 jboolean ret_conv = CResult_TransactionNoneZ_is_ok(o_conv);
17005 void __attribute__((export_name("TS_CResult_TransactionNoneZ_free"))) TS_CResult_TransactionNoneZ_free(uint64_t _res) {
17006 if (!ptr_is_owned(_res)) return;
17007 void* _res_ptr = untag_ptr(_res);
17008 CHECK_ACCESS(_res_ptr);
17009 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
17010 FREE(untag_ptr(_res));
17011 CResult_TransactionNoneZ_free(_res_conv);
17014 static inline uint64_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
17015 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17016 *ret_conv = CResult_TransactionNoneZ_clone(arg);
17017 return tag_ptr(ret_conv, true);
17019 int64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone_ptr"))) TS_CResult_TransactionNoneZ_clone_ptr(uint64_t arg) {
17020 LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(arg);
17021 int64_t ret_conv = CResult_TransactionNoneZ_clone_ptr(arg_conv);
17025 uint64_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone"))) TS_CResult_TransactionNoneZ_clone(uint64_t orig) {
17026 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)untag_ptr(orig);
17027 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
17028 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
17029 return tag_ptr(ret_conv, true);
17032 void __attribute__((export_name("TS_CVec_ChannelDetailsZ_free"))) TS_CVec_ChannelDetailsZ_free(uint64_tArray _res) {
17033 LDKCVec_ChannelDetailsZ _res_constr;
17034 _res_constr.datalen = _res->arr_len;
17035 if (_res_constr.datalen > 0)
17036 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
17038 _res_constr.data = NULL;
17039 uint64_t* _res_vals = _res->elems;
17040 for (size_t q = 0; q < _res_constr.datalen; q++) {
17041 uint64_t _res_conv_16 = _res_vals[q];
17042 LDKChannelDetails _res_conv_16_conv;
17043 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
17044 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
17045 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
17046 _res_constr.data[q] = _res_conv_16_conv;
17049 CVec_ChannelDetailsZ_free(_res_constr);
17052 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_ok"))) TS_CResult_RouteLightningErrorZ_ok(uint64_t o) {
17054 o_conv.inner = untag_ptr(o);
17055 o_conv.is_owned = ptr_is_owned(o);
17056 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17057 o_conv = Route_clone(&o_conv);
17058 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
17059 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
17060 return tag_ptr(ret_conv, true);
17063 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_err"))) TS_CResult_RouteLightningErrorZ_err(uint64_t e) {
17064 LDKLightningError e_conv;
17065 e_conv.inner = untag_ptr(e);
17066 e_conv.is_owned = ptr_is_owned(e);
17067 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
17068 e_conv = LightningError_clone(&e_conv);
17069 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
17070 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
17071 return tag_ptr(ret_conv, true);
17074 jboolean __attribute__((export_name("TS_CResult_RouteLightningErrorZ_is_ok"))) TS_CResult_RouteLightningErrorZ_is_ok(uint64_t o) {
17075 LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(o);
17076 jboolean ret_conv = CResult_RouteLightningErrorZ_is_ok(o_conv);
17080 void __attribute__((export_name("TS_CResult_RouteLightningErrorZ_free"))) TS_CResult_RouteLightningErrorZ_free(uint64_t _res) {
17081 if (!ptr_is_owned(_res)) return;
17082 void* _res_ptr = untag_ptr(_res);
17083 CHECK_ACCESS(_res_ptr);
17084 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
17085 FREE(untag_ptr(_res));
17086 CResult_RouteLightningErrorZ_free(_res_conv);
17089 static inline uint64_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
17090 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
17091 *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
17092 return tag_ptr(ret_conv, true);
17094 int64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone_ptr"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint64_t arg) {
17095 LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(arg);
17096 int64_t ret_conv = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
17100 uint64_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone"))) TS_CResult_RouteLightningErrorZ_clone(uint64_t orig) {
17101 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)untag_ptr(orig);
17102 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
17103 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
17104 return tag_ptr(ret_conv, true);
17107 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_ok(uint64_t o) {
17108 LDKInFlightHtlcs o_conv;
17109 o_conv.inner = untag_ptr(o);
17110 o_conv.is_owned = ptr_is_owned(o);
17111 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17112 o_conv = InFlightHtlcs_clone(&o_conv);
17113 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
17114 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_ok(o_conv);
17115 return tag_ptr(ret_conv, true);
17118 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_err"))) TS_CResult_InFlightHtlcsDecodeErrorZ_err(uint64_t e) {
17119 void* e_ptr = untag_ptr(e);
17120 CHECK_ACCESS(e_ptr);
17121 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17122 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17123 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
17124 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_err(e_conv);
17125 return tag_ptr(ret_conv, true);
17128 jboolean __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok"))) TS_CResult_InFlightHtlcsDecodeErrorZ_is_ok(uint64_t o) {
17129 LDKCResult_InFlightHtlcsDecodeErrorZ* o_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(o);
17130 jboolean ret_conv = CResult_InFlightHtlcsDecodeErrorZ_is_ok(o_conv);
17134 void __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_free"))) TS_CResult_InFlightHtlcsDecodeErrorZ_free(uint64_t _res) {
17135 if (!ptr_is_owned(_res)) return;
17136 void* _res_ptr = untag_ptr(_res);
17137 CHECK_ACCESS(_res_ptr);
17138 LDKCResult_InFlightHtlcsDecodeErrorZ _res_conv = *(LDKCResult_InFlightHtlcsDecodeErrorZ*)(_res_ptr);
17139 FREE(untag_ptr(_res));
17140 CResult_InFlightHtlcsDecodeErrorZ_free(_res_conv);
17143 static inline uint64_t CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(LDKCResult_InFlightHtlcsDecodeErrorZ *NONNULL_PTR arg) {
17144 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
17145 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(arg);
17146 return tag_ptr(ret_conv, true);
17148 int64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(uint64_t arg) {
17149 LDKCResult_InFlightHtlcsDecodeErrorZ* arg_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(arg);
17150 int64_t ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone_ptr(arg_conv);
17154 uint64_t __attribute__((export_name("TS_CResult_InFlightHtlcsDecodeErrorZ_clone"))) TS_CResult_InFlightHtlcsDecodeErrorZ_clone(uint64_t orig) {
17155 LDKCResult_InFlightHtlcsDecodeErrorZ* orig_conv = (LDKCResult_InFlightHtlcsDecodeErrorZ*)untag_ptr(orig);
17156 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
17157 *ret_conv = CResult_InFlightHtlcsDecodeErrorZ_clone(orig_conv);
17158 return tag_ptr(ret_conv, true);
17161 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_ok"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint64_t o) {
17162 LDKRouteHop o_conv;
17163 o_conv.inner = untag_ptr(o);
17164 o_conv.is_owned = ptr_is_owned(o);
17165 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17166 o_conv = RouteHop_clone(&o_conv);
17167 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
17168 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
17169 return tag_ptr(ret_conv, true);
17172 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_err"))) TS_CResult_RouteHopDecodeErrorZ_err(uint64_t e) {
17173 void* e_ptr = untag_ptr(e);
17174 CHECK_ACCESS(e_ptr);
17175 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17176 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17177 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
17178 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
17179 return tag_ptr(ret_conv, true);
17182 jboolean __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint64_t o) {
17183 LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(o);
17184 jboolean ret_conv = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
17188 void __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_free"))) TS_CResult_RouteHopDecodeErrorZ_free(uint64_t _res) {
17189 if (!ptr_is_owned(_res)) return;
17190 void* _res_ptr = untag_ptr(_res);
17191 CHECK_ACCESS(_res_ptr);
17192 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(_res_ptr);
17193 FREE(untag_ptr(_res));
17194 CResult_RouteHopDecodeErrorZ_free(_res_conv);
17197 static inline uint64_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
17198 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
17199 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
17200 return tag_ptr(ret_conv, true);
17202 int64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint64_t arg) {
17203 LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(arg);
17204 int64_t ret_conv = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
17208 uint64_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint64_t orig) {
17209 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)untag_ptr(orig);
17210 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
17211 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
17212 return tag_ptr(ret_conv, true);
17215 void __attribute__((export_name("TS_CVec_BlindedHopZ_free"))) TS_CVec_BlindedHopZ_free(uint64_tArray _res) {
17216 LDKCVec_BlindedHopZ _res_constr;
17217 _res_constr.datalen = _res->arr_len;
17218 if (_res_constr.datalen > 0)
17219 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
17221 _res_constr.data = NULL;
17222 uint64_t* _res_vals = _res->elems;
17223 for (size_t m = 0; m < _res_constr.datalen; m++) {
17224 uint64_t _res_conv_12 = _res_vals[m];
17225 LDKBlindedHop _res_conv_12_conv;
17226 _res_conv_12_conv.inner = untag_ptr(_res_conv_12);
17227 _res_conv_12_conv.is_owned = ptr_is_owned(_res_conv_12);
17228 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv);
17229 _res_constr.data[m] = _res_conv_12_conv;
17232 CVec_BlindedHopZ_free(_res_constr);
17235 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_ok"))) TS_CResult_BlindedTailDecodeErrorZ_ok(uint64_t o) {
17236 LDKBlindedTail o_conv;
17237 o_conv.inner = untag_ptr(o);
17238 o_conv.is_owned = ptr_is_owned(o);
17239 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17240 o_conv = BlindedTail_clone(&o_conv);
17241 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
17242 *ret_conv = CResult_BlindedTailDecodeErrorZ_ok(o_conv);
17243 return tag_ptr(ret_conv, true);
17246 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_err"))) TS_CResult_BlindedTailDecodeErrorZ_err(uint64_t e) {
17247 void* e_ptr = untag_ptr(e);
17248 CHECK_ACCESS(e_ptr);
17249 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17250 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17251 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
17252 *ret_conv = CResult_BlindedTailDecodeErrorZ_err(e_conv);
17253 return tag_ptr(ret_conv, true);
17256 jboolean __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_is_ok"))) TS_CResult_BlindedTailDecodeErrorZ_is_ok(uint64_t o) {
17257 LDKCResult_BlindedTailDecodeErrorZ* o_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(o);
17258 jboolean ret_conv = CResult_BlindedTailDecodeErrorZ_is_ok(o_conv);
17262 void __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_free"))) TS_CResult_BlindedTailDecodeErrorZ_free(uint64_t _res) {
17263 if (!ptr_is_owned(_res)) return;
17264 void* _res_ptr = untag_ptr(_res);
17265 CHECK_ACCESS(_res_ptr);
17266 LDKCResult_BlindedTailDecodeErrorZ _res_conv = *(LDKCResult_BlindedTailDecodeErrorZ*)(_res_ptr);
17267 FREE(untag_ptr(_res));
17268 CResult_BlindedTailDecodeErrorZ_free(_res_conv);
17271 static inline uint64_t CResult_BlindedTailDecodeErrorZ_clone_ptr(LDKCResult_BlindedTailDecodeErrorZ *NONNULL_PTR arg) {
17272 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
17273 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(arg);
17274 return tag_ptr(ret_conv, true);
17276 int64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedTailDecodeErrorZ_clone_ptr(uint64_t arg) {
17277 LDKCResult_BlindedTailDecodeErrorZ* arg_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(arg);
17278 int64_t ret_conv = CResult_BlindedTailDecodeErrorZ_clone_ptr(arg_conv);
17282 uint64_t __attribute__((export_name("TS_CResult_BlindedTailDecodeErrorZ_clone"))) TS_CResult_BlindedTailDecodeErrorZ_clone(uint64_t orig) {
17283 LDKCResult_BlindedTailDecodeErrorZ* orig_conv = (LDKCResult_BlindedTailDecodeErrorZ*)untag_ptr(orig);
17284 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
17285 *ret_conv = CResult_BlindedTailDecodeErrorZ_clone(orig_conv);
17286 return tag_ptr(ret_conv, true);
17289 void __attribute__((export_name("TS_CVec_RouteHopZ_free"))) TS_CVec_RouteHopZ_free(uint64_tArray _res) {
17290 LDKCVec_RouteHopZ _res_constr;
17291 _res_constr.datalen = _res->arr_len;
17292 if (_res_constr.datalen > 0)
17293 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
17295 _res_constr.data = NULL;
17296 uint64_t* _res_vals = _res->elems;
17297 for (size_t k = 0; k < _res_constr.datalen; k++) {
17298 uint64_t _res_conv_10 = _res_vals[k];
17299 LDKRouteHop _res_conv_10_conv;
17300 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
17301 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
17302 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
17303 _res_constr.data[k] = _res_conv_10_conv;
17306 CVec_RouteHopZ_free(_res_constr);
17309 void __attribute__((export_name("TS_CVec_PathZ_free"))) TS_CVec_PathZ_free(uint64_tArray _res) {
17310 LDKCVec_PathZ _res_constr;
17311 _res_constr.datalen = _res->arr_len;
17312 if (_res_constr.datalen > 0)
17313 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
17315 _res_constr.data = NULL;
17316 uint64_t* _res_vals = _res->elems;
17317 for (size_t g = 0; g < _res_constr.datalen; g++) {
17318 uint64_t _res_conv_6 = _res_vals[g];
17319 LDKPath _res_conv_6_conv;
17320 _res_conv_6_conv.inner = untag_ptr(_res_conv_6);
17321 _res_conv_6_conv.is_owned = ptr_is_owned(_res_conv_6);
17322 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_6_conv);
17323 _res_constr.data[g] = _res_conv_6_conv;
17326 CVec_PathZ_free(_res_constr);
17329 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_ok"))) TS_CResult_RouteDecodeErrorZ_ok(uint64_t o) {
17331 o_conv.inner = untag_ptr(o);
17332 o_conv.is_owned = ptr_is_owned(o);
17333 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17334 o_conv = Route_clone(&o_conv);
17335 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
17336 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
17337 return tag_ptr(ret_conv, true);
17340 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_err"))) TS_CResult_RouteDecodeErrorZ_err(uint64_t e) {
17341 void* e_ptr = untag_ptr(e);
17342 CHECK_ACCESS(e_ptr);
17343 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17344 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17345 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
17346 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
17347 return tag_ptr(ret_conv, true);
17350 jboolean __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_is_ok"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint64_t o) {
17351 LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(o);
17352 jboolean ret_conv = CResult_RouteDecodeErrorZ_is_ok(o_conv);
17356 void __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_free"))) TS_CResult_RouteDecodeErrorZ_free(uint64_t _res) {
17357 if (!ptr_is_owned(_res)) return;
17358 void* _res_ptr = untag_ptr(_res);
17359 CHECK_ACCESS(_res_ptr);
17360 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(_res_ptr);
17361 FREE(untag_ptr(_res));
17362 CResult_RouteDecodeErrorZ_free(_res_conv);
17365 static inline uint64_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
17366 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
17367 *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
17368 return tag_ptr(ret_conv, true);
17370 int64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone_ptr"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint64_t arg) {
17371 LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(arg);
17372 int64_t ret_conv = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
17376 uint64_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone"))) TS_CResult_RouteDecodeErrorZ_clone(uint64_t orig) {
17377 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)untag_ptr(orig);
17378 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
17379 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
17380 return tag_ptr(ret_conv, true);
17383 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_ok"))) TS_CResult_RouteParametersDecodeErrorZ_ok(uint64_t o) {
17384 LDKRouteParameters o_conv;
17385 o_conv.inner = untag_ptr(o);
17386 o_conv.is_owned = ptr_is_owned(o);
17387 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17388 o_conv = RouteParameters_clone(&o_conv);
17389 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
17390 *ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
17391 return tag_ptr(ret_conv, true);
17394 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_err"))) TS_CResult_RouteParametersDecodeErrorZ_err(uint64_t e) {
17395 void* e_ptr = untag_ptr(e);
17396 CHECK_ACCESS(e_ptr);
17397 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17398 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17399 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
17400 *ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
17401 return tag_ptr(ret_conv, true);
17404 jboolean __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_is_ok"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint64_t o) {
17405 LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(o);
17406 jboolean ret_conv = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
17410 void __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_free"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint64_t _res) {
17411 if (!ptr_is_owned(_res)) return;
17412 void* _res_ptr = untag_ptr(_res);
17413 CHECK_ACCESS(_res_ptr);
17414 LDKCResult_RouteParametersDecodeErrorZ _res_conv = *(LDKCResult_RouteParametersDecodeErrorZ*)(_res_ptr);
17415 FREE(untag_ptr(_res));
17416 CResult_RouteParametersDecodeErrorZ_free(_res_conv);
17419 static inline uint64_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
17420 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
17421 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
17422 return tag_ptr(ret_conv, true);
17424 int64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone_ptr"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
17425 LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(arg);
17426 int64_t ret_conv = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
17430 uint64_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint64_t orig) {
17431 LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)untag_ptr(orig);
17432 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
17433 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(orig_conv);
17434 return tag_ptr(ret_conv, true);
17437 void __attribute__((export_name("TS_CVec_u64Z_free"))) TS_CVec_u64Z_free(int64_tArray _res) {
17438 LDKCVec_u64Z _res_constr;
17439 _res_constr.datalen = _res->arr_len;
17440 if (_res_constr.datalen > 0)
17441 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
17443 _res_constr.data = NULL;
17444 int64_t* _res_vals = _res->elems;
17445 for (size_t i = 0; i < _res_constr.datalen; i++) {
17446 int64_t _res_conv_8 = _res_vals[i];
17447 _res_constr.data[i] = _res_conv_8;
17450 CVec_u64Z_free(_res_constr);
17453 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_ok(uint64_t o) {
17454 LDKPaymentParameters o_conv;
17455 o_conv.inner = untag_ptr(o);
17456 o_conv.is_owned = ptr_is_owned(o);
17457 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17458 o_conv = PaymentParameters_clone(&o_conv);
17459 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
17460 *ret_conv = CResult_PaymentParametersDecodeErrorZ_ok(o_conv);
17461 return tag_ptr(ret_conv, true);
17464 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_err"))) TS_CResult_PaymentParametersDecodeErrorZ_err(uint64_t e) {
17465 void* e_ptr = untag_ptr(e);
17466 CHECK_ACCESS(e_ptr);
17467 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17468 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17469 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
17470 *ret_conv = CResult_PaymentParametersDecodeErrorZ_err(e_conv);
17471 return tag_ptr(ret_conv, true);
17474 jboolean __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_is_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_is_ok(uint64_t o) {
17475 LDKCResult_PaymentParametersDecodeErrorZ* o_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(o);
17476 jboolean ret_conv = CResult_PaymentParametersDecodeErrorZ_is_ok(o_conv);
17480 void __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_free"))) TS_CResult_PaymentParametersDecodeErrorZ_free(uint64_t _res) {
17481 if (!ptr_is_owned(_res)) return;
17482 void* _res_ptr = untag_ptr(_res);
17483 CHECK_ACCESS(_res_ptr);
17484 LDKCResult_PaymentParametersDecodeErrorZ _res_conv = *(LDKCResult_PaymentParametersDecodeErrorZ*)(_res_ptr);
17485 FREE(untag_ptr(_res));
17486 CResult_PaymentParametersDecodeErrorZ_free(_res_conv);
17489 static inline uint64_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg) {
17490 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
17491 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(arg);
17492 return tag_ptr(ret_conv, true);
17494 int64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
17495 LDKCResult_PaymentParametersDecodeErrorZ* arg_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(arg);
17496 int64_t ret_conv = CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg_conv);
17500 uint64_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone"))) TS_CResult_PaymentParametersDecodeErrorZ_clone(uint64_t orig) {
17501 LDKCResult_PaymentParametersDecodeErrorZ* orig_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)untag_ptr(orig);
17502 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
17503 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(orig_conv);
17504 return tag_ptr(ret_conv, true);
17507 static inline uint64_t C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(LDKC2Tuple_BlindedPayInfoBlindedPathZ *NONNULL_PTR arg) {
17508 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
17509 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(arg);
17510 return tag_ptr(ret_conv, true);
17512 int64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(uint64_t arg) {
17513 LDKC2Tuple_BlindedPayInfoBlindedPathZ* arg_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(arg);
17514 int64_t ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone_ptr(arg_conv);
17518 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_clone(uint64_t orig) {
17519 LDKC2Tuple_BlindedPayInfoBlindedPathZ* orig_conv = (LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(orig);
17520 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
17521 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone(orig_conv);
17522 return tag_ptr(ret_conv, true);
17525 uint64_t __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_new"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_new(uint64_t a, uint64_t b) {
17526 LDKBlindedPayInfo a_conv;
17527 a_conv.inner = untag_ptr(a);
17528 a_conv.is_owned = ptr_is_owned(a);
17529 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
17530 a_conv = BlindedPayInfo_clone(&a_conv);
17531 LDKBlindedPath b_conv;
17532 b_conv.inner = untag_ptr(b);
17533 b_conv.is_owned = ptr_is_owned(b);
17534 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
17535 b_conv = BlindedPath_clone(&b_conv);
17536 LDKC2Tuple_BlindedPayInfoBlindedPathZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKC2Tuple_BlindedPayInfoBlindedPathZ");
17537 *ret_conv = C2Tuple_BlindedPayInfoBlindedPathZ_new(a_conv, b_conv);
17538 return tag_ptr(ret_conv, true);
17541 void __attribute__((export_name("TS_C2Tuple_BlindedPayInfoBlindedPathZ_free"))) TS_C2Tuple_BlindedPayInfoBlindedPathZ_free(uint64_t _res) {
17542 if (!ptr_is_owned(_res)) return;
17543 void* _res_ptr = untag_ptr(_res);
17544 CHECK_ACCESS(_res_ptr);
17545 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_ptr);
17546 FREE(untag_ptr(_res));
17547 C2Tuple_BlindedPayInfoBlindedPathZ_free(_res_conv);
17550 void __attribute__((export_name("TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free"))) TS_CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(uint64_tArray _res) {
17551 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ _res_constr;
17552 _res_constr.datalen = _res->arr_len;
17553 if (_res_constr.datalen > 0)
17554 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
17556 _res_constr.data = NULL;
17557 uint64_t* _res_vals = _res->elems;
17558 for (size_t l = 0; l < _res_constr.datalen; l++) {
17559 uint64_t _res_conv_37 = _res_vals[l];
17560 void* _res_conv_37_ptr = untag_ptr(_res_conv_37);
17561 CHECK_ACCESS(_res_conv_37_ptr);
17562 LDKC2Tuple_BlindedPayInfoBlindedPathZ _res_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(_res_conv_37_ptr);
17563 FREE(untag_ptr(_res_conv_37));
17564 _res_constr.data[l] = _res_conv_37_conv;
17567 CVec_C2Tuple_BlindedPayInfoBlindedPathZZ_free(_res_constr);
17570 void __attribute__((export_name("TS_CVec_RouteHintZ_free"))) TS_CVec_RouteHintZ_free(uint64_tArray _res) {
17571 LDKCVec_RouteHintZ _res_constr;
17572 _res_constr.datalen = _res->arr_len;
17573 if (_res_constr.datalen > 0)
17574 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
17576 _res_constr.data = NULL;
17577 uint64_t* _res_vals = _res->elems;
17578 for (size_t l = 0; l < _res_constr.datalen; l++) {
17579 uint64_t _res_conv_11 = _res_vals[l];
17580 LDKRouteHint _res_conv_11_conv;
17581 _res_conv_11_conv.inner = untag_ptr(_res_conv_11);
17582 _res_conv_11_conv.is_owned = ptr_is_owned(_res_conv_11);
17583 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
17584 _res_constr.data[l] = _res_conv_11_conv;
17587 CVec_RouteHintZ_free(_res_constr);
17590 void __attribute__((export_name("TS_CVec_RouteHintHopZ_free"))) TS_CVec_RouteHintHopZ_free(uint64_tArray _res) {
17591 LDKCVec_RouteHintHopZ _res_constr;
17592 _res_constr.datalen = _res->arr_len;
17593 if (_res_constr.datalen > 0)
17594 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
17596 _res_constr.data = NULL;
17597 uint64_t* _res_vals = _res->elems;
17598 for (size_t o = 0; o < _res_constr.datalen; o++) {
17599 uint64_t _res_conv_14 = _res_vals[o];
17600 LDKRouteHintHop _res_conv_14_conv;
17601 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
17602 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
17603 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
17604 _res_constr.data[o] = _res_conv_14_conv;
17607 CVec_RouteHintHopZ_free(_res_constr);
17610 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_ok"))) TS_CResult_RouteHintDecodeErrorZ_ok(uint64_t o) {
17611 LDKRouteHint o_conv;
17612 o_conv.inner = untag_ptr(o);
17613 o_conv.is_owned = ptr_is_owned(o);
17614 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17615 o_conv = RouteHint_clone(&o_conv);
17616 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
17617 *ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
17618 return tag_ptr(ret_conv, true);
17621 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_err"))) TS_CResult_RouteHintDecodeErrorZ_err(uint64_t e) {
17622 void* e_ptr = untag_ptr(e);
17623 CHECK_ACCESS(e_ptr);
17624 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17625 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17626 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
17627 *ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
17628 return tag_ptr(ret_conv, true);
17631 jboolean __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_is_ok"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint64_t o) {
17632 LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(o);
17633 jboolean ret_conv = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
17637 void __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_free"))) TS_CResult_RouteHintDecodeErrorZ_free(uint64_t _res) {
17638 if (!ptr_is_owned(_res)) return;
17639 void* _res_ptr = untag_ptr(_res);
17640 CHECK_ACCESS(_res_ptr);
17641 LDKCResult_RouteHintDecodeErrorZ _res_conv = *(LDKCResult_RouteHintDecodeErrorZ*)(_res_ptr);
17642 FREE(untag_ptr(_res));
17643 CResult_RouteHintDecodeErrorZ_free(_res_conv);
17646 static inline uint64_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
17647 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
17648 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
17649 return tag_ptr(ret_conv, true);
17651 int64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint64_t arg) {
17652 LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(arg);
17653 int64_t ret_conv = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
17657 uint64_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint64_t orig) {
17658 LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)untag_ptr(orig);
17659 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
17660 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(orig_conv);
17661 return tag_ptr(ret_conv, true);
17664 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_ok(uint64_t o) {
17665 LDKRouteHintHop o_conv;
17666 o_conv.inner = untag_ptr(o);
17667 o_conv.is_owned = ptr_is_owned(o);
17668 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17669 o_conv = RouteHintHop_clone(&o_conv);
17670 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
17671 *ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
17672 return tag_ptr(ret_conv, true);
17675 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_err"))) TS_CResult_RouteHintHopDecodeErrorZ_err(uint64_t e) {
17676 void* e_ptr = untag_ptr(e);
17677 CHECK_ACCESS(e_ptr);
17678 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17679 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17680 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
17681 *ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
17682 return tag_ptr(ret_conv, true);
17685 jboolean __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint64_t o) {
17686 LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(o);
17687 jboolean ret_conv = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
17691 void __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_free"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint64_t _res) {
17692 if (!ptr_is_owned(_res)) return;
17693 void* _res_ptr = untag_ptr(_res);
17694 CHECK_ACCESS(_res_ptr);
17695 LDKCResult_RouteHintHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHintHopDecodeErrorZ*)(_res_ptr);
17696 FREE(untag_ptr(_res));
17697 CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
17700 static inline uint64_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
17701 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
17702 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
17703 return tag_ptr(ret_conv, true);
17705 int64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint64_t arg) {
17706 LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(arg);
17707 int64_t ret_conv = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
17711 uint64_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint64_t orig) {
17712 LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)untag_ptr(orig);
17713 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
17714 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(orig_conv);
17715 return tag_ptr(ret_conv, true);
17718 void __attribute__((export_name("TS_CVec_PublicKeyZ_free"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
17719 LDKCVec_PublicKeyZ _res_constr;
17720 _res_constr.datalen = _res->arr_len;
17721 if (_res_constr.datalen > 0)
17722 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
17724 _res_constr.data = NULL;
17725 int8_tArray* _res_vals = (void*) _res->elems;
17726 for (size_t m = 0; m < _res_constr.datalen; m++) {
17727 int8_tArray _res_conv_12 = _res_vals[m];
17728 LDKPublicKey _res_conv_12_ref;
17729 CHECK(_res_conv_12->arr_len == 33);
17730 memcpy(_res_conv_12_ref.compressed_form, _res_conv_12->elems, 33); FREE(_res_conv_12);
17731 _res_constr.data[m] = _res_conv_12_ref;
17734 CVec_PublicKeyZ_free(_res_constr);
17737 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(uint64_t o) {
17738 LDKFixedPenaltyScorer o_conv;
17739 o_conv.inner = untag_ptr(o);
17740 o_conv.is_owned = ptr_is_owned(o);
17741 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17742 o_conv = FixedPenaltyScorer_clone(&o_conv);
17743 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
17744 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_ok(o_conv);
17745 return tag_ptr(ret_conv, true);
17748 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(uint64_t e) {
17749 void* e_ptr = untag_ptr(e);
17750 CHECK_ACCESS(e_ptr);
17751 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
17752 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
17753 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
17754 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_err(e_conv);
17755 return tag_ptr(ret_conv, true);
17758 jboolean __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(uint64_t o) {
17759 LDKCResult_FixedPenaltyScorerDecodeErrorZ* o_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(o);
17760 jboolean ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o_conv);
17764 void __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_free"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(uint64_t _res) {
17765 if (!ptr_is_owned(_res)) return;
17766 void* _res_ptr = untag_ptr(_res);
17767 CHECK_ACCESS(_res_ptr);
17768 LDKCResult_FixedPenaltyScorerDecodeErrorZ _res_conv = *(LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(_res_ptr);
17769 FREE(untag_ptr(_res));
17770 CResult_FixedPenaltyScorerDecodeErrorZ_free(_res_conv);
17773 static inline uint64_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg) {
17774 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
17775 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(arg);
17776 return tag_ptr(ret_conv, true);
17778 int64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(uint64_t arg) {
17779 LDKCResult_FixedPenaltyScorerDecodeErrorZ* arg_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(arg);
17780 int64_t ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg_conv);
17784 uint64_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(uint64_t orig) {
17785 LDKCResult_FixedPenaltyScorerDecodeErrorZ* orig_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)untag_ptr(orig);
17786 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
17787 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig_conv);
17788 return tag_ptr(ret_conv, true);
17791 void __attribute__((export_name("TS_CVec_NodeIdZ_free"))) TS_CVec_NodeIdZ_free(uint64_tArray _res) {
17792 LDKCVec_NodeIdZ _res_constr;
17793 _res_constr.datalen = _res->arr_len;
17794 if (_res_constr.datalen > 0)
17795 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
17797 _res_constr.data = NULL;
17798 uint64_t* _res_vals = _res->elems;
17799 for (size_t i = 0; i < _res_constr.datalen; i++) {
17800 uint64_t _res_conv_8 = _res_vals[i];
17801 LDKNodeId _res_conv_8_conv;
17802 _res_conv_8_conv.inner = untag_ptr(_res_conv_8);
17803 _res_conv_8_conv.is_owned = ptr_is_owned(_res_conv_8);
17804 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_8_conv);
17805 _res_constr.data[i] = _res_conv_8_conv;
17808 CVec_NodeIdZ_free(_res_constr);
17811 static inline uint64_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg) {
17812 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
17813 *ret_conv = C2Tuple_u64u64Z_clone(arg);
17814 return tag_ptr(ret_conv, true);
17816 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone_ptr"))) TS_C2Tuple_u64u64Z_clone_ptr(uint64_t arg) {
17817 LDKC2Tuple_u64u64Z* arg_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(arg);
17818 int64_t ret_conv = C2Tuple_u64u64Z_clone_ptr(arg_conv);
17822 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone"))) TS_C2Tuple_u64u64Z_clone(uint64_t orig) {
17823 LDKC2Tuple_u64u64Z* orig_conv = (LDKC2Tuple_u64u64Z*)untag_ptr(orig);
17824 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
17825 *ret_conv = C2Tuple_u64u64Z_clone(orig_conv);
17826 return tag_ptr(ret_conv, true);
17829 uint64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_new"))) TS_C2Tuple_u64u64Z_new(int64_t a, int64_t b) {
17830 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
17831 *ret_conv = C2Tuple_u64u64Z_new(a, b);
17832 return tag_ptr(ret_conv, true);
17835 void __attribute__((export_name("TS_C2Tuple_u64u64Z_free"))) TS_C2Tuple_u64u64Z_free(uint64_t _res) {
17836 if (!ptr_is_owned(_res)) return;
17837 void* _res_ptr = untag_ptr(_res);
17838 CHECK_ACCESS(_res_ptr);
17839 LDKC2Tuple_u64u64Z _res_conv = *(LDKC2Tuple_u64u64Z*)(_res_ptr);
17840 FREE(untag_ptr(_res));
17841 C2Tuple_u64u64Z_free(_res_conv);
17844 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_some"))) TS_COption_C2Tuple_u64u64ZZ_some(uint64_t o) {
17845 void* o_ptr = untag_ptr(o);
17846 CHECK_ACCESS(o_ptr);
17847 LDKC2Tuple_u64u64Z o_conv = *(LDKC2Tuple_u64u64Z*)(o_ptr);
17848 o_conv = C2Tuple_u64u64Z_clone((LDKC2Tuple_u64u64Z*)untag_ptr(o));
17849 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
17850 *ret_copy = COption_C2Tuple_u64u64ZZ_some(o_conv);
17851 uint64_t ret_ref = tag_ptr(ret_copy, true);
17855 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_none"))) TS_COption_C2Tuple_u64u64ZZ_none() {
17856 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
17857 *ret_copy = COption_C2Tuple_u64u64ZZ_none();
17858 uint64_t ret_ref = tag_ptr(ret_copy, true);
17862 void __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_free"))) TS_COption_C2Tuple_u64u64ZZ_free(uint64_t _res) {
17863 if (!ptr_is_owned(_res)) return;
17864 void* _res_ptr = untag_ptr(_res);
17865 CHECK_ACCESS(_res_ptr);
17866 LDKCOption_C2Tuple_u64u64ZZ _res_conv = *(LDKCOption_C2Tuple_u64u64ZZ*)(_res_ptr);
17867 FREE(untag_ptr(_res));
17868 COption_C2Tuple_u64u64ZZ_free(_res_conv);
17871 static inline uint64_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg) {
17872 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
17873 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(arg);
17874 uint64_t ret_ref = tag_ptr(ret_copy, true);
17877 int64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u64ZZ_clone_ptr(uint64_t arg) {
17878 LDKCOption_C2Tuple_u64u64ZZ* arg_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(arg);
17879 int64_t ret_conv = COption_C2Tuple_u64u64ZZ_clone_ptr(arg_conv);
17883 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone"))) TS_COption_C2Tuple_u64u64ZZ_clone(uint64_t orig) {
17884 LDKCOption_C2Tuple_u64u64ZZ* orig_conv = (LDKCOption_C2Tuple_u64u64ZZ*)untag_ptr(orig);
17885 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
17886 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(orig_conv);
17887 uint64_t ret_ref = tag_ptr(ret_copy, true);
17891 uint64_t __attribute__((export_name("TS_C2Tuple_Z_new"))) TS_C2Tuple_Z_new(int16_tArray a, int16_tArray b) {
17892 LDKThirtyTwoU16s a_ref;
17893 CHECK(a->arr_len == 32);
17894 memcpy(a_ref.data, a->elems, 32 * 2); FREE(a);
17895 LDKThirtyTwoU16s b_ref;
17896 CHECK(b->arr_len == 32);
17897 memcpy(b_ref.data, b->elems, 32 * 2); FREE(b);
17898 LDKC2Tuple_Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_Z), "LDKC2Tuple_Z");
17899 *ret_conv = C2Tuple_Z_new(a_ref, b_ref);
17900 return tag_ptr(ret_conv, true);
17903 void __attribute__((export_name("TS_C2Tuple_Z_free"))) TS_C2Tuple_Z_free(uint64_t _res) {
17904 if (!ptr_is_owned(_res)) return;
17905 void* _res_ptr = untag_ptr(_res);
17906 CHECK_ACCESS(_res_ptr);
17907 LDKC2Tuple_Z _res_conv = *(LDKC2Tuple_Z*)(_res_ptr);
17908 FREE(untag_ptr(_res));
17909 C2Tuple_Z_free(_res_conv);
17912 uint64_t __attribute__((export_name("TS_C2Tuple__u1632_u1632Z_new"))) TS_C2Tuple__u1632_u1632Z_new(int16_tArray a, int16_tArray b) {
17913 LDKThirtyTwoU16s a_ref;
17914 CHECK(a->arr_len == 32);
17915 memcpy(a_ref.data, a->elems, 32 * 2); FREE(a);
17916 LDKThirtyTwoU16s b_ref;
17917 CHECK(b->arr_len == 32);
17918 memcpy(b_ref.data, b->elems, 32 * 2); FREE(b);
17919 LDKC2Tuple__u1632_u1632Z* ret_conv = MALLOC(sizeof(LDKC2Tuple__u1632_u1632Z), "LDKC2Tuple__u1632_u1632Z");
17920 *ret_conv = C2Tuple__u1632_u1632Z_new(a_ref, b_ref);
17921 return tag_ptr(ret_conv, true);
17924 void __attribute__((export_name("TS_C2Tuple__u1632_u1632Z_free"))) TS_C2Tuple__u1632_u1632Z_free(uint64_t _res) {
17925 if (!ptr_is_owned(_res)) return;
17926 void* _res_ptr = untag_ptr(_res);
17927 CHECK_ACCESS(_res_ptr);
17928 LDKC2Tuple__u1632_u1632Z _res_conv = *(LDKC2Tuple__u1632_u1632Z*)(_res_ptr);
17929 FREE(untag_ptr(_res));
17930 C2Tuple__u1632_u1632Z_free(_res_conv);
17933 uint64_t __attribute__((export_name("TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some"))) TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(uint64_t o) {
17934 void* o_ptr = untag_ptr(o);
17935 CHECK_ACCESS(o_ptr);
17936 LDKC2Tuple__u1632_u1632Z o_conv = *(LDKC2Tuple__u1632_u1632Z*)(o_ptr);
17937 // WARNING: we may need a move here but no clone is available for LDKC2Tuple__u1632_u1632Z
17938 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ), "LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ");
17939 *ret_copy = COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_some(o_conv);
17940 uint64_t ret_ref = tag_ptr(ret_copy, true);
17944 uint64_t __attribute__((export_name("TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none"))) TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none() {
17945 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ), "LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ");
17946 *ret_copy = COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_none();
17947 uint64_t ret_ref = tag_ptr(ret_copy, true);
17951 void __attribute__((export_name("TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free"))) TS_COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(uint64_t _res) {
17952 if (!ptr_is_owned(_res)) return;
17953 void* _res_ptr = untag_ptr(_res);
17954 CHECK_ACCESS(_res_ptr);
17955 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ _res_conv = *(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ*)(_res_ptr);
17956 FREE(untag_ptr(_res));
17957 COption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ_free(_res_conv);
17960 uint64_t __attribute__((export_name("TS_COption_f64Z_some"))) TS_COption_f64Z_some(double o) {
17961 LDKCOption_f64Z *ret_copy = MALLOC(sizeof(LDKCOption_f64Z), "LDKCOption_f64Z");
17962 *ret_copy = COption_f64Z_some(o);
17963 uint64_t ret_ref = tag_ptr(ret_copy, true);
17967 uint64_t __attribute__((export_name("TS_COption_f64Z_none"))) TS_COption_f64Z_none() {
17968 LDKCOption_f64Z *ret_copy = MALLOC(sizeof(LDKCOption_f64Z), "LDKCOption_f64Z");
17969 *ret_copy = COption_f64Z_none();
17970 uint64_t ret_ref = tag_ptr(ret_copy, true);
17974 void __attribute__((export_name("TS_COption_f64Z_free"))) TS_COption_f64Z_free(uint64_t _res) {
17975 if (!ptr_is_owned(_res)) return;
17976 void* _res_ptr = untag_ptr(_res);
17977 CHECK_ACCESS(_res_ptr);
17978 LDKCOption_f64Z _res_conv = *(LDKCOption_f64Z*)(_res_ptr);
17979 FREE(untag_ptr(_res));
17980 COption_f64Z_free(_res_conv);
17983 static inline uint64_t COption_f64Z_clone_ptr(LDKCOption_f64Z *NONNULL_PTR arg) {
17984 LDKCOption_f64Z *ret_copy = MALLOC(sizeof(LDKCOption_f64Z), "LDKCOption_f64Z");
17985 *ret_copy = COption_f64Z_clone(arg);
17986 uint64_t ret_ref = tag_ptr(ret_copy, true);
17989 int64_t __attribute__((export_name("TS_COption_f64Z_clone_ptr"))) TS_COption_f64Z_clone_ptr(uint64_t arg) {
17990 LDKCOption_f64Z* arg_conv = (LDKCOption_f64Z*)untag_ptr(arg);
17991 int64_t ret_conv = COption_f64Z_clone_ptr(arg_conv);
17995 uint64_t __attribute__((export_name("TS_COption_f64Z_clone"))) TS_COption_f64Z_clone(uint64_t orig) {
17996 LDKCOption_f64Z* orig_conv = (LDKCOption_f64Z*)untag_ptr(orig);
17997 LDKCOption_f64Z *ret_copy = MALLOC(sizeof(LDKCOption_f64Z), "LDKCOption_f64Z");
17998 *ret_copy = COption_f64Z_clone(orig_conv);
17999 uint64_t ret_ref = tag_ptr(ret_copy, true);
18003 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(uint64_t o) {
18004 LDKProbabilisticScorer o_conv;
18005 o_conv.inner = untag_ptr(o);
18006 o_conv.is_owned = ptr_is_owned(o);
18007 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18008 // WARNING: we need a move here but no clone is available for LDKProbabilisticScorer
18010 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
18011 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_ok(o_conv);
18012 return tag_ptr(ret_conv, true);
18015 uint64_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_err(uint64_t e) {
18016 void* e_ptr = untag_ptr(e);
18017 CHECK_ACCESS(e_ptr);
18018 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18019 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18020 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
18021 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_err(e_conv);
18022 return tag_ptr(ret_conv, true);
18025 jboolean __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(uint64_t o) {
18026 LDKCResult_ProbabilisticScorerDecodeErrorZ* o_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)untag_ptr(o);
18027 jboolean ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o_conv);
18031 void __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_free"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_free(uint64_t _res) {
18032 if (!ptr_is_owned(_res)) return;
18033 void* _res_ptr = untag_ptr(_res);
18034 CHECK_ACCESS(_res_ptr);
18035 LDKCResult_ProbabilisticScorerDecodeErrorZ _res_conv = *(LDKCResult_ProbabilisticScorerDecodeErrorZ*)(_res_ptr);
18036 FREE(untag_ptr(_res));
18037 CResult_ProbabilisticScorerDecodeErrorZ_free(_res_conv);
18040 static inline uint64_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
18041 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
18042 *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
18043 return tag_ptr(ret_conv, true);
18045 int64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone_ptr"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint64_t arg) {
18046 LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(arg);
18047 int64_t ret_conv = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
18051 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone"))) TS_C2Tuple_usizeTransactionZ_clone(uint64_t orig) {
18052 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)untag_ptr(orig);
18053 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
18054 *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv);
18055 return tag_ptr(ret_conv, true);
18058 uint64_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_new"))) TS_C2Tuple_usizeTransactionZ_new(uint32_t a, int8_tArray b) {
18059 LDKTransaction b_ref;
18060 b_ref.datalen = b->arr_len;
18061 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
18062 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
18063 b_ref.data_is_owned = true;
18064 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
18065 *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref);
18066 return tag_ptr(ret_conv, true);
18069 void __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_free"))) TS_C2Tuple_usizeTransactionZ_free(uint64_t _res) {
18070 if (!ptr_is_owned(_res)) return;
18071 void* _res_ptr = untag_ptr(_res);
18072 CHECK_ACCESS(_res_ptr);
18073 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_ptr);
18074 FREE(untag_ptr(_res));
18075 C2Tuple_usizeTransactionZ_free(_res_conv);
18078 void __attribute__((export_name("TS_CVec_C2Tuple_usizeTransactionZZ_free"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint64_tArray _res) {
18079 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
18080 _res_constr.datalen = _res->arr_len;
18081 if (_res_constr.datalen > 0)
18082 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
18084 _res_constr.data = NULL;
18085 uint64_t* _res_vals = _res->elems;
18086 for (size_t c = 0; c < _res_constr.datalen; c++) {
18087 uint64_t _res_conv_28 = _res_vals[c];
18088 void* _res_conv_28_ptr = untag_ptr(_res_conv_28);
18089 CHECK_ACCESS(_res_conv_28_ptr);
18090 LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_conv_28_ptr);
18091 FREE(untag_ptr(_res_conv_28));
18092 _res_constr.data[c] = _res_conv_28_conv;
18095 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
18098 static inline uint64_t C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ *NONNULL_PTR arg) {
18099 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ");
18100 *ret_conv = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(arg);
18101 return tag_ptr(ret_conv, true);
18103 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(uint64_t arg) {
18104 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)untag_ptr(arg);
18105 int64_t ret_conv = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone_ptr(arg_conv);
18109 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(uint64_t orig) {
18110 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)untag_ptr(orig);
18111 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ");
18112 *ret_conv = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_clone(orig_conv);
18113 return tag_ptr(ret_conv, true);
18116 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(int8_tArray a, uint64_t b) {
18117 LDKThirtyTwoBytes a_ref;
18118 CHECK(a->arr_len == 32);
18119 memcpy(a_ref.data, a->elems, 32); FREE(a);
18120 void* b_ptr = untag_ptr(b);
18121 CHECK_ACCESS(b_ptr);
18122 LDKCOption_ThirtyTwoBytesZ b_conv = *(LDKCOption_ThirtyTwoBytesZ*)(b_ptr);
18123 b_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(b));
18124 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ");
18125 *ret_conv = C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_new(a_ref, b_conv);
18126 return tag_ptr(ret_conv, true);
18129 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free"))) TS_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(uint64_t _res) {
18130 if (!ptr_is_owned(_res)) return;
18131 void* _res_ptr = untag_ptr(_res);
18132 CHECK_ACCESS(_res_ptr);
18133 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)(_res_ptr);
18134 FREE(untag_ptr(_res));
18135 C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ_free(_res_conv);
18138 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(uint64_tArray _res) {
18139 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ _res_constr;
18140 _res_constr.datalen = _res->arr_len;
18141 if (_res_constr.datalen > 0)
18142 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ Elements");
18144 _res_constr.data = NULL;
18145 uint64_t* _res_vals = _res->elems;
18146 for (size_t x = 0; x < _res_constr.datalen; x++) {
18147 uint64_t _res_conv_49 = _res_vals[x];
18148 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
18149 CHECK_ACCESS(_res_conv_49_ptr);
18150 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ _res_conv_49_conv = *(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ*)(_res_conv_49_ptr);
18151 FREE(untag_ptr(_res_conv_49));
18152 _res_constr.data[x] = _res_conv_49_conv;
18155 CVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ_free(_res_constr);
18158 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_ok(uint32_t o) {
18159 LDKChannelMonitorUpdateStatus o_conv = LDKChannelMonitorUpdateStatus_from_js(o);
18160 LDKCResult_ChannelMonitorUpdateStatusNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ), "LDKCResult_ChannelMonitorUpdateStatusNoneZ");
18161 *ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_ok(o_conv);
18162 return tag_ptr(ret_conv, true);
18165 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_err"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_err() {
18166 LDKCResult_ChannelMonitorUpdateStatusNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ), "LDKCResult_ChannelMonitorUpdateStatusNoneZ");
18167 *ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_err();
18168 return tag_ptr(ret_conv, true);
18171 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(uint64_t o) {
18172 LDKCResult_ChannelMonitorUpdateStatusNoneZ* o_conv = (LDKCResult_ChannelMonitorUpdateStatusNoneZ*)untag_ptr(o);
18173 jboolean ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_is_ok(o_conv);
18177 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_free"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_free(uint64_t _res) {
18178 if (!ptr_is_owned(_res)) return;
18179 void* _res_ptr = untag_ptr(_res);
18180 CHECK_ACCESS(_res_ptr);
18181 LDKCResult_ChannelMonitorUpdateStatusNoneZ _res_conv = *(LDKCResult_ChannelMonitorUpdateStatusNoneZ*)(_res_ptr);
18182 FREE(untag_ptr(_res));
18183 CResult_ChannelMonitorUpdateStatusNoneZ_free(_res_conv);
18186 static inline uint64_t CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(LDKCResult_ChannelMonitorUpdateStatusNoneZ *NONNULL_PTR arg) {
18187 LDKCResult_ChannelMonitorUpdateStatusNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ), "LDKCResult_ChannelMonitorUpdateStatusNoneZ");
18188 *ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_clone(arg);
18189 return tag_ptr(ret_conv, true);
18191 int64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(uint64_t arg) {
18192 LDKCResult_ChannelMonitorUpdateStatusNoneZ* arg_conv = (LDKCResult_ChannelMonitorUpdateStatusNoneZ*)untag_ptr(arg);
18193 int64_t ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_clone_ptr(arg_conv);
18197 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone"))) TS_CResult_ChannelMonitorUpdateStatusNoneZ_clone(uint64_t orig) {
18198 LDKCResult_ChannelMonitorUpdateStatusNoneZ* orig_conv = (LDKCResult_ChannelMonitorUpdateStatusNoneZ*)untag_ptr(orig);
18199 LDKCResult_ChannelMonitorUpdateStatusNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateStatusNoneZ), "LDKCResult_ChannelMonitorUpdateStatusNoneZ");
18200 *ret_conv = CResult_ChannelMonitorUpdateStatusNoneZ_clone(orig_conv);
18201 return tag_ptr(ret_conv, true);
18204 void __attribute__((export_name("TS_CVec_MonitorEventZ_free"))) TS_CVec_MonitorEventZ_free(uint64_tArray _res) {
18205 LDKCVec_MonitorEventZ _res_constr;
18206 _res_constr.datalen = _res->arr_len;
18207 if (_res_constr.datalen > 0)
18208 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
18210 _res_constr.data = NULL;
18211 uint64_t* _res_vals = _res->elems;
18212 for (size_t o = 0; o < _res_constr.datalen; o++) {
18213 uint64_t _res_conv_14 = _res_vals[o];
18214 void* _res_conv_14_ptr = untag_ptr(_res_conv_14);
18215 CHECK_ACCESS(_res_conv_14_ptr);
18216 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
18217 FREE(untag_ptr(_res_conv_14));
18218 _res_constr.data[o] = _res_conv_14_conv;
18221 CVec_MonitorEventZ_free(_res_constr);
18224 static inline uint64_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg) {
18225 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
18226 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(arg);
18227 return tag_ptr(ret_conv, true);
18229 int64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(uint64_t arg) {
18230 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* arg_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(arg);
18231 int64_t ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg_conv);
18235 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(uint64_t orig) {
18236 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* orig_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)untag_ptr(orig);
18237 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
18238 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig_conv);
18239 return tag_ptr(ret_conv, true);
18242 uint64_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(uint64_t a, uint64_tArray b, int8_tArray c) {
18243 LDKOutPoint a_conv;
18244 a_conv.inner = untag_ptr(a);
18245 a_conv.is_owned = ptr_is_owned(a);
18246 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
18247 a_conv = OutPoint_clone(&a_conv);
18248 LDKCVec_MonitorEventZ b_constr;
18249 b_constr.datalen = b->arr_len;
18250 if (b_constr.datalen > 0)
18251 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
18253 b_constr.data = NULL;
18254 uint64_t* b_vals = b->elems;
18255 for (size_t o = 0; o < b_constr.datalen; o++) {
18256 uint64_t b_conv_14 = b_vals[o];
18257 void* b_conv_14_ptr = untag_ptr(b_conv_14);
18258 CHECK_ACCESS(b_conv_14_ptr);
18259 LDKMonitorEvent b_conv_14_conv = *(LDKMonitorEvent*)(b_conv_14_ptr);
18260 b_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(b_conv_14));
18261 b_constr.data[o] = b_conv_14_conv;
18264 LDKPublicKey c_ref;
18265 CHECK(c->arr_len == 33);
18266 memcpy(c_ref.compressed_form, c->elems, 33); FREE(c);
18267 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
18268 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a_conv, b_constr, c_ref);
18269 return tag_ptr(ret_conv, true);
18272 void __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(uint64_t _res) {
18273 if (!ptr_is_owned(_res)) return;
18274 void* _res_ptr = untag_ptr(_res);
18275 CHECK_ACCESS(_res_ptr);
18276 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_ptr);
18277 FREE(untag_ptr(_res));
18278 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res_conv);
18281 void __attribute__((export_name("TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free"))) TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(uint64_tArray _res) {
18282 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res_constr;
18283 _res_constr.datalen = _res->arr_len;
18284 if (_res_constr.datalen > 0)
18285 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
18287 _res_constr.data = NULL;
18288 uint64_t* _res_vals = _res->elems;
18289 for (size_t x = 0; x < _res_constr.datalen; x++) {
18290 uint64_t _res_conv_49 = _res_vals[x];
18291 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
18292 CHECK_ACCESS(_res_conv_49_ptr);
18293 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_conv_49_ptr);
18294 FREE(untag_ptr(_res_conv_49));
18295 _res_constr.data[x] = _res_conv_49_conv;
18298 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
18301 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint64_t o) {
18302 LDKInitFeatures o_conv;
18303 o_conv.inner = untag_ptr(o);
18304 o_conv.is_owned = ptr_is_owned(o);
18305 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18306 o_conv = InitFeatures_clone(&o_conv);
18307 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
18308 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
18309 return tag_ptr(ret_conv, true);
18312 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_err"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint64_t e) {
18313 void* e_ptr = untag_ptr(e);
18314 CHECK_ACCESS(e_ptr);
18315 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18316 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18317 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
18318 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
18319 return tag_ptr(ret_conv, true);
18322 jboolean __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18323 LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(o);
18324 jboolean ret_conv = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
18328 void __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_free"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint64_t _res) {
18329 if (!ptr_is_owned(_res)) return;
18330 void* _res_ptr = untag_ptr(_res);
18331 CHECK_ACCESS(_res_ptr);
18332 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
18333 FREE(untag_ptr(_res));
18334 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
18337 static inline uint64_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18338 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
18339 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(arg);
18340 return tag_ptr(ret_conv, true);
18342 int64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18343 LDKCResult_InitFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(arg);
18344 int64_t ret_conv = CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18348 uint64_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone"))) TS_CResult_InitFeaturesDecodeErrorZ_clone(uint64_t orig) {
18349 LDKCResult_InitFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)untag_ptr(orig);
18350 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
18351 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(orig_conv);
18352 return tag_ptr(ret_conv, true);
18355 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint64_t o) {
18356 LDKChannelFeatures o_conv;
18357 o_conv.inner = untag_ptr(o);
18358 o_conv.is_owned = ptr_is_owned(o);
18359 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18360 o_conv = ChannelFeatures_clone(&o_conv);
18361 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
18362 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
18363 return tag_ptr(ret_conv, true);
18366 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint64_t e) {
18367 void* e_ptr = untag_ptr(e);
18368 CHECK_ACCESS(e_ptr);
18369 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18370 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18371 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
18372 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
18373 return tag_ptr(ret_conv, true);
18376 jboolean __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18377 LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(o);
18378 jboolean ret_conv = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
18382 void __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint64_t _res) {
18383 if (!ptr_is_owned(_res)) return;
18384 void* _res_ptr = untag_ptr(_res);
18385 CHECK_ACCESS(_res_ptr);
18386 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
18387 FREE(untag_ptr(_res));
18388 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
18391 static inline uint64_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18392 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
18393 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(arg);
18394 return tag_ptr(ret_conv, true);
18396 int64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18397 LDKCResult_ChannelFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(arg);
18398 int64_t ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18402 uint64_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone(uint64_t orig) {
18403 LDKCResult_ChannelFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)untag_ptr(orig);
18404 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
18405 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(orig_conv);
18406 return tag_ptr(ret_conv, true);
18409 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint64_t o) {
18410 LDKNodeFeatures o_conv;
18411 o_conv.inner = untag_ptr(o);
18412 o_conv.is_owned = ptr_is_owned(o);
18413 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18414 o_conv = NodeFeatures_clone(&o_conv);
18415 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
18416 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
18417 return tag_ptr(ret_conv, true);
18420 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint64_t e) {
18421 void* e_ptr = untag_ptr(e);
18422 CHECK_ACCESS(e_ptr);
18423 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18424 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18425 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
18426 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
18427 return tag_ptr(ret_conv, true);
18430 jboolean __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18431 LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(o);
18432 jboolean ret_conv = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
18436 void __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_free"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint64_t _res) {
18437 if (!ptr_is_owned(_res)) return;
18438 void* _res_ptr = untag_ptr(_res);
18439 CHECK_ACCESS(_res_ptr);
18440 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
18441 FREE(untag_ptr(_res));
18442 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
18445 static inline uint64_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18446 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
18447 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(arg);
18448 return tag_ptr(ret_conv, true);
18450 int64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18451 LDKCResult_NodeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(arg);
18452 int64_t ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18456 uint64_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone(uint64_t orig) {
18457 LDKCResult_NodeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)untag_ptr(orig);
18458 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
18459 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(orig_conv);
18460 return tag_ptr(ret_conv, true);
18463 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(uint64_t o) {
18464 LDKBolt11InvoiceFeatures o_conv;
18465 o_conv.inner = untag_ptr(o);
18466 o_conv.is_owned = ptr_is_owned(o);
18467 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18468 o_conv = Bolt11InvoiceFeatures_clone(&o_conv);
18469 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ");
18470 *ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_ok(o_conv);
18471 return tag_ptr(ret_conv, true);
18474 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(uint64_t e) {
18475 void* e_ptr = untag_ptr(e);
18476 CHECK_ACCESS(e_ptr);
18477 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18478 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18479 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ");
18480 *ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_err(e_conv);
18481 return tag_ptr(ret_conv, true);
18484 jboolean __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18485 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)untag_ptr(o);
18486 jboolean ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
18490 void __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(uint64_t _res) {
18491 if (!ptr_is_owned(_res)) return;
18492 void* _res_ptr = untag_ptr(_res);
18493 CHECK_ACCESS(_res_ptr);
18494 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
18495 FREE(untag_ptr(_res));
18496 CResult_Bolt11InvoiceFeaturesDecodeErrorZ_free(_res_conv);
18499 static inline uint64_t CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18500 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ");
18501 *ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(arg);
18502 return tag_ptr(ret_conv, true);
18504 int64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18505 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)untag_ptr(arg);
18506 int64_t ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18510 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(uint64_t orig) {
18511 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ*)untag_ptr(orig);
18512 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ");
18513 *ret_conv = CResult_Bolt11InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
18514 return tag_ptr(ret_conv, true);
18517 uint64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(uint64_t o) {
18518 LDKBolt12InvoiceFeatures o_conv;
18519 o_conv.inner = untag_ptr(o);
18520 o_conv.is_owned = ptr_is_owned(o);
18521 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18522 o_conv = Bolt12InvoiceFeatures_clone(&o_conv);
18523 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ");
18524 *ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_ok(o_conv);
18525 return tag_ptr(ret_conv, true);
18528 uint64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(uint64_t e) {
18529 void* e_ptr = untag_ptr(e);
18530 CHECK_ACCESS(e_ptr);
18531 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18532 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18533 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ");
18534 *ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_err(e_conv);
18535 return tag_ptr(ret_conv, true);
18538 jboolean __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18539 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)untag_ptr(o);
18540 jboolean ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
18544 void __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(uint64_t _res) {
18545 if (!ptr_is_owned(_res)) return;
18546 void* _res_ptr = untag_ptr(_res);
18547 CHECK_ACCESS(_res_ptr);
18548 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
18549 FREE(untag_ptr(_res));
18550 CResult_Bolt12InvoiceFeaturesDecodeErrorZ_free(_res_conv);
18553 static inline uint64_t CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18554 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ");
18555 *ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(arg);
18556 return tag_ptr(ret_conv, true);
18558 int64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18559 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)untag_ptr(arg);
18560 int64_t ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18564 uint64_t __attribute__((export_name("TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(uint64_t orig) {
18565 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ*)untag_ptr(orig);
18566 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ");
18567 *ret_conv = CResult_Bolt12InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
18568 return tag_ptr(ret_conv, true);
18571 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_ok(uint64_t o) {
18572 LDKBlindedHopFeatures o_conv;
18573 o_conv.inner = untag_ptr(o);
18574 o_conv.is_owned = ptr_is_owned(o);
18575 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18576 o_conv = BlindedHopFeatures_clone(&o_conv);
18577 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
18578 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_ok(o_conv);
18579 return tag_ptr(ret_conv, true);
18582 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_err"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_err(uint64_t e) {
18583 void* e_ptr = untag_ptr(e);
18584 CHECK_ACCESS(e_ptr);
18585 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18586 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18587 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
18588 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_err(e_conv);
18589 return tag_ptr(ret_conv, true);
18592 jboolean __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18593 LDKCResult_BlindedHopFeaturesDecodeErrorZ* o_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(o);
18594 jboolean ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_is_ok(o_conv);
18598 void __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_free"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_free(uint64_t _res) {
18599 if (!ptr_is_owned(_res)) return;
18600 void* _res_ptr = untag_ptr(_res);
18601 CHECK_ACCESS(_res_ptr);
18602 LDKCResult_BlindedHopFeaturesDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopFeaturesDecodeErrorZ*)(_res_ptr);
18603 FREE(untag_ptr(_res));
18604 CResult_BlindedHopFeaturesDecodeErrorZ_free(_res_conv);
18607 static inline uint64_t CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18608 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
18609 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(arg);
18610 return tag_ptr(ret_conv, true);
18612 int64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18613 LDKCResult_BlindedHopFeaturesDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(arg);
18614 int64_t ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18618 uint64_t __attribute__((export_name("TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone"))) TS_CResult_BlindedHopFeaturesDecodeErrorZ_clone(uint64_t orig) {
18619 LDKCResult_BlindedHopFeaturesDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopFeaturesDecodeErrorZ*)untag_ptr(orig);
18620 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
18621 *ret_conv = CResult_BlindedHopFeaturesDecodeErrorZ_clone(orig_conv);
18622 return tag_ptr(ret_conv, true);
18625 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(uint64_t o) {
18626 LDKChannelTypeFeatures o_conv;
18627 o_conv.inner = untag_ptr(o);
18628 o_conv.is_owned = ptr_is_owned(o);
18629 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18630 o_conv = ChannelTypeFeatures_clone(&o_conv);
18631 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
18632 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o_conv);
18633 return tag_ptr(ret_conv, true);
18636 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(uint64_t e) {
18637 void* e_ptr = untag_ptr(e);
18638 CHECK_ACCESS(e_ptr);
18639 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18640 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18641 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
18642 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_err(e_conv);
18643 return tag_ptr(ret_conv, true);
18646 jboolean __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(uint64_t o) {
18647 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(o);
18648 jboolean ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o_conv);
18652 void __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(uint64_t _res) {
18653 if (!ptr_is_owned(_res)) return;
18654 void* _res_ptr = untag_ptr(_res);
18655 CHECK_ACCESS(_res_ptr);
18656 LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(_res_ptr);
18657 FREE(untag_ptr(_res));
18658 CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res_conv);
18661 static inline uint64_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
18662 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
18663 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(arg);
18664 return tag_ptr(ret_conv, true);
18666 int64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
18667 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(arg);
18668 int64_t ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
18672 uint64_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(uint64_t orig) {
18673 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)untag_ptr(orig);
18674 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
18675 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig_conv);
18676 return tag_ptr(ret_conv, true);
18679 uint64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_ok"))) TS_CResult_OfferBolt12ParseErrorZ_ok(uint64_t o) {
18681 o_conv.inner = untag_ptr(o);
18682 o_conv.is_owned = ptr_is_owned(o);
18683 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18684 o_conv = Offer_clone(&o_conv);
18685 LDKCResult_OfferBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferBolt12ParseErrorZ), "LDKCResult_OfferBolt12ParseErrorZ");
18686 *ret_conv = CResult_OfferBolt12ParseErrorZ_ok(o_conv);
18687 return tag_ptr(ret_conv, true);
18690 uint64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_err"))) TS_CResult_OfferBolt12ParseErrorZ_err(uint64_t e) {
18691 LDKBolt12ParseError e_conv;
18692 e_conv.inner = untag_ptr(e);
18693 e_conv.is_owned = ptr_is_owned(e);
18694 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18695 e_conv = Bolt12ParseError_clone(&e_conv);
18696 LDKCResult_OfferBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferBolt12ParseErrorZ), "LDKCResult_OfferBolt12ParseErrorZ");
18697 *ret_conv = CResult_OfferBolt12ParseErrorZ_err(e_conv);
18698 return tag_ptr(ret_conv, true);
18701 jboolean __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_is_ok"))) TS_CResult_OfferBolt12ParseErrorZ_is_ok(uint64_t o) {
18702 LDKCResult_OfferBolt12ParseErrorZ* o_conv = (LDKCResult_OfferBolt12ParseErrorZ*)untag_ptr(o);
18703 jboolean ret_conv = CResult_OfferBolt12ParseErrorZ_is_ok(o_conv);
18707 void __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_free"))) TS_CResult_OfferBolt12ParseErrorZ_free(uint64_t _res) {
18708 if (!ptr_is_owned(_res)) return;
18709 void* _res_ptr = untag_ptr(_res);
18710 CHECK_ACCESS(_res_ptr);
18711 LDKCResult_OfferBolt12ParseErrorZ _res_conv = *(LDKCResult_OfferBolt12ParseErrorZ*)(_res_ptr);
18712 FREE(untag_ptr(_res));
18713 CResult_OfferBolt12ParseErrorZ_free(_res_conv);
18716 static inline uint64_t CResult_OfferBolt12ParseErrorZ_clone_ptr(LDKCResult_OfferBolt12ParseErrorZ *NONNULL_PTR arg) {
18717 LDKCResult_OfferBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferBolt12ParseErrorZ), "LDKCResult_OfferBolt12ParseErrorZ");
18718 *ret_conv = CResult_OfferBolt12ParseErrorZ_clone(arg);
18719 return tag_ptr(ret_conv, true);
18721 int64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_clone_ptr"))) TS_CResult_OfferBolt12ParseErrorZ_clone_ptr(uint64_t arg) {
18722 LDKCResult_OfferBolt12ParseErrorZ* arg_conv = (LDKCResult_OfferBolt12ParseErrorZ*)untag_ptr(arg);
18723 int64_t ret_conv = CResult_OfferBolt12ParseErrorZ_clone_ptr(arg_conv);
18727 uint64_t __attribute__((export_name("TS_CResult_OfferBolt12ParseErrorZ_clone"))) TS_CResult_OfferBolt12ParseErrorZ_clone(uint64_t orig) {
18728 LDKCResult_OfferBolt12ParseErrorZ* orig_conv = (LDKCResult_OfferBolt12ParseErrorZ*)untag_ptr(orig);
18729 LDKCResult_OfferBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferBolt12ParseErrorZ), "LDKCResult_OfferBolt12ParseErrorZ");
18730 *ret_conv = CResult_OfferBolt12ParseErrorZ_clone(orig_conv);
18731 return tag_ptr(ret_conv, true);
18734 uint64_t __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_ok"))) TS_CResult_PublicKeySecp256k1ErrorZ_ok(int8_tArray o) {
18735 LDKPublicKey o_ref;
18736 CHECK(o->arr_len == 33);
18737 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
18738 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
18739 *ret_conv = CResult_PublicKeySecp256k1ErrorZ_ok(o_ref);
18740 return tag_ptr(ret_conv, true);
18743 uint64_t __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_err"))) TS_CResult_PublicKeySecp256k1ErrorZ_err(uint32_t e) {
18744 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
18745 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
18746 *ret_conv = CResult_PublicKeySecp256k1ErrorZ_err(e_conv);
18747 return tag_ptr(ret_conv, true);
18750 jboolean __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_is_ok"))) TS_CResult_PublicKeySecp256k1ErrorZ_is_ok(uint64_t o) {
18751 LDKCResult_PublicKeySecp256k1ErrorZ* o_conv = (LDKCResult_PublicKeySecp256k1ErrorZ*)untag_ptr(o);
18752 jboolean ret_conv = CResult_PublicKeySecp256k1ErrorZ_is_ok(o_conv);
18756 void __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_free"))) TS_CResult_PublicKeySecp256k1ErrorZ_free(uint64_t _res) {
18757 if (!ptr_is_owned(_res)) return;
18758 void* _res_ptr = untag_ptr(_res);
18759 CHECK_ACCESS(_res_ptr);
18760 LDKCResult_PublicKeySecp256k1ErrorZ _res_conv = *(LDKCResult_PublicKeySecp256k1ErrorZ*)(_res_ptr);
18761 FREE(untag_ptr(_res));
18762 CResult_PublicKeySecp256k1ErrorZ_free(_res_conv);
18765 static inline uint64_t CResult_PublicKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PublicKeySecp256k1ErrorZ *NONNULL_PTR arg) {
18766 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
18767 *ret_conv = CResult_PublicKeySecp256k1ErrorZ_clone(arg);
18768 return tag_ptr(ret_conv, true);
18770 int64_t __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr"))) TS_CResult_PublicKeySecp256k1ErrorZ_clone_ptr(uint64_t arg) {
18771 LDKCResult_PublicKeySecp256k1ErrorZ* arg_conv = (LDKCResult_PublicKeySecp256k1ErrorZ*)untag_ptr(arg);
18772 int64_t ret_conv = CResult_PublicKeySecp256k1ErrorZ_clone_ptr(arg_conv);
18776 uint64_t __attribute__((export_name("TS_CResult_PublicKeySecp256k1ErrorZ_clone"))) TS_CResult_PublicKeySecp256k1ErrorZ_clone(uint64_t orig) {
18777 LDKCResult_PublicKeySecp256k1ErrorZ* orig_conv = (LDKCResult_PublicKeySecp256k1ErrorZ*)untag_ptr(orig);
18778 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
18779 *ret_conv = CResult_PublicKeySecp256k1ErrorZ_clone(orig_conv);
18780 return tag_ptr(ret_conv, true);
18783 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_ok"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint64_t o) {
18785 o_conv.inner = untag_ptr(o);
18786 o_conv.is_owned = ptr_is_owned(o);
18787 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18788 o_conv = NodeId_clone(&o_conv);
18789 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
18790 *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
18791 return tag_ptr(ret_conv, true);
18794 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_err"))) TS_CResult_NodeIdDecodeErrorZ_err(uint64_t e) {
18795 void* e_ptr = untag_ptr(e);
18796 CHECK_ACCESS(e_ptr);
18797 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18798 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18799 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
18800 *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
18801 return tag_ptr(ret_conv, true);
18804 jboolean __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_is_ok"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint64_t o) {
18805 LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(o);
18806 jboolean ret_conv = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
18810 void __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_free"))) TS_CResult_NodeIdDecodeErrorZ_free(uint64_t _res) {
18811 if (!ptr_is_owned(_res)) return;
18812 void* _res_ptr = untag_ptr(_res);
18813 CHECK_ACCESS(_res_ptr);
18814 LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
18815 FREE(untag_ptr(_res));
18816 CResult_NodeIdDecodeErrorZ_free(_res_conv);
18819 static inline uint64_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
18820 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
18821 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
18822 return tag_ptr(ret_conv, true);
18824 int64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone_ptr"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint64_t arg) {
18825 LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(arg);
18826 int64_t ret_conv = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
18830 uint64_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint64_t orig) {
18831 LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)untag_ptr(orig);
18832 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
18833 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
18834 return tag_ptr(ret_conv, true);
18837 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_some"))) TS_COption_NetworkUpdateZ_some(uint64_t o) {
18838 void* o_ptr = untag_ptr(o);
18839 CHECK_ACCESS(o_ptr);
18840 LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
18841 o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)untag_ptr(o));
18842 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
18843 *ret_copy = COption_NetworkUpdateZ_some(o_conv);
18844 uint64_t ret_ref = tag_ptr(ret_copy, true);
18848 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_none"))) TS_COption_NetworkUpdateZ_none() {
18849 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
18850 *ret_copy = COption_NetworkUpdateZ_none();
18851 uint64_t ret_ref = tag_ptr(ret_copy, true);
18855 void __attribute__((export_name("TS_COption_NetworkUpdateZ_free"))) TS_COption_NetworkUpdateZ_free(uint64_t _res) {
18856 if (!ptr_is_owned(_res)) return;
18857 void* _res_ptr = untag_ptr(_res);
18858 CHECK_ACCESS(_res_ptr);
18859 LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
18860 FREE(untag_ptr(_res));
18861 COption_NetworkUpdateZ_free(_res_conv);
18864 static inline uint64_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
18865 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
18866 *ret_copy = COption_NetworkUpdateZ_clone(arg);
18867 uint64_t ret_ref = tag_ptr(ret_copy, true);
18870 int64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone_ptr"))) TS_COption_NetworkUpdateZ_clone_ptr(uint64_t arg) {
18871 LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(arg);
18872 int64_t ret_conv = COption_NetworkUpdateZ_clone_ptr(arg_conv);
18876 uint64_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone"))) TS_COption_NetworkUpdateZ_clone(uint64_t orig) {
18877 LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)untag_ptr(orig);
18878 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
18879 *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
18880 uint64_t ret_ref = tag_ptr(ret_copy, true);
18884 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint64_t o) {
18885 void* o_ptr = untag_ptr(o);
18886 CHECK_ACCESS(o_ptr);
18887 LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
18888 o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(o));
18889 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
18890 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
18891 return tag_ptr(ret_conv, true);
18894 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint64_t e) {
18895 void* e_ptr = untag_ptr(e);
18896 CHECK_ACCESS(e_ptr);
18897 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
18898 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
18899 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
18900 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
18901 return tag_ptr(ret_conv, true);
18904 jboolean __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint64_t o) {
18905 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(o);
18906 jboolean ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
18910 void __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint64_t _res) {
18911 if (!ptr_is_owned(_res)) return;
18912 void* _res_ptr = untag_ptr(_res);
18913 CHECK_ACCESS(_res_ptr);
18914 LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
18915 FREE(untag_ptr(_res));
18916 CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
18919 static inline uint64_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
18920 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
18921 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
18922 return tag_ptr(ret_conv, true);
18924 int64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint64_t arg) {
18925 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(arg);
18926 int64_t ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
18930 uint64_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint64_t orig) {
18931 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)untag_ptr(orig);
18932 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
18933 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
18934 return tag_ptr(ret_conv, true);
18937 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_some"))) TS_COption_UtxoLookupZ_some(uint64_t o) {
18938 void* o_ptr = untag_ptr(o);
18939 CHECK_ACCESS(o_ptr);
18940 LDKUtxoLookup o_conv = *(LDKUtxoLookup*)(o_ptr);
18941 if (o_conv.free == LDKUtxoLookup_JCalls_free) {
18942 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18943 LDKUtxoLookup_JCalls_cloned(&o_conv);
18945 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
18946 *ret_copy = COption_UtxoLookupZ_some(o_conv);
18947 uint64_t ret_ref = tag_ptr(ret_copy, true);
18951 uint64_t __attribute__((export_name("TS_COption_UtxoLookupZ_none"))) TS_COption_UtxoLookupZ_none() {
18952 LDKCOption_UtxoLookupZ *ret_copy = MALLOC(sizeof(LDKCOption_UtxoLookupZ), "LDKCOption_UtxoLookupZ");
18953 *ret_copy = COption_UtxoLookupZ_none();
18954 uint64_t ret_ref = tag_ptr(ret_copy, true);
18958 void __attribute__((export_name("TS_COption_UtxoLookupZ_free"))) TS_COption_UtxoLookupZ_free(uint64_t _res) {
18959 if (!ptr_is_owned(_res)) return;
18960 void* _res_ptr = untag_ptr(_res);
18961 CHECK_ACCESS(_res_ptr);
18962 LDKCOption_UtxoLookupZ _res_conv = *(LDKCOption_UtxoLookupZ*)(_res_ptr);
18963 FREE(untag_ptr(_res));
18964 COption_UtxoLookupZ_free(_res_conv);
18967 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_ok"))) TS_CResult_NoneLightningErrorZ_ok() {
18968 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
18969 *ret_conv = CResult_NoneLightningErrorZ_ok();
18970 return tag_ptr(ret_conv, true);
18973 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_err"))) TS_CResult_NoneLightningErrorZ_err(uint64_t e) {
18974 LDKLightningError e_conv;
18975 e_conv.inner = untag_ptr(e);
18976 e_conv.is_owned = ptr_is_owned(e);
18977 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18978 e_conv = LightningError_clone(&e_conv);
18979 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
18980 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
18981 return tag_ptr(ret_conv, true);
18984 jboolean __attribute__((export_name("TS_CResult_NoneLightningErrorZ_is_ok"))) TS_CResult_NoneLightningErrorZ_is_ok(uint64_t o) {
18985 LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(o);
18986 jboolean ret_conv = CResult_NoneLightningErrorZ_is_ok(o_conv);
18990 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_free"))) TS_CResult_NoneLightningErrorZ_free(uint64_t _res) {
18991 if (!ptr_is_owned(_res)) return;
18992 void* _res_ptr = untag_ptr(_res);
18993 CHECK_ACCESS(_res_ptr);
18994 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
18995 FREE(untag_ptr(_res));
18996 CResult_NoneLightningErrorZ_free(_res_conv);
18999 static inline uint64_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
19000 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
19001 *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
19002 return tag_ptr(ret_conv, true);
19004 int64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone_ptr"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint64_t arg) {
19005 LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(arg);
19006 int64_t ret_conv = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
19010 uint64_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone"))) TS_CResult_NoneLightningErrorZ_clone(uint64_t orig) {
19011 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)untag_ptr(orig);
19012 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
19013 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
19014 return tag_ptr(ret_conv, true);
19017 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_ok"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
19018 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
19019 *ret_conv = CResult_boolLightningErrorZ_ok(o);
19020 return tag_ptr(ret_conv, true);
19023 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_err"))) TS_CResult_boolLightningErrorZ_err(uint64_t e) {
19024 LDKLightningError e_conv;
19025 e_conv.inner = untag_ptr(e);
19026 e_conv.is_owned = ptr_is_owned(e);
19027 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19028 e_conv = LightningError_clone(&e_conv);
19029 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
19030 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
19031 return tag_ptr(ret_conv, true);
19034 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_is_ok"))) TS_CResult_boolLightningErrorZ_is_ok(uint64_t o) {
19035 LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(o);
19036 jboolean ret_conv = CResult_boolLightningErrorZ_is_ok(o_conv);
19040 void __attribute__((export_name("TS_CResult_boolLightningErrorZ_free"))) TS_CResult_boolLightningErrorZ_free(uint64_t _res) {
19041 if (!ptr_is_owned(_res)) return;
19042 void* _res_ptr = untag_ptr(_res);
19043 CHECK_ACCESS(_res_ptr);
19044 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
19045 FREE(untag_ptr(_res));
19046 CResult_boolLightningErrorZ_free(_res_conv);
19049 static inline uint64_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
19050 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
19051 *ret_conv = CResult_boolLightningErrorZ_clone(arg);
19052 return tag_ptr(ret_conv, true);
19054 int64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone_ptr"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint64_t arg) {
19055 LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(arg);
19056 int64_t ret_conv = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
19060 uint64_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone"))) TS_CResult_boolLightningErrorZ_clone(uint64_t orig) {
19061 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)untag_ptr(orig);
19062 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
19063 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
19064 return tag_ptr(ret_conv, true);
19067 static inline uint64_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
19068 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
19069 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
19070 return tag_ptr(ret_conv, true);
19072 int64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint64_t arg) {
19073 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(arg);
19074 int64_t ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
19078 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint64_t orig) {
19079 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(orig);
19080 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
19081 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
19082 return tag_ptr(ret_conv, true);
19085 uint64_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint64_t a, uint64_t b, uint64_t c) {
19086 LDKChannelAnnouncement a_conv;
19087 a_conv.inner = untag_ptr(a);
19088 a_conv.is_owned = ptr_is_owned(a);
19089 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
19090 a_conv = ChannelAnnouncement_clone(&a_conv);
19091 LDKChannelUpdate b_conv;
19092 b_conv.inner = untag_ptr(b);
19093 b_conv.is_owned = ptr_is_owned(b);
19094 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
19095 b_conv = ChannelUpdate_clone(&b_conv);
19096 LDKChannelUpdate c_conv;
19097 c_conv.inner = untag_ptr(c);
19098 c_conv.is_owned = ptr_is_owned(c);
19099 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
19100 c_conv = ChannelUpdate_clone(&c_conv);
19101 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
19102 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
19103 return tag_ptr(ret_conv, true);
19106 void __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint64_t _res) {
19107 if (!ptr_is_owned(_res)) return;
19108 void* _res_ptr = untag_ptr(_res);
19109 CHECK_ACCESS(_res_ptr);
19110 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
19111 FREE(untag_ptr(_res));
19112 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
19115 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(uint64_t o) {
19116 void* o_ptr = untag_ptr(o);
19117 CHECK_ACCESS(o_ptr);
19118 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ o_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(o_ptr);
19119 o_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)untag_ptr(o));
19120 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
19121 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_some(o_conv);
19122 uint64_t ret_ref = tag_ptr(ret_copy, true);
19126 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none() {
19127 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
19128 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_none();
19129 uint64_t ret_ref = tag_ptr(ret_copy, true);
19133 void __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint64_t _res) {
19134 if (!ptr_is_owned(_res)) return;
19135 void* _res_ptr = untag_ptr(_res);
19136 CHECK_ACCESS(_res_ptr);
19137 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_conv = *(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)(_res_ptr);
19138 FREE(untag_ptr(_res));
19139 COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_conv);
19142 static inline uint64_t COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *NONNULL_PTR arg) {
19143 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
19144 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(arg);
19145 uint64_t ret_ref = tag_ptr(ret_copy, true);
19148 int64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(uint64_t arg) {
19149 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* arg_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(arg);
19150 int64_t ret_conv = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone_ptr(arg_conv);
19154 uint64_t __attribute__((export_name("TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone"))) TS_COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(uint64_t orig) {
19155 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ* orig_conv = (LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ*)untag_ptr(orig);
19156 LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret_copy = MALLOC(sizeof(LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCOption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
19157 *ret_copy = COption_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(orig_conv);
19158 uint64_t ret_ref = tag_ptr(ret_copy, true);
19162 void __attribute__((export_name("TS_CVec_MessageSendEventZ_free"))) TS_CVec_MessageSendEventZ_free(uint64_tArray _res) {
19163 LDKCVec_MessageSendEventZ _res_constr;
19164 _res_constr.datalen = _res->arr_len;
19165 if (_res_constr.datalen > 0)
19166 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
19168 _res_constr.data = NULL;
19169 uint64_t* _res_vals = _res->elems;
19170 for (size_t s = 0; s < _res_constr.datalen; s++) {
19171 uint64_t _res_conv_18 = _res_vals[s];
19172 void* _res_conv_18_ptr = untag_ptr(_res_conv_18);
19173 CHECK_ACCESS(_res_conv_18_ptr);
19174 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
19175 FREE(untag_ptr(_res_conv_18));
19176 _res_constr.data[s] = _res_conv_18_conv;
19179 CVec_MessageSendEventZ_free(_res_constr);
19182 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(uint64_t o) {
19183 LDKChannelUpdateInfo o_conv;
19184 o_conv.inner = untag_ptr(o);
19185 o_conv.is_owned = ptr_is_owned(o);
19186 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19187 o_conv = ChannelUpdateInfo_clone(&o_conv);
19188 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
19189 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_ok(o_conv);
19190 return tag_ptr(ret_conv, true);
19193 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(uint64_t e) {
19194 void* e_ptr = untag_ptr(e);
19195 CHECK_ACCESS(e_ptr);
19196 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19197 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19198 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
19199 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_err(e_conv);
19200 return tag_ptr(ret_conv, true);
19203 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(uint64_t o) {
19204 LDKCResult_ChannelUpdateInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(o);
19205 jboolean ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o_conv);
19209 void __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_free"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(uint64_t _res) {
19210 if (!ptr_is_owned(_res)) return;
19211 void* _res_ptr = untag_ptr(_res);
19212 CHECK_ACCESS(_res_ptr);
19213 LDKCResult_ChannelUpdateInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(_res_ptr);
19214 FREE(untag_ptr(_res));
19215 CResult_ChannelUpdateInfoDecodeErrorZ_free(_res_conv);
19218 static inline uint64_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg) {
19219 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
19220 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(arg);
19221 return tag_ptr(ret_conv, true);
19223 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
19224 LDKCResult_ChannelUpdateInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(arg);
19225 int64_t ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg_conv);
19229 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(uint64_t orig) {
19230 LDKCResult_ChannelUpdateInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)untag_ptr(orig);
19231 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
19232 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig_conv);
19233 return tag_ptr(ret_conv, true);
19236 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint64_t o) {
19237 LDKChannelInfo o_conv;
19238 o_conv.inner = untag_ptr(o);
19239 o_conv.is_owned = ptr_is_owned(o);
19240 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19241 o_conv = ChannelInfo_clone(&o_conv);
19242 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
19243 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
19244 return tag_ptr(ret_conv, true);
19247 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_err"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint64_t e) {
19248 void* e_ptr = untag_ptr(e);
19249 CHECK_ACCESS(e_ptr);
19250 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19251 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19252 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
19253 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
19254 return tag_ptr(ret_conv, true);
19257 jboolean __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint64_t o) {
19258 LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(o);
19259 jboolean ret_conv = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
19263 void __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_free"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint64_t _res) {
19264 if (!ptr_is_owned(_res)) return;
19265 void* _res_ptr = untag_ptr(_res);
19266 CHECK_ACCESS(_res_ptr);
19267 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
19268 FREE(untag_ptr(_res));
19269 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
19272 static inline uint64_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
19273 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
19274 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
19275 return tag_ptr(ret_conv, true);
19277 int64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
19278 LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(arg);
19279 int64_t ret_conv = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
19283 uint64_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint64_t orig) {
19284 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)untag_ptr(orig);
19285 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
19286 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
19287 return tag_ptr(ret_conv, true);
19290 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint64_t o) {
19291 LDKRoutingFees o_conv;
19292 o_conv.inner = untag_ptr(o);
19293 o_conv.is_owned = ptr_is_owned(o);
19294 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19295 o_conv = RoutingFees_clone(&o_conv);
19296 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
19297 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
19298 return tag_ptr(ret_conv, true);
19301 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_err"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint64_t e) {
19302 void* e_ptr = untag_ptr(e);
19303 CHECK_ACCESS(e_ptr);
19304 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19305 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19306 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
19307 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
19308 return tag_ptr(ret_conv, true);
19311 jboolean __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_is_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint64_t o) {
19312 LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(o);
19313 jboolean ret_conv = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
19317 void __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_free"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint64_t _res) {
19318 if (!ptr_is_owned(_res)) return;
19319 void* _res_ptr = untag_ptr(_res);
19320 CHECK_ACCESS(_res_ptr);
19321 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
19322 FREE(untag_ptr(_res));
19323 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
19326 static inline uint64_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
19327 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
19328 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
19329 return tag_ptr(ret_conv, true);
19331 int64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint64_t arg) {
19332 LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(arg);
19333 int64_t ret_conv = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
19337 uint64_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint64_t orig) {
19338 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)untag_ptr(orig);
19339 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
19340 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
19341 return tag_ptr(ret_conv, true);
19344 void __attribute__((export_name("TS_CVec_SocketAddressZ_free"))) TS_CVec_SocketAddressZ_free(uint64_tArray _res) {
19345 LDKCVec_SocketAddressZ _res_constr;
19346 _res_constr.datalen = _res->arr_len;
19347 if (_res_constr.datalen > 0)
19348 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSocketAddress), "LDKCVec_SocketAddressZ Elements");
19350 _res_constr.data = NULL;
19351 uint64_t* _res_vals = _res->elems;
19352 for (size_t p = 0; p < _res_constr.datalen; p++) {
19353 uint64_t _res_conv_15 = _res_vals[p];
19354 void* _res_conv_15_ptr = untag_ptr(_res_conv_15);
19355 CHECK_ACCESS(_res_conv_15_ptr);
19356 LDKSocketAddress _res_conv_15_conv = *(LDKSocketAddress*)(_res_conv_15_ptr);
19357 FREE(untag_ptr(_res_conv_15));
19358 _res_constr.data[p] = _res_conv_15_conv;
19361 CVec_SocketAddressZ_free(_res_constr);
19364 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint64_t o) {
19365 LDKNodeAnnouncementInfo o_conv;
19366 o_conv.inner = untag_ptr(o);
19367 o_conv.is_owned = ptr_is_owned(o);
19368 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19369 o_conv = NodeAnnouncementInfo_clone(&o_conv);
19370 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
19371 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
19372 return tag_ptr(ret_conv, true);
19375 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint64_t e) {
19376 void* e_ptr = untag_ptr(e);
19377 CHECK_ACCESS(e_ptr);
19378 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19379 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19380 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
19381 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
19382 return tag_ptr(ret_conv, true);
19385 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint64_t o) {
19386 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(o);
19387 jboolean ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
19391 void __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint64_t _res) {
19392 if (!ptr_is_owned(_res)) return;
19393 void* _res_ptr = untag_ptr(_res);
19394 CHECK_ACCESS(_res_ptr);
19395 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
19396 FREE(untag_ptr(_res));
19397 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
19400 static inline uint64_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
19401 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
19402 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
19403 return tag_ptr(ret_conv, true);
19405 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
19406 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(arg);
19407 int64_t ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
19411 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint64_t orig) {
19412 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)untag_ptr(orig);
19413 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
19414 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
19415 return tag_ptr(ret_conv, true);
19418 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_ok"))) TS_CResult_NodeAliasDecodeErrorZ_ok(uint64_t o) {
19419 LDKNodeAlias o_conv;
19420 o_conv.inner = untag_ptr(o);
19421 o_conv.is_owned = ptr_is_owned(o);
19422 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19423 o_conv = NodeAlias_clone(&o_conv);
19424 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
19425 *ret_conv = CResult_NodeAliasDecodeErrorZ_ok(o_conv);
19426 return tag_ptr(ret_conv, true);
19429 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_err"))) TS_CResult_NodeAliasDecodeErrorZ_err(uint64_t e) {
19430 void* e_ptr = untag_ptr(e);
19431 CHECK_ACCESS(e_ptr);
19432 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19433 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19434 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
19435 *ret_conv = CResult_NodeAliasDecodeErrorZ_err(e_conv);
19436 return tag_ptr(ret_conv, true);
19439 jboolean __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_is_ok"))) TS_CResult_NodeAliasDecodeErrorZ_is_ok(uint64_t o) {
19440 LDKCResult_NodeAliasDecodeErrorZ* o_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(o);
19441 jboolean ret_conv = CResult_NodeAliasDecodeErrorZ_is_ok(o_conv);
19445 void __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_free"))) TS_CResult_NodeAliasDecodeErrorZ_free(uint64_t _res) {
19446 if (!ptr_is_owned(_res)) return;
19447 void* _res_ptr = untag_ptr(_res);
19448 CHECK_ACCESS(_res_ptr);
19449 LDKCResult_NodeAliasDecodeErrorZ _res_conv = *(LDKCResult_NodeAliasDecodeErrorZ*)(_res_ptr);
19450 FREE(untag_ptr(_res));
19451 CResult_NodeAliasDecodeErrorZ_free(_res_conv);
19454 static inline uint64_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg) {
19455 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
19456 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(arg);
19457 return tag_ptr(ret_conv, true);
19459 int64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(uint64_t arg) {
19460 LDKCResult_NodeAliasDecodeErrorZ* arg_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(arg);
19461 int64_t ret_conv = CResult_NodeAliasDecodeErrorZ_clone_ptr(arg_conv);
19465 uint64_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone"))) TS_CResult_NodeAliasDecodeErrorZ_clone(uint64_t orig) {
19466 LDKCResult_NodeAliasDecodeErrorZ* orig_conv = (LDKCResult_NodeAliasDecodeErrorZ*)untag_ptr(orig);
19467 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
19468 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(orig_conv);
19469 return tag_ptr(ret_conv, true);
19472 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_ok"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint64_t o) {
19473 LDKNodeInfo o_conv;
19474 o_conv.inner = untag_ptr(o);
19475 o_conv.is_owned = ptr_is_owned(o);
19476 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19477 o_conv = NodeInfo_clone(&o_conv);
19478 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
19479 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
19480 return tag_ptr(ret_conv, true);
19483 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_err"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint64_t e) {
19484 void* e_ptr = untag_ptr(e);
19485 CHECK_ACCESS(e_ptr);
19486 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19487 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19488 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
19489 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
19490 return tag_ptr(ret_conv, true);
19493 jboolean __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint64_t o) {
19494 LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(o);
19495 jboolean ret_conv = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
19499 void __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_free"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint64_t _res) {
19500 if (!ptr_is_owned(_res)) return;
19501 void* _res_ptr = untag_ptr(_res);
19502 CHECK_ACCESS(_res_ptr);
19503 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
19504 FREE(untag_ptr(_res));
19505 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
19508 static inline uint64_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
19509 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
19510 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
19511 return tag_ptr(ret_conv, true);
19513 int64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
19514 LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(arg);
19515 int64_t ret_conv = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
19519 uint64_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint64_t orig) {
19520 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)untag_ptr(orig);
19521 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
19522 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
19523 return tag_ptr(ret_conv, true);
19526 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint64_t o) {
19527 LDKNetworkGraph o_conv;
19528 o_conv.inner = untag_ptr(o);
19529 o_conv.is_owned = ptr_is_owned(o);
19530 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19531 // WARNING: we need a move here but no clone is available for LDKNetworkGraph
19533 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
19534 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
19535 return tag_ptr(ret_conv, true);
19538 uint64_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_err"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint64_t e) {
19539 void* e_ptr = untag_ptr(e);
19540 CHECK_ACCESS(e_ptr);
19541 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19542 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19543 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
19544 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
19545 return tag_ptr(ret_conv, true);
19548 jboolean __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_is_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint64_t o) {
19549 LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)untag_ptr(o);
19550 jboolean ret_conv = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
19554 void __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_free"))) TS_CResult_NetworkGraphDecodeErrorZ_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_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
19559 FREE(untag_ptr(_res));
19560 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
19563 uint64_t __attribute__((export_name("TS_COption_CVec_SocketAddressZZ_some"))) TS_COption_CVec_SocketAddressZZ_some(uint64_tArray o) {
19564 LDKCVec_SocketAddressZ o_constr;
19565 o_constr.datalen = o->arr_len;
19566 if (o_constr.datalen > 0)
19567 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSocketAddress), "LDKCVec_SocketAddressZ Elements");
19569 o_constr.data = NULL;
19570 uint64_t* o_vals = o->elems;
19571 for (size_t p = 0; p < o_constr.datalen; p++) {
19572 uint64_t o_conv_15 = o_vals[p];
19573 void* o_conv_15_ptr = untag_ptr(o_conv_15);
19574 CHECK_ACCESS(o_conv_15_ptr);
19575 LDKSocketAddress o_conv_15_conv = *(LDKSocketAddress*)(o_conv_15_ptr);
19576 o_conv_15_conv = SocketAddress_clone((LDKSocketAddress*)untag_ptr(o_conv_15));
19577 o_constr.data[p] = o_conv_15_conv;
19580 LDKCOption_CVec_SocketAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_SocketAddressZZ), "LDKCOption_CVec_SocketAddressZZ");
19581 *ret_copy = COption_CVec_SocketAddressZZ_some(o_constr);
19582 uint64_t ret_ref = tag_ptr(ret_copy, true);
19586 uint64_t __attribute__((export_name("TS_COption_CVec_SocketAddressZZ_none"))) TS_COption_CVec_SocketAddressZZ_none() {
19587 LDKCOption_CVec_SocketAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_SocketAddressZZ), "LDKCOption_CVec_SocketAddressZZ");
19588 *ret_copy = COption_CVec_SocketAddressZZ_none();
19589 uint64_t ret_ref = tag_ptr(ret_copy, true);
19593 void __attribute__((export_name("TS_COption_CVec_SocketAddressZZ_free"))) TS_COption_CVec_SocketAddressZZ_free(uint64_t _res) {
19594 if (!ptr_is_owned(_res)) return;
19595 void* _res_ptr = untag_ptr(_res);
19596 CHECK_ACCESS(_res_ptr);
19597 LDKCOption_CVec_SocketAddressZZ _res_conv = *(LDKCOption_CVec_SocketAddressZZ*)(_res_ptr);
19598 FREE(untag_ptr(_res));
19599 COption_CVec_SocketAddressZZ_free(_res_conv);
19602 static inline uint64_t COption_CVec_SocketAddressZZ_clone_ptr(LDKCOption_CVec_SocketAddressZZ *NONNULL_PTR arg) {
19603 LDKCOption_CVec_SocketAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_SocketAddressZZ), "LDKCOption_CVec_SocketAddressZZ");
19604 *ret_copy = COption_CVec_SocketAddressZZ_clone(arg);
19605 uint64_t ret_ref = tag_ptr(ret_copy, true);
19608 int64_t __attribute__((export_name("TS_COption_CVec_SocketAddressZZ_clone_ptr"))) TS_COption_CVec_SocketAddressZZ_clone_ptr(uint64_t arg) {
19609 LDKCOption_CVec_SocketAddressZZ* arg_conv = (LDKCOption_CVec_SocketAddressZZ*)untag_ptr(arg);
19610 int64_t ret_conv = COption_CVec_SocketAddressZZ_clone_ptr(arg_conv);
19614 uint64_t __attribute__((export_name("TS_COption_CVec_SocketAddressZZ_clone"))) TS_COption_CVec_SocketAddressZZ_clone(uint64_t orig) {
19615 LDKCOption_CVec_SocketAddressZZ* orig_conv = (LDKCOption_CVec_SocketAddressZZ*)untag_ptr(orig);
19616 LDKCOption_CVec_SocketAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_SocketAddressZZ), "LDKCOption_CVec_SocketAddressZZ");
19617 *ret_copy = COption_CVec_SocketAddressZZ_clone(orig_conv);
19618 uint64_t ret_ref = tag_ptr(ret_copy, true);
19622 uint64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_ok(uint64_t o) {
19623 LDKChannelDerivationParameters o_conv;
19624 o_conv.inner = untag_ptr(o);
19625 o_conv.is_owned = ptr_is_owned(o);
19626 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19627 o_conv = ChannelDerivationParameters_clone(&o_conv);
19628 LDKCResult_ChannelDerivationParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ), "LDKCResult_ChannelDerivationParametersDecodeErrorZ");
19629 *ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_ok(o_conv);
19630 return tag_ptr(ret_conv, true);
19633 uint64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_err"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_err(uint64_t e) {
19634 void* e_ptr = untag_ptr(e);
19635 CHECK_ACCESS(e_ptr);
19636 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19637 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19638 LDKCResult_ChannelDerivationParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ), "LDKCResult_ChannelDerivationParametersDecodeErrorZ");
19639 *ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_err(e_conv);
19640 return tag_ptr(ret_conv, true);
19643 jboolean __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(uint64_t o) {
19644 LDKCResult_ChannelDerivationParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelDerivationParametersDecodeErrorZ*)untag_ptr(o);
19645 jboolean ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_is_ok(o_conv);
19649 void __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_free"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_free(uint64_t _res) {
19650 if (!ptr_is_owned(_res)) return;
19651 void* _res_ptr = untag_ptr(_res);
19652 CHECK_ACCESS(_res_ptr);
19653 LDKCResult_ChannelDerivationParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelDerivationParametersDecodeErrorZ*)(_res_ptr);
19654 FREE(untag_ptr(_res));
19655 CResult_ChannelDerivationParametersDecodeErrorZ_free(_res_conv);
19658 static inline uint64_t CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelDerivationParametersDecodeErrorZ *NONNULL_PTR arg) {
19659 LDKCResult_ChannelDerivationParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ), "LDKCResult_ChannelDerivationParametersDecodeErrorZ");
19660 *ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_clone(arg);
19661 return tag_ptr(ret_conv, true);
19663 int64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
19664 LDKCResult_ChannelDerivationParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelDerivationParametersDecodeErrorZ*)untag_ptr(arg);
19665 int64_t ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_clone_ptr(arg_conv);
19669 uint64_t __attribute__((export_name("TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone"))) TS_CResult_ChannelDerivationParametersDecodeErrorZ_clone(uint64_t orig) {
19670 LDKCResult_ChannelDerivationParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelDerivationParametersDecodeErrorZ*)untag_ptr(orig);
19671 LDKCResult_ChannelDerivationParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ), "LDKCResult_ChannelDerivationParametersDecodeErrorZ");
19672 *ret_conv = CResult_ChannelDerivationParametersDecodeErrorZ_clone(orig_conv);
19673 return tag_ptr(ret_conv, true);
19676 uint64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_ok"))) TS_CResult_HTLCDescriptorDecodeErrorZ_ok(uint64_t o) {
19677 LDKHTLCDescriptor o_conv;
19678 o_conv.inner = untag_ptr(o);
19679 o_conv.is_owned = ptr_is_owned(o);
19680 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19681 o_conv = HTLCDescriptor_clone(&o_conv);
19682 LDKCResult_HTLCDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ), "LDKCResult_HTLCDescriptorDecodeErrorZ");
19683 *ret_conv = CResult_HTLCDescriptorDecodeErrorZ_ok(o_conv);
19684 return tag_ptr(ret_conv, true);
19687 uint64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_err"))) TS_CResult_HTLCDescriptorDecodeErrorZ_err(uint64_t e) {
19688 void* e_ptr = untag_ptr(e);
19689 CHECK_ACCESS(e_ptr);
19690 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
19691 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
19692 LDKCResult_HTLCDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ), "LDKCResult_HTLCDescriptorDecodeErrorZ");
19693 *ret_conv = CResult_HTLCDescriptorDecodeErrorZ_err(e_conv);
19694 return tag_ptr(ret_conv, true);
19697 jboolean __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok"))) TS_CResult_HTLCDescriptorDecodeErrorZ_is_ok(uint64_t o) {
19698 LDKCResult_HTLCDescriptorDecodeErrorZ* o_conv = (LDKCResult_HTLCDescriptorDecodeErrorZ*)untag_ptr(o);
19699 jboolean ret_conv = CResult_HTLCDescriptorDecodeErrorZ_is_ok(o_conv);
19703 void __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_free"))) TS_CResult_HTLCDescriptorDecodeErrorZ_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_HTLCDescriptorDecodeErrorZ _res_conv = *(LDKCResult_HTLCDescriptorDecodeErrorZ*)(_res_ptr);
19708 FREE(untag_ptr(_res));
19709 CResult_HTLCDescriptorDecodeErrorZ_free(_res_conv);
19712 static inline uint64_t CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(LDKCResult_HTLCDescriptorDecodeErrorZ *NONNULL_PTR arg) {
19713 LDKCResult_HTLCDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ), "LDKCResult_HTLCDescriptorDecodeErrorZ");
19714 *ret_conv = CResult_HTLCDescriptorDecodeErrorZ_clone(arg);
19715 return tag_ptr(ret_conv, true);
19717 int64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(uint64_t arg) {
19718 LDKCResult_HTLCDescriptorDecodeErrorZ* arg_conv = (LDKCResult_HTLCDescriptorDecodeErrorZ*)untag_ptr(arg);
19719 int64_t ret_conv = CResult_HTLCDescriptorDecodeErrorZ_clone_ptr(arg_conv);
19723 uint64_t __attribute__((export_name("TS_CResult_HTLCDescriptorDecodeErrorZ_clone"))) TS_CResult_HTLCDescriptorDecodeErrorZ_clone(uint64_t orig) {
19724 LDKCResult_HTLCDescriptorDecodeErrorZ* orig_conv = (LDKCResult_HTLCDescriptorDecodeErrorZ*)untag_ptr(orig);
19725 LDKCResult_HTLCDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ), "LDKCResult_HTLCDescriptorDecodeErrorZ");
19726 *ret_conv = CResult_HTLCDescriptorDecodeErrorZ_clone(orig_conv);
19727 return tag_ptr(ret_conv, true);
19730 void __attribute__((export_name("TS_CVec_HTLCOutputInCommitmentZ_free"))) TS_CVec_HTLCOutputInCommitmentZ_free(uint64_tArray _res) {
19731 LDKCVec_HTLCOutputInCommitmentZ _res_constr;
19732 _res_constr.datalen = _res->arr_len;
19733 if (_res_constr.datalen > 0)
19734 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKHTLCOutputInCommitment), "LDKCVec_HTLCOutputInCommitmentZ Elements");
19736 _res_constr.data = NULL;
19737 uint64_t* _res_vals = _res->elems;
19738 for (size_t y = 0; y < _res_constr.datalen; y++) {
19739 uint64_t _res_conv_24 = _res_vals[y];
19740 LDKHTLCOutputInCommitment _res_conv_24_conv;
19741 _res_conv_24_conv.inner = untag_ptr(_res_conv_24);
19742 _res_conv_24_conv.is_owned = ptr_is_owned(_res_conv_24);
19743 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_24_conv);
19744 _res_constr.data[y] = _res_conv_24_conv;
19747 CVec_HTLCOutputInCommitmentZ_free(_res_constr);
19750 void __attribute__((export_name("TS_CVec_HTLCDescriptorZ_free"))) TS_CVec_HTLCDescriptorZ_free(uint64_tArray _res) {
19751 LDKCVec_HTLCDescriptorZ _res_constr;
19752 _res_constr.datalen = _res->arr_len;
19753 if (_res_constr.datalen > 0)
19754 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKHTLCDescriptor), "LDKCVec_HTLCDescriptorZ Elements");
19756 _res_constr.data = NULL;
19757 uint64_t* _res_vals = _res->elems;
19758 for (size_t q = 0; q < _res_constr.datalen; q++) {
19759 uint64_t _res_conv_16 = _res_vals[q];
19760 LDKHTLCDescriptor _res_conv_16_conv;
19761 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
19762 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
19763 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
19764 _res_constr.data[q] = _res_conv_16_conv;
19767 CVec_HTLCDescriptorZ_free(_res_constr);
19770 void __attribute__((export_name("TS_CVec_UtxoZ_free"))) TS_CVec_UtxoZ_free(uint64_tArray _res) {
19771 LDKCVec_UtxoZ _res_constr;
19772 _res_constr.datalen = _res->arr_len;
19773 if (_res_constr.datalen > 0)
19774 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUtxo), "LDKCVec_UtxoZ Elements");
19776 _res_constr.data = NULL;
19777 uint64_t* _res_vals = _res->elems;
19778 for (size_t g = 0; g < _res_constr.datalen; g++) {
19779 uint64_t _res_conv_6 = _res_vals[g];
19780 LDKUtxo _res_conv_6_conv;
19781 _res_conv_6_conv.inner = untag_ptr(_res_conv_6);
19782 _res_conv_6_conv.is_owned = ptr_is_owned(_res_conv_6);
19783 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_6_conv);
19784 _res_constr.data[g] = _res_conv_6_conv;
19787 CVec_UtxoZ_free(_res_constr);
19790 uint64_t __attribute__((export_name("TS_COption_TxOutZ_some"))) TS_COption_TxOutZ_some(uint64_t o) {
19791 void* o_ptr = untag_ptr(o);
19792 CHECK_ACCESS(o_ptr);
19793 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
19794 o_conv = TxOut_clone((LDKTxOut*)untag_ptr(o));
19795 LDKCOption_TxOutZ *ret_copy = MALLOC(sizeof(LDKCOption_TxOutZ), "LDKCOption_TxOutZ");
19796 *ret_copy = COption_TxOutZ_some(o_conv);
19797 uint64_t ret_ref = tag_ptr(ret_copy, true);
19801 uint64_t __attribute__((export_name("TS_COption_TxOutZ_none"))) TS_COption_TxOutZ_none() {
19802 LDKCOption_TxOutZ *ret_copy = MALLOC(sizeof(LDKCOption_TxOutZ), "LDKCOption_TxOutZ");
19803 *ret_copy = COption_TxOutZ_none();
19804 uint64_t ret_ref = tag_ptr(ret_copy, true);
19808 void __attribute__((export_name("TS_COption_TxOutZ_free"))) TS_COption_TxOutZ_free(uint64_t _res) {
19809 if (!ptr_is_owned(_res)) return;
19810 void* _res_ptr = untag_ptr(_res);
19811 CHECK_ACCESS(_res_ptr);
19812 LDKCOption_TxOutZ _res_conv = *(LDKCOption_TxOutZ*)(_res_ptr);
19813 FREE(untag_ptr(_res));
19814 COption_TxOutZ_free(_res_conv);
19817 static inline uint64_t COption_TxOutZ_clone_ptr(LDKCOption_TxOutZ *NONNULL_PTR arg) {
19818 LDKCOption_TxOutZ *ret_copy = MALLOC(sizeof(LDKCOption_TxOutZ), "LDKCOption_TxOutZ");
19819 *ret_copy = COption_TxOutZ_clone(arg);
19820 uint64_t ret_ref = tag_ptr(ret_copy, true);
19823 int64_t __attribute__((export_name("TS_COption_TxOutZ_clone_ptr"))) TS_COption_TxOutZ_clone_ptr(uint64_t arg) {
19824 LDKCOption_TxOutZ* arg_conv = (LDKCOption_TxOutZ*)untag_ptr(arg);
19825 int64_t ret_conv = COption_TxOutZ_clone_ptr(arg_conv);
19829 uint64_t __attribute__((export_name("TS_COption_TxOutZ_clone"))) TS_COption_TxOutZ_clone(uint64_t orig) {
19830 LDKCOption_TxOutZ* orig_conv = (LDKCOption_TxOutZ*)untag_ptr(orig);
19831 LDKCOption_TxOutZ *ret_copy = MALLOC(sizeof(LDKCOption_TxOutZ), "LDKCOption_TxOutZ");
19832 *ret_copy = COption_TxOutZ_clone(orig_conv);
19833 uint64_t ret_ref = tag_ptr(ret_copy, true);
19837 void __attribute__((export_name("TS_CVec_InputZ_free"))) TS_CVec_InputZ_free(uint64_tArray _res) {
19838 LDKCVec_InputZ _res_constr;
19839 _res_constr.datalen = _res->arr_len;
19840 if (_res_constr.datalen > 0)
19841 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKInput), "LDKCVec_InputZ Elements");
19843 _res_constr.data = NULL;
19844 uint64_t* _res_vals = _res->elems;
19845 for (size_t h = 0; h < _res_constr.datalen; h++) {
19846 uint64_t _res_conv_7 = _res_vals[h];
19847 LDKInput _res_conv_7_conv;
19848 _res_conv_7_conv.inner = untag_ptr(_res_conv_7);
19849 _res_conv_7_conv.is_owned = ptr_is_owned(_res_conv_7);
19850 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_7_conv);
19851 _res_constr.data[h] = _res_conv_7_conv;
19854 CVec_InputZ_free(_res_constr);
19857 uint64_t __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_ok"))) TS_CResult_CoinSelectionNoneZ_ok(uint64_t o) {
19858 LDKCoinSelection o_conv;
19859 o_conv.inner = untag_ptr(o);
19860 o_conv.is_owned = ptr_is_owned(o);
19861 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19862 o_conv = CoinSelection_clone(&o_conv);
19863 LDKCResult_CoinSelectionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CoinSelectionNoneZ), "LDKCResult_CoinSelectionNoneZ");
19864 *ret_conv = CResult_CoinSelectionNoneZ_ok(o_conv);
19865 return tag_ptr(ret_conv, true);
19868 uint64_t __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_err"))) TS_CResult_CoinSelectionNoneZ_err() {
19869 LDKCResult_CoinSelectionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CoinSelectionNoneZ), "LDKCResult_CoinSelectionNoneZ");
19870 *ret_conv = CResult_CoinSelectionNoneZ_err();
19871 return tag_ptr(ret_conv, true);
19874 jboolean __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_is_ok"))) TS_CResult_CoinSelectionNoneZ_is_ok(uint64_t o) {
19875 LDKCResult_CoinSelectionNoneZ* o_conv = (LDKCResult_CoinSelectionNoneZ*)untag_ptr(o);
19876 jboolean ret_conv = CResult_CoinSelectionNoneZ_is_ok(o_conv);
19880 void __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_free"))) TS_CResult_CoinSelectionNoneZ_free(uint64_t _res) {
19881 if (!ptr_is_owned(_res)) return;
19882 void* _res_ptr = untag_ptr(_res);
19883 CHECK_ACCESS(_res_ptr);
19884 LDKCResult_CoinSelectionNoneZ _res_conv = *(LDKCResult_CoinSelectionNoneZ*)(_res_ptr);
19885 FREE(untag_ptr(_res));
19886 CResult_CoinSelectionNoneZ_free(_res_conv);
19889 static inline uint64_t CResult_CoinSelectionNoneZ_clone_ptr(LDKCResult_CoinSelectionNoneZ *NONNULL_PTR arg) {
19890 LDKCResult_CoinSelectionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CoinSelectionNoneZ), "LDKCResult_CoinSelectionNoneZ");
19891 *ret_conv = CResult_CoinSelectionNoneZ_clone(arg);
19892 return tag_ptr(ret_conv, true);
19894 int64_t __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_clone_ptr"))) TS_CResult_CoinSelectionNoneZ_clone_ptr(uint64_t arg) {
19895 LDKCResult_CoinSelectionNoneZ* arg_conv = (LDKCResult_CoinSelectionNoneZ*)untag_ptr(arg);
19896 int64_t ret_conv = CResult_CoinSelectionNoneZ_clone_ptr(arg_conv);
19900 uint64_t __attribute__((export_name("TS_CResult_CoinSelectionNoneZ_clone"))) TS_CResult_CoinSelectionNoneZ_clone(uint64_t orig) {
19901 LDKCResult_CoinSelectionNoneZ* orig_conv = (LDKCResult_CoinSelectionNoneZ*)untag_ptr(orig);
19902 LDKCResult_CoinSelectionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CoinSelectionNoneZ), "LDKCResult_CoinSelectionNoneZ");
19903 *ret_conv = CResult_CoinSelectionNoneZ_clone(orig_conv);
19904 return tag_ptr(ret_conv, true);
19907 uint64_t __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_ok"))) TS_CResult_CVec_UtxoZNoneZ_ok(uint64_tArray o) {
19908 LDKCVec_UtxoZ o_constr;
19909 o_constr.datalen = o->arr_len;
19910 if (o_constr.datalen > 0)
19911 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKUtxo), "LDKCVec_UtxoZ Elements");
19913 o_constr.data = NULL;
19914 uint64_t* o_vals = o->elems;
19915 for (size_t g = 0; g < o_constr.datalen; g++) {
19916 uint64_t o_conv_6 = o_vals[g];
19917 LDKUtxo o_conv_6_conv;
19918 o_conv_6_conv.inner = untag_ptr(o_conv_6);
19919 o_conv_6_conv.is_owned = ptr_is_owned(o_conv_6);
19920 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv_6_conv);
19921 o_conv_6_conv = Utxo_clone(&o_conv_6_conv);
19922 o_constr.data[g] = o_conv_6_conv;
19925 LDKCResult_CVec_UtxoZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_UtxoZNoneZ), "LDKCResult_CVec_UtxoZNoneZ");
19926 *ret_conv = CResult_CVec_UtxoZNoneZ_ok(o_constr);
19927 return tag_ptr(ret_conv, true);
19930 uint64_t __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_err"))) TS_CResult_CVec_UtxoZNoneZ_err() {
19931 LDKCResult_CVec_UtxoZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_UtxoZNoneZ), "LDKCResult_CVec_UtxoZNoneZ");
19932 *ret_conv = CResult_CVec_UtxoZNoneZ_err();
19933 return tag_ptr(ret_conv, true);
19936 jboolean __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_is_ok"))) TS_CResult_CVec_UtxoZNoneZ_is_ok(uint64_t o) {
19937 LDKCResult_CVec_UtxoZNoneZ* o_conv = (LDKCResult_CVec_UtxoZNoneZ*)untag_ptr(o);
19938 jboolean ret_conv = CResult_CVec_UtxoZNoneZ_is_ok(o_conv);
19942 void __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_free"))) TS_CResult_CVec_UtxoZNoneZ_free(uint64_t _res) {
19943 if (!ptr_is_owned(_res)) return;
19944 void* _res_ptr = untag_ptr(_res);
19945 CHECK_ACCESS(_res_ptr);
19946 LDKCResult_CVec_UtxoZNoneZ _res_conv = *(LDKCResult_CVec_UtxoZNoneZ*)(_res_ptr);
19947 FREE(untag_ptr(_res));
19948 CResult_CVec_UtxoZNoneZ_free(_res_conv);
19951 static inline uint64_t CResult_CVec_UtxoZNoneZ_clone_ptr(LDKCResult_CVec_UtxoZNoneZ *NONNULL_PTR arg) {
19952 LDKCResult_CVec_UtxoZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_UtxoZNoneZ), "LDKCResult_CVec_UtxoZNoneZ");
19953 *ret_conv = CResult_CVec_UtxoZNoneZ_clone(arg);
19954 return tag_ptr(ret_conv, true);
19956 int64_t __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_clone_ptr"))) TS_CResult_CVec_UtxoZNoneZ_clone_ptr(uint64_t arg) {
19957 LDKCResult_CVec_UtxoZNoneZ* arg_conv = (LDKCResult_CVec_UtxoZNoneZ*)untag_ptr(arg);
19958 int64_t ret_conv = CResult_CVec_UtxoZNoneZ_clone_ptr(arg_conv);
19962 uint64_t __attribute__((export_name("TS_CResult_CVec_UtxoZNoneZ_clone"))) TS_CResult_CVec_UtxoZNoneZ_clone(uint64_t orig) {
19963 LDKCResult_CVec_UtxoZNoneZ* orig_conv = (LDKCResult_CVec_UtxoZNoneZ*)untag_ptr(orig);
19964 LDKCResult_CVec_UtxoZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_UtxoZNoneZ), "LDKCResult_CVec_UtxoZNoneZ");
19965 *ret_conv = CResult_CVec_UtxoZNoneZ_clone(orig_conv);
19966 return tag_ptr(ret_conv, true);
19969 static inline uint64_t C2Tuple_u64u16Z_clone_ptr(LDKC2Tuple_u64u16Z *NONNULL_PTR arg) {
19970 LDKC2Tuple_u64u16Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u16Z), "LDKC2Tuple_u64u16Z");
19971 *ret_conv = C2Tuple_u64u16Z_clone(arg);
19972 return tag_ptr(ret_conv, true);
19974 int64_t __attribute__((export_name("TS_C2Tuple_u64u16Z_clone_ptr"))) TS_C2Tuple_u64u16Z_clone_ptr(uint64_t arg) {
19975 LDKC2Tuple_u64u16Z* arg_conv = (LDKC2Tuple_u64u16Z*)untag_ptr(arg);
19976 int64_t ret_conv = C2Tuple_u64u16Z_clone_ptr(arg_conv);
19980 uint64_t __attribute__((export_name("TS_C2Tuple_u64u16Z_clone"))) TS_C2Tuple_u64u16Z_clone(uint64_t orig) {
19981 LDKC2Tuple_u64u16Z* orig_conv = (LDKC2Tuple_u64u16Z*)untag_ptr(orig);
19982 LDKC2Tuple_u64u16Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u16Z), "LDKC2Tuple_u64u16Z");
19983 *ret_conv = C2Tuple_u64u16Z_clone(orig_conv);
19984 return tag_ptr(ret_conv, true);
19987 uint64_t __attribute__((export_name("TS_C2Tuple_u64u16Z_new"))) TS_C2Tuple_u64u16Z_new(int64_t a, int16_t b) {
19988 LDKC2Tuple_u64u16Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u16Z), "LDKC2Tuple_u64u16Z");
19989 *ret_conv = C2Tuple_u64u16Z_new(a, b);
19990 return tag_ptr(ret_conv, true);
19993 void __attribute__((export_name("TS_C2Tuple_u64u16Z_free"))) TS_C2Tuple_u64u16Z_free(uint64_t _res) {
19994 if (!ptr_is_owned(_res)) return;
19995 void* _res_ptr = untag_ptr(_res);
19996 CHECK_ACCESS(_res_ptr);
19997 LDKC2Tuple_u64u16Z _res_conv = *(LDKC2Tuple_u64u16Z*)(_res_ptr);
19998 FREE(untag_ptr(_res));
19999 C2Tuple_u64u16Z_free(_res_conv);
20002 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u16ZZ_some"))) TS_COption_C2Tuple_u64u16ZZ_some(uint64_t o) {
20003 void* o_ptr = untag_ptr(o);
20004 CHECK_ACCESS(o_ptr);
20005 LDKC2Tuple_u64u16Z o_conv = *(LDKC2Tuple_u64u16Z*)(o_ptr);
20006 o_conv = C2Tuple_u64u16Z_clone((LDKC2Tuple_u64u16Z*)untag_ptr(o));
20007 LDKCOption_C2Tuple_u64u16ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u16ZZ), "LDKCOption_C2Tuple_u64u16ZZ");
20008 *ret_copy = COption_C2Tuple_u64u16ZZ_some(o_conv);
20009 uint64_t ret_ref = tag_ptr(ret_copy, true);
20013 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u16ZZ_none"))) TS_COption_C2Tuple_u64u16ZZ_none() {
20014 LDKCOption_C2Tuple_u64u16ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u16ZZ), "LDKCOption_C2Tuple_u64u16ZZ");
20015 *ret_copy = COption_C2Tuple_u64u16ZZ_none();
20016 uint64_t ret_ref = tag_ptr(ret_copy, true);
20020 void __attribute__((export_name("TS_COption_C2Tuple_u64u16ZZ_free"))) TS_COption_C2Tuple_u64u16ZZ_free(uint64_t _res) {
20021 if (!ptr_is_owned(_res)) return;
20022 void* _res_ptr = untag_ptr(_res);
20023 CHECK_ACCESS(_res_ptr);
20024 LDKCOption_C2Tuple_u64u16ZZ _res_conv = *(LDKCOption_C2Tuple_u64u16ZZ*)(_res_ptr);
20025 FREE(untag_ptr(_res));
20026 COption_C2Tuple_u64u16ZZ_free(_res_conv);
20029 static inline uint64_t COption_C2Tuple_u64u16ZZ_clone_ptr(LDKCOption_C2Tuple_u64u16ZZ *NONNULL_PTR arg) {
20030 LDKCOption_C2Tuple_u64u16ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u16ZZ), "LDKCOption_C2Tuple_u64u16ZZ");
20031 *ret_copy = COption_C2Tuple_u64u16ZZ_clone(arg);
20032 uint64_t ret_ref = tag_ptr(ret_copy, true);
20035 int64_t __attribute__((export_name("TS_COption_C2Tuple_u64u16ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u16ZZ_clone_ptr(uint64_t arg) {
20036 LDKCOption_C2Tuple_u64u16ZZ* arg_conv = (LDKCOption_C2Tuple_u64u16ZZ*)untag_ptr(arg);
20037 int64_t ret_conv = COption_C2Tuple_u64u16ZZ_clone_ptr(arg_conv);
20041 uint64_t __attribute__((export_name("TS_COption_C2Tuple_u64u16ZZ_clone"))) TS_COption_C2Tuple_u64u16ZZ_clone(uint64_t orig) {
20042 LDKCOption_C2Tuple_u64u16ZZ* orig_conv = (LDKCOption_C2Tuple_u64u16ZZ*)untag_ptr(orig);
20043 LDKCOption_C2Tuple_u64u16ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u16ZZ), "LDKCOption_C2Tuple_u64u16ZZ");
20044 *ret_copy = COption_C2Tuple_u64u16ZZ_clone(orig_conv);
20045 uint64_t ret_ref = tag_ptr(ret_copy, true);
20049 uint64_t __attribute__((export_name("TS_COption_ChannelShutdownStateZ_some"))) TS_COption_ChannelShutdownStateZ_some(uint32_t o) {
20050 LDKChannelShutdownState o_conv = LDKChannelShutdownState_from_js(o);
20051 LDKCOption_ChannelShutdownStateZ *ret_copy = MALLOC(sizeof(LDKCOption_ChannelShutdownStateZ), "LDKCOption_ChannelShutdownStateZ");
20052 *ret_copy = COption_ChannelShutdownStateZ_some(o_conv);
20053 uint64_t ret_ref = tag_ptr(ret_copy, true);
20057 uint64_t __attribute__((export_name("TS_COption_ChannelShutdownStateZ_none"))) TS_COption_ChannelShutdownStateZ_none() {
20058 LDKCOption_ChannelShutdownStateZ *ret_copy = MALLOC(sizeof(LDKCOption_ChannelShutdownStateZ), "LDKCOption_ChannelShutdownStateZ");
20059 *ret_copy = COption_ChannelShutdownStateZ_none();
20060 uint64_t ret_ref = tag_ptr(ret_copy, true);
20064 void __attribute__((export_name("TS_COption_ChannelShutdownStateZ_free"))) TS_COption_ChannelShutdownStateZ_free(uint64_t _res) {
20065 if (!ptr_is_owned(_res)) return;
20066 void* _res_ptr = untag_ptr(_res);
20067 CHECK_ACCESS(_res_ptr);
20068 LDKCOption_ChannelShutdownStateZ _res_conv = *(LDKCOption_ChannelShutdownStateZ*)(_res_ptr);
20069 FREE(untag_ptr(_res));
20070 COption_ChannelShutdownStateZ_free(_res_conv);
20073 static inline uint64_t COption_ChannelShutdownStateZ_clone_ptr(LDKCOption_ChannelShutdownStateZ *NONNULL_PTR arg) {
20074 LDKCOption_ChannelShutdownStateZ *ret_copy = MALLOC(sizeof(LDKCOption_ChannelShutdownStateZ), "LDKCOption_ChannelShutdownStateZ");
20075 *ret_copy = COption_ChannelShutdownStateZ_clone(arg);
20076 uint64_t ret_ref = tag_ptr(ret_copy, true);
20079 int64_t __attribute__((export_name("TS_COption_ChannelShutdownStateZ_clone_ptr"))) TS_COption_ChannelShutdownStateZ_clone_ptr(uint64_t arg) {
20080 LDKCOption_ChannelShutdownStateZ* arg_conv = (LDKCOption_ChannelShutdownStateZ*)untag_ptr(arg);
20081 int64_t ret_conv = COption_ChannelShutdownStateZ_clone_ptr(arg_conv);
20085 uint64_t __attribute__((export_name("TS_COption_ChannelShutdownStateZ_clone"))) TS_COption_ChannelShutdownStateZ_clone(uint64_t orig) {
20086 LDKCOption_ChannelShutdownStateZ* orig_conv = (LDKCOption_ChannelShutdownStateZ*)untag_ptr(orig);
20087 LDKCOption_ChannelShutdownStateZ *ret_copy = MALLOC(sizeof(LDKCOption_ChannelShutdownStateZ), "LDKCOption_ChannelShutdownStateZ");
20088 *ret_copy = COption_ChannelShutdownStateZ_clone(orig_conv);
20089 uint64_t ret_ref = tag_ptr(ret_copy, true);
20093 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_ok"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_ok(int8_tArray o) {
20094 LDKThirtyTwoBytes o_ref;
20095 CHECK(o->arr_len == 32);
20096 memcpy(o_ref.data, o->elems, 32); FREE(o);
20097 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
20098 *ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_ok(o_ref);
20099 return tag_ptr(ret_conv, true);
20102 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_err"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_err(uint64_t e) {
20103 void* e_ptr = untag_ptr(e);
20104 CHECK_ACCESS(e_ptr);
20105 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
20106 e_conv = APIError_clone((LDKAPIError*)untag_ptr(e));
20107 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
20108 *ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_err(e_conv);
20109 return tag_ptr(ret_conv, true);
20112 jboolean __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_is_ok(uint64_t o) {
20113 LDKCResult_ThirtyTwoBytesAPIErrorZ* o_conv = (LDKCResult_ThirtyTwoBytesAPIErrorZ*)untag_ptr(o);
20114 jboolean ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_is_ok(o_conv);
20118 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_free"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_free(uint64_t _res) {
20119 if (!ptr_is_owned(_res)) return;
20120 void* _res_ptr = untag_ptr(_res);
20121 CHECK_ACCESS(_res_ptr);
20122 LDKCResult_ThirtyTwoBytesAPIErrorZ _res_conv = *(LDKCResult_ThirtyTwoBytesAPIErrorZ*)(_res_ptr);
20123 FREE(untag_ptr(_res));
20124 CResult_ThirtyTwoBytesAPIErrorZ_free(_res_conv);
20127 static inline uint64_t CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesAPIErrorZ *NONNULL_PTR arg) {
20128 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
20129 *ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_clone(arg);
20130 return tag_ptr(ret_conv, true);
20132 int64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(uint64_t arg) {
20133 LDKCResult_ThirtyTwoBytesAPIErrorZ* arg_conv = (LDKCResult_ThirtyTwoBytesAPIErrorZ*)untag_ptr(arg);
20134 int64_t ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_clone_ptr(arg_conv);
20138 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesAPIErrorZ_clone"))) TS_CResult_ThirtyTwoBytesAPIErrorZ_clone(uint64_t orig) {
20139 LDKCResult_ThirtyTwoBytesAPIErrorZ* orig_conv = (LDKCResult_ThirtyTwoBytesAPIErrorZ*)untag_ptr(orig);
20140 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
20141 *ret_conv = CResult_ThirtyTwoBytesAPIErrorZ_clone(orig_conv);
20142 return tag_ptr(ret_conv, true);
20145 void __attribute__((export_name("TS_CVec_RecentPaymentDetailsZ_free"))) TS_CVec_RecentPaymentDetailsZ_free(uint64_tArray _res) {
20146 LDKCVec_RecentPaymentDetailsZ _res_constr;
20147 _res_constr.datalen = _res->arr_len;
20148 if (_res_constr.datalen > 0)
20149 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRecentPaymentDetails), "LDKCVec_RecentPaymentDetailsZ Elements");
20151 _res_constr.data = NULL;
20152 uint64_t* _res_vals = _res->elems;
20153 for (size_t w = 0; w < _res_constr.datalen; w++) {
20154 uint64_t _res_conv_22 = _res_vals[w];
20155 void* _res_conv_22_ptr = untag_ptr(_res_conv_22);
20156 CHECK_ACCESS(_res_conv_22_ptr);
20157 LDKRecentPaymentDetails _res_conv_22_conv = *(LDKRecentPaymentDetails*)(_res_conv_22_ptr);
20158 FREE(untag_ptr(_res_conv_22));
20159 _res_constr.data[w] = _res_conv_22_conv;
20162 CVec_RecentPaymentDetailsZ_free(_res_constr);
20165 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_ok"))) TS_CResult_NonePaymentSendFailureZ_ok() {
20166 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
20167 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
20168 return tag_ptr(ret_conv, true);
20171 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_err"))) TS_CResult_NonePaymentSendFailureZ_err(uint64_t e) {
20172 void* e_ptr = untag_ptr(e);
20173 CHECK_ACCESS(e_ptr);
20174 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
20175 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
20176 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
20177 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
20178 return tag_ptr(ret_conv, true);
20181 jboolean __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_is_ok"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint64_t o) {
20182 LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(o);
20183 jboolean ret_conv = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
20187 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_free"))) TS_CResult_NonePaymentSendFailureZ_free(uint64_t _res) {
20188 if (!ptr_is_owned(_res)) return;
20189 void* _res_ptr = untag_ptr(_res);
20190 CHECK_ACCESS(_res_ptr);
20191 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
20192 FREE(untag_ptr(_res));
20193 CResult_NonePaymentSendFailureZ_free(_res_conv);
20196 static inline uint64_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
20197 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
20198 *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
20199 return tag_ptr(ret_conv, true);
20201 int64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone_ptr"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint64_t arg) {
20202 LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(arg);
20203 int64_t ret_conv = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
20207 uint64_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone"))) TS_CResult_NonePaymentSendFailureZ_clone(uint64_t orig) {
20208 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)untag_ptr(orig);
20209 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
20210 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
20211 return tag_ptr(ret_conv, true);
20214 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_ok"))) TS_CResult_NoneRetryableSendFailureZ_ok() {
20215 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
20216 *ret_conv = CResult_NoneRetryableSendFailureZ_ok();
20217 return tag_ptr(ret_conv, true);
20220 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_err"))) TS_CResult_NoneRetryableSendFailureZ_err(uint32_t e) {
20221 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
20222 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
20223 *ret_conv = CResult_NoneRetryableSendFailureZ_err(e_conv);
20224 return tag_ptr(ret_conv, true);
20227 jboolean __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_is_ok"))) TS_CResult_NoneRetryableSendFailureZ_is_ok(uint64_t o) {
20228 LDKCResult_NoneRetryableSendFailureZ* o_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(o);
20229 jboolean ret_conv = CResult_NoneRetryableSendFailureZ_is_ok(o_conv);
20233 void __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_free"))) TS_CResult_NoneRetryableSendFailureZ_free(uint64_t _res) {
20234 if (!ptr_is_owned(_res)) return;
20235 void* _res_ptr = untag_ptr(_res);
20236 CHECK_ACCESS(_res_ptr);
20237 LDKCResult_NoneRetryableSendFailureZ _res_conv = *(LDKCResult_NoneRetryableSendFailureZ*)(_res_ptr);
20238 FREE(untag_ptr(_res));
20239 CResult_NoneRetryableSendFailureZ_free(_res_conv);
20242 static inline uint64_t CResult_NoneRetryableSendFailureZ_clone_ptr(LDKCResult_NoneRetryableSendFailureZ *NONNULL_PTR arg) {
20243 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
20244 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(arg);
20245 return tag_ptr(ret_conv, true);
20247 int64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone_ptr"))) TS_CResult_NoneRetryableSendFailureZ_clone_ptr(uint64_t arg) {
20248 LDKCResult_NoneRetryableSendFailureZ* arg_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(arg);
20249 int64_t ret_conv = CResult_NoneRetryableSendFailureZ_clone_ptr(arg_conv);
20253 uint64_t __attribute__((export_name("TS_CResult_NoneRetryableSendFailureZ_clone"))) TS_CResult_NoneRetryableSendFailureZ_clone(uint64_t orig) {
20254 LDKCResult_NoneRetryableSendFailureZ* orig_conv = (LDKCResult_NoneRetryableSendFailureZ*)untag_ptr(orig);
20255 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
20256 *ret_conv = CResult_NoneRetryableSendFailureZ_clone(orig_conv);
20257 return tag_ptr(ret_conv, true);
20260 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(int8_tArray o) {
20261 LDKThirtyTwoBytes o_ref;
20262 CHECK(o->arr_len == 32);
20263 memcpy(o_ref.data, o->elems, 32); FREE(o);
20264 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ), "LDKCResult_ThirtyTwoBytesPaymentSendFailureZ");
20265 *ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_ok(o_ref);
20266 return tag_ptr(ret_conv, true);
20269 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_err(uint64_t e) {
20270 void* e_ptr = untag_ptr(e);
20271 CHECK_ACCESS(e_ptr);
20272 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
20273 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
20274 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ), "LDKCResult_ThirtyTwoBytesPaymentSendFailureZ");
20275 *ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_err(e_conv);
20276 return tag_ptr(ret_conv, true);
20279 jboolean __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(uint64_t o) {
20280 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* o_conv = (LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)untag_ptr(o);
20281 jboolean ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_is_ok(o_conv);
20285 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_free(uint64_t _res) {
20286 if (!ptr_is_owned(_res)) return;
20287 void* _res_ptr = untag_ptr(_res);
20288 CHECK_ACCESS(_res_ptr);
20289 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ _res_conv = *(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)(_res_ptr);
20290 FREE(untag_ptr(_res));
20291 CResult_ThirtyTwoBytesPaymentSendFailureZ_free(_res_conv);
20294 static inline uint64_t CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ *NONNULL_PTR arg) {
20295 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ), "LDKCResult_ThirtyTwoBytesPaymentSendFailureZ");
20296 *ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(arg);
20297 return tag_ptr(ret_conv, true);
20299 int64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(uint64_t arg) {
20300 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* arg_conv = (LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)untag_ptr(arg);
20301 int64_t ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_clone_ptr(arg_conv);
20305 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone"))) TS_CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(uint64_t orig) {
20306 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* orig_conv = (LDKCResult_ThirtyTwoBytesPaymentSendFailureZ*)untag_ptr(orig);
20307 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ), "LDKCResult_ThirtyTwoBytesPaymentSendFailureZ");
20308 *ret_conv = CResult_ThirtyTwoBytesPaymentSendFailureZ_clone(orig_conv);
20309 return tag_ptr(ret_conv, true);
20312 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(int8_tArray o) {
20313 LDKThirtyTwoBytes o_ref;
20314 CHECK(o->arr_len == 32);
20315 memcpy(o_ref.data, o->elems, 32); FREE(o);
20316 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ), "LDKCResult_ThirtyTwoBytesRetryableSendFailureZ");
20317 *ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_ok(o_ref);
20318 return tag_ptr(ret_conv, true);
20321 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_err(uint32_t e) {
20322 LDKRetryableSendFailure e_conv = LDKRetryableSendFailure_from_js(e);
20323 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ), "LDKCResult_ThirtyTwoBytesRetryableSendFailureZ");
20324 *ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_err(e_conv);
20325 return tag_ptr(ret_conv, true);
20328 jboolean __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(uint64_t o) {
20329 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* o_conv = (LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)untag_ptr(o);
20330 jboolean ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_is_ok(o_conv);
20334 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_free(uint64_t _res) {
20335 if (!ptr_is_owned(_res)) return;
20336 void* _res_ptr = untag_ptr(_res);
20337 CHECK_ACCESS(_res_ptr);
20338 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ _res_conv = *(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)(_res_ptr);
20339 FREE(untag_ptr(_res));
20340 CResult_ThirtyTwoBytesRetryableSendFailureZ_free(_res_conv);
20343 static inline uint64_t CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ *NONNULL_PTR arg) {
20344 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ), "LDKCResult_ThirtyTwoBytesRetryableSendFailureZ");
20345 *ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(arg);
20346 return tag_ptr(ret_conv, true);
20348 int64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(uint64_t arg) {
20349 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* arg_conv = (LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)untag_ptr(arg);
20350 int64_t ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_clone_ptr(arg_conv);
20354 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone"))) TS_CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(uint64_t orig) {
20355 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* orig_conv = (LDKCResult_ThirtyTwoBytesRetryableSendFailureZ*)untag_ptr(orig);
20356 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ), "LDKCResult_ThirtyTwoBytesRetryableSendFailureZ");
20357 *ret_conv = CResult_ThirtyTwoBytesRetryableSendFailureZ_clone(orig_conv);
20358 return tag_ptr(ret_conv, true);
20361 static inline uint64_t C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ *NONNULL_PTR arg) {
20362 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
20363 *ret_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(arg);
20364 return tag_ptr(ret_conv, true);
20366 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(uint64_t arg) {
20367 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(arg);
20368 int64_t ret_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone_ptr(arg_conv);
20372 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(uint64_t orig) {
20373 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(orig);
20374 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
20375 *ret_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone(orig_conv);
20376 return tag_ptr(ret_conv, true);
20379 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(int8_tArray a, int8_tArray b) {
20380 LDKThirtyTwoBytes a_ref;
20381 CHECK(a->arr_len == 32);
20382 memcpy(a_ref.data, a->elems, 32); FREE(a);
20383 LDKThirtyTwoBytes b_ref;
20384 CHECK(b->arr_len == 32);
20385 memcpy(b_ref.data, b->elems, 32); FREE(b);
20386 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ");
20387 *ret_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_new(a_ref, b_ref);
20388 return tag_ptr(ret_conv, true);
20391 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free"))) TS_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(uint64_t _res) {
20392 if (!ptr_is_owned(_res)) return;
20393 void* _res_ptr = untag_ptr(_res);
20394 CHECK_ACCESS(_res_ptr);
20395 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(_res_ptr);
20396 FREE(untag_ptr(_res));
20397 C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_free(_res_conv);
20400 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(uint64_t o) {
20401 void* o_ptr = untag_ptr(o);
20402 CHECK_ACCESS(o_ptr);
20403 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(o_ptr);
20404 o_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone((LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(o));
20405 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ");
20406 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_ok(o_conv);
20407 return tag_ptr(ret_conv, true);
20410 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(uint64_t e) {
20411 void* e_ptr = untag_ptr(e);
20412 CHECK_ACCESS(e_ptr);
20413 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
20414 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(e));
20415 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ");
20416 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_err(e_conv);
20417 return tag_ptr(ret_conv, true);
20420 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(uint64_t o) {
20421 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)untag_ptr(o);
20422 jboolean ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_is_ok(o_conv);
20426 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(uint64_t _res) {
20427 if (!ptr_is_owned(_res)) return;
20428 void* _res_ptr = untag_ptr(_res);
20429 CHECK_ACCESS(_res_ptr);
20430 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)(_res_ptr);
20431 FREE(untag_ptr(_res));
20432 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_free(_res_conv);
20435 static inline uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ *NONNULL_PTR arg) {
20436 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ");
20437 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(arg);
20438 return tag_ptr(ret_conv, true);
20440 int64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(uint64_t arg) {
20441 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)untag_ptr(arg);
20442 int64_t ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone_ptr(arg_conv);
20446 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(uint64_t orig) {
20447 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ*)untag_ptr(orig);
20448 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ");
20449 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ_clone(orig_conv);
20450 return tag_ptr(ret_conv, true);
20453 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(uint64_tArray _res) {
20454 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ _res_constr;
20455 _res_constr.datalen = _res->arr_len;
20456 if (_res_constr.datalen > 0)
20457 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ Elements");
20459 _res_constr.data = NULL;
20460 uint64_t* _res_vals = _res->elems;
20461 for (size_t o = 0; o < _res_constr.datalen; o++) {
20462 uint64_t _res_conv_40 = _res_vals[o];
20463 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
20464 CHECK_ACCESS(_res_conv_40_ptr);
20465 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ _res_conv_40_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(_res_conv_40_ptr);
20466 FREE(untag_ptr(_res_conv_40));
20467 _res_constr.data[o] = _res_conv_40_conv;
20470 CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ_free(_res_constr);
20473 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(uint64_tArray o) {
20474 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o_constr;
20475 o_constr.datalen = o->arr_len;
20476 if (o_constr.datalen > 0)
20477 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ Elements");
20479 o_constr.data = NULL;
20480 uint64_t* o_vals = o->elems;
20481 for (size_t o = 0; o < o_constr.datalen; o++) {
20482 uint64_t o_conv_40 = o_vals[o];
20483 void* o_conv_40_ptr = untag_ptr(o_conv_40);
20484 CHECK_ACCESS(o_conv_40_ptr);
20485 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o_conv_40_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(o_conv_40_ptr);
20486 o_conv_40_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone((LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(o_conv_40));
20487 o_constr.data[o] = o_conv_40_conv;
20490 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
20491 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_ok(o_constr);
20492 return tag_ptr(ret_conv, true);
20495 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(uint64_t e) {
20496 void* e_ptr = untag_ptr(e);
20497 CHECK_ACCESS(e_ptr);
20498 LDKProbeSendFailure e_conv = *(LDKProbeSendFailure*)(e_ptr);
20499 e_conv = ProbeSendFailure_clone((LDKProbeSendFailure*)untag_ptr(e));
20500 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
20501 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_err(e_conv);
20502 return tag_ptr(ret_conv, true);
20505 jboolean __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(uint64_t o) {
20506 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* o_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)untag_ptr(o);
20507 jboolean ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_is_ok(o_conv);
20511 void __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(uint64_t _res) {
20512 if (!ptr_is_owned(_res)) return;
20513 void* _res_ptr = untag_ptr(_res);
20514 CHECK_ACCESS(_res_ptr);
20515 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ _res_conv = *(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)(_res_ptr);
20516 FREE(untag_ptr(_res));
20517 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_free(_res_conv);
20520 static inline uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ *NONNULL_PTR arg) {
20521 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
20522 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(arg);
20523 return tag_ptr(ret_conv, true);
20525 int64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(uint64_t arg) {
20526 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* arg_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)untag_ptr(arg);
20527 int64_t ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone_ptr(arg_conv);
20531 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(uint64_t orig) {
20532 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* orig_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ*)untag_ptr(orig);
20533 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
20534 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ_clone(orig_conv);
20535 return tag_ptr(ret_conv, true);
20538 static inline uint64_t C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ *NONNULL_PTR arg) {
20539 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ), "LDKC2Tuple_ThirtyTwoBytesPublicKeyZ");
20540 *ret_conv = C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(arg);
20541 return tag_ptr(ret_conv, true);
20543 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(uint64_t arg) {
20544 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)untag_ptr(arg);
20545 int64_t ret_conv = C2Tuple_ThirtyTwoBytesPublicKeyZ_clone_ptr(arg_conv);
20549 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(uint64_t orig) {
20550 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)untag_ptr(orig);
20551 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ), "LDKC2Tuple_ThirtyTwoBytesPublicKeyZ");
20552 *ret_conv = C2Tuple_ThirtyTwoBytesPublicKeyZ_clone(orig_conv);
20553 return tag_ptr(ret_conv, true);
20556 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_new"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_new(int8_tArray a, int8_tArray b) {
20557 LDKThirtyTwoBytes a_ref;
20558 CHECK(a->arr_len == 32);
20559 memcpy(a_ref.data, a->elems, 32); FREE(a);
20560 LDKPublicKey b_ref;
20561 CHECK(b->arr_len == 33);
20562 memcpy(b_ref.compressed_form, b->elems, 33); FREE(b);
20563 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ), "LDKC2Tuple_ThirtyTwoBytesPublicKeyZ");
20564 *ret_conv = C2Tuple_ThirtyTwoBytesPublicKeyZ_new(a_ref, b_ref);
20565 return tag_ptr(ret_conv, true);
20568 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_free"))) TS_C2Tuple_ThirtyTwoBytesPublicKeyZ_free(uint64_t _res) {
20569 if (!ptr_is_owned(_res)) return;
20570 void* _res_ptr = untag_ptr(_res);
20571 CHECK_ACCESS(_res_ptr);
20572 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)(_res_ptr);
20573 FREE(untag_ptr(_res));
20574 C2Tuple_ThirtyTwoBytesPublicKeyZ_free(_res_conv);
20577 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(uint64_tArray _res) {
20578 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ _res_constr;
20579 _res_constr.datalen = _res->arr_len;
20580 if (_res_constr.datalen > 0)
20581 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ), "LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ Elements");
20583 _res_constr.data = NULL;
20584 uint64_t* _res_vals = _res->elems;
20585 for (size_t j = 0; j < _res_constr.datalen; j++) {
20586 uint64_t _res_conv_35 = _res_vals[j];
20587 void* _res_conv_35_ptr = untag_ptr(_res_conv_35);
20588 CHECK_ACCESS(_res_conv_35_ptr);
20589 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ _res_conv_35_conv = *(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)(_res_conv_35_ptr);
20590 FREE(untag_ptr(_res_conv_35));
20591 _res_constr.data[j] = _res_conv_35_conv;
20594 CVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ_free(_res_constr);
20597 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(uint64_t o) {
20598 void* o_ptr = untag_ptr(o);
20599 CHECK_ACCESS(o_ptr);
20600 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(o_ptr);
20601 o_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone((LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(o));
20602 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
20603 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_ok(o_conv);
20604 return tag_ptr(ret_conv, true);
20607 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err() {
20608 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
20609 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_err();
20610 return tag_ptr(ret_conv, true);
20613 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(uint64_t o) {
20614 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* o_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)untag_ptr(o);
20615 jboolean ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_is_ok(o_conv);
20619 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(uint64_t _res) {
20620 if (!ptr_is_owned(_res)) return;
20621 void* _res_ptr = untag_ptr(_res);
20622 CHECK_ACCESS(_res_ptr);
20623 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ _res_conv = *(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)(_res_ptr);
20624 FREE(untag_ptr(_res));
20625 CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_free(_res_conv);
20628 static inline uint64_t CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ *NONNULL_PTR arg) {
20629 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
20630 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(arg);
20631 return tag_ptr(ret_conv, true);
20633 int64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(uint64_t arg) {
20634 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* arg_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)untag_ptr(arg);
20635 int64_t ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone_ptr(arg_conv);
20639 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone"))) TS_CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(uint64_t orig) {
20640 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* orig_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ*)untag_ptr(orig);
20641 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
20642 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ_clone(orig_conv);
20643 return tag_ptr(ret_conv, true);
20646 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(uint64_t o) {
20647 LDKCounterpartyForwardingInfo o_conv;
20648 o_conv.inner = untag_ptr(o);
20649 o_conv.is_owned = ptr_is_owned(o);
20650 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20651 o_conv = CounterpartyForwardingInfo_clone(&o_conv);
20652 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
20653 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o_conv);
20654 return tag_ptr(ret_conv, true);
20657 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(uint64_t e) {
20658 void* e_ptr = untag_ptr(e);
20659 CHECK_ACCESS(e_ptr);
20660 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20661 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20662 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
20663 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e_conv);
20664 return tag_ptr(ret_conv, true);
20667 jboolean __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(uint64_t o) {
20668 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* o_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(o);
20669 jboolean ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o_conv);
20673 void __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(uint64_t _res) {
20674 if (!ptr_is_owned(_res)) return;
20675 void* _res_ptr = untag_ptr(_res);
20676 CHECK_ACCESS(_res_ptr);
20677 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(_res_ptr);
20678 FREE(untag_ptr(_res));
20679 CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res_conv);
20682 static inline uint64_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg) {
20683 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
20684 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(arg);
20685 return tag_ptr(ret_conv, true);
20687 int64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(uint64_t arg) {
20688 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(arg);
20689 int64_t ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg_conv);
20693 uint64_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(uint64_t orig) {
20694 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)untag_ptr(orig);
20695 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
20696 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig_conv);
20697 return tag_ptr(ret_conv, true);
20700 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(uint64_t o) {
20701 LDKChannelCounterparty o_conv;
20702 o_conv.inner = untag_ptr(o);
20703 o_conv.is_owned = ptr_is_owned(o);
20704 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20705 o_conv = ChannelCounterparty_clone(&o_conv);
20706 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
20707 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_ok(o_conv);
20708 return tag_ptr(ret_conv, true);
20711 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_err(uint64_t e) {
20712 void* e_ptr = untag_ptr(e);
20713 CHECK_ACCESS(e_ptr);
20714 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20715 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20716 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
20717 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_err(e_conv);
20718 return tag_ptr(ret_conv, true);
20721 jboolean __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(uint64_t o) {
20722 LDKCResult_ChannelCounterpartyDecodeErrorZ* o_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(o);
20723 jboolean ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o_conv);
20727 void __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_free"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_free(uint64_t _res) {
20728 if (!ptr_is_owned(_res)) return;
20729 void* _res_ptr = untag_ptr(_res);
20730 CHECK_ACCESS(_res_ptr);
20731 LDKCResult_ChannelCounterpartyDecodeErrorZ _res_conv = *(LDKCResult_ChannelCounterpartyDecodeErrorZ*)(_res_ptr);
20732 FREE(untag_ptr(_res));
20733 CResult_ChannelCounterpartyDecodeErrorZ_free(_res_conv);
20736 static inline uint64_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg) {
20737 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
20738 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(arg);
20739 return tag_ptr(ret_conv, true);
20741 int64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(uint64_t arg) {
20742 LDKCResult_ChannelCounterpartyDecodeErrorZ* arg_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(arg);
20743 int64_t ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg_conv);
20747 uint64_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(uint64_t orig) {
20748 LDKCResult_ChannelCounterpartyDecodeErrorZ* orig_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)untag_ptr(orig);
20749 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
20750 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(orig_conv);
20751 return tag_ptr(ret_conv, true);
20754 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_ok(uint64_t o) {
20755 LDKChannelDetails o_conv;
20756 o_conv.inner = untag_ptr(o);
20757 o_conv.is_owned = ptr_is_owned(o);
20758 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20759 o_conv = ChannelDetails_clone(&o_conv);
20760 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
20761 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_ok(o_conv);
20762 return tag_ptr(ret_conv, true);
20765 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_err(uint64_t e) {
20766 void* e_ptr = untag_ptr(e);
20767 CHECK_ACCESS(e_ptr);
20768 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20769 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20770 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
20771 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_err(e_conv);
20772 return tag_ptr(ret_conv, true);
20775 jboolean __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_is_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(uint64_t o) {
20776 LDKCResult_ChannelDetailsDecodeErrorZ* o_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(o);
20777 jboolean ret_conv = CResult_ChannelDetailsDecodeErrorZ_is_ok(o_conv);
20781 void __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_free"))) TS_CResult_ChannelDetailsDecodeErrorZ_free(uint64_t _res) {
20782 if (!ptr_is_owned(_res)) return;
20783 void* _res_ptr = untag_ptr(_res);
20784 CHECK_ACCESS(_res_ptr);
20785 LDKCResult_ChannelDetailsDecodeErrorZ _res_conv = *(LDKCResult_ChannelDetailsDecodeErrorZ*)(_res_ptr);
20786 FREE(untag_ptr(_res));
20787 CResult_ChannelDetailsDecodeErrorZ_free(_res_conv);
20790 static inline uint64_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg) {
20791 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
20792 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(arg);
20793 return tag_ptr(ret_conv, true);
20795 int64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(uint64_t arg) {
20796 LDKCResult_ChannelDetailsDecodeErrorZ* arg_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(arg);
20797 int64_t ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg_conv);
20801 uint64_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone(uint64_t orig) {
20802 LDKCResult_ChannelDetailsDecodeErrorZ* orig_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)untag_ptr(orig);
20803 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
20804 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(orig_conv);
20805 return tag_ptr(ret_conv, true);
20808 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(uint64_t o) {
20809 LDKPhantomRouteHints o_conv;
20810 o_conv.inner = untag_ptr(o);
20811 o_conv.is_owned = ptr_is_owned(o);
20812 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20813 o_conv = PhantomRouteHints_clone(&o_conv);
20814 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
20815 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_ok(o_conv);
20816 return tag_ptr(ret_conv, true);
20819 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_err(uint64_t e) {
20820 void* e_ptr = untag_ptr(e);
20821 CHECK_ACCESS(e_ptr);
20822 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20823 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20824 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
20825 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_err(e_conv);
20826 return tag_ptr(ret_conv, true);
20829 jboolean __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(uint64_t o) {
20830 LDKCResult_PhantomRouteHintsDecodeErrorZ* o_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(o);
20831 jboolean ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o_conv);
20835 void __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_free"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_free(uint64_t _res) {
20836 if (!ptr_is_owned(_res)) return;
20837 void* _res_ptr = untag_ptr(_res);
20838 CHECK_ACCESS(_res_ptr);
20839 LDKCResult_PhantomRouteHintsDecodeErrorZ _res_conv = *(LDKCResult_PhantomRouteHintsDecodeErrorZ*)(_res_ptr);
20840 FREE(untag_ptr(_res));
20841 CResult_PhantomRouteHintsDecodeErrorZ_free(_res_conv);
20844 static inline uint64_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg) {
20845 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
20846 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(arg);
20847 return tag_ptr(ret_conv, true);
20849 int64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(uint64_t arg) {
20850 LDKCResult_PhantomRouteHintsDecodeErrorZ* arg_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(arg);
20851 int64_t ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg_conv);
20855 uint64_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(uint64_t orig) {
20856 LDKCResult_PhantomRouteHintsDecodeErrorZ* orig_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)untag_ptr(orig);
20857 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
20858 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(orig_conv);
20859 return tag_ptr(ret_conv, true);
20862 uint64_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_ok"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_ok(uint32_t o) {
20863 LDKChannelShutdownState o_conv = LDKChannelShutdownState_from_js(o);
20864 LDKCResult_ChannelShutdownStateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ), "LDKCResult_ChannelShutdownStateDecodeErrorZ");
20865 *ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_ok(o_conv);
20866 return tag_ptr(ret_conv, true);
20869 uint64_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_err"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_err(uint64_t e) {
20870 void* e_ptr = untag_ptr(e);
20871 CHECK_ACCESS(e_ptr);
20872 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20873 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20874 LDKCResult_ChannelShutdownStateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ), "LDKCResult_ChannelShutdownStateDecodeErrorZ");
20875 *ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_err(e_conv);
20876 return tag_ptr(ret_conv, true);
20879 jboolean __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_is_ok(uint64_t o) {
20880 LDKCResult_ChannelShutdownStateDecodeErrorZ* o_conv = (LDKCResult_ChannelShutdownStateDecodeErrorZ*)untag_ptr(o);
20881 jboolean ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_is_ok(o_conv);
20885 void __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_free"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_free(uint64_t _res) {
20886 if (!ptr_is_owned(_res)) return;
20887 void* _res_ptr = untag_ptr(_res);
20888 CHECK_ACCESS(_res_ptr);
20889 LDKCResult_ChannelShutdownStateDecodeErrorZ _res_conv = *(LDKCResult_ChannelShutdownStateDecodeErrorZ*)(_res_ptr);
20890 FREE(untag_ptr(_res));
20891 CResult_ChannelShutdownStateDecodeErrorZ_free(_res_conv);
20894 static inline uint64_t CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(LDKCResult_ChannelShutdownStateDecodeErrorZ *NONNULL_PTR arg) {
20895 LDKCResult_ChannelShutdownStateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ), "LDKCResult_ChannelShutdownStateDecodeErrorZ");
20896 *ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_clone(arg);
20897 return tag_ptr(ret_conv, true);
20899 int64_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(uint64_t arg) {
20900 LDKCResult_ChannelShutdownStateDecodeErrorZ* arg_conv = (LDKCResult_ChannelShutdownStateDecodeErrorZ*)untag_ptr(arg);
20901 int64_t ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_clone_ptr(arg_conv);
20905 uint64_t __attribute__((export_name("TS_CResult_ChannelShutdownStateDecodeErrorZ_clone"))) TS_CResult_ChannelShutdownStateDecodeErrorZ_clone(uint64_t orig) {
20906 LDKCResult_ChannelShutdownStateDecodeErrorZ* orig_conv = (LDKCResult_ChannelShutdownStateDecodeErrorZ*)untag_ptr(orig);
20907 LDKCResult_ChannelShutdownStateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ), "LDKCResult_ChannelShutdownStateDecodeErrorZ");
20908 *ret_conv = CResult_ChannelShutdownStateDecodeErrorZ_clone(orig_conv);
20909 return tag_ptr(ret_conv, true);
20912 void __attribute__((export_name("TS_CVec_ChannelMonitorZ_free"))) TS_CVec_ChannelMonitorZ_free(uint64_tArray _res) {
20913 LDKCVec_ChannelMonitorZ _res_constr;
20914 _res_constr.datalen = _res->arr_len;
20915 if (_res_constr.datalen > 0)
20916 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
20918 _res_constr.data = NULL;
20919 uint64_t* _res_vals = _res->elems;
20920 for (size_t q = 0; q < _res_constr.datalen; q++) {
20921 uint64_t _res_conv_16 = _res_vals[q];
20922 LDKChannelMonitor _res_conv_16_conv;
20923 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
20924 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
20925 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
20926 _res_constr.data[q] = _res_conv_16_conv;
20929 CVec_ChannelMonitorZ_free(_res_constr);
20932 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new"))) TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_new(int8_tArray a, uint64_t b) {
20933 LDKThirtyTwoBytes a_ref;
20934 CHECK(a->arr_len == 32);
20935 memcpy(a_ref.data, a->elems, 32); FREE(a);
20936 LDKChannelManager b_conv;
20937 b_conv.inner = untag_ptr(b);
20938 b_conv.is_owned = ptr_is_owned(b);
20939 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
20940 // WARNING: we need a move here but no clone is available for LDKChannelManager
20942 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ), "LDKC2Tuple_ThirtyTwoBytesChannelManagerZ");
20943 *ret_conv = C2Tuple_ThirtyTwoBytesChannelManagerZ_new(a_ref, b_conv);
20944 return tag_ptr(ret_conv, true);
20947 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free"))) TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_free(uint64_t _res) {
20948 if (!ptr_is_owned(_res)) return;
20949 void* _res_ptr = untag_ptr(_res);
20950 CHECK_ACCESS(_res_ptr);
20951 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ*)(_res_ptr);
20952 FREE(untag_ptr(_res));
20953 C2Tuple_ThirtyTwoBytesChannelManagerZ_free(_res_conv);
20956 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(uint64_t o) {
20957 void* o_ptr = untag_ptr(o);
20958 CHECK_ACCESS(o_ptr);
20959 LDKC2Tuple_ThirtyTwoBytesChannelManagerZ o_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelManagerZ*)(o_ptr);
20960 // WARNING: we may need a move here but no clone is available for LDKC2Tuple_ThirtyTwoBytesChannelManagerZ
20961 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ");
20962 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_ok(o_conv);
20963 return tag_ptr(ret_conv, true);
20966 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(uint64_t e) {
20967 void* e_ptr = untag_ptr(e);
20968 CHECK_ACCESS(e_ptr);
20969 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
20970 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
20971 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ");
20972 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_err(e_conv);
20973 return tag_ptr(ret_conv, true);
20976 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(uint64_t o) {
20977 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ*)untag_ptr(o);
20978 jboolean ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_is_ok(o_conv);
20982 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(uint64_t _res) {
20983 if (!ptr_is_owned(_res)) return;
20984 void* _res_ptr = untag_ptr(_res);
20985 CHECK_ACCESS(_res_ptr);
20986 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ*)(_res_ptr);
20987 FREE(untag_ptr(_res));
20988 CResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ_free(_res_conv);
20991 uint64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_ok(uint64_t o) {
20992 void* o_ptr = untag_ptr(o);
20993 CHECK_ACCESS(o_ptr);
20994 LDKMaxDustHTLCExposure o_conv = *(LDKMaxDustHTLCExposure*)(o_ptr);
20995 o_conv = MaxDustHTLCExposure_clone((LDKMaxDustHTLCExposure*)untag_ptr(o));
20996 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ), "LDKCResult_MaxDustHTLCExposureDecodeErrorZ");
20997 *ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_ok(o_conv);
20998 return tag_ptr(ret_conv, true);
21001 uint64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_err(uint64_t e) {
21002 void* e_ptr = untag_ptr(e);
21003 CHECK_ACCESS(e_ptr);
21004 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21005 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21006 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ), "LDKCResult_MaxDustHTLCExposureDecodeErrorZ");
21007 *ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_err(e_conv);
21008 return tag_ptr(ret_conv, true);
21011 jboolean __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(uint64_t o) {
21012 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* o_conv = (LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)untag_ptr(o);
21013 jboolean ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_is_ok(o_conv);
21017 void __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_free(uint64_t _res) {
21018 if (!ptr_is_owned(_res)) return;
21019 void* _res_ptr = untag_ptr(_res);
21020 CHECK_ACCESS(_res_ptr);
21021 LDKCResult_MaxDustHTLCExposureDecodeErrorZ _res_conv = *(LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)(_res_ptr);
21022 FREE(untag_ptr(_res));
21023 CResult_MaxDustHTLCExposureDecodeErrorZ_free(_res_conv);
21026 static inline uint64_t CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(LDKCResult_MaxDustHTLCExposureDecodeErrorZ *NONNULL_PTR arg) {
21027 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ), "LDKCResult_MaxDustHTLCExposureDecodeErrorZ");
21028 *ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_clone(arg);
21029 return tag_ptr(ret_conv, true);
21031 int64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(uint64_t arg) {
21032 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* arg_conv = (LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)untag_ptr(arg);
21033 int64_t ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_clone_ptr(arg_conv);
21037 uint64_t __attribute__((export_name("TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone"))) TS_CResult_MaxDustHTLCExposureDecodeErrorZ_clone(uint64_t orig) {
21038 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* orig_conv = (LDKCResult_MaxDustHTLCExposureDecodeErrorZ*)untag_ptr(orig);
21039 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ), "LDKCResult_MaxDustHTLCExposureDecodeErrorZ");
21040 *ret_conv = CResult_MaxDustHTLCExposureDecodeErrorZ_clone(orig_conv);
21041 return tag_ptr(ret_conv, true);
21044 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint64_t o) {
21045 LDKChannelConfig o_conv;
21046 o_conv.inner = untag_ptr(o);
21047 o_conv.is_owned = ptr_is_owned(o);
21048 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21049 o_conv = ChannelConfig_clone(&o_conv);
21050 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
21051 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
21052 return tag_ptr(ret_conv, true);
21055 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_err"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint64_t e) {
21056 void* e_ptr = untag_ptr(e);
21057 CHECK_ACCESS(e_ptr);
21058 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21059 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21060 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
21061 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
21062 return tag_ptr(ret_conv, true);
21065 jboolean __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_is_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint64_t o) {
21066 LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(o);
21067 jboolean ret_conv = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
21071 void __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_free"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint64_t _res) {
21072 if (!ptr_is_owned(_res)) return;
21073 void* _res_ptr = untag_ptr(_res);
21074 CHECK_ACCESS(_res_ptr);
21075 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
21076 FREE(untag_ptr(_res));
21077 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
21080 static inline uint64_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
21081 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
21082 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
21083 return tag_ptr(ret_conv, true);
21085 int64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint64_t arg) {
21086 LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(arg);
21087 int64_t ret_conv = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
21091 uint64_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint64_t orig) {
21092 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)untag_ptr(orig);
21093 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
21094 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
21095 return tag_ptr(ret_conv, true);
21098 uint64_t __attribute__((export_name("TS_COption_MaxDustHTLCExposureZ_some"))) TS_COption_MaxDustHTLCExposureZ_some(uint64_t o) {
21099 void* o_ptr = untag_ptr(o);
21100 CHECK_ACCESS(o_ptr);
21101 LDKMaxDustHTLCExposure o_conv = *(LDKMaxDustHTLCExposure*)(o_ptr);
21102 o_conv = MaxDustHTLCExposure_clone((LDKMaxDustHTLCExposure*)untag_ptr(o));
21103 LDKCOption_MaxDustHTLCExposureZ *ret_copy = MALLOC(sizeof(LDKCOption_MaxDustHTLCExposureZ), "LDKCOption_MaxDustHTLCExposureZ");
21104 *ret_copy = COption_MaxDustHTLCExposureZ_some(o_conv);
21105 uint64_t ret_ref = tag_ptr(ret_copy, true);
21109 uint64_t __attribute__((export_name("TS_COption_MaxDustHTLCExposureZ_none"))) TS_COption_MaxDustHTLCExposureZ_none() {
21110 LDKCOption_MaxDustHTLCExposureZ *ret_copy = MALLOC(sizeof(LDKCOption_MaxDustHTLCExposureZ), "LDKCOption_MaxDustHTLCExposureZ");
21111 *ret_copy = COption_MaxDustHTLCExposureZ_none();
21112 uint64_t ret_ref = tag_ptr(ret_copy, true);
21116 void __attribute__((export_name("TS_COption_MaxDustHTLCExposureZ_free"))) TS_COption_MaxDustHTLCExposureZ_free(uint64_t _res) {
21117 if (!ptr_is_owned(_res)) return;
21118 void* _res_ptr = untag_ptr(_res);
21119 CHECK_ACCESS(_res_ptr);
21120 LDKCOption_MaxDustHTLCExposureZ _res_conv = *(LDKCOption_MaxDustHTLCExposureZ*)(_res_ptr);
21121 FREE(untag_ptr(_res));
21122 COption_MaxDustHTLCExposureZ_free(_res_conv);
21125 static inline uint64_t COption_MaxDustHTLCExposureZ_clone_ptr(LDKCOption_MaxDustHTLCExposureZ *NONNULL_PTR arg) {
21126 LDKCOption_MaxDustHTLCExposureZ *ret_copy = MALLOC(sizeof(LDKCOption_MaxDustHTLCExposureZ), "LDKCOption_MaxDustHTLCExposureZ");
21127 *ret_copy = COption_MaxDustHTLCExposureZ_clone(arg);
21128 uint64_t ret_ref = tag_ptr(ret_copy, true);
21131 int64_t __attribute__((export_name("TS_COption_MaxDustHTLCExposureZ_clone_ptr"))) TS_COption_MaxDustHTLCExposureZ_clone_ptr(uint64_t arg) {
21132 LDKCOption_MaxDustHTLCExposureZ* arg_conv = (LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(arg);
21133 int64_t ret_conv = COption_MaxDustHTLCExposureZ_clone_ptr(arg_conv);
21137 uint64_t __attribute__((export_name("TS_COption_MaxDustHTLCExposureZ_clone"))) TS_COption_MaxDustHTLCExposureZ_clone(uint64_t orig) {
21138 LDKCOption_MaxDustHTLCExposureZ* orig_conv = (LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(orig);
21139 LDKCOption_MaxDustHTLCExposureZ *ret_copy = MALLOC(sizeof(LDKCOption_MaxDustHTLCExposureZ), "LDKCOption_MaxDustHTLCExposureZ");
21140 *ret_copy = COption_MaxDustHTLCExposureZ_clone(orig_conv);
21141 uint64_t ret_ref = tag_ptr(ret_copy, true);
21145 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_some"))) TS_COption_APIErrorZ_some(uint64_t o) {
21146 void* o_ptr = untag_ptr(o);
21147 CHECK_ACCESS(o_ptr);
21148 LDKAPIError o_conv = *(LDKAPIError*)(o_ptr);
21149 o_conv = APIError_clone((LDKAPIError*)untag_ptr(o));
21150 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
21151 *ret_copy = COption_APIErrorZ_some(o_conv);
21152 uint64_t ret_ref = tag_ptr(ret_copy, true);
21156 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_none"))) TS_COption_APIErrorZ_none() {
21157 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
21158 *ret_copy = COption_APIErrorZ_none();
21159 uint64_t ret_ref = tag_ptr(ret_copy, true);
21163 void __attribute__((export_name("TS_COption_APIErrorZ_free"))) TS_COption_APIErrorZ_free(uint64_t _res) {
21164 if (!ptr_is_owned(_res)) return;
21165 void* _res_ptr = untag_ptr(_res);
21166 CHECK_ACCESS(_res_ptr);
21167 LDKCOption_APIErrorZ _res_conv = *(LDKCOption_APIErrorZ*)(_res_ptr);
21168 FREE(untag_ptr(_res));
21169 COption_APIErrorZ_free(_res_conv);
21172 static inline uint64_t COption_APIErrorZ_clone_ptr(LDKCOption_APIErrorZ *NONNULL_PTR arg) {
21173 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
21174 *ret_copy = COption_APIErrorZ_clone(arg);
21175 uint64_t ret_ref = tag_ptr(ret_copy, true);
21178 int64_t __attribute__((export_name("TS_COption_APIErrorZ_clone_ptr"))) TS_COption_APIErrorZ_clone_ptr(uint64_t arg) {
21179 LDKCOption_APIErrorZ* arg_conv = (LDKCOption_APIErrorZ*)untag_ptr(arg);
21180 int64_t ret_conv = COption_APIErrorZ_clone_ptr(arg_conv);
21184 uint64_t __attribute__((export_name("TS_COption_APIErrorZ_clone"))) TS_COption_APIErrorZ_clone(uint64_t orig) {
21185 LDKCOption_APIErrorZ* orig_conv = (LDKCOption_APIErrorZ*)untag_ptr(orig);
21186 LDKCOption_APIErrorZ *ret_copy = MALLOC(sizeof(LDKCOption_APIErrorZ), "LDKCOption_APIErrorZ");
21187 *ret_copy = COption_APIErrorZ_clone(orig_conv);
21188 uint64_t ret_ref = tag_ptr(ret_copy, true);
21192 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_ok(uint64_t o) {
21193 void* o_ptr = untag_ptr(o);
21194 CHECK_ACCESS(o_ptr);
21195 LDKCOption_APIErrorZ o_conv = *(LDKCOption_APIErrorZ*)(o_ptr);
21196 o_conv = COption_APIErrorZ_clone((LDKCOption_APIErrorZ*)untag_ptr(o));
21197 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
21198 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_ok(o_conv);
21199 return tag_ptr(ret_conv, true);
21202 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_err"))) TS_CResult_COption_APIErrorZDecodeErrorZ_err(uint64_t e) {
21203 void* e_ptr = untag_ptr(e);
21204 CHECK_ACCESS(e_ptr);
21205 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21206 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21207 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
21208 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_err(e_conv);
21209 return tag_ptr(ret_conv, true);
21212 jboolean __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok"))) TS_CResult_COption_APIErrorZDecodeErrorZ_is_ok(uint64_t o) {
21213 LDKCResult_COption_APIErrorZDecodeErrorZ* o_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(o);
21214 jboolean ret_conv = CResult_COption_APIErrorZDecodeErrorZ_is_ok(o_conv);
21218 void __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_free"))) TS_CResult_COption_APIErrorZDecodeErrorZ_free(uint64_t _res) {
21219 if (!ptr_is_owned(_res)) return;
21220 void* _res_ptr = untag_ptr(_res);
21221 CHECK_ACCESS(_res_ptr);
21222 LDKCResult_COption_APIErrorZDecodeErrorZ _res_conv = *(LDKCResult_COption_APIErrorZDecodeErrorZ*)(_res_ptr);
21223 FREE(untag_ptr(_res));
21224 CResult_COption_APIErrorZDecodeErrorZ_free(_res_conv);
21227 static inline uint64_t CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(LDKCResult_COption_APIErrorZDecodeErrorZ *NONNULL_PTR arg) {
21228 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
21229 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(arg);
21230 return tag_ptr(ret_conv, true);
21232 int64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(uint64_t arg) {
21233 LDKCResult_COption_APIErrorZDecodeErrorZ* arg_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(arg);
21234 int64_t ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone_ptr(arg_conv);
21238 uint64_t __attribute__((export_name("TS_CResult_COption_APIErrorZDecodeErrorZ_clone"))) TS_CResult_COption_APIErrorZDecodeErrorZ_clone(uint64_t orig) {
21239 LDKCResult_COption_APIErrorZDecodeErrorZ* orig_conv = (LDKCResult_COption_APIErrorZDecodeErrorZ*)untag_ptr(orig);
21240 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
21241 *ret_conv = CResult_COption_APIErrorZDecodeErrorZ_clone(orig_conv);
21242 return tag_ptr(ret_conv, true);
21245 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint64_t o) {
21246 LDKChannelMonitorUpdate o_conv;
21247 o_conv.inner = untag_ptr(o);
21248 o_conv.is_owned = ptr_is_owned(o);
21249 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21250 o_conv = ChannelMonitorUpdate_clone(&o_conv);
21251 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
21252 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
21253 return tag_ptr(ret_conv, true);
21256 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint64_t e) {
21257 void* e_ptr = untag_ptr(e);
21258 CHECK_ACCESS(e_ptr);
21259 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21260 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21261 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
21262 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
21263 return tag_ptr(ret_conv, true);
21266 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint64_t o) {
21267 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(o);
21268 jboolean ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
21272 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint64_t _res) {
21273 if (!ptr_is_owned(_res)) return;
21274 void* _res_ptr = untag_ptr(_res);
21275 CHECK_ACCESS(_res_ptr);
21276 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
21277 FREE(untag_ptr(_res));
21278 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
21281 static inline uint64_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
21282 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
21283 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
21284 return tag_ptr(ret_conv, true);
21286 int64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21287 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(arg);
21288 int64_t ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
21292 uint64_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint64_t orig) {
21293 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)untag_ptr(orig);
21294 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
21295 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
21296 return tag_ptr(ret_conv, true);
21299 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_some"))) TS_COption_MonitorEventZ_some(uint64_t o) {
21300 void* o_ptr = untag_ptr(o);
21301 CHECK_ACCESS(o_ptr);
21302 LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
21303 o_conv = MonitorEvent_clone((LDKMonitorEvent*)untag_ptr(o));
21304 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
21305 *ret_copy = COption_MonitorEventZ_some(o_conv);
21306 uint64_t ret_ref = tag_ptr(ret_copy, true);
21310 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_none"))) TS_COption_MonitorEventZ_none() {
21311 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
21312 *ret_copy = COption_MonitorEventZ_none();
21313 uint64_t ret_ref = tag_ptr(ret_copy, true);
21317 void __attribute__((export_name("TS_COption_MonitorEventZ_free"))) TS_COption_MonitorEventZ_free(uint64_t _res) {
21318 if (!ptr_is_owned(_res)) return;
21319 void* _res_ptr = untag_ptr(_res);
21320 CHECK_ACCESS(_res_ptr);
21321 LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
21322 FREE(untag_ptr(_res));
21323 COption_MonitorEventZ_free(_res_conv);
21326 static inline uint64_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
21327 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
21328 *ret_copy = COption_MonitorEventZ_clone(arg);
21329 uint64_t ret_ref = tag_ptr(ret_copy, true);
21332 int64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone_ptr"))) TS_COption_MonitorEventZ_clone_ptr(uint64_t arg) {
21333 LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)untag_ptr(arg);
21334 int64_t ret_conv = COption_MonitorEventZ_clone_ptr(arg_conv);
21338 uint64_t __attribute__((export_name("TS_COption_MonitorEventZ_clone"))) TS_COption_MonitorEventZ_clone(uint64_t orig) {
21339 LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)untag_ptr(orig);
21340 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
21341 *ret_copy = COption_MonitorEventZ_clone(orig_conv);
21342 uint64_t ret_ref = tag_ptr(ret_copy, true);
21346 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint64_t o) {
21347 void* o_ptr = untag_ptr(o);
21348 CHECK_ACCESS(o_ptr);
21349 LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
21350 o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)untag_ptr(o));
21351 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
21352 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
21353 return tag_ptr(ret_conv, true);
21356 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint64_t e) {
21357 void* e_ptr = untag_ptr(e);
21358 CHECK_ACCESS(e_ptr);
21359 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21360 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21361 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
21362 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
21363 return tag_ptr(ret_conv, true);
21366 jboolean __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint64_t o) {
21367 LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(o);
21368 jboolean ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
21372 void __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_free"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint64_t _res) {
21373 if (!ptr_is_owned(_res)) return;
21374 void* _res_ptr = untag_ptr(_res);
21375 CHECK_ACCESS(_res_ptr);
21376 LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
21377 FREE(untag_ptr(_res));
21378 CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
21381 static inline uint64_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
21382 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
21383 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
21384 return tag_ptr(ret_conv, true);
21386 int64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint64_t arg) {
21387 LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(arg);
21388 int64_t ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
21392 uint64_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint64_t orig) {
21393 LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)untag_ptr(orig);
21394 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
21395 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
21396 return tag_ptr(ret_conv, true);
21399 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint64_t o) {
21400 LDKHTLCUpdate o_conv;
21401 o_conv.inner = untag_ptr(o);
21402 o_conv.is_owned = ptr_is_owned(o);
21403 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
21404 o_conv = HTLCUpdate_clone(&o_conv);
21405 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
21406 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
21407 return tag_ptr(ret_conv, true);
21410 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint64_t e) {
21411 void* e_ptr = untag_ptr(e);
21412 CHECK_ACCESS(e_ptr);
21413 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21414 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21415 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
21416 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
21417 return tag_ptr(ret_conv, true);
21420 jboolean __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_is_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint64_t o) {
21421 LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(o);
21422 jboolean ret_conv = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
21426 void __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_free"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint64_t _res) {
21427 if (!ptr_is_owned(_res)) return;
21428 void* _res_ptr = untag_ptr(_res);
21429 CHECK_ACCESS(_res_ptr);
21430 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
21431 FREE(untag_ptr(_res));
21432 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
21435 static inline uint64_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
21436 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
21437 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
21438 return tag_ptr(ret_conv, true);
21440 int64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
21441 LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(arg);
21442 int64_t ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
21446 uint64_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint64_t orig) {
21447 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)untag_ptr(orig);
21448 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
21449 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
21450 return tag_ptr(ret_conv, true);
21453 static inline uint64_t C2Tuple_OutPointCVec_u8ZZ_clone_ptr(LDKC2Tuple_OutPointCVec_u8ZZ *NONNULL_PTR arg) {
21454 LDKC2Tuple_OutPointCVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_u8ZZ), "LDKC2Tuple_OutPointCVec_u8ZZ");
21455 *ret_conv = C2Tuple_OutPointCVec_u8ZZ_clone(arg);
21456 return tag_ptr(ret_conv, true);
21458 int64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr"))) TS_C2Tuple_OutPointCVec_u8ZZ_clone_ptr(uint64_t arg) {
21459 LDKC2Tuple_OutPointCVec_u8ZZ* arg_conv = (LDKC2Tuple_OutPointCVec_u8ZZ*)untag_ptr(arg);
21460 int64_t ret_conv = C2Tuple_OutPointCVec_u8ZZ_clone_ptr(arg_conv);
21464 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_clone"))) TS_C2Tuple_OutPointCVec_u8ZZ_clone(uint64_t orig) {
21465 LDKC2Tuple_OutPointCVec_u8ZZ* orig_conv = (LDKC2Tuple_OutPointCVec_u8ZZ*)untag_ptr(orig);
21466 LDKC2Tuple_OutPointCVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_u8ZZ), "LDKC2Tuple_OutPointCVec_u8ZZ");
21467 *ret_conv = C2Tuple_OutPointCVec_u8ZZ_clone(orig_conv);
21468 return tag_ptr(ret_conv, true);
21471 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_new"))) TS_C2Tuple_OutPointCVec_u8ZZ_new(uint64_t a, int8_tArray b) {
21472 LDKOutPoint a_conv;
21473 a_conv.inner = untag_ptr(a);
21474 a_conv.is_owned = ptr_is_owned(a);
21475 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
21476 a_conv = OutPoint_clone(&a_conv);
21478 b_ref.datalen = b->arr_len;
21479 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
21480 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
21481 LDKC2Tuple_OutPointCVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_u8ZZ), "LDKC2Tuple_OutPointCVec_u8ZZ");
21482 *ret_conv = C2Tuple_OutPointCVec_u8ZZ_new(a_conv, b_ref);
21483 return tag_ptr(ret_conv, true);
21486 void __attribute__((export_name("TS_C2Tuple_OutPointCVec_u8ZZ_free"))) TS_C2Tuple_OutPointCVec_u8ZZ_free(uint64_t _res) {
21487 if (!ptr_is_owned(_res)) return;
21488 void* _res_ptr = untag_ptr(_res);
21489 CHECK_ACCESS(_res_ptr);
21490 LDKC2Tuple_OutPointCVec_u8ZZ _res_conv = *(LDKC2Tuple_OutPointCVec_u8ZZ*)(_res_ptr);
21491 FREE(untag_ptr(_res));
21492 C2Tuple_OutPointCVec_u8ZZ_free(_res_conv);
21495 static inline uint64_t C2Tuple_u32CVec_u8ZZ_clone_ptr(LDKC2Tuple_u32CVec_u8ZZ *NONNULL_PTR arg) {
21496 LDKC2Tuple_u32CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKC2Tuple_u32CVec_u8ZZ");
21497 *ret_conv = C2Tuple_u32CVec_u8ZZ_clone(arg);
21498 return tag_ptr(ret_conv, true);
21500 int64_t __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_clone_ptr"))) TS_C2Tuple_u32CVec_u8ZZ_clone_ptr(uint64_t arg) {
21501 LDKC2Tuple_u32CVec_u8ZZ* arg_conv = (LDKC2Tuple_u32CVec_u8ZZ*)untag_ptr(arg);
21502 int64_t ret_conv = C2Tuple_u32CVec_u8ZZ_clone_ptr(arg_conv);
21506 uint64_t __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_clone"))) TS_C2Tuple_u32CVec_u8ZZ_clone(uint64_t orig) {
21507 LDKC2Tuple_u32CVec_u8ZZ* orig_conv = (LDKC2Tuple_u32CVec_u8ZZ*)untag_ptr(orig);
21508 LDKC2Tuple_u32CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKC2Tuple_u32CVec_u8ZZ");
21509 *ret_conv = C2Tuple_u32CVec_u8ZZ_clone(orig_conv);
21510 return tag_ptr(ret_conv, true);
21513 uint64_t __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_new"))) TS_C2Tuple_u32CVec_u8ZZ_new(int32_t a, int8_tArray b) {
21515 b_ref.datalen = b->arr_len;
21516 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
21517 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
21518 LDKC2Tuple_u32CVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKC2Tuple_u32CVec_u8ZZ");
21519 *ret_conv = C2Tuple_u32CVec_u8ZZ_new(a, b_ref);
21520 return tag_ptr(ret_conv, true);
21523 void __attribute__((export_name("TS_C2Tuple_u32CVec_u8ZZ_free"))) TS_C2Tuple_u32CVec_u8ZZ_free(uint64_t _res) {
21524 if (!ptr_is_owned(_res)) return;
21525 void* _res_ptr = untag_ptr(_res);
21526 CHECK_ACCESS(_res_ptr);
21527 LDKC2Tuple_u32CVec_u8ZZ _res_conv = *(LDKC2Tuple_u32CVec_u8ZZ*)(_res_ptr);
21528 FREE(untag_ptr(_res));
21529 C2Tuple_u32CVec_u8ZZ_free(_res_conv);
21532 void __attribute__((export_name("TS_CVec_C2Tuple_u32CVec_u8ZZZ_free"))) TS_CVec_C2Tuple_u32CVec_u8ZZZ_free(uint64_tArray _res) {
21533 LDKCVec_C2Tuple_u32CVec_u8ZZZ _res_constr;
21534 _res_constr.datalen = _res->arr_len;
21535 if (_res_constr.datalen > 0)
21536 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKCVec_C2Tuple_u32CVec_u8ZZZ Elements");
21538 _res_constr.data = NULL;
21539 uint64_t* _res_vals = _res->elems;
21540 for (size_t x = 0; x < _res_constr.datalen; x++) {
21541 uint64_t _res_conv_23 = _res_vals[x];
21542 void* _res_conv_23_ptr = untag_ptr(_res_conv_23);
21543 CHECK_ACCESS(_res_conv_23_ptr);
21544 LDKC2Tuple_u32CVec_u8ZZ _res_conv_23_conv = *(LDKC2Tuple_u32CVec_u8ZZ*)(_res_conv_23_ptr);
21545 FREE(untag_ptr(_res_conv_23));
21546 _res_constr.data[x] = _res_conv_23_conv;
21549 CVec_C2Tuple_u32CVec_u8ZZZ_free(_res_constr);
21552 static inline uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ *NONNULL_PTR arg) {
21553 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ");
21554 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(arg);
21555 return tag_ptr(ret_conv, true);
21557 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(uint64_t arg) {
21558 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)untag_ptr(arg);
21559 int64_t ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone_ptr(arg_conv);
21563 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(uint64_t orig) {
21564 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)untag_ptr(orig);
21565 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ");
21566 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_clone(orig_conv);
21567 return tag_ptr(ret_conv, true);
21570 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(int8_tArray a, uint64_tArray b) {
21571 LDKThirtyTwoBytes a_ref;
21572 CHECK(a->arr_len == 32);
21573 memcpy(a_ref.data, a->elems, 32); FREE(a);
21574 LDKCVec_C2Tuple_u32CVec_u8ZZZ b_constr;
21575 b_constr.datalen = b->arr_len;
21576 if (b_constr.datalen > 0)
21577 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32CVec_u8ZZ), "LDKCVec_C2Tuple_u32CVec_u8ZZZ Elements");
21579 b_constr.data = NULL;
21580 uint64_t* b_vals = b->elems;
21581 for (size_t x = 0; x < b_constr.datalen; x++) {
21582 uint64_t b_conv_23 = b_vals[x];
21583 void* b_conv_23_ptr = untag_ptr(b_conv_23);
21584 CHECK_ACCESS(b_conv_23_ptr);
21585 LDKC2Tuple_u32CVec_u8ZZ b_conv_23_conv = *(LDKC2Tuple_u32CVec_u8ZZ*)(b_conv_23_ptr);
21586 b_conv_23_conv = C2Tuple_u32CVec_u8ZZ_clone((LDKC2Tuple_u32CVec_u8ZZ*)untag_ptr(b_conv_23));
21587 b_constr.data[x] = b_conv_23_conv;
21590 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ");
21591 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_new(a_ref, b_constr);
21592 return tag_ptr(ret_conv, true);
21595 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(uint64_t _res) {
21596 if (!ptr_is_owned(_res)) return;
21597 void* _res_ptr = untag_ptr(_res);
21598 CHECK_ACCESS(_res_ptr);
21599 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)(_res_ptr);
21600 FREE(untag_ptr(_res));
21601 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ_free(_res_conv);
21604 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(uint64_tArray _res) {
21605 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ _res_constr;
21606 _res_constr.datalen = _res->arr_len;
21607 if (_res_constr.datalen > 0)
21608 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ), "LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ Elements");
21610 _res_constr.data = NULL;
21611 uint64_t* _res_vals = _res->elems;
21612 for (size_t a = 0; a < _res_constr.datalen; a++) {
21613 uint64_t _res_conv_52 = _res_vals[a];
21614 void* _res_conv_52_ptr = untag_ptr(_res_conv_52);
21615 CHECK_ACCESS(_res_conv_52_ptr);
21616 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ _res_conv_52_conv = *(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ*)(_res_conv_52_ptr);
21617 FREE(untag_ptr(_res_conv_52));
21618 _res_constr.data[a] = _res_conv_52_conv;
21621 CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ_free(_res_constr);
21624 void __attribute__((export_name("TS_CVec_CommitmentTransactionZ_free"))) TS_CVec_CommitmentTransactionZ_free(uint64_tArray _res) {
21625 LDKCVec_CommitmentTransactionZ _res_constr;
21626 _res_constr.datalen = _res->arr_len;
21627 if (_res_constr.datalen > 0)
21628 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCommitmentTransaction), "LDKCVec_CommitmentTransactionZ Elements");
21630 _res_constr.data = NULL;
21631 uint64_t* _res_vals = _res->elems;
21632 for (size_t x = 0; x < _res_constr.datalen; x++) {
21633 uint64_t _res_conv_23 = _res_vals[x];
21634 LDKCommitmentTransaction _res_conv_23_conv;
21635 _res_conv_23_conv.inner = untag_ptr(_res_conv_23);
21636 _res_conv_23_conv.is_owned = ptr_is_owned(_res_conv_23);
21637 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_23_conv);
21638 _res_constr.data[x] = _res_conv_23_conv;
21641 CVec_CommitmentTransactionZ_free(_res_constr);
21644 void __attribute__((export_name("TS_CVec_TransactionZ_free"))) TS_CVec_TransactionZ_free(ptrArray _res) {
21645 LDKCVec_TransactionZ _res_constr;
21646 _res_constr.datalen = _res->arr_len;
21647 if (_res_constr.datalen > 0)
21648 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
21650 _res_constr.data = NULL;
21651 int8_tArray* _res_vals = (void*) _res->elems;
21652 for (size_t m = 0; m < _res_constr.datalen; m++) {
21653 int8_tArray _res_conv_12 = _res_vals[m];
21654 LDKTransaction _res_conv_12_ref;
21655 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
21656 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
21657 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
21658 _res_conv_12_ref.data_is_owned = true;
21659 _res_constr.data[m] = _res_conv_12_ref;
21662 CVec_TransactionZ_free(_res_constr);
21665 static inline uint64_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
21666 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
21667 *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
21668 return tag_ptr(ret_conv, true);
21670 int64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone_ptr"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint64_t arg) {
21671 LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(arg);
21672 int64_t ret_conv = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
21676 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone"))) TS_C2Tuple_u32TxOutZ_clone(uint64_t orig) {
21677 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)untag_ptr(orig);
21678 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
21679 *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
21680 return tag_ptr(ret_conv, true);
21683 uint64_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_new"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint64_t b) {
21684 void* b_ptr = untag_ptr(b);
21685 CHECK_ACCESS(b_ptr);
21686 LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
21687 b_conv = TxOut_clone((LDKTxOut*)untag_ptr(b));
21688 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
21689 *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
21690 return tag_ptr(ret_conv, true);
21693 void __attribute__((export_name("TS_C2Tuple_u32TxOutZ_free"))) TS_C2Tuple_u32TxOutZ_free(uint64_t _res) {
21694 if (!ptr_is_owned(_res)) return;
21695 void* _res_ptr = untag_ptr(_res);
21696 CHECK_ACCESS(_res_ptr);
21697 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
21698 FREE(untag_ptr(_res));
21699 C2Tuple_u32TxOutZ_free(_res_conv);
21702 void __attribute__((export_name("TS_CVec_C2Tuple_u32TxOutZZ_free"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint64_tArray _res) {
21703 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
21704 _res_constr.datalen = _res->arr_len;
21705 if (_res_constr.datalen > 0)
21706 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
21708 _res_constr.data = NULL;
21709 uint64_t* _res_vals = _res->elems;
21710 for (size_t u = 0; u < _res_constr.datalen; u++) {
21711 uint64_t _res_conv_20 = _res_vals[u];
21712 void* _res_conv_20_ptr = untag_ptr(_res_conv_20);
21713 CHECK_ACCESS(_res_conv_20_ptr);
21714 LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
21715 FREE(untag_ptr(_res_conv_20));
21716 _res_constr.data[u] = _res_conv_20_conv;
21719 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
21722 static inline uint64_t C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
21723 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
21724 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(arg);
21725 return tag_ptr(ret_conv, true);
21727 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint64_t arg) {
21728 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(arg);
21729 int64_t ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
21733 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(uint64_t orig) {
21734 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)untag_ptr(orig);
21735 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
21736 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
21737 return tag_ptr(ret_conv, true);
21740 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint64_tArray b) {
21741 LDKThirtyTwoBytes a_ref;
21742 CHECK(a->arr_len == 32);
21743 memcpy(a_ref.data, a->elems, 32); FREE(a);
21744 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
21745 b_constr.datalen = b->arr_len;
21746 if (b_constr.datalen > 0)
21747 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
21749 b_constr.data = NULL;
21750 uint64_t* b_vals = b->elems;
21751 for (size_t u = 0; u < b_constr.datalen; u++) {
21752 uint64_t b_conv_20 = b_vals[u];
21753 void* b_conv_20_ptr = untag_ptr(b_conv_20);
21754 CHECK_ACCESS(b_conv_20_ptr);
21755 LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
21756 b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)untag_ptr(b_conv_20));
21757 b_constr.data[u] = b_conv_20_conv;
21760 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
21761 *ret_conv = C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
21762 return tag_ptr(ret_conv, true);
21765 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free"))) TS_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(uint64_t _res) {
21766 if (!ptr_is_owned(_res)) return;
21767 void* _res_ptr = untag_ptr(_res);
21768 CHECK_ACCESS(_res_ptr);
21769 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
21770 FREE(untag_ptr(_res));
21771 C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
21774 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(uint64_tArray _res) {
21775 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ _res_constr;
21776 _res_constr.datalen = _res->arr_len;
21777 if (_res_constr.datalen > 0)
21778 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ Elements");
21780 _res_constr.data = NULL;
21781 uint64_t* _res_vals = _res->elems;
21782 for (size_t x = 0; x < _res_constr.datalen; x++) {
21783 uint64_t _res_conv_49 = _res_vals[x];
21784 void* _res_conv_49_ptr = untag_ptr(_res_conv_49);
21785 CHECK_ACCESS(_res_conv_49_ptr);
21786 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ _res_conv_49_conv = *(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_49_ptr);
21787 FREE(untag_ptr(_res_conv_49));
21788 _res_constr.data[x] = _res_conv_49_conv;
21791 CVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
21794 void __attribute__((export_name("TS_CVec_BalanceZ_free"))) TS_CVec_BalanceZ_free(uint64_tArray _res) {
21795 LDKCVec_BalanceZ _res_constr;
21796 _res_constr.datalen = _res->arr_len;
21797 if (_res_constr.datalen > 0)
21798 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
21800 _res_constr.data = NULL;
21801 uint64_t* _res_vals = _res->elems;
21802 for (size_t j = 0; j < _res_constr.datalen; j++) {
21803 uint64_t _res_conv_9 = _res_vals[j];
21804 void* _res_conv_9_ptr = untag_ptr(_res_conv_9);
21805 CHECK_ACCESS(_res_conv_9_ptr);
21806 LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
21807 FREE(untag_ptr(_res_conv_9));
21808 _res_constr.data[j] = _res_conv_9_conv;
21811 CVec_BalanceZ_free(_res_constr);
21814 static inline uint64_t C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ *NONNULL_PTR arg) {
21815 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
21816 *ret_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(arg);
21817 return tag_ptr(ret_conv, true);
21819 int64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(uint64_t arg) {
21820 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* arg_conv = (LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(arg);
21821 int64_t ret_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone_ptr(arg_conv);
21825 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(uint64_t orig) {
21826 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* orig_conv = (LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(orig);
21827 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
21828 *ret_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone(orig_conv);
21829 return tag_ptr(ret_conv, true);
21832 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(int8_tArray a, uint64_t b) {
21833 LDKThirtyTwoBytes a_ref;
21834 CHECK(a->arr_len == 32);
21835 memcpy(a_ref.data, a->elems, 32); FREE(a);
21836 LDKChannelMonitor b_conv;
21837 b_conv.inner = untag_ptr(b);
21838 b_conv.is_owned = ptr_is_owned(b);
21839 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
21840 b_conv = ChannelMonitor_clone(&b_conv);
21841 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ");
21842 *ret_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_new(a_ref, b_conv);
21843 return tag_ptr(ret_conv, true);
21846 void __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(uint64_t _res) {
21847 if (!ptr_is_owned(_res)) return;
21848 void* _res_ptr = untag_ptr(_res);
21849 CHECK_ACCESS(_res_ptr);
21850 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)(_res_ptr);
21851 FREE(untag_ptr(_res));
21852 C2Tuple_ThirtyTwoBytesChannelMonitorZ_free(_res_conv);
21855 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(uint64_t o) {
21856 void* o_ptr = untag_ptr(o);
21857 CHECK_ACCESS(o_ptr);
21858 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)(o_ptr);
21859 o_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone((LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(o));
21860 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ");
21861 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_ok(o_conv);
21862 return tag_ptr(ret_conv, true);
21865 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(uint64_t e) {
21866 void* e_ptr = untag_ptr(e);
21867 CHECK_ACCESS(e_ptr);
21868 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
21869 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
21870 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ");
21871 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_err(e_conv);
21872 return tag_ptr(ret_conv, true);
21875 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(uint64_t o) {
21876 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)untag_ptr(o);
21877 jboolean ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_is_ok(o_conv);
21881 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(uint64_t _res) {
21882 if (!ptr_is_owned(_res)) return;
21883 void* _res_ptr = untag_ptr(_res);
21884 CHECK_ACCESS(_res_ptr);
21885 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)(_res_ptr);
21886 FREE(untag_ptr(_res));
21887 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_free(_res_conv);
21890 static inline uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
21891 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ");
21892 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(arg);
21893 return tag_ptr(ret_conv, true);
21895 int64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(uint64_t arg) {
21896 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)untag_ptr(arg);
21897 int64_t ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
21901 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(uint64_t orig) {
21902 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ*)untag_ptr(orig);
21903 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ");
21904 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ_clone(orig_conv);
21905 return tag_ptr(ret_conv, true);
21908 static inline uint64_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
21909 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
21910 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
21911 return tag_ptr(ret_conv, true);
21913 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone_ptr"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint64_t arg) {
21914 LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(arg);
21915 int64_t ret_conv = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
21919 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint64_t orig) {
21920 LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)untag_ptr(orig);
21921 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
21922 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
21923 return tag_ptr(ret_conv, true);
21926 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_new"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint64_t b) {
21927 LDKPublicKey a_ref;
21928 CHECK(a->arr_len == 33);
21929 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
21930 void* b_ptr = untag_ptr(b);
21931 CHECK_ACCESS(b_ptr);
21932 LDKType b_conv = *(LDKType*)(b_ptr);
21933 if (b_conv.free == LDKType_JCalls_free) {
21934 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
21935 LDKType_JCalls_cloned(&b_conv);
21937 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
21938 *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
21939 return tag_ptr(ret_conv, true);
21942 void __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_free"))) TS_C2Tuple_PublicKeyTypeZ_free(uint64_t _res) {
21943 if (!ptr_is_owned(_res)) return;
21944 void* _res_ptr = untag_ptr(_res);
21945 CHECK_ACCESS(_res_ptr);
21946 LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
21947 FREE(untag_ptr(_res));
21948 C2Tuple_PublicKeyTypeZ_free(_res_conv);
21951 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyTypeZZ_free"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint64_tArray _res) {
21952 LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
21953 _res_constr.datalen = _res->arr_len;
21954 if (_res_constr.datalen > 0)
21955 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
21957 _res_constr.data = NULL;
21958 uint64_t* _res_vals = _res->elems;
21959 for (size_t z = 0; z < _res_constr.datalen; z++) {
21960 uint64_t _res_conv_25 = _res_vals[z];
21961 void* _res_conv_25_ptr = untag_ptr(_res_conv_25);
21962 CHECK_ACCESS(_res_conv_25_ptr);
21963 LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
21964 FREE(untag_ptr(_res_conv_25));
21965 _res_constr.data[z] = _res_conv_25_conv;
21968 CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
21971 uint64_t __attribute__((export_name("TS_COption_OffersMessageZ_some"))) TS_COption_OffersMessageZ_some(uint64_t o) {
21972 void* o_ptr = untag_ptr(o);
21973 CHECK_ACCESS(o_ptr);
21974 LDKOffersMessage o_conv = *(LDKOffersMessage*)(o_ptr);
21975 o_conv = OffersMessage_clone((LDKOffersMessage*)untag_ptr(o));
21976 LDKCOption_OffersMessageZ *ret_copy = MALLOC(sizeof(LDKCOption_OffersMessageZ), "LDKCOption_OffersMessageZ");
21977 *ret_copy = COption_OffersMessageZ_some(o_conv);
21978 uint64_t ret_ref = tag_ptr(ret_copy, true);
21982 uint64_t __attribute__((export_name("TS_COption_OffersMessageZ_none"))) TS_COption_OffersMessageZ_none() {
21983 LDKCOption_OffersMessageZ *ret_copy = MALLOC(sizeof(LDKCOption_OffersMessageZ), "LDKCOption_OffersMessageZ");
21984 *ret_copy = COption_OffersMessageZ_none();
21985 uint64_t ret_ref = tag_ptr(ret_copy, true);
21989 void __attribute__((export_name("TS_COption_OffersMessageZ_free"))) TS_COption_OffersMessageZ_free(uint64_t _res) {
21990 if (!ptr_is_owned(_res)) return;
21991 void* _res_ptr = untag_ptr(_res);
21992 CHECK_ACCESS(_res_ptr);
21993 LDKCOption_OffersMessageZ _res_conv = *(LDKCOption_OffersMessageZ*)(_res_ptr);
21994 FREE(untag_ptr(_res));
21995 COption_OffersMessageZ_free(_res_conv);
21998 static inline uint64_t COption_OffersMessageZ_clone_ptr(LDKCOption_OffersMessageZ *NONNULL_PTR arg) {
21999 LDKCOption_OffersMessageZ *ret_copy = MALLOC(sizeof(LDKCOption_OffersMessageZ), "LDKCOption_OffersMessageZ");
22000 *ret_copy = COption_OffersMessageZ_clone(arg);
22001 uint64_t ret_ref = tag_ptr(ret_copy, true);
22004 int64_t __attribute__((export_name("TS_COption_OffersMessageZ_clone_ptr"))) TS_COption_OffersMessageZ_clone_ptr(uint64_t arg) {
22005 LDKCOption_OffersMessageZ* arg_conv = (LDKCOption_OffersMessageZ*)untag_ptr(arg);
22006 int64_t ret_conv = COption_OffersMessageZ_clone_ptr(arg_conv);
22010 uint64_t __attribute__((export_name("TS_COption_OffersMessageZ_clone"))) TS_COption_OffersMessageZ_clone(uint64_t orig) {
22011 LDKCOption_OffersMessageZ* orig_conv = (LDKCOption_OffersMessageZ*)untag_ptr(orig);
22012 LDKCOption_OffersMessageZ *ret_copy = MALLOC(sizeof(LDKCOption_OffersMessageZ), "LDKCOption_OffersMessageZ");
22013 *ret_copy = COption_OffersMessageZ_clone(orig_conv);
22014 uint64_t ret_ref = tag_ptr(ret_copy, true);
22018 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_some"))) TS_COption_CustomOnionMessageContentsZ_some(uint64_t o) {
22019 void* o_ptr = untag_ptr(o);
22020 CHECK_ACCESS(o_ptr);
22021 LDKCustomOnionMessageContents o_conv = *(LDKCustomOnionMessageContents*)(o_ptr);
22022 if (o_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
22023 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
22024 LDKCustomOnionMessageContents_JCalls_cloned(&o_conv);
22026 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
22027 *ret_copy = COption_CustomOnionMessageContentsZ_some(o_conv);
22028 uint64_t ret_ref = tag_ptr(ret_copy, true);
22032 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_none"))) TS_COption_CustomOnionMessageContentsZ_none() {
22033 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
22034 *ret_copy = COption_CustomOnionMessageContentsZ_none();
22035 uint64_t ret_ref = tag_ptr(ret_copy, true);
22039 void __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_free"))) TS_COption_CustomOnionMessageContentsZ_free(uint64_t _res) {
22040 if (!ptr_is_owned(_res)) return;
22041 void* _res_ptr = untag_ptr(_res);
22042 CHECK_ACCESS(_res_ptr);
22043 LDKCOption_CustomOnionMessageContentsZ _res_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(_res_ptr);
22044 FREE(untag_ptr(_res));
22045 COption_CustomOnionMessageContentsZ_free(_res_conv);
22048 static inline uint64_t COption_CustomOnionMessageContentsZ_clone_ptr(LDKCOption_CustomOnionMessageContentsZ *NONNULL_PTR arg) {
22049 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
22050 *ret_copy = COption_CustomOnionMessageContentsZ_clone(arg);
22051 uint64_t ret_ref = tag_ptr(ret_copy, true);
22054 int64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone_ptr"))) TS_COption_CustomOnionMessageContentsZ_clone_ptr(uint64_t arg) {
22055 LDKCOption_CustomOnionMessageContentsZ* arg_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(arg);
22056 int64_t ret_conv = COption_CustomOnionMessageContentsZ_clone_ptr(arg_conv);
22060 uint64_t __attribute__((export_name("TS_COption_CustomOnionMessageContentsZ_clone"))) TS_COption_CustomOnionMessageContentsZ_clone(uint64_t orig) {
22061 LDKCOption_CustomOnionMessageContentsZ* orig_conv = (LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(orig);
22062 LDKCOption_CustomOnionMessageContentsZ *ret_copy = MALLOC(sizeof(LDKCOption_CustomOnionMessageContentsZ), "LDKCOption_CustomOnionMessageContentsZ");
22063 *ret_copy = COption_CustomOnionMessageContentsZ_clone(orig_conv);
22064 uint64_t ret_ref = tag_ptr(ret_copy, true);
22068 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(uint64_t o) {
22069 void* o_ptr = untag_ptr(o);
22070 CHECK_ACCESS(o_ptr);
22071 LDKCOption_CustomOnionMessageContentsZ o_conv = *(LDKCOption_CustomOnionMessageContentsZ*)(o_ptr);
22072 o_conv = COption_CustomOnionMessageContentsZ_clone((LDKCOption_CustomOnionMessageContentsZ*)untag_ptr(o));
22073 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
22074 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_ok(o_conv);
22075 return tag_ptr(ret_conv, true);
22078 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(uint64_t e) {
22079 void* e_ptr = untag_ptr(e);
22080 CHECK_ACCESS(e_ptr);
22081 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
22082 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
22083 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
22084 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_err(e_conv);
22085 return tag_ptr(ret_conv, true);
22088 jboolean __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(uint64_t o) {
22089 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* o_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(o);
22090 jboolean ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_is_ok(o_conv);
22094 void __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(uint64_t _res) {
22095 if (!ptr_is_owned(_res)) return;
22096 void* _res_ptr = untag_ptr(_res);
22097 CHECK_ACCESS(_res_ptr);
22098 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ _res_conv = *(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)(_res_ptr);
22099 FREE(untag_ptr(_res));
22100 CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_free(_res_conv);
22103 static inline uint64_t CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ *NONNULL_PTR arg) {
22104 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
22105 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(arg);
22106 return tag_ptr(ret_conv, true);
22108 int64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(uint64_t arg) {
22109 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* arg_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(arg);
22110 int64_t ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone_ptr(arg_conv);
22114 uint64_t __attribute__((export_name("TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone"))) TS_CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(uint64_t orig) {
22115 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* orig_conv = (LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ*)untag_ptr(orig);
22116 LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ), "LDKCResult_COption_CustomOnionMessageContentsZDecodeErrorZ");
22117 *ret_conv = CResult_COption_CustomOnionMessageContentsZDecodeErrorZ_clone(orig_conv);
22118 return tag_ptr(ret_conv, true);
22121 uint64_t __attribute__((export_name("TS_COption_TypeZ_some"))) TS_COption_TypeZ_some(uint64_t o) {
22122 void* o_ptr = untag_ptr(o);
22123 CHECK_ACCESS(o_ptr);
22124 LDKType o_conv = *(LDKType*)(o_ptr);
22125 if (o_conv.free == LDKType_JCalls_free) {
22126 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
22127 LDKType_JCalls_cloned(&o_conv);
22129 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
22130 *ret_copy = COption_TypeZ_some(o_conv);
22131 uint64_t ret_ref = tag_ptr(ret_copy, true);
22135 uint64_t __attribute__((export_name("TS_COption_TypeZ_none"))) TS_COption_TypeZ_none() {
22136 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
22137 *ret_copy = COption_TypeZ_none();
22138 uint64_t ret_ref = tag_ptr(ret_copy, true);
22142 void __attribute__((export_name("TS_COption_TypeZ_free"))) TS_COption_TypeZ_free(uint64_t _res) {
22143 if (!ptr_is_owned(_res)) return;
22144 void* _res_ptr = untag_ptr(_res);
22145 CHECK_ACCESS(_res_ptr);
22146 LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
22147 FREE(untag_ptr(_res));
22148 COption_TypeZ_free(_res_conv);
22151 static inline uint64_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
22152 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
22153 *ret_copy = COption_TypeZ_clone(arg);
22154 uint64_t ret_ref = tag_ptr(ret_copy, true);
22157 int64_t __attribute__((export_name("TS_COption_TypeZ_clone_ptr"))) TS_COption_TypeZ_clone_ptr(uint64_t arg) {
22158 LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)untag_ptr(arg);
22159 int64_t ret_conv = COption_TypeZ_clone_ptr(arg_conv);
22163 uint64_t __attribute__((export_name("TS_COption_TypeZ_clone"))) TS_COption_TypeZ_clone(uint64_t orig) {
22164 LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)untag_ptr(orig);
22165 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
22166 *ret_copy = COption_TypeZ_clone(orig_conv);
22167 uint64_t ret_ref = tag_ptr(ret_copy, true);
22171 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint64_t o) {
22172 void* o_ptr = untag_ptr(o);
22173 CHECK_ACCESS(o_ptr);
22174 LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
22175 o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)untag_ptr(o));
22176 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
22177 *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
22178 return tag_ptr(ret_conv, true);
22181 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_err"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint64_t e) {
22182 void* e_ptr = untag_ptr(e);
22183 CHECK_ACCESS(e_ptr);
22184 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
22185 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
22186 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
22187 *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
22188 return tag_ptr(ret_conv, true);
22191 jboolean __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_is_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint64_t o) {
22192 LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(o);
22193 jboolean ret_conv = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
22197 void __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_free"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint64_t _res) {
22198 if (!ptr_is_owned(_res)) return;
22199 void* _res_ptr = untag_ptr(_res);
22200 CHECK_ACCESS(_res_ptr);
22201 LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
22202 FREE(untag_ptr(_res));
22203 CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
22206 static inline uint64_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
22207 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
22208 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
22209 return tag_ptr(ret_conv, true);
22211 int64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint64_t arg) {
22212 LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(arg);
22213 int64_t ret_conv = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
22217 uint64_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint64_t orig) {
22218 LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)untag_ptr(orig);
22219 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
22220 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
22221 return tag_ptr(ret_conv, true);
22224 uint64_t __attribute__((export_name("TS_COption_SocketAddressZ_some"))) TS_COption_SocketAddressZ_some(uint64_t o) {
22225 void* o_ptr = untag_ptr(o);
22226 CHECK_ACCESS(o_ptr);
22227 LDKSocketAddress o_conv = *(LDKSocketAddress*)(o_ptr);
22228 o_conv = SocketAddress_clone((LDKSocketAddress*)untag_ptr(o));
22229 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
22230 *ret_copy = COption_SocketAddressZ_some(o_conv);
22231 uint64_t ret_ref = tag_ptr(ret_copy, true);
22235 uint64_t __attribute__((export_name("TS_COption_SocketAddressZ_none"))) TS_COption_SocketAddressZ_none() {
22236 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
22237 *ret_copy = COption_SocketAddressZ_none();
22238 uint64_t ret_ref = tag_ptr(ret_copy, true);
22242 void __attribute__((export_name("TS_COption_SocketAddressZ_free"))) TS_COption_SocketAddressZ_free(uint64_t _res) {
22243 if (!ptr_is_owned(_res)) return;
22244 void* _res_ptr = untag_ptr(_res);
22245 CHECK_ACCESS(_res_ptr);
22246 LDKCOption_SocketAddressZ _res_conv = *(LDKCOption_SocketAddressZ*)(_res_ptr);
22247 FREE(untag_ptr(_res));
22248 COption_SocketAddressZ_free(_res_conv);
22251 static inline uint64_t COption_SocketAddressZ_clone_ptr(LDKCOption_SocketAddressZ *NONNULL_PTR arg) {
22252 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
22253 *ret_copy = COption_SocketAddressZ_clone(arg);
22254 uint64_t ret_ref = tag_ptr(ret_copy, true);
22257 int64_t __attribute__((export_name("TS_COption_SocketAddressZ_clone_ptr"))) TS_COption_SocketAddressZ_clone_ptr(uint64_t arg) {
22258 LDKCOption_SocketAddressZ* arg_conv = (LDKCOption_SocketAddressZ*)untag_ptr(arg);
22259 int64_t ret_conv = COption_SocketAddressZ_clone_ptr(arg_conv);
22263 uint64_t __attribute__((export_name("TS_COption_SocketAddressZ_clone"))) TS_COption_SocketAddressZ_clone(uint64_t orig) {
22264 LDKCOption_SocketAddressZ* orig_conv = (LDKCOption_SocketAddressZ*)untag_ptr(orig);
22265 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
22266 *ret_copy = COption_SocketAddressZ_clone(orig_conv);
22267 uint64_t ret_ref = tag_ptr(ret_copy, true);
22271 static inline uint64_t C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ *NONNULL_PTR arg) {
22272 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ), "LDKC2Tuple_PublicKeyCOption_SocketAddressZZ");
22273 *ret_conv = C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(arg);
22274 return tag_ptr(ret_conv, true);
22276 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(uint64_t arg) {
22277 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* arg_conv = (LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)untag_ptr(arg);
22278 int64_t ret_conv = C2Tuple_PublicKeyCOption_SocketAddressZZ_clone_ptr(arg_conv);
22282 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(uint64_t orig) {
22283 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* orig_conv = (LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)untag_ptr(orig);
22284 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ), "LDKC2Tuple_PublicKeyCOption_SocketAddressZZ");
22285 *ret_conv = C2Tuple_PublicKeyCOption_SocketAddressZZ_clone(orig_conv);
22286 return tag_ptr(ret_conv, true);
22289 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_new"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_new(int8_tArray a, uint64_t b) {
22290 LDKPublicKey a_ref;
22291 CHECK(a->arr_len == 33);
22292 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
22293 void* b_ptr = untag_ptr(b);
22294 CHECK_ACCESS(b_ptr);
22295 LDKCOption_SocketAddressZ b_conv = *(LDKCOption_SocketAddressZ*)(b_ptr);
22296 b_conv = COption_SocketAddressZ_clone((LDKCOption_SocketAddressZ*)untag_ptr(b));
22297 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ), "LDKC2Tuple_PublicKeyCOption_SocketAddressZZ");
22298 *ret_conv = C2Tuple_PublicKeyCOption_SocketAddressZZ_new(a_ref, b_conv);
22299 return tag_ptr(ret_conv, true);
22302 void __attribute__((export_name("TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_free"))) TS_C2Tuple_PublicKeyCOption_SocketAddressZZ_free(uint64_t _res) {
22303 if (!ptr_is_owned(_res)) return;
22304 void* _res_ptr = untag_ptr(_res);
22305 CHECK_ACCESS(_res_ptr);
22306 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ _res_conv = *(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)(_res_ptr);
22307 FREE(untag_ptr(_res));
22308 C2Tuple_PublicKeyCOption_SocketAddressZZ_free(_res_conv);
22311 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free"))) TS_CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(uint64_tArray _res) {
22312 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ _res_constr;
22313 _res_constr.datalen = _res->arr_len;
22314 if (_res_constr.datalen > 0)
22315 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ), "LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ Elements");
22317 _res_constr.data = NULL;
22318 uint64_t* _res_vals = _res->elems;
22319 for (size_t r = 0; r < _res_constr.datalen; r++) {
22320 uint64_t _res_conv_43 = _res_vals[r];
22321 void* _res_conv_43_ptr = untag_ptr(_res_conv_43);
22322 CHECK_ACCESS(_res_conv_43_ptr);
22323 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ _res_conv_43_conv = *(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ*)(_res_conv_43_ptr);
22324 FREE(untag_ptr(_res_conv_43));
22325 _res_constr.data[r] = _res_conv_43_conv;
22328 CVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ_free(_res_constr);
22331 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
22333 o_ref.datalen = o->arr_len;
22334 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
22335 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
22336 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
22337 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
22338 return tag_ptr(ret_conv, true);
22341 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint64_t e) {
22342 LDKPeerHandleError e_conv;
22343 e_conv.inner = untag_ptr(e);
22344 e_conv.is_owned = ptr_is_owned(e);
22345 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
22346 e_conv = PeerHandleError_clone(&e_conv);
22347 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
22348 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
22349 return tag_ptr(ret_conv, true);
22352 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint64_t o) {
22353 LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(o);
22354 jboolean ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
22358 void __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_free"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint64_t _res) {
22359 if (!ptr_is_owned(_res)) return;
22360 void* _res_ptr = untag_ptr(_res);
22361 CHECK_ACCESS(_res_ptr);
22362 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
22363 FREE(untag_ptr(_res));
22364 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
22367 static inline uint64_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
22368 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
22369 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
22370 return tag_ptr(ret_conv, true);
22372 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint64_t arg) {
22373 LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(arg);
22374 int64_t ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
22378 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint64_t orig) {
22379 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)untag_ptr(orig);
22380 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
22381 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
22382 return tag_ptr(ret_conv, true);
22385 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_ok"))) TS_CResult_NonePeerHandleErrorZ_ok() {
22386 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
22387 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
22388 return tag_ptr(ret_conv, true);
22391 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_err"))) TS_CResult_NonePeerHandleErrorZ_err(uint64_t e) {
22392 LDKPeerHandleError e_conv;
22393 e_conv.inner = untag_ptr(e);
22394 e_conv.is_owned = ptr_is_owned(e);
22395 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
22396 e_conv = PeerHandleError_clone(&e_conv);
22397 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
22398 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
22399 return tag_ptr(ret_conv, true);
22402 jboolean __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_is_ok"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint64_t o) {
22403 LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(o);
22404 jboolean ret_conv = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
22408 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_free"))) TS_CResult_NonePeerHandleErrorZ_free(uint64_t _res) {
22409 if (!ptr_is_owned(_res)) return;
22410 void* _res_ptr = untag_ptr(_res);
22411 CHECK_ACCESS(_res_ptr);
22412 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
22413 FREE(untag_ptr(_res));
22414 CResult_NonePeerHandleErrorZ_free(_res_conv);
22417 static inline uint64_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
22418 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
22419 *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
22420 return tag_ptr(ret_conv, true);
22422 int64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone_ptr"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint64_t arg) {
22423 LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(arg);
22424 int64_t ret_conv = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
22428 uint64_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone"))) TS_CResult_NonePeerHandleErrorZ_clone(uint64_t orig) {
22429 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)untag_ptr(orig);
22430 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
22431 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
22432 return tag_ptr(ret_conv, true);
22435 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_ok"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
22436 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
22437 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
22438 return tag_ptr(ret_conv, true);
22441 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_err"))) TS_CResult_boolPeerHandleErrorZ_err(uint64_t e) {
22442 LDKPeerHandleError e_conv;
22443 e_conv.inner = untag_ptr(e);
22444 e_conv.is_owned = ptr_is_owned(e);
22445 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
22446 e_conv = PeerHandleError_clone(&e_conv);
22447 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
22448 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
22449 return tag_ptr(ret_conv, true);
22452 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_is_ok"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint64_t o) {
22453 LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(o);
22454 jboolean ret_conv = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
22458 void __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_free"))) TS_CResult_boolPeerHandleErrorZ_free(uint64_t _res) {
22459 if (!ptr_is_owned(_res)) return;
22460 void* _res_ptr = untag_ptr(_res);
22461 CHECK_ACCESS(_res_ptr);
22462 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
22463 FREE(untag_ptr(_res));
22464 CResult_boolPeerHandleErrorZ_free(_res_conv);
22467 static inline uint64_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
22468 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
22469 *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
22470 return tag_ptr(ret_conv, true);
22472 int64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone_ptr"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint64_t arg) {
22473 LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(arg);
22474 int64_t ret_conv = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
22478 uint64_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone"))) TS_CResult_boolPeerHandleErrorZ_clone(uint64_t orig) {
22479 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)untag_ptr(orig);
22480 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
22481 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
22482 return tag_ptr(ret_conv, true);
22485 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_ok"))) TS_CResult_u32GraphSyncErrorZ_ok(int32_t o) {
22486 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
22487 *ret_conv = CResult_u32GraphSyncErrorZ_ok(o);
22488 return tag_ptr(ret_conv, true);
22491 uint64_t __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_err"))) TS_CResult_u32GraphSyncErrorZ_err(uint64_t e) {
22492 void* e_ptr = untag_ptr(e);
22493 CHECK_ACCESS(e_ptr);
22494 LDKGraphSyncError e_conv = *(LDKGraphSyncError*)(e_ptr);
22495 e_conv = GraphSyncError_clone((LDKGraphSyncError*)untag_ptr(e));
22496 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
22497 *ret_conv = CResult_u32GraphSyncErrorZ_err(e_conv);
22498 return tag_ptr(ret_conv, true);
22501 jboolean __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_is_ok"))) TS_CResult_u32GraphSyncErrorZ_is_ok(uint64_t o) {
22502 LDKCResult_u32GraphSyncErrorZ* o_conv = (LDKCResult_u32GraphSyncErrorZ*)untag_ptr(o);
22503 jboolean ret_conv = CResult_u32GraphSyncErrorZ_is_ok(o_conv);
22507 void __attribute__((export_name("TS_CResult_u32GraphSyncErrorZ_free"))) TS_CResult_u32GraphSyncErrorZ_free(uint64_t _res) {
22508 if (!ptr_is_owned(_res)) return;
22509 void* _res_ptr = untag_ptr(_res);
22510 CHECK_ACCESS(_res_ptr);
22511 LDKCResult_u32GraphSyncErrorZ _res_conv = *(LDKCResult_u32GraphSyncErrorZ*)(_res_ptr);
22512 FREE(untag_ptr(_res));
22513 CResult_u32GraphSyncErrorZ_free(_res_conv);
22516 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_ok"))) TS_CResult_CVec_u8ZIOErrorZ_ok(int8_tArray o) {
22518 o_ref.datalen = o->arr_len;
22519 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
22520 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
22521 LDKCResult_CVec_u8ZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZIOErrorZ), "LDKCResult_CVec_u8ZIOErrorZ");
22522 *ret_conv = CResult_CVec_u8ZIOErrorZ_ok(o_ref);
22523 return tag_ptr(ret_conv, true);
22526 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_err"))) TS_CResult_CVec_u8ZIOErrorZ_err(uint32_t e) {
22527 LDKIOError e_conv = LDKIOError_from_js(e);
22528 LDKCResult_CVec_u8ZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZIOErrorZ), "LDKCResult_CVec_u8ZIOErrorZ");
22529 *ret_conv = CResult_CVec_u8ZIOErrorZ_err(e_conv);
22530 return tag_ptr(ret_conv, true);
22533 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_is_ok"))) TS_CResult_CVec_u8ZIOErrorZ_is_ok(uint64_t o) {
22534 LDKCResult_CVec_u8ZIOErrorZ* o_conv = (LDKCResult_CVec_u8ZIOErrorZ*)untag_ptr(o);
22535 jboolean ret_conv = CResult_CVec_u8ZIOErrorZ_is_ok(o_conv);
22539 void __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_free"))) TS_CResult_CVec_u8ZIOErrorZ_free(uint64_t _res) {
22540 if (!ptr_is_owned(_res)) return;
22541 void* _res_ptr = untag_ptr(_res);
22542 CHECK_ACCESS(_res_ptr);
22543 LDKCResult_CVec_u8ZIOErrorZ _res_conv = *(LDKCResult_CVec_u8ZIOErrorZ*)(_res_ptr);
22544 FREE(untag_ptr(_res));
22545 CResult_CVec_u8ZIOErrorZ_free(_res_conv);
22548 static inline uint64_t CResult_CVec_u8ZIOErrorZ_clone_ptr(LDKCResult_CVec_u8ZIOErrorZ *NONNULL_PTR arg) {
22549 LDKCResult_CVec_u8ZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZIOErrorZ), "LDKCResult_CVec_u8ZIOErrorZ");
22550 *ret_conv = CResult_CVec_u8ZIOErrorZ_clone(arg);
22551 return tag_ptr(ret_conv, true);
22553 int64_t __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZIOErrorZ_clone_ptr(uint64_t arg) {
22554 LDKCResult_CVec_u8ZIOErrorZ* arg_conv = (LDKCResult_CVec_u8ZIOErrorZ*)untag_ptr(arg);
22555 int64_t ret_conv = CResult_CVec_u8ZIOErrorZ_clone_ptr(arg_conv);
22559 uint64_t __attribute__((export_name("TS_CResult_CVec_u8ZIOErrorZ_clone"))) TS_CResult_CVec_u8ZIOErrorZ_clone(uint64_t orig) {
22560 LDKCResult_CVec_u8ZIOErrorZ* orig_conv = (LDKCResult_CVec_u8ZIOErrorZ*)untag_ptr(orig);
22561 LDKCResult_CVec_u8ZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZIOErrorZ), "LDKCResult_CVec_u8ZIOErrorZ");
22562 *ret_conv = CResult_CVec_u8ZIOErrorZ_clone(orig_conv);
22563 return tag_ptr(ret_conv, true);
22566 uint64_t __attribute__((export_name("TS_CResult_NoneIOErrorZ_ok"))) TS_CResult_NoneIOErrorZ_ok() {
22567 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
22568 *ret_conv = CResult_NoneIOErrorZ_ok();
22569 return tag_ptr(ret_conv, true);
22572 uint64_t __attribute__((export_name("TS_CResult_NoneIOErrorZ_err"))) TS_CResult_NoneIOErrorZ_err(uint32_t e) {
22573 LDKIOError e_conv = LDKIOError_from_js(e);
22574 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
22575 *ret_conv = CResult_NoneIOErrorZ_err(e_conv);
22576 return tag_ptr(ret_conv, true);
22579 jboolean __attribute__((export_name("TS_CResult_NoneIOErrorZ_is_ok"))) TS_CResult_NoneIOErrorZ_is_ok(uint64_t o) {
22580 LDKCResult_NoneIOErrorZ* o_conv = (LDKCResult_NoneIOErrorZ*)untag_ptr(o);
22581 jboolean ret_conv = CResult_NoneIOErrorZ_is_ok(o_conv);
22585 void __attribute__((export_name("TS_CResult_NoneIOErrorZ_free"))) TS_CResult_NoneIOErrorZ_free(uint64_t _res) {
22586 if (!ptr_is_owned(_res)) return;
22587 void* _res_ptr = untag_ptr(_res);
22588 CHECK_ACCESS(_res_ptr);
22589 LDKCResult_NoneIOErrorZ _res_conv = *(LDKCResult_NoneIOErrorZ*)(_res_ptr);
22590 FREE(untag_ptr(_res));
22591 CResult_NoneIOErrorZ_free(_res_conv);
22594 static inline uint64_t CResult_NoneIOErrorZ_clone_ptr(LDKCResult_NoneIOErrorZ *NONNULL_PTR arg) {
22595 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
22596 *ret_conv = CResult_NoneIOErrorZ_clone(arg);
22597 return tag_ptr(ret_conv, true);
22599 int64_t __attribute__((export_name("TS_CResult_NoneIOErrorZ_clone_ptr"))) TS_CResult_NoneIOErrorZ_clone_ptr(uint64_t arg) {
22600 LDKCResult_NoneIOErrorZ* arg_conv = (LDKCResult_NoneIOErrorZ*)untag_ptr(arg);
22601 int64_t ret_conv = CResult_NoneIOErrorZ_clone_ptr(arg_conv);
22605 uint64_t __attribute__((export_name("TS_CResult_NoneIOErrorZ_clone"))) TS_CResult_NoneIOErrorZ_clone(uint64_t orig) {
22606 LDKCResult_NoneIOErrorZ* orig_conv = (LDKCResult_NoneIOErrorZ*)untag_ptr(orig);
22607 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
22608 *ret_conv = CResult_NoneIOErrorZ_clone(orig_conv);
22609 return tag_ptr(ret_conv, true);
22612 void __attribute__((export_name("TS_CVec_StrZ_free"))) TS_CVec_StrZ_free(ptrArray _res) {
22613 LDKCVec_StrZ _res_constr;
22614 _res_constr.datalen = _res->arr_len;
22615 if (_res_constr.datalen > 0)
22616 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKStr), "LDKCVec_StrZ Elements");
22618 _res_constr.data = NULL;
22619 jstring* _res_vals = (void*) _res->elems;
22620 for (size_t i = 0; i < _res_constr.datalen; i++) {
22621 jstring _res_conv_8 = _res_vals[i];
22622 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
22623 _res_constr.data[i] = dummy;
22626 CVec_StrZ_free(_res_constr);
22629 uint64_t __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_ok"))) TS_CResult_CVec_StrZIOErrorZ_ok(ptrArray o) {
22630 LDKCVec_StrZ o_constr;
22631 o_constr.datalen = o->arr_len;
22632 if (o_constr.datalen > 0)
22633 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKStr), "LDKCVec_StrZ Elements");
22635 o_constr.data = NULL;
22636 jstring* o_vals = (void*) o->elems;
22637 for (size_t i = 0; i < o_constr.datalen; i++) {
22638 jstring o_conv_8 = o_vals[i];
22639 LDKStr o_conv_8_conv = str_ref_to_owned_c(o_conv_8);
22640 o_constr.data[i] = o_conv_8_conv;
22643 LDKCResult_CVec_StrZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_StrZIOErrorZ), "LDKCResult_CVec_StrZIOErrorZ");
22644 *ret_conv = CResult_CVec_StrZIOErrorZ_ok(o_constr);
22645 return tag_ptr(ret_conv, true);
22648 uint64_t __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_err"))) TS_CResult_CVec_StrZIOErrorZ_err(uint32_t e) {
22649 LDKIOError e_conv = LDKIOError_from_js(e);
22650 LDKCResult_CVec_StrZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_StrZIOErrorZ), "LDKCResult_CVec_StrZIOErrorZ");
22651 *ret_conv = CResult_CVec_StrZIOErrorZ_err(e_conv);
22652 return tag_ptr(ret_conv, true);
22655 jboolean __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_is_ok"))) TS_CResult_CVec_StrZIOErrorZ_is_ok(uint64_t o) {
22656 LDKCResult_CVec_StrZIOErrorZ* o_conv = (LDKCResult_CVec_StrZIOErrorZ*)untag_ptr(o);
22657 jboolean ret_conv = CResult_CVec_StrZIOErrorZ_is_ok(o_conv);
22661 void __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_free"))) TS_CResult_CVec_StrZIOErrorZ_free(uint64_t _res) {
22662 if (!ptr_is_owned(_res)) return;
22663 void* _res_ptr = untag_ptr(_res);
22664 CHECK_ACCESS(_res_ptr);
22665 LDKCResult_CVec_StrZIOErrorZ _res_conv = *(LDKCResult_CVec_StrZIOErrorZ*)(_res_ptr);
22666 FREE(untag_ptr(_res));
22667 CResult_CVec_StrZIOErrorZ_free(_res_conv);
22670 static inline uint64_t CResult_CVec_StrZIOErrorZ_clone_ptr(LDKCResult_CVec_StrZIOErrorZ *NONNULL_PTR arg) {
22671 LDKCResult_CVec_StrZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_StrZIOErrorZ), "LDKCResult_CVec_StrZIOErrorZ");
22672 *ret_conv = CResult_CVec_StrZIOErrorZ_clone(arg);
22673 return tag_ptr(ret_conv, true);
22675 int64_t __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_clone_ptr"))) TS_CResult_CVec_StrZIOErrorZ_clone_ptr(uint64_t arg) {
22676 LDKCResult_CVec_StrZIOErrorZ* arg_conv = (LDKCResult_CVec_StrZIOErrorZ*)untag_ptr(arg);
22677 int64_t ret_conv = CResult_CVec_StrZIOErrorZ_clone_ptr(arg_conv);
22681 uint64_t __attribute__((export_name("TS_CResult_CVec_StrZIOErrorZ_clone"))) TS_CResult_CVec_StrZIOErrorZ_clone(uint64_t orig) {
22682 LDKCResult_CVec_StrZIOErrorZ* orig_conv = (LDKCResult_CVec_StrZIOErrorZ*)untag_ptr(orig);
22683 LDKCResult_CVec_StrZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_StrZIOErrorZ), "LDKCResult_CVec_StrZIOErrorZ");
22684 *ret_conv = CResult_CVec_StrZIOErrorZ_clone(orig_conv);
22685 return tag_ptr(ret_conv, true);
22688 void __attribute__((export_name("TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free"))) TS_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(uint64_tArray _res) {
22689 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ _res_constr;
22690 _res_constr.datalen = _res->arr_len;
22691 if (_res_constr.datalen > 0)
22692 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ Elements");
22694 _res_constr.data = NULL;
22695 uint64_t* _res_vals = _res->elems;
22696 for (size_t o = 0; o < _res_constr.datalen; o++) {
22697 uint64_t _res_conv_40 = _res_vals[o];
22698 void* _res_conv_40_ptr = untag_ptr(_res_conv_40);
22699 CHECK_ACCESS(_res_conv_40_ptr);
22700 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ _res_conv_40_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)(_res_conv_40_ptr);
22701 FREE(untag_ptr(_res_conv_40));
22702 _res_constr.data[o] = _res_conv_40_conv;
22705 CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ_free(_res_constr);
22708 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(uint64_tArray o) {
22709 LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ o_constr;
22710 o_constr.datalen = o->arr_len;
22711 if (o_constr.datalen > 0)
22712 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ), "LDKCVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZ Elements");
22714 o_constr.data = NULL;
22715 uint64_t* o_vals = o->elems;
22716 for (size_t o = 0; o < o_constr.datalen; o++) {
22717 uint64_t o_conv_40 = o_vals[o];
22718 void* o_conv_40_ptr = untag_ptr(o_conv_40);
22719 CHECK_ACCESS(o_conv_40_ptr);
22720 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o_conv_40_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)(o_conv_40_ptr);
22721 o_conv_40_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone((LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(o_conv_40));
22722 o_constr.data[o] = o_conv_40_conv;
22725 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
22726 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_ok(o_constr);
22727 return tag_ptr(ret_conv, true);
22730 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(uint32_t e) {
22731 LDKIOError e_conv = LDKIOError_from_js(e);
22732 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
22733 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_err(e_conv);
22734 return tag_ptr(ret_conv, true);
22737 jboolean __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(uint64_t o) {
22738 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)untag_ptr(o);
22739 jboolean ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_is_ok(o_conv);
22743 void __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(uint64_t _res) {
22744 if (!ptr_is_owned(_res)) return;
22745 void* _res_ptr = untag_ptr(_res);
22746 CHECK_ACCESS(_res_ptr);
22747 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ _res_conv = *(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)(_res_ptr);
22748 FREE(untag_ptr(_res));
22749 CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_free(_res_conv);
22752 static inline uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ *NONNULL_PTR arg) {
22753 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
22754 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(arg);
22755 return tag_ptr(ret_conv, true);
22757 int64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(uint64_t arg) {
22758 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)untag_ptr(arg);
22759 int64_t ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone_ptr(arg_conv);
22763 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(uint64_t orig) {
22764 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ*)untag_ptr(orig);
22765 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
22766 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ_clone(orig_conv);
22767 return tag_ptr(ret_conv, true);
22770 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(uint64_t o) {
22771 void* o_ptr = untag_ptr(o);
22772 CHECK_ACCESS(o_ptr);
22773 LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ o_conv = *(LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)(o_ptr);
22774 o_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_clone((LDKC2Tuple_ThirtyTwoBytesChannelMonitorZ*)untag_ptr(o));
22775 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ");
22776 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_ok(o_conv);
22777 return tag_ptr(ret_conv, true);
22780 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(uint32_t e) {
22781 LDKIOError e_conv = LDKIOError_from_js(e);
22782 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ");
22783 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_err(e_conv);
22784 return tag_ptr(ret_conv, true);
22787 jboolean __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(uint64_t o) {
22788 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* o_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)untag_ptr(o);
22789 jboolean ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_is_ok(o_conv);
22793 void __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(uint64_t _res) {
22794 if (!ptr_is_owned(_res)) return;
22795 void* _res_ptr = untag_ptr(_res);
22796 CHECK_ACCESS(_res_ptr);
22797 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ _res_conv = *(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)(_res_ptr);
22798 FREE(untag_ptr(_res));
22799 CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_free(_res_conv);
22802 static inline uint64_t CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ *NONNULL_PTR arg) {
22803 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ");
22804 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(arg);
22805 return tag_ptr(ret_conv, true);
22807 int64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(uint64_t arg) {
22808 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* arg_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)untag_ptr(arg);
22809 int64_t ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone_ptr(arg_conv);
22813 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone"))) TS_CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(uint64_t orig) {
22814 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* orig_conv = (LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ*)untag_ptr(orig);
22815 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ");
22816 *ret_conv = CResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ_clone(orig_conv);
22817 return tag_ptr(ret_conv, true);
22820 uint64_t __attribute__((export_name("TS_COption_SecretKeyZ_some"))) TS_COption_SecretKeyZ_some(int8_tArray o) {
22821 LDKSecretKey o_ref;
22822 CHECK(o->arr_len == 32);
22823 memcpy(o_ref.bytes, o->elems, 32); FREE(o);
22824 LDKCOption_SecretKeyZ *ret_copy = MALLOC(sizeof(LDKCOption_SecretKeyZ), "LDKCOption_SecretKeyZ");
22825 *ret_copy = COption_SecretKeyZ_some(o_ref);
22826 uint64_t ret_ref = tag_ptr(ret_copy, true);
22830 uint64_t __attribute__((export_name("TS_COption_SecretKeyZ_none"))) TS_COption_SecretKeyZ_none() {
22831 LDKCOption_SecretKeyZ *ret_copy = MALLOC(sizeof(LDKCOption_SecretKeyZ), "LDKCOption_SecretKeyZ");
22832 *ret_copy = COption_SecretKeyZ_none();
22833 uint64_t ret_ref = tag_ptr(ret_copy, true);
22837 void __attribute__((export_name("TS_COption_SecretKeyZ_free"))) TS_COption_SecretKeyZ_free(uint64_t _res) {
22838 if (!ptr_is_owned(_res)) return;
22839 void* _res_ptr = untag_ptr(_res);
22840 CHECK_ACCESS(_res_ptr);
22841 LDKCOption_SecretKeyZ _res_conv = *(LDKCOption_SecretKeyZ*)(_res_ptr);
22842 FREE(untag_ptr(_res));
22843 COption_SecretKeyZ_free(_res_conv);
22846 static inline uint64_t COption_SecretKeyZ_clone_ptr(LDKCOption_SecretKeyZ *NONNULL_PTR arg) {
22847 LDKCOption_SecretKeyZ *ret_copy = MALLOC(sizeof(LDKCOption_SecretKeyZ), "LDKCOption_SecretKeyZ");
22848 *ret_copy = COption_SecretKeyZ_clone(arg);
22849 uint64_t ret_ref = tag_ptr(ret_copy, true);
22852 int64_t __attribute__((export_name("TS_COption_SecretKeyZ_clone_ptr"))) TS_COption_SecretKeyZ_clone_ptr(uint64_t arg) {
22853 LDKCOption_SecretKeyZ* arg_conv = (LDKCOption_SecretKeyZ*)untag_ptr(arg);
22854 int64_t ret_conv = COption_SecretKeyZ_clone_ptr(arg_conv);
22858 uint64_t __attribute__((export_name("TS_COption_SecretKeyZ_clone"))) TS_COption_SecretKeyZ_clone(uint64_t orig) {
22859 LDKCOption_SecretKeyZ* orig_conv = (LDKCOption_SecretKeyZ*)untag_ptr(orig);
22860 LDKCOption_SecretKeyZ *ret_copy = MALLOC(sizeof(LDKCOption_SecretKeyZ), "LDKCOption_SecretKeyZ");
22861 *ret_copy = COption_SecretKeyZ_clone(orig_conv);
22862 uint64_t ret_ref = tag_ptr(ret_copy, true);
22866 uint64_t __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_ok"))) TS_CResult_VerifiedInvoiceRequestNoneZ_ok(uint64_t o) {
22867 LDKVerifiedInvoiceRequest o_conv;
22868 o_conv.inner = untag_ptr(o);
22869 o_conv.is_owned = ptr_is_owned(o);
22870 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
22871 o_conv = VerifiedInvoiceRequest_clone(&o_conv);
22872 LDKCResult_VerifiedInvoiceRequestNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ), "LDKCResult_VerifiedInvoiceRequestNoneZ");
22873 *ret_conv = CResult_VerifiedInvoiceRequestNoneZ_ok(o_conv);
22874 return tag_ptr(ret_conv, true);
22877 uint64_t __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_err"))) TS_CResult_VerifiedInvoiceRequestNoneZ_err() {
22878 LDKCResult_VerifiedInvoiceRequestNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ), "LDKCResult_VerifiedInvoiceRequestNoneZ");
22879 *ret_conv = CResult_VerifiedInvoiceRequestNoneZ_err();
22880 return tag_ptr(ret_conv, true);
22883 jboolean __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok"))) TS_CResult_VerifiedInvoiceRequestNoneZ_is_ok(uint64_t o) {
22884 LDKCResult_VerifiedInvoiceRequestNoneZ* o_conv = (LDKCResult_VerifiedInvoiceRequestNoneZ*)untag_ptr(o);
22885 jboolean ret_conv = CResult_VerifiedInvoiceRequestNoneZ_is_ok(o_conv);
22889 void __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_free"))) TS_CResult_VerifiedInvoiceRequestNoneZ_free(uint64_t _res) {
22890 if (!ptr_is_owned(_res)) return;
22891 void* _res_ptr = untag_ptr(_res);
22892 CHECK_ACCESS(_res_ptr);
22893 LDKCResult_VerifiedInvoiceRequestNoneZ _res_conv = *(LDKCResult_VerifiedInvoiceRequestNoneZ*)(_res_ptr);
22894 FREE(untag_ptr(_res));
22895 CResult_VerifiedInvoiceRequestNoneZ_free(_res_conv);
22898 static inline uint64_t CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(LDKCResult_VerifiedInvoiceRequestNoneZ *NONNULL_PTR arg) {
22899 LDKCResult_VerifiedInvoiceRequestNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ), "LDKCResult_VerifiedInvoiceRequestNoneZ");
22900 *ret_conv = CResult_VerifiedInvoiceRequestNoneZ_clone(arg);
22901 return tag_ptr(ret_conv, true);
22903 int64_t __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr"))) TS_CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(uint64_t arg) {
22904 LDKCResult_VerifiedInvoiceRequestNoneZ* arg_conv = (LDKCResult_VerifiedInvoiceRequestNoneZ*)untag_ptr(arg);
22905 int64_t ret_conv = CResult_VerifiedInvoiceRequestNoneZ_clone_ptr(arg_conv);
22909 uint64_t __attribute__((export_name("TS_CResult_VerifiedInvoiceRequestNoneZ_clone"))) TS_CResult_VerifiedInvoiceRequestNoneZ_clone(uint64_t orig) {
22910 LDKCResult_VerifiedInvoiceRequestNoneZ* orig_conv = (LDKCResult_VerifiedInvoiceRequestNoneZ*)untag_ptr(orig);
22911 LDKCResult_VerifiedInvoiceRequestNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ), "LDKCResult_VerifiedInvoiceRequestNoneZ");
22912 *ret_conv = CResult_VerifiedInvoiceRequestNoneZ_clone(orig_conv);
22913 return tag_ptr(ret_conv, true);
22916 uint32_t __attribute__((export_name("TS_COption_NoneZ_some"))) TS_COption_NoneZ_some() {
22917 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_some());
22921 uint32_t __attribute__((export_name("TS_COption_NoneZ_none"))) TS_COption_NoneZ_none() {
22922 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_none());
22926 void __attribute__((export_name("TS_COption_NoneZ_free"))) TS_COption_NoneZ_free(uint32_t _res) {
22927 LDKCOption_NoneZ _res_conv = LDKCOption_NoneZ_from_js(_res);
22928 COption_NoneZ_free(_res_conv);
22931 void __attribute__((export_name("TS_CVec_WitnessZ_free"))) TS_CVec_WitnessZ_free(ptrArray _res) {
22932 LDKCVec_WitnessZ _res_constr;
22933 _res_constr.datalen = _res->arr_len;
22934 if (_res_constr.datalen > 0)
22935 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKWitness), "LDKCVec_WitnessZ Elements");
22937 _res_constr.data = NULL;
22938 int8_tArray* _res_vals = (void*) _res->elems;
22939 for (size_t m = 0; m < _res_constr.datalen; m++) {
22940 int8_tArray _res_conv_12 = _res_vals[m];
22941 LDKWitness _res_conv_12_ref;
22942 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
22943 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKWitness Bytes");
22944 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
22945 _res_conv_12_ref.data_is_owned = true;
22946 _res_constr.data[m] = _res_conv_12_ref;
22949 CVec_WitnessZ_free(_res_constr);
22952 uint64_t __attribute__((export_name("TS_COption_i64Z_some"))) TS_COption_i64Z_some(int64_t o) {
22953 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
22954 *ret_copy = COption_i64Z_some(o);
22955 uint64_t ret_ref = tag_ptr(ret_copy, true);
22959 uint64_t __attribute__((export_name("TS_COption_i64Z_none"))) TS_COption_i64Z_none() {
22960 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
22961 *ret_copy = COption_i64Z_none();
22962 uint64_t ret_ref = tag_ptr(ret_copy, true);
22966 void __attribute__((export_name("TS_COption_i64Z_free"))) TS_COption_i64Z_free(uint64_t _res) {
22967 if (!ptr_is_owned(_res)) return;
22968 void* _res_ptr = untag_ptr(_res);
22969 CHECK_ACCESS(_res_ptr);
22970 LDKCOption_i64Z _res_conv = *(LDKCOption_i64Z*)(_res_ptr);
22971 FREE(untag_ptr(_res));
22972 COption_i64Z_free(_res_conv);
22975 static inline uint64_t COption_i64Z_clone_ptr(LDKCOption_i64Z *NONNULL_PTR arg) {
22976 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
22977 *ret_copy = COption_i64Z_clone(arg);
22978 uint64_t ret_ref = tag_ptr(ret_copy, true);
22981 int64_t __attribute__((export_name("TS_COption_i64Z_clone_ptr"))) TS_COption_i64Z_clone_ptr(uint64_t arg) {
22982 LDKCOption_i64Z* arg_conv = (LDKCOption_i64Z*)untag_ptr(arg);
22983 int64_t ret_conv = COption_i64Z_clone_ptr(arg_conv);
22987 uint64_t __attribute__((export_name("TS_COption_i64Z_clone"))) TS_COption_i64Z_clone(uint64_t orig) {
22988 LDKCOption_i64Z* orig_conv = (LDKCOption_i64Z*)untag_ptr(orig);
22989 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
22990 *ret_copy = COption_i64Z_clone(orig_conv);
22991 uint64_t ret_ref = tag_ptr(ret_copy, true);
22995 uint64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_ok"))) TS_CResult_SocketAddressDecodeErrorZ_ok(uint64_t o) {
22996 void* o_ptr = untag_ptr(o);
22997 CHECK_ACCESS(o_ptr);
22998 LDKSocketAddress o_conv = *(LDKSocketAddress*)(o_ptr);
22999 o_conv = SocketAddress_clone((LDKSocketAddress*)untag_ptr(o));
23000 LDKCResult_SocketAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressDecodeErrorZ), "LDKCResult_SocketAddressDecodeErrorZ");
23001 *ret_conv = CResult_SocketAddressDecodeErrorZ_ok(o_conv);
23002 return tag_ptr(ret_conv, true);
23005 uint64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_err"))) TS_CResult_SocketAddressDecodeErrorZ_err(uint64_t e) {
23006 void* e_ptr = untag_ptr(e);
23007 CHECK_ACCESS(e_ptr);
23008 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23009 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23010 LDKCResult_SocketAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressDecodeErrorZ), "LDKCResult_SocketAddressDecodeErrorZ");
23011 *ret_conv = CResult_SocketAddressDecodeErrorZ_err(e_conv);
23012 return tag_ptr(ret_conv, true);
23015 jboolean __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_is_ok"))) TS_CResult_SocketAddressDecodeErrorZ_is_ok(uint64_t o) {
23016 LDKCResult_SocketAddressDecodeErrorZ* o_conv = (LDKCResult_SocketAddressDecodeErrorZ*)untag_ptr(o);
23017 jboolean ret_conv = CResult_SocketAddressDecodeErrorZ_is_ok(o_conv);
23021 void __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_free"))) TS_CResult_SocketAddressDecodeErrorZ_free(uint64_t _res) {
23022 if (!ptr_is_owned(_res)) return;
23023 void* _res_ptr = untag_ptr(_res);
23024 CHECK_ACCESS(_res_ptr);
23025 LDKCResult_SocketAddressDecodeErrorZ _res_conv = *(LDKCResult_SocketAddressDecodeErrorZ*)(_res_ptr);
23026 FREE(untag_ptr(_res));
23027 CResult_SocketAddressDecodeErrorZ_free(_res_conv);
23030 static inline uint64_t CResult_SocketAddressDecodeErrorZ_clone_ptr(LDKCResult_SocketAddressDecodeErrorZ *NONNULL_PTR arg) {
23031 LDKCResult_SocketAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressDecodeErrorZ), "LDKCResult_SocketAddressDecodeErrorZ");
23032 *ret_conv = CResult_SocketAddressDecodeErrorZ_clone(arg);
23033 return tag_ptr(ret_conv, true);
23035 int64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_clone_ptr"))) TS_CResult_SocketAddressDecodeErrorZ_clone_ptr(uint64_t arg) {
23036 LDKCResult_SocketAddressDecodeErrorZ* arg_conv = (LDKCResult_SocketAddressDecodeErrorZ*)untag_ptr(arg);
23037 int64_t ret_conv = CResult_SocketAddressDecodeErrorZ_clone_ptr(arg_conv);
23041 uint64_t __attribute__((export_name("TS_CResult_SocketAddressDecodeErrorZ_clone"))) TS_CResult_SocketAddressDecodeErrorZ_clone(uint64_t orig) {
23042 LDKCResult_SocketAddressDecodeErrorZ* orig_conv = (LDKCResult_SocketAddressDecodeErrorZ*)untag_ptr(orig);
23043 LDKCResult_SocketAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressDecodeErrorZ), "LDKCResult_SocketAddressDecodeErrorZ");
23044 *ret_conv = CResult_SocketAddressDecodeErrorZ_clone(orig_conv);
23045 return tag_ptr(ret_conv, true);
23048 uint64_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_ok"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_ok(uint64_t o) {
23049 void* o_ptr = untag_ptr(o);
23050 CHECK_ACCESS(o_ptr);
23051 LDKSocketAddress o_conv = *(LDKSocketAddress*)(o_ptr);
23052 o_conv = SocketAddress_clone((LDKSocketAddress*)untag_ptr(o));
23053 LDKCResult_SocketAddressSocketAddressParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ), "LDKCResult_SocketAddressSocketAddressParseErrorZ");
23054 *ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_ok(o_conv);
23055 return tag_ptr(ret_conv, true);
23058 uint64_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_err"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_err(uint32_t e) {
23059 LDKSocketAddressParseError e_conv = LDKSocketAddressParseError_from_js(e);
23060 LDKCResult_SocketAddressSocketAddressParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ), "LDKCResult_SocketAddressSocketAddressParseErrorZ");
23061 *ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_err(e_conv);
23062 return tag_ptr(ret_conv, true);
23065 jboolean __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_is_ok(uint64_t o) {
23066 LDKCResult_SocketAddressSocketAddressParseErrorZ* o_conv = (LDKCResult_SocketAddressSocketAddressParseErrorZ*)untag_ptr(o);
23067 jboolean ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_is_ok(o_conv);
23071 void __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_free"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_free(uint64_t _res) {
23072 if (!ptr_is_owned(_res)) return;
23073 void* _res_ptr = untag_ptr(_res);
23074 CHECK_ACCESS(_res_ptr);
23075 LDKCResult_SocketAddressSocketAddressParseErrorZ _res_conv = *(LDKCResult_SocketAddressSocketAddressParseErrorZ*)(_res_ptr);
23076 FREE(untag_ptr(_res));
23077 CResult_SocketAddressSocketAddressParseErrorZ_free(_res_conv);
23080 static inline uint64_t CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(LDKCResult_SocketAddressSocketAddressParseErrorZ *NONNULL_PTR arg) {
23081 LDKCResult_SocketAddressSocketAddressParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ), "LDKCResult_SocketAddressSocketAddressParseErrorZ");
23082 *ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_clone(arg);
23083 return tag_ptr(ret_conv, true);
23085 int64_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(uint64_t arg) {
23086 LDKCResult_SocketAddressSocketAddressParseErrorZ* arg_conv = (LDKCResult_SocketAddressSocketAddressParseErrorZ*)untag_ptr(arg);
23087 int64_t ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_clone_ptr(arg_conv);
23091 uint64_t __attribute__((export_name("TS_CResult_SocketAddressSocketAddressParseErrorZ_clone"))) TS_CResult_SocketAddressSocketAddressParseErrorZ_clone(uint64_t orig) {
23092 LDKCResult_SocketAddressSocketAddressParseErrorZ* orig_conv = (LDKCResult_SocketAddressSocketAddressParseErrorZ*)untag_ptr(orig);
23093 LDKCResult_SocketAddressSocketAddressParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ), "LDKCResult_SocketAddressSocketAddressParseErrorZ");
23094 *ret_conv = CResult_SocketAddressSocketAddressParseErrorZ_clone(orig_conv);
23095 return tag_ptr(ret_conv, true);
23098 void __attribute__((export_name("TS_CVec_UpdateAddHTLCZ_free"))) TS_CVec_UpdateAddHTLCZ_free(uint64_tArray _res) {
23099 LDKCVec_UpdateAddHTLCZ _res_constr;
23100 _res_constr.datalen = _res->arr_len;
23101 if (_res_constr.datalen > 0)
23102 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
23104 _res_constr.data = NULL;
23105 uint64_t* _res_vals = _res->elems;
23106 for (size_t p = 0; p < _res_constr.datalen; p++) {
23107 uint64_t _res_conv_15 = _res_vals[p];
23108 LDKUpdateAddHTLC _res_conv_15_conv;
23109 _res_conv_15_conv.inner = untag_ptr(_res_conv_15);
23110 _res_conv_15_conv.is_owned = ptr_is_owned(_res_conv_15);
23111 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
23112 _res_constr.data[p] = _res_conv_15_conv;
23115 CVec_UpdateAddHTLCZ_free(_res_constr);
23118 void __attribute__((export_name("TS_CVec_UpdateFulfillHTLCZ_free"))) TS_CVec_UpdateFulfillHTLCZ_free(uint64_tArray _res) {
23119 LDKCVec_UpdateFulfillHTLCZ _res_constr;
23120 _res_constr.datalen = _res->arr_len;
23121 if (_res_constr.datalen > 0)
23122 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
23124 _res_constr.data = NULL;
23125 uint64_t* _res_vals = _res->elems;
23126 for (size_t t = 0; t < _res_constr.datalen; t++) {
23127 uint64_t _res_conv_19 = _res_vals[t];
23128 LDKUpdateFulfillHTLC _res_conv_19_conv;
23129 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
23130 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
23131 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
23132 _res_constr.data[t] = _res_conv_19_conv;
23135 CVec_UpdateFulfillHTLCZ_free(_res_constr);
23138 void __attribute__((export_name("TS_CVec_UpdateFailHTLCZ_free"))) TS_CVec_UpdateFailHTLCZ_free(uint64_tArray _res) {
23139 LDKCVec_UpdateFailHTLCZ _res_constr;
23140 _res_constr.datalen = _res->arr_len;
23141 if (_res_constr.datalen > 0)
23142 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
23144 _res_constr.data = NULL;
23145 uint64_t* _res_vals = _res->elems;
23146 for (size_t q = 0; q < _res_constr.datalen; q++) {
23147 uint64_t _res_conv_16 = _res_vals[q];
23148 LDKUpdateFailHTLC _res_conv_16_conv;
23149 _res_conv_16_conv.inner = untag_ptr(_res_conv_16);
23150 _res_conv_16_conv.is_owned = ptr_is_owned(_res_conv_16);
23151 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
23152 _res_constr.data[q] = _res_conv_16_conv;
23155 CVec_UpdateFailHTLCZ_free(_res_constr);
23158 void __attribute__((export_name("TS_CVec_UpdateFailMalformedHTLCZ_free"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint64_tArray _res) {
23159 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
23160 _res_constr.datalen = _res->arr_len;
23161 if (_res_constr.datalen > 0)
23162 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
23164 _res_constr.data = NULL;
23165 uint64_t* _res_vals = _res->elems;
23166 for (size_t z = 0; z < _res_constr.datalen; z++) {
23167 uint64_t _res_conv_25 = _res_vals[z];
23168 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
23169 _res_conv_25_conv.inner = untag_ptr(_res_conv_25);
23170 _res_conv_25_conv.is_owned = ptr_is_owned(_res_conv_25);
23171 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
23172 _res_constr.data[z] = _res_conv_25_conv;
23175 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
23178 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint64_t o) {
23179 LDKAcceptChannel o_conv;
23180 o_conv.inner = untag_ptr(o);
23181 o_conv.is_owned = ptr_is_owned(o);
23182 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23183 o_conv = AcceptChannel_clone(&o_conv);
23184 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
23185 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
23186 return tag_ptr(ret_conv, true);
23189 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_err"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint64_t e) {
23190 void* e_ptr = untag_ptr(e);
23191 CHECK_ACCESS(e_ptr);
23192 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23193 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23194 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
23195 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
23196 return tag_ptr(ret_conv, true);
23199 jboolean __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint64_t o) {
23200 LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(o);
23201 jboolean ret_conv = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
23205 void __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_free"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint64_t _res) {
23206 if (!ptr_is_owned(_res)) return;
23207 void* _res_ptr = untag_ptr(_res);
23208 CHECK_ACCESS(_res_ptr);
23209 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
23210 FREE(untag_ptr(_res));
23211 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
23214 static inline uint64_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
23215 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
23216 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
23217 return tag_ptr(ret_conv, true);
23219 int64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
23220 LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(arg);
23221 int64_t ret_conv = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
23225 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint64_t orig) {
23226 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)untag_ptr(orig);
23227 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
23228 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
23229 return tag_ptr(ret_conv, true);
23232 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_ok"))) TS_CResult_AcceptChannelV2DecodeErrorZ_ok(uint64_t o) {
23233 LDKAcceptChannelV2 o_conv;
23234 o_conv.inner = untag_ptr(o);
23235 o_conv.is_owned = ptr_is_owned(o);
23236 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23237 o_conv = AcceptChannelV2_clone(&o_conv);
23238 LDKCResult_AcceptChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ), "LDKCResult_AcceptChannelV2DecodeErrorZ");
23239 *ret_conv = CResult_AcceptChannelV2DecodeErrorZ_ok(o_conv);
23240 return tag_ptr(ret_conv, true);
23243 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_err"))) TS_CResult_AcceptChannelV2DecodeErrorZ_err(uint64_t e) {
23244 void* e_ptr = untag_ptr(e);
23245 CHECK_ACCESS(e_ptr);
23246 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23247 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23248 LDKCResult_AcceptChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ), "LDKCResult_AcceptChannelV2DecodeErrorZ");
23249 *ret_conv = CResult_AcceptChannelV2DecodeErrorZ_err(e_conv);
23250 return tag_ptr(ret_conv, true);
23253 jboolean __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelV2DecodeErrorZ_is_ok(uint64_t o) {
23254 LDKCResult_AcceptChannelV2DecodeErrorZ* o_conv = (LDKCResult_AcceptChannelV2DecodeErrorZ*)untag_ptr(o);
23255 jboolean ret_conv = CResult_AcceptChannelV2DecodeErrorZ_is_ok(o_conv);
23259 void __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_free"))) TS_CResult_AcceptChannelV2DecodeErrorZ_free(uint64_t _res) {
23260 if (!ptr_is_owned(_res)) return;
23261 void* _res_ptr = untag_ptr(_res);
23262 CHECK_ACCESS(_res_ptr);
23263 LDKCResult_AcceptChannelV2DecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelV2DecodeErrorZ*)(_res_ptr);
23264 FREE(untag_ptr(_res));
23265 CResult_AcceptChannelV2DecodeErrorZ_free(_res_conv);
23268 static inline uint64_t CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelV2DecodeErrorZ *NONNULL_PTR arg) {
23269 LDKCResult_AcceptChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ), "LDKCResult_AcceptChannelV2DecodeErrorZ");
23270 *ret_conv = CResult_AcceptChannelV2DecodeErrorZ_clone(arg);
23271 return tag_ptr(ret_conv, true);
23273 int64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(uint64_t arg) {
23274 LDKCResult_AcceptChannelV2DecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelV2DecodeErrorZ*)untag_ptr(arg);
23275 int64_t ret_conv = CResult_AcceptChannelV2DecodeErrorZ_clone_ptr(arg_conv);
23279 uint64_t __attribute__((export_name("TS_CResult_AcceptChannelV2DecodeErrorZ_clone"))) TS_CResult_AcceptChannelV2DecodeErrorZ_clone(uint64_t orig) {
23280 LDKCResult_AcceptChannelV2DecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelV2DecodeErrorZ*)untag_ptr(orig);
23281 LDKCResult_AcceptChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ), "LDKCResult_AcceptChannelV2DecodeErrorZ");
23282 *ret_conv = CResult_AcceptChannelV2DecodeErrorZ_clone(orig_conv);
23283 return tag_ptr(ret_conv, true);
23286 uint64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_ok"))) TS_CResult_TxAddInputDecodeErrorZ_ok(uint64_t o) {
23287 LDKTxAddInput o_conv;
23288 o_conv.inner = untag_ptr(o);
23289 o_conv.is_owned = ptr_is_owned(o);
23290 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23291 o_conv = TxAddInput_clone(&o_conv);
23292 LDKCResult_TxAddInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddInputDecodeErrorZ), "LDKCResult_TxAddInputDecodeErrorZ");
23293 *ret_conv = CResult_TxAddInputDecodeErrorZ_ok(o_conv);
23294 return tag_ptr(ret_conv, true);
23297 uint64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_err"))) TS_CResult_TxAddInputDecodeErrorZ_err(uint64_t e) {
23298 void* e_ptr = untag_ptr(e);
23299 CHECK_ACCESS(e_ptr);
23300 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23301 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23302 LDKCResult_TxAddInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddInputDecodeErrorZ), "LDKCResult_TxAddInputDecodeErrorZ");
23303 *ret_conv = CResult_TxAddInputDecodeErrorZ_err(e_conv);
23304 return tag_ptr(ret_conv, true);
23307 jboolean __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_is_ok"))) TS_CResult_TxAddInputDecodeErrorZ_is_ok(uint64_t o) {
23308 LDKCResult_TxAddInputDecodeErrorZ* o_conv = (LDKCResult_TxAddInputDecodeErrorZ*)untag_ptr(o);
23309 jboolean ret_conv = CResult_TxAddInputDecodeErrorZ_is_ok(o_conv);
23313 void __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_free"))) TS_CResult_TxAddInputDecodeErrorZ_free(uint64_t _res) {
23314 if (!ptr_is_owned(_res)) return;
23315 void* _res_ptr = untag_ptr(_res);
23316 CHECK_ACCESS(_res_ptr);
23317 LDKCResult_TxAddInputDecodeErrorZ _res_conv = *(LDKCResult_TxAddInputDecodeErrorZ*)(_res_ptr);
23318 FREE(untag_ptr(_res));
23319 CResult_TxAddInputDecodeErrorZ_free(_res_conv);
23322 static inline uint64_t CResult_TxAddInputDecodeErrorZ_clone_ptr(LDKCResult_TxAddInputDecodeErrorZ *NONNULL_PTR arg) {
23323 LDKCResult_TxAddInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddInputDecodeErrorZ), "LDKCResult_TxAddInputDecodeErrorZ");
23324 *ret_conv = CResult_TxAddInputDecodeErrorZ_clone(arg);
23325 return tag_ptr(ret_conv, true);
23327 int64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_clone_ptr"))) TS_CResult_TxAddInputDecodeErrorZ_clone_ptr(uint64_t arg) {
23328 LDKCResult_TxAddInputDecodeErrorZ* arg_conv = (LDKCResult_TxAddInputDecodeErrorZ*)untag_ptr(arg);
23329 int64_t ret_conv = CResult_TxAddInputDecodeErrorZ_clone_ptr(arg_conv);
23333 uint64_t __attribute__((export_name("TS_CResult_TxAddInputDecodeErrorZ_clone"))) TS_CResult_TxAddInputDecodeErrorZ_clone(uint64_t orig) {
23334 LDKCResult_TxAddInputDecodeErrorZ* orig_conv = (LDKCResult_TxAddInputDecodeErrorZ*)untag_ptr(orig);
23335 LDKCResult_TxAddInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddInputDecodeErrorZ), "LDKCResult_TxAddInputDecodeErrorZ");
23336 *ret_conv = CResult_TxAddInputDecodeErrorZ_clone(orig_conv);
23337 return tag_ptr(ret_conv, true);
23340 uint64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_ok"))) TS_CResult_TxAddOutputDecodeErrorZ_ok(uint64_t o) {
23341 LDKTxAddOutput o_conv;
23342 o_conv.inner = untag_ptr(o);
23343 o_conv.is_owned = ptr_is_owned(o);
23344 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23345 o_conv = TxAddOutput_clone(&o_conv);
23346 LDKCResult_TxAddOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddOutputDecodeErrorZ), "LDKCResult_TxAddOutputDecodeErrorZ");
23347 *ret_conv = CResult_TxAddOutputDecodeErrorZ_ok(o_conv);
23348 return tag_ptr(ret_conv, true);
23351 uint64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_err"))) TS_CResult_TxAddOutputDecodeErrorZ_err(uint64_t e) {
23352 void* e_ptr = untag_ptr(e);
23353 CHECK_ACCESS(e_ptr);
23354 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23355 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23356 LDKCResult_TxAddOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddOutputDecodeErrorZ), "LDKCResult_TxAddOutputDecodeErrorZ");
23357 *ret_conv = CResult_TxAddOutputDecodeErrorZ_err(e_conv);
23358 return tag_ptr(ret_conv, true);
23361 jboolean __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_is_ok"))) TS_CResult_TxAddOutputDecodeErrorZ_is_ok(uint64_t o) {
23362 LDKCResult_TxAddOutputDecodeErrorZ* o_conv = (LDKCResult_TxAddOutputDecodeErrorZ*)untag_ptr(o);
23363 jboolean ret_conv = CResult_TxAddOutputDecodeErrorZ_is_ok(o_conv);
23367 void __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_free"))) TS_CResult_TxAddOutputDecodeErrorZ_free(uint64_t _res) {
23368 if (!ptr_is_owned(_res)) return;
23369 void* _res_ptr = untag_ptr(_res);
23370 CHECK_ACCESS(_res_ptr);
23371 LDKCResult_TxAddOutputDecodeErrorZ _res_conv = *(LDKCResult_TxAddOutputDecodeErrorZ*)(_res_ptr);
23372 FREE(untag_ptr(_res));
23373 CResult_TxAddOutputDecodeErrorZ_free(_res_conv);
23376 static inline uint64_t CResult_TxAddOutputDecodeErrorZ_clone_ptr(LDKCResult_TxAddOutputDecodeErrorZ *NONNULL_PTR arg) {
23377 LDKCResult_TxAddOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddOutputDecodeErrorZ), "LDKCResult_TxAddOutputDecodeErrorZ");
23378 *ret_conv = CResult_TxAddOutputDecodeErrorZ_clone(arg);
23379 return tag_ptr(ret_conv, true);
23381 int64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr"))) TS_CResult_TxAddOutputDecodeErrorZ_clone_ptr(uint64_t arg) {
23382 LDKCResult_TxAddOutputDecodeErrorZ* arg_conv = (LDKCResult_TxAddOutputDecodeErrorZ*)untag_ptr(arg);
23383 int64_t ret_conv = CResult_TxAddOutputDecodeErrorZ_clone_ptr(arg_conv);
23387 uint64_t __attribute__((export_name("TS_CResult_TxAddOutputDecodeErrorZ_clone"))) TS_CResult_TxAddOutputDecodeErrorZ_clone(uint64_t orig) {
23388 LDKCResult_TxAddOutputDecodeErrorZ* orig_conv = (LDKCResult_TxAddOutputDecodeErrorZ*)untag_ptr(orig);
23389 LDKCResult_TxAddOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddOutputDecodeErrorZ), "LDKCResult_TxAddOutputDecodeErrorZ");
23390 *ret_conv = CResult_TxAddOutputDecodeErrorZ_clone(orig_conv);
23391 return tag_ptr(ret_conv, true);
23394 uint64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_ok"))) TS_CResult_TxRemoveInputDecodeErrorZ_ok(uint64_t o) {
23395 LDKTxRemoveInput o_conv;
23396 o_conv.inner = untag_ptr(o);
23397 o_conv.is_owned = ptr_is_owned(o);
23398 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23399 o_conv = TxRemoveInput_clone(&o_conv);
23400 LDKCResult_TxRemoveInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveInputDecodeErrorZ), "LDKCResult_TxRemoveInputDecodeErrorZ");
23401 *ret_conv = CResult_TxRemoveInputDecodeErrorZ_ok(o_conv);
23402 return tag_ptr(ret_conv, true);
23405 uint64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_err"))) TS_CResult_TxRemoveInputDecodeErrorZ_err(uint64_t e) {
23406 void* e_ptr = untag_ptr(e);
23407 CHECK_ACCESS(e_ptr);
23408 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23409 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23410 LDKCResult_TxRemoveInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveInputDecodeErrorZ), "LDKCResult_TxRemoveInputDecodeErrorZ");
23411 *ret_conv = CResult_TxRemoveInputDecodeErrorZ_err(e_conv);
23412 return tag_ptr(ret_conv, true);
23415 jboolean __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_is_ok"))) TS_CResult_TxRemoveInputDecodeErrorZ_is_ok(uint64_t o) {
23416 LDKCResult_TxRemoveInputDecodeErrorZ* o_conv = (LDKCResult_TxRemoveInputDecodeErrorZ*)untag_ptr(o);
23417 jboolean ret_conv = CResult_TxRemoveInputDecodeErrorZ_is_ok(o_conv);
23421 void __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_free"))) TS_CResult_TxRemoveInputDecodeErrorZ_free(uint64_t _res) {
23422 if (!ptr_is_owned(_res)) return;
23423 void* _res_ptr = untag_ptr(_res);
23424 CHECK_ACCESS(_res_ptr);
23425 LDKCResult_TxRemoveInputDecodeErrorZ _res_conv = *(LDKCResult_TxRemoveInputDecodeErrorZ*)(_res_ptr);
23426 FREE(untag_ptr(_res));
23427 CResult_TxRemoveInputDecodeErrorZ_free(_res_conv);
23430 static inline uint64_t CResult_TxRemoveInputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveInputDecodeErrorZ *NONNULL_PTR arg) {
23431 LDKCResult_TxRemoveInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveInputDecodeErrorZ), "LDKCResult_TxRemoveInputDecodeErrorZ");
23432 *ret_conv = CResult_TxRemoveInputDecodeErrorZ_clone(arg);
23433 return tag_ptr(ret_conv, true);
23435 int64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr"))) TS_CResult_TxRemoveInputDecodeErrorZ_clone_ptr(uint64_t arg) {
23436 LDKCResult_TxRemoveInputDecodeErrorZ* arg_conv = (LDKCResult_TxRemoveInputDecodeErrorZ*)untag_ptr(arg);
23437 int64_t ret_conv = CResult_TxRemoveInputDecodeErrorZ_clone_ptr(arg_conv);
23441 uint64_t __attribute__((export_name("TS_CResult_TxRemoveInputDecodeErrorZ_clone"))) TS_CResult_TxRemoveInputDecodeErrorZ_clone(uint64_t orig) {
23442 LDKCResult_TxRemoveInputDecodeErrorZ* orig_conv = (LDKCResult_TxRemoveInputDecodeErrorZ*)untag_ptr(orig);
23443 LDKCResult_TxRemoveInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveInputDecodeErrorZ), "LDKCResult_TxRemoveInputDecodeErrorZ");
23444 *ret_conv = CResult_TxRemoveInputDecodeErrorZ_clone(orig_conv);
23445 return tag_ptr(ret_conv, true);
23448 uint64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_ok"))) TS_CResult_TxRemoveOutputDecodeErrorZ_ok(uint64_t o) {
23449 LDKTxRemoveOutput o_conv;
23450 o_conv.inner = untag_ptr(o);
23451 o_conv.is_owned = ptr_is_owned(o);
23452 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23453 o_conv = TxRemoveOutput_clone(&o_conv);
23454 LDKCResult_TxRemoveOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ), "LDKCResult_TxRemoveOutputDecodeErrorZ");
23455 *ret_conv = CResult_TxRemoveOutputDecodeErrorZ_ok(o_conv);
23456 return tag_ptr(ret_conv, true);
23459 uint64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_err"))) TS_CResult_TxRemoveOutputDecodeErrorZ_err(uint64_t e) {
23460 void* e_ptr = untag_ptr(e);
23461 CHECK_ACCESS(e_ptr);
23462 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23463 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23464 LDKCResult_TxRemoveOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ), "LDKCResult_TxRemoveOutputDecodeErrorZ");
23465 *ret_conv = CResult_TxRemoveOutputDecodeErrorZ_err(e_conv);
23466 return tag_ptr(ret_conv, true);
23469 jboolean __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok"))) TS_CResult_TxRemoveOutputDecodeErrorZ_is_ok(uint64_t o) {
23470 LDKCResult_TxRemoveOutputDecodeErrorZ* o_conv = (LDKCResult_TxRemoveOutputDecodeErrorZ*)untag_ptr(o);
23471 jboolean ret_conv = CResult_TxRemoveOutputDecodeErrorZ_is_ok(o_conv);
23475 void __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_free"))) TS_CResult_TxRemoveOutputDecodeErrorZ_free(uint64_t _res) {
23476 if (!ptr_is_owned(_res)) return;
23477 void* _res_ptr = untag_ptr(_res);
23478 CHECK_ACCESS(_res_ptr);
23479 LDKCResult_TxRemoveOutputDecodeErrorZ _res_conv = *(LDKCResult_TxRemoveOutputDecodeErrorZ*)(_res_ptr);
23480 FREE(untag_ptr(_res));
23481 CResult_TxRemoveOutputDecodeErrorZ_free(_res_conv);
23484 static inline uint64_t CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(LDKCResult_TxRemoveOutputDecodeErrorZ *NONNULL_PTR arg) {
23485 LDKCResult_TxRemoveOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ), "LDKCResult_TxRemoveOutputDecodeErrorZ");
23486 *ret_conv = CResult_TxRemoveOutputDecodeErrorZ_clone(arg);
23487 return tag_ptr(ret_conv, true);
23489 int64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr"))) TS_CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(uint64_t arg) {
23490 LDKCResult_TxRemoveOutputDecodeErrorZ* arg_conv = (LDKCResult_TxRemoveOutputDecodeErrorZ*)untag_ptr(arg);
23491 int64_t ret_conv = CResult_TxRemoveOutputDecodeErrorZ_clone_ptr(arg_conv);
23495 uint64_t __attribute__((export_name("TS_CResult_TxRemoveOutputDecodeErrorZ_clone"))) TS_CResult_TxRemoveOutputDecodeErrorZ_clone(uint64_t orig) {
23496 LDKCResult_TxRemoveOutputDecodeErrorZ* orig_conv = (LDKCResult_TxRemoveOutputDecodeErrorZ*)untag_ptr(orig);
23497 LDKCResult_TxRemoveOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ), "LDKCResult_TxRemoveOutputDecodeErrorZ");
23498 *ret_conv = CResult_TxRemoveOutputDecodeErrorZ_clone(orig_conv);
23499 return tag_ptr(ret_conv, true);
23502 uint64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_ok"))) TS_CResult_TxCompleteDecodeErrorZ_ok(uint64_t o) {
23503 LDKTxComplete o_conv;
23504 o_conv.inner = untag_ptr(o);
23505 o_conv.is_owned = ptr_is_owned(o);
23506 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23507 o_conv = TxComplete_clone(&o_conv);
23508 LDKCResult_TxCompleteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCompleteDecodeErrorZ), "LDKCResult_TxCompleteDecodeErrorZ");
23509 *ret_conv = CResult_TxCompleteDecodeErrorZ_ok(o_conv);
23510 return tag_ptr(ret_conv, true);
23513 uint64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_err"))) TS_CResult_TxCompleteDecodeErrorZ_err(uint64_t e) {
23514 void* e_ptr = untag_ptr(e);
23515 CHECK_ACCESS(e_ptr);
23516 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23517 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23518 LDKCResult_TxCompleteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCompleteDecodeErrorZ), "LDKCResult_TxCompleteDecodeErrorZ");
23519 *ret_conv = CResult_TxCompleteDecodeErrorZ_err(e_conv);
23520 return tag_ptr(ret_conv, true);
23523 jboolean __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_is_ok"))) TS_CResult_TxCompleteDecodeErrorZ_is_ok(uint64_t o) {
23524 LDKCResult_TxCompleteDecodeErrorZ* o_conv = (LDKCResult_TxCompleteDecodeErrorZ*)untag_ptr(o);
23525 jboolean ret_conv = CResult_TxCompleteDecodeErrorZ_is_ok(o_conv);
23529 void __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_free"))) TS_CResult_TxCompleteDecodeErrorZ_free(uint64_t _res) {
23530 if (!ptr_is_owned(_res)) return;
23531 void* _res_ptr = untag_ptr(_res);
23532 CHECK_ACCESS(_res_ptr);
23533 LDKCResult_TxCompleteDecodeErrorZ _res_conv = *(LDKCResult_TxCompleteDecodeErrorZ*)(_res_ptr);
23534 FREE(untag_ptr(_res));
23535 CResult_TxCompleteDecodeErrorZ_free(_res_conv);
23538 static inline uint64_t CResult_TxCompleteDecodeErrorZ_clone_ptr(LDKCResult_TxCompleteDecodeErrorZ *NONNULL_PTR arg) {
23539 LDKCResult_TxCompleteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCompleteDecodeErrorZ), "LDKCResult_TxCompleteDecodeErrorZ");
23540 *ret_conv = CResult_TxCompleteDecodeErrorZ_clone(arg);
23541 return tag_ptr(ret_conv, true);
23543 int64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_clone_ptr"))) TS_CResult_TxCompleteDecodeErrorZ_clone_ptr(uint64_t arg) {
23544 LDKCResult_TxCompleteDecodeErrorZ* arg_conv = (LDKCResult_TxCompleteDecodeErrorZ*)untag_ptr(arg);
23545 int64_t ret_conv = CResult_TxCompleteDecodeErrorZ_clone_ptr(arg_conv);
23549 uint64_t __attribute__((export_name("TS_CResult_TxCompleteDecodeErrorZ_clone"))) TS_CResult_TxCompleteDecodeErrorZ_clone(uint64_t orig) {
23550 LDKCResult_TxCompleteDecodeErrorZ* orig_conv = (LDKCResult_TxCompleteDecodeErrorZ*)untag_ptr(orig);
23551 LDKCResult_TxCompleteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCompleteDecodeErrorZ), "LDKCResult_TxCompleteDecodeErrorZ");
23552 *ret_conv = CResult_TxCompleteDecodeErrorZ_clone(orig_conv);
23553 return tag_ptr(ret_conv, true);
23556 uint64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_ok"))) TS_CResult_TxSignaturesDecodeErrorZ_ok(uint64_t o) {
23557 LDKTxSignatures o_conv;
23558 o_conv.inner = untag_ptr(o);
23559 o_conv.is_owned = ptr_is_owned(o);
23560 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23561 o_conv = TxSignatures_clone(&o_conv);
23562 LDKCResult_TxSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxSignaturesDecodeErrorZ), "LDKCResult_TxSignaturesDecodeErrorZ");
23563 *ret_conv = CResult_TxSignaturesDecodeErrorZ_ok(o_conv);
23564 return tag_ptr(ret_conv, true);
23567 uint64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_err"))) TS_CResult_TxSignaturesDecodeErrorZ_err(uint64_t e) {
23568 void* e_ptr = untag_ptr(e);
23569 CHECK_ACCESS(e_ptr);
23570 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23571 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23572 LDKCResult_TxSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxSignaturesDecodeErrorZ), "LDKCResult_TxSignaturesDecodeErrorZ");
23573 *ret_conv = CResult_TxSignaturesDecodeErrorZ_err(e_conv);
23574 return tag_ptr(ret_conv, true);
23577 jboolean __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_is_ok"))) TS_CResult_TxSignaturesDecodeErrorZ_is_ok(uint64_t o) {
23578 LDKCResult_TxSignaturesDecodeErrorZ* o_conv = (LDKCResult_TxSignaturesDecodeErrorZ*)untag_ptr(o);
23579 jboolean ret_conv = CResult_TxSignaturesDecodeErrorZ_is_ok(o_conv);
23583 void __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_free"))) TS_CResult_TxSignaturesDecodeErrorZ_free(uint64_t _res) {
23584 if (!ptr_is_owned(_res)) return;
23585 void* _res_ptr = untag_ptr(_res);
23586 CHECK_ACCESS(_res_ptr);
23587 LDKCResult_TxSignaturesDecodeErrorZ _res_conv = *(LDKCResult_TxSignaturesDecodeErrorZ*)(_res_ptr);
23588 FREE(untag_ptr(_res));
23589 CResult_TxSignaturesDecodeErrorZ_free(_res_conv);
23592 static inline uint64_t CResult_TxSignaturesDecodeErrorZ_clone_ptr(LDKCResult_TxSignaturesDecodeErrorZ *NONNULL_PTR arg) {
23593 LDKCResult_TxSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxSignaturesDecodeErrorZ), "LDKCResult_TxSignaturesDecodeErrorZ");
23594 *ret_conv = CResult_TxSignaturesDecodeErrorZ_clone(arg);
23595 return tag_ptr(ret_conv, true);
23597 int64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_TxSignaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
23598 LDKCResult_TxSignaturesDecodeErrorZ* arg_conv = (LDKCResult_TxSignaturesDecodeErrorZ*)untag_ptr(arg);
23599 int64_t ret_conv = CResult_TxSignaturesDecodeErrorZ_clone_ptr(arg_conv);
23603 uint64_t __attribute__((export_name("TS_CResult_TxSignaturesDecodeErrorZ_clone"))) TS_CResult_TxSignaturesDecodeErrorZ_clone(uint64_t orig) {
23604 LDKCResult_TxSignaturesDecodeErrorZ* orig_conv = (LDKCResult_TxSignaturesDecodeErrorZ*)untag_ptr(orig);
23605 LDKCResult_TxSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxSignaturesDecodeErrorZ), "LDKCResult_TxSignaturesDecodeErrorZ");
23606 *ret_conv = CResult_TxSignaturesDecodeErrorZ_clone(orig_conv);
23607 return tag_ptr(ret_conv, true);
23610 uint64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_ok"))) TS_CResult_TxInitRbfDecodeErrorZ_ok(uint64_t o) {
23611 LDKTxInitRbf o_conv;
23612 o_conv.inner = untag_ptr(o);
23613 o_conv.is_owned = ptr_is_owned(o);
23614 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23615 o_conv = TxInitRbf_clone(&o_conv);
23616 LDKCResult_TxInitRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxInitRbfDecodeErrorZ), "LDKCResult_TxInitRbfDecodeErrorZ");
23617 *ret_conv = CResult_TxInitRbfDecodeErrorZ_ok(o_conv);
23618 return tag_ptr(ret_conv, true);
23621 uint64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_err"))) TS_CResult_TxInitRbfDecodeErrorZ_err(uint64_t e) {
23622 void* e_ptr = untag_ptr(e);
23623 CHECK_ACCESS(e_ptr);
23624 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23625 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23626 LDKCResult_TxInitRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxInitRbfDecodeErrorZ), "LDKCResult_TxInitRbfDecodeErrorZ");
23627 *ret_conv = CResult_TxInitRbfDecodeErrorZ_err(e_conv);
23628 return tag_ptr(ret_conv, true);
23631 jboolean __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_is_ok"))) TS_CResult_TxInitRbfDecodeErrorZ_is_ok(uint64_t o) {
23632 LDKCResult_TxInitRbfDecodeErrorZ* o_conv = (LDKCResult_TxInitRbfDecodeErrorZ*)untag_ptr(o);
23633 jboolean ret_conv = CResult_TxInitRbfDecodeErrorZ_is_ok(o_conv);
23637 void __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_free"))) TS_CResult_TxInitRbfDecodeErrorZ_free(uint64_t _res) {
23638 if (!ptr_is_owned(_res)) return;
23639 void* _res_ptr = untag_ptr(_res);
23640 CHECK_ACCESS(_res_ptr);
23641 LDKCResult_TxInitRbfDecodeErrorZ _res_conv = *(LDKCResult_TxInitRbfDecodeErrorZ*)(_res_ptr);
23642 FREE(untag_ptr(_res));
23643 CResult_TxInitRbfDecodeErrorZ_free(_res_conv);
23646 static inline uint64_t CResult_TxInitRbfDecodeErrorZ_clone_ptr(LDKCResult_TxInitRbfDecodeErrorZ *NONNULL_PTR arg) {
23647 LDKCResult_TxInitRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxInitRbfDecodeErrorZ), "LDKCResult_TxInitRbfDecodeErrorZ");
23648 *ret_conv = CResult_TxInitRbfDecodeErrorZ_clone(arg);
23649 return tag_ptr(ret_conv, true);
23651 int64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr"))) TS_CResult_TxInitRbfDecodeErrorZ_clone_ptr(uint64_t arg) {
23652 LDKCResult_TxInitRbfDecodeErrorZ* arg_conv = (LDKCResult_TxInitRbfDecodeErrorZ*)untag_ptr(arg);
23653 int64_t ret_conv = CResult_TxInitRbfDecodeErrorZ_clone_ptr(arg_conv);
23657 uint64_t __attribute__((export_name("TS_CResult_TxInitRbfDecodeErrorZ_clone"))) TS_CResult_TxInitRbfDecodeErrorZ_clone(uint64_t orig) {
23658 LDKCResult_TxInitRbfDecodeErrorZ* orig_conv = (LDKCResult_TxInitRbfDecodeErrorZ*)untag_ptr(orig);
23659 LDKCResult_TxInitRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxInitRbfDecodeErrorZ), "LDKCResult_TxInitRbfDecodeErrorZ");
23660 *ret_conv = CResult_TxInitRbfDecodeErrorZ_clone(orig_conv);
23661 return tag_ptr(ret_conv, true);
23664 uint64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_ok"))) TS_CResult_TxAckRbfDecodeErrorZ_ok(uint64_t o) {
23665 LDKTxAckRbf o_conv;
23666 o_conv.inner = untag_ptr(o);
23667 o_conv.is_owned = ptr_is_owned(o);
23668 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23669 o_conv = TxAckRbf_clone(&o_conv);
23670 LDKCResult_TxAckRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAckRbfDecodeErrorZ), "LDKCResult_TxAckRbfDecodeErrorZ");
23671 *ret_conv = CResult_TxAckRbfDecodeErrorZ_ok(o_conv);
23672 return tag_ptr(ret_conv, true);
23675 uint64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_err"))) TS_CResult_TxAckRbfDecodeErrorZ_err(uint64_t e) {
23676 void* e_ptr = untag_ptr(e);
23677 CHECK_ACCESS(e_ptr);
23678 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23679 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23680 LDKCResult_TxAckRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAckRbfDecodeErrorZ), "LDKCResult_TxAckRbfDecodeErrorZ");
23681 *ret_conv = CResult_TxAckRbfDecodeErrorZ_err(e_conv);
23682 return tag_ptr(ret_conv, true);
23685 jboolean __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_is_ok"))) TS_CResult_TxAckRbfDecodeErrorZ_is_ok(uint64_t o) {
23686 LDKCResult_TxAckRbfDecodeErrorZ* o_conv = (LDKCResult_TxAckRbfDecodeErrorZ*)untag_ptr(o);
23687 jboolean ret_conv = CResult_TxAckRbfDecodeErrorZ_is_ok(o_conv);
23691 void __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_free"))) TS_CResult_TxAckRbfDecodeErrorZ_free(uint64_t _res) {
23692 if (!ptr_is_owned(_res)) return;
23693 void* _res_ptr = untag_ptr(_res);
23694 CHECK_ACCESS(_res_ptr);
23695 LDKCResult_TxAckRbfDecodeErrorZ _res_conv = *(LDKCResult_TxAckRbfDecodeErrorZ*)(_res_ptr);
23696 FREE(untag_ptr(_res));
23697 CResult_TxAckRbfDecodeErrorZ_free(_res_conv);
23700 static inline uint64_t CResult_TxAckRbfDecodeErrorZ_clone_ptr(LDKCResult_TxAckRbfDecodeErrorZ *NONNULL_PTR arg) {
23701 LDKCResult_TxAckRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAckRbfDecodeErrorZ), "LDKCResult_TxAckRbfDecodeErrorZ");
23702 *ret_conv = CResult_TxAckRbfDecodeErrorZ_clone(arg);
23703 return tag_ptr(ret_conv, true);
23705 int64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr"))) TS_CResult_TxAckRbfDecodeErrorZ_clone_ptr(uint64_t arg) {
23706 LDKCResult_TxAckRbfDecodeErrorZ* arg_conv = (LDKCResult_TxAckRbfDecodeErrorZ*)untag_ptr(arg);
23707 int64_t ret_conv = CResult_TxAckRbfDecodeErrorZ_clone_ptr(arg_conv);
23711 uint64_t __attribute__((export_name("TS_CResult_TxAckRbfDecodeErrorZ_clone"))) TS_CResult_TxAckRbfDecodeErrorZ_clone(uint64_t orig) {
23712 LDKCResult_TxAckRbfDecodeErrorZ* orig_conv = (LDKCResult_TxAckRbfDecodeErrorZ*)untag_ptr(orig);
23713 LDKCResult_TxAckRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAckRbfDecodeErrorZ), "LDKCResult_TxAckRbfDecodeErrorZ");
23714 *ret_conv = CResult_TxAckRbfDecodeErrorZ_clone(orig_conv);
23715 return tag_ptr(ret_conv, true);
23718 uint64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_ok"))) TS_CResult_TxAbortDecodeErrorZ_ok(uint64_t o) {
23720 o_conv.inner = untag_ptr(o);
23721 o_conv.is_owned = ptr_is_owned(o);
23722 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23723 o_conv = TxAbort_clone(&o_conv);
23724 LDKCResult_TxAbortDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAbortDecodeErrorZ), "LDKCResult_TxAbortDecodeErrorZ");
23725 *ret_conv = CResult_TxAbortDecodeErrorZ_ok(o_conv);
23726 return tag_ptr(ret_conv, true);
23729 uint64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_err"))) TS_CResult_TxAbortDecodeErrorZ_err(uint64_t e) {
23730 void* e_ptr = untag_ptr(e);
23731 CHECK_ACCESS(e_ptr);
23732 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23733 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23734 LDKCResult_TxAbortDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAbortDecodeErrorZ), "LDKCResult_TxAbortDecodeErrorZ");
23735 *ret_conv = CResult_TxAbortDecodeErrorZ_err(e_conv);
23736 return tag_ptr(ret_conv, true);
23739 jboolean __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_is_ok"))) TS_CResult_TxAbortDecodeErrorZ_is_ok(uint64_t o) {
23740 LDKCResult_TxAbortDecodeErrorZ* o_conv = (LDKCResult_TxAbortDecodeErrorZ*)untag_ptr(o);
23741 jboolean ret_conv = CResult_TxAbortDecodeErrorZ_is_ok(o_conv);
23745 void __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_free"))) TS_CResult_TxAbortDecodeErrorZ_free(uint64_t _res) {
23746 if (!ptr_is_owned(_res)) return;
23747 void* _res_ptr = untag_ptr(_res);
23748 CHECK_ACCESS(_res_ptr);
23749 LDKCResult_TxAbortDecodeErrorZ _res_conv = *(LDKCResult_TxAbortDecodeErrorZ*)(_res_ptr);
23750 FREE(untag_ptr(_res));
23751 CResult_TxAbortDecodeErrorZ_free(_res_conv);
23754 static inline uint64_t CResult_TxAbortDecodeErrorZ_clone_ptr(LDKCResult_TxAbortDecodeErrorZ *NONNULL_PTR arg) {
23755 LDKCResult_TxAbortDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAbortDecodeErrorZ), "LDKCResult_TxAbortDecodeErrorZ");
23756 *ret_conv = CResult_TxAbortDecodeErrorZ_clone(arg);
23757 return tag_ptr(ret_conv, true);
23759 int64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_clone_ptr"))) TS_CResult_TxAbortDecodeErrorZ_clone_ptr(uint64_t arg) {
23760 LDKCResult_TxAbortDecodeErrorZ* arg_conv = (LDKCResult_TxAbortDecodeErrorZ*)untag_ptr(arg);
23761 int64_t ret_conv = CResult_TxAbortDecodeErrorZ_clone_ptr(arg_conv);
23765 uint64_t __attribute__((export_name("TS_CResult_TxAbortDecodeErrorZ_clone"))) TS_CResult_TxAbortDecodeErrorZ_clone(uint64_t orig) {
23766 LDKCResult_TxAbortDecodeErrorZ* orig_conv = (LDKCResult_TxAbortDecodeErrorZ*)untag_ptr(orig);
23767 LDKCResult_TxAbortDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAbortDecodeErrorZ), "LDKCResult_TxAbortDecodeErrorZ");
23768 *ret_conv = CResult_TxAbortDecodeErrorZ_clone(orig_conv);
23769 return tag_ptr(ret_conv, true);
23772 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint64_t o) {
23773 LDKAnnouncementSignatures o_conv;
23774 o_conv.inner = untag_ptr(o);
23775 o_conv.is_owned = ptr_is_owned(o);
23776 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23777 o_conv = AnnouncementSignatures_clone(&o_conv);
23778 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
23779 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
23780 return tag_ptr(ret_conv, true);
23783 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint64_t e) {
23784 void* e_ptr = untag_ptr(e);
23785 CHECK_ACCESS(e_ptr);
23786 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23787 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23788 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
23789 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
23790 return tag_ptr(ret_conv, true);
23793 jboolean __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint64_t o) {
23794 LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(o);
23795 jboolean ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
23799 void __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_free"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint64_t _res) {
23800 if (!ptr_is_owned(_res)) return;
23801 void* _res_ptr = untag_ptr(_res);
23802 CHECK_ACCESS(_res_ptr);
23803 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
23804 FREE(untag_ptr(_res));
23805 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
23808 static inline uint64_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
23809 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
23810 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
23811 return tag_ptr(ret_conv, true);
23813 int64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint64_t arg) {
23814 LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(arg);
23815 int64_t ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
23819 uint64_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint64_t orig) {
23820 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)untag_ptr(orig);
23821 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
23822 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
23823 return tag_ptr(ret_conv, true);
23826 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint64_t o) {
23827 LDKChannelReestablish o_conv;
23828 o_conv.inner = untag_ptr(o);
23829 o_conv.is_owned = ptr_is_owned(o);
23830 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23831 o_conv = ChannelReestablish_clone(&o_conv);
23832 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
23833 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
23834 return tag_ptr(ret_conv, true);
23837 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint64_t e) {
23838 void* e_ptr = untag_ptr(e);
23839 CHECK_ACCESS(e_ptr);
23840 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23841 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23842 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
23843 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
23844 return tag_ptr(ret_conv, true);
23847 jboolean __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_is_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint64_t o) {
23848 LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(o);
23849 jboolean ret_conv = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
23853 void __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_free"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint64_t _res) {
23854 if (!ptr_is_owned(_res)) return;
23855 void* _res_ptr = untag_ptr(_res);
23856 CHECK_ACCESS(_res_ptr);
23857 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
23858 FREE(untag_ptr(_res));
23859 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
23862 static inline uint64_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
23863 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
23864 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
23865 return tag_ptr(ret_conv, true);
23867 int64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint64_t arg) {
23868 LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(arg);
23869 int64_t ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
23873 uint64_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint64_t orig) {
23874 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)untag_ptr(orig);
23875 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
23876 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
23877 return tag_ptr(ret_conv, true);
23880 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint64_t o) {
23881 LDKClosingSigned o_conv;
23882 o_conv.inner = untag_ptr(o);
23883 o_conv.is_owned = ptr_is_owned(o);
23884 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23885 o_conv = ClosingSigned_clone(&o_conv);
23886 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
23887 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
23888 return tag_ptr(ret_conv, true);
23891 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_err"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint64_t e) {
23892 void* e_ptr = untag_ptr(e);
23893 CHECK_ACCESS(e_ptr);
23894 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23895 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23896 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
23897 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
23898 return tag_ptr(ret_conv, true);
23901 jboolean __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint64_t o) {
23902 LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(o);
23903 jboolean ret_conv = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
23907 void __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_free"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint64_t _res) {
23908 if (!ptr_is_owned(_res)) return;
23909 void* _res_ptr = untag_ptr(_res);
23910 CHECK_ACCESS(_res_ptr);
23911 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
23912 FREE(untag_ptr(_res));
23913 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
23916 static inline uint64_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
23917 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
23918 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
23919 return tag_ptr(ret_conv, true);
23921 int64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
23922 LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(arg);
23923 int64_t ret_conv = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
23927 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint64_t orig) {
23928 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)untag_ptr(orig);
23929 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
23930 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
23931 return tag_ptr(ret_conv, true);
23934 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint64_t o) {
23935 LDKClosingSignedFeeRange o_conv;
23936 o_conv.inner = untag_ptr(o);
23937 o_conv.is_owned = ptr_is_owned(o);
23938 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23939 o_conv = ClosingSignedFeeRange_clone(&o_conv);
23940 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
23941 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
23942 return tag_ptr(ret_conv, true);
23945 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint64_t e) {
23946 void* e_ptr = untag_ptr(e);
23947 CHECK_ACCESS(e_ptr);
23948 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
23949 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
23950 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
23951 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
23952 return tag_ptr(ret_conv, true);
23955 jboolean __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint64_t o) {
23956 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(o);
23957 jboolean ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
23961 void __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint64_t _res) {
23962 if (!ptr_is_owned(_res)) return;
23963 void* _res_ptr = untag_ptr(_res);
23964 CHECK_ACCESS(_res_ptr);
23965 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
23966 FREE(untag_ptr(_res));
23967 CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
23970 static inline uint64_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
23971 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
23972 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
23973 return tag_ptr(ret_conv, true);
23975 int64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
23976 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(arg);
23977 int64_t ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
23981 uint64_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint64_t orig) {
23982 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)untag_ptr(orig);
23983 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
23984 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
23985 return tag_ptr(ret_conv, true);
23988 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint64_t o) {
23989 LDKCommitmentSigned o_conv;
23990 o_conv.inner = untag_ptr(o);
23991 o_conv.is_owned = ptr_is_owned(o);
23992 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23993 o_conv = CommitmentSigned_clone(&o_conv);
23994 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
23995 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
23996 return tag_ptr(ret_conv, true);
23999 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint64_t e) {
24000 void* e_ptr = untag_ptr(e);
24001 CHECK_ACCESS(e_ptr);
24002 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24003 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24004 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
24005 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
24006 return tag_ptr(ret_conv, true);
24009 jboolean __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_is_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint64_t o) {
24010 LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(o);
24011 jboolean ret_conv = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
24015 void __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_free"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint64_t _res) {
24016 if (!ptr_is_owned(_res)) return;
24017 void* _res_ptr = untag_ptr(_res);
24018 CHECK_ACCESS(_res_ptr);
24019 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
24020 FREE(untag_ptr(_res));
24021 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
24024 static inline uint64_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
24025 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
24026 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
24027 return tag_ptr(ret_conv, true);
24029 int64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
24030 LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(arg);
24031 int64_t ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
24035 uint64_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint64_t orig) {
24036 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)untag_ptr(orig);
24037 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
24038 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
24039 return tag_ptr(ret_conv, true);
24042 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint64_t o) {
24043 LDKFundingCreated o_conv;
24044 o_conv.inner = untag_ptr(o);
24045 o_conv.is_owned = ptr_is_owned(o);
24046 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24047 o_conv = FundingCreated_clone(&o_conv);
24048 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
24049 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
24050 return tag_ptr(ret_conv, true);
24053 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_err"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint64_t e) {
24054 void* e_ptr = untag_ptr(e);
24055 CHECK_ACCESS(e_ptr);
24056 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24057 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24058 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
24059 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
24060 return tag_ptr(ret_conv, true);
24063 jboolean __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_is_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint64_t o) {
24064 LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(o);
24065 jboolean ret_conv = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
24069 void __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_free"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint64_t _res) {
24070 if (!ptr_is_owned(_res)) return;
24071 void* _res_ptr = untag_ptr(_res);
24072 CHECK_ACCESS(_res_ptr);
24073 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
24074 FREE(untag_ptr(_res));
24075 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
24078 static inline uint64_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
24079 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
24080 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
24081 return tag_ptr(ret_conv, true);
24083 int64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint64_t arg) {
24084 LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(arg);
24085 int64_t ret_conv = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
24089 uint64_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint64_t orig) {
24090 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)untag_ptr(orig);
24091 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
24092 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
24093 return tag_ptr(ret_conv, true);
24096 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_ok"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint64_t o) {
24097 LDKFundingSigned o_conv;
24098 o_conv.inner = untag_ptr(o);
24099 o_conv.is_owned = ptr_is_owned(o);
24100 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24101 o_conv = FundingSigned_clone(&o_conv);
24102 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
24103 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
24104 return tag_ptr(ret_conv, true);
24107 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_err"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint64_t e) {
24108 void* e_ptr = untag_ptr(e);
24109 CHECK_ACCESS(e_ptr);
24110 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24111 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24112 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
24113 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
24114 return tag_ptr(ret_conv, true);
24117 jboolean __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_is_ok"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint64_t o) {
24118 LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(o);
24119 jboolean ret_conv = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
24123 void __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_free"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint64_t _res) {
24124 if (!ptr_is_owned(_res)) return;
24125 void* _res_ptr = untag_ptr(_res);
24126 CHECK_ACCESS(_res_ptr);
24127 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
24128 FREE(untag_ptr(_res));
24129 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
24132 static inline uint64_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
24133 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
24134 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
24135 return tag_ptr(ret_conv, true);
24137 int64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint64_t arg) {
24138 LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(arg);
24139 int64_t ret_conv = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
24143 uint64_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint64_t orig) {
24144 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)untag_ptr(orig);
24145 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
24146 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
24147 return tag_ptr(ret_conv, true);
24150 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_ok(uint64_t o) {
24151 LDKChannelReady o_conv;
24152 o_conv.inner = untag_ptr(o);
24153 o_conv.is_owned = ptr_is_owned(o);
24154 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24155 o_conv = ChannelReady_clone(&o_conv);
24156 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
24157 *ret_conv = CResult_ChannelReadyDecodeErrorZ_ok(o_conv);
24158 return tag_ptr(ret_conv, true);
24161 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_err"))) TS_CResult_ChannelReadyDecodeErrorZ_err(uint64_t e) {
24162 void* e_ptr = untag_ptr(e);
24163 CHECK_ACCESS(e_ptr);
24164 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24165 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24166 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
24167 *ret_conv = CResult_ChannelReadyDecodeErrorZ_err(e_conv);
24168 return tag_ptr(ret_conv, true);
24171 jboolean __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_is_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_is_ok(uint64_t o) {
24172 LDKCResult_ChannelReadyDecodeErrorZ* o_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(o);
24173 jboolean ret_conv = CResult_ChannelReadyDecodeErrorZ_is_ok(o_conv);
24177 void __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_free"))) TS_CResult_ChannelReadyDecodeErrorZ_free(uint64_t _res) {
24178 if (!ptr_is_owned(_res)) return;
24179 void* _res_ptr = untag_ptr(_res);
24180 CHECK_ACCESS(_res_ptr);
24181 LDKCResult_ChannelReadyDecodeErrorZ _res_conv = *(LDKCResult_ChannelReadyDecodeErrorZ*)(_res_ptr);
24182 FREE(untag_ptr(_res));
24183 CResult_ChannelReadyDecodeErrorZ_free(_res_conv);
24186 static inline uint64_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg) {
24187 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
24188 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(arg);
24189 return tag_ptr(ret_conv, true);
24191 int64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(uint64_t arg) {
24192 LDKCResult_ChannelReadyDecodeErrorZ* arg_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(arg);
24193 int64_t ret_conv = CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg_conv);
24197 uint64_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone"))) TS_CResult_ChannelReadyDecodeErrorZ_clone(uint64_t orig) {
24198 LDKCResult_ChannelReadyDecodeErrorZ* orig_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)untag_ptr(orig);
24199 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
24200 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(orig_conv);
24201 return tag_ptr(ret_conv, true);
24204 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_ok"))) TS_CResult_InitDecodeErrorZ_ok(uint64_t o) {
24206 o_conv.inner = untag_ptr(o);
24207 o_conv.is_owned = ptr_is_owned(o);
24208 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24209 o_conv = Init_clone(&o_conv);
24210 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
24211 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
24212 return tag_ptr(ret_conv, true);
24215 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_err"))) TS_CResult_InitDecodeErrorZ_err(uint64_t e) {
24216 void* e_ptr = untag_ptr(e);
24217 CHECK_ACCESS(e_ptr);
24218 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24219 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24220 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
24221 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
24222 return tag_ptr(ret_conv, true);
24225 jboolean __attribute__((export_name("TS_CResult_InitDecodeErrorZ_is_ok"))) TS_CResult_InitDecodeErrorZ_is_ok(uint64_t o) {
24226 LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(o);
24227 jboolean ret_conv = CResult_InitDecodeErrorZ_is_ok(o_conv);
24231 void __attribute__((export_name("TS_CResult_InitDecodeErrorZ_free"))) TS_CResult_InitDecodeErrorZ_free(uint64_t _res) {
24232 if (!ptr_is_owned(_res)) return;
24233 void* _res_ptr = untag_ptr(_res);
24234 CHECK_ACCESS(_res_ptr);
24235 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
24236 FREE(untag_ptr(_res));
24237 CResult_InitDecodeErrorZ_free(_res_conv);
24240 static inline uint64_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
24241 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
24242 *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
24243 return tag_ptr(ret_conv, true);
24245 int64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone_ptr"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint64_t arg) {
24246 LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(arg);
24247 int64_t ret_conv = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
24251 uint64_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone"))) TS_CResult_InitDecodeErrorZ_clone(uint64_t orig) {
24252 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)untag_ptr(orig);
24253 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
24254 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
24255 return tag_ptr(ret_conv, true);
24258 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_ok"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint64_t o) {
24259 LDKOpenChannel o_conv;
24260 o_conv.inner = untag_ptr(o);
24261 o_conv.is_owned = ptr_is_owned(o);
24262 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24263 o_conv = OpenChannel_clone(&o_conv);
24264 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
24265 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
24266 return tag_ptr(ret_conv, true);
24269 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_err"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint64_t e) {
24270 void* e_ptr = untag_ptr(e);
24271 CHECK_ACCESS(e_ptr);
24272 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24273 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24274 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
24275 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
24276 return tag_ptr(ret_conv, true);
24279 jboolean __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_is_ok"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint64_t o) {
24280 LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(o);
24281 jboolean ret_conv = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
24285 void __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_free"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint64_t _res) {
24286 if (!ptr_is_owned(_res)) return;
24287 void* _res_ptr = untag_ptr(_res);
24288 CHECK_ACCESS(_res_ptr);
24289 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
24290 FREE(untag_ptr(_res));
24291 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
24294 static inline uint64_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
24295 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
24296 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
24297 return tag_ptr(ret_conv, true);
24299 int64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint64_t arg) {
24300 LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(arg);
24301 int64_t ret_conv = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
24305 uint64_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint64_t orig) {
24306 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)untag_ptr(orig);
24307 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
24308 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
24309 return tag_ptr(ret_conv, true);
24312 uint64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_ok"))) TS_CResult_OpenChannelV2DecodeErrorZ_ok(uint64_t o) {
24313 LDKOpenChannelV2 o_conv;
24314 o_conv.inner = untag_ptr(o);
24315 o_conv.is_owned = ptr_is_owned(o);
24316 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24317 o_conv = OpenChannelV2_clone(&o_conv);
24318 LDKCResult_OpenChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelV2DecodeErrorZ), "LDKCResult_OpenChannelV2DecodeErrorZ");
24319 *ret_conv = CResult_OpenChannelV2DecodeErrorZ_ok(o_conv);
24320 return tag_ptr(ret_conv, true);
24323 uint64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_err"))) TS_CResult_OpenChannelV2DecodeErrorZ_err(uint64_t e) {
24324 void* e_ptr = untag_ptr(e);
24325 CHECK_ACCESS(e_ptr);
24326 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24327 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24328 LDKCResult_OpenChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelV2DecodeErrorZ), "LDKCResult_OpenChannelV2DecodeErrorZ");
24329 *ret_conv = CResult_OpenChannelV2DecodeErrorZ_err(e_conv);
24330 return tag_ptr(ret_conv, true);
24333 jboolean __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_is_ok"))) TS_CResult_OpenChannelV2DecodeErrorZ_is_ok(uint64_t o) {
24334 LDKCResult_OpenChannelV2DecodeErrorZ* o_conv = (LDKCResult_OpenChannelV2DecodeErrorZ*)untag_ptr(o);
24335 jboolean ret_conv = CResult_OpenChannelV2DecodeErrorZ_is_ok(o_conv);
24339 void __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_free"))) TS_CResult_OpenChannelV2DecodeErrorZ_free(uint64_t _res) {
24340 if (!ptr_is_owned(_res)) return;
24341 void* _res_ptr = untag_ptr(_res);
24342 CHECK_ACCESS(_res_ptr);
24343 LDKCResult_OpenChannelV2DecodeErrorZ _res_conv = *(LDKCResult_OpenChannelV2DecodeErrorZ*)(_res_ptr);
24344 FREE(untag_ptr(_res));
24345 CResult_OpenChannelV2DecodeErrorZ_free(_res_conv);
24348 static inline uint64_t CResult_OpenChannelV2DecodeErrorZ_clone_ptr(LDKCResult_OpenChannelV2DecodeErrorZ *NONNULL_PTR arg) {
24349 LDKCResult_OpenChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelV2DecodeErrorZ), "LDKCResult_OpenChannelV2DecodeErrorZ");
24350 *ret_conv = CResult_OpenChannelV2DecodeErrorZ_clone(arg);
24351 return tag_ptr(ret_conv, true);
24353 int64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelV2DecodeErrorZ_clone_ptr(uint64_t arg) {
24354 LDKCResult_OpenChannelV2DecodeErrorZ* arg_conv = (LDKCResult_OpenChannelV2DecodeErrorZ*)untag_ptr(arg);
24355 int64_t ret_conv = CResult_OpenChannelV2DecodeErrorZ_clone_ptr(arg_conv);
24359 uint64_t __attribute__((export_name("TS_CResult_OpenChannelV2DecodeErrorZ_clone"))) TS_CResult_OpenChannelV2DecodeErrorZ_clone(uint64_t orig) {
24360 LDKCResult_OpenChannelV2DecodeErrorZ* orig_conv = (LDKCResult_OpenChannelV2DecodeErrorZ*)untag_ptr(orig);
24361 LDKCResult_OpenChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelV2DecodeErrorZ), "LDKCResult_OpenChannelV2DecodeErrorZ");
24362 *ret_conv = CResult_OpenChannelV2DecodeErrorZ_clone(orig_conv);
24363 return tag_ptr(ret_conv, true);
24366 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint64_t o) {
24367 LDKRevokeAndACK o_conv;
24368 o_conv.inner = untag_ptr(o);
24369 o_conv.is_owned = ptr_is_owned(o);
24370 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24371 o_conv = RevokeAndACK_clone(&o_conv);
24372 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
24373 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
24374 return tag_ptr(ret_conv, true);
24377 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint64_t e) {
24378 void* e_ptr = untag_ptr(e);
24379 CHECK_ACCESS(e_ptr);
24380 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24381 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24382 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
24383 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
24384 return tag_ptr(ret_conv, true);
24387 jboolean __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_is_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint64_t o) {
24388 LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(o);
24389 jboolean ret_conv = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
24393 void __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_free"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint64_t _res) {
24394 if (!ptr_is_owned(_res)) return;
24395 void* _res_ptr = untag_ptr(_res);
24396 CHECK_ACCESS(_res_ptr);
24397 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
24398 FREE(untag_ptr(_res));
24399 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
24402 static inline uint64_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
24403 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
24404 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
24405 return tag_ptr(ret_conv, true);
24407 int64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint64_t arg) {
24408 LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(arg);
24409 int64_t ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
24413 uint64_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint64_t orig) {
24414 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)untag_ptr(orig);
24415 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
24416 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
24417 return tag_ptr(ret_conv, true);
24420 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_ok"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint64_t o) {
24421 LDKShutdown o_conv;
24422 o_conv.inner = untag_ptr(o);
24423 o_conv.is_owned = ptr_is_owned(o);
24424 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24425 o_conv = Shutdown_clone(&o_conv);
24426 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
24427 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
24428 return tag_ptr(ret_conv, true);
24431 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_err"))) TS_CResult_ShutdownDecodeErrorZ_err(uint64_t e) {
24432 void* e_ptr = untag_ptr(e);
24433 CHECK_ACCESS(e_ptr);
24434 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24435 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24436 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
24437 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
24438 return tag_ptr(ret_conv, true);
24441 jboolean __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_is_ok"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint64_t o) {
24442 LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(o);
24443 jboolean ret_conv = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
24447 void __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_free"))) TS_CResult_ShutdownDecodeErrorZ_free(uint64_t _res) {
24448 if (!ptr_is_owned(_res)) return;
24449 void* _res_ptr = untag_ptr(_res);
24450 CHECK_ACCESS(_res_ptr);
24451 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
24452 FREE(untag_ptr(_res));
24453 CResult_ShutdownDecodeErrorZ_free(_res_conv);
24456 static inline uint64_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
24457 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
24458 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
24459 return tag_ptr(ret_conv, true);
24461 int64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint64_t arg) {
24462 LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(arg);
24463 int64_t ret_conv = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
24467 uint64_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint64_t orig) {
24468 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)untag_ptr(orig);
24469 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
24470 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
24471 return tag_ptr(ret_conv, true);
24474 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint64_t o) {
24475 LDKUpdateFailHTLC o_conv;
24476 o_conv.inner = untag_ptr(o);
24477 o_conv.is_owned = ptr_is_owned(o);
24478 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24479 o_conv = UpdateFailHTLC_clone(&o_conv);
24480 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
24481 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
24482 return tag_ptr(ret_conv, true);
24485 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint64_t e) {
24486 void* e_ptr = untag_ptr(e);
24487 CHECK_ACCESS(e_ptr);
24488 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24489 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24490 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
24491 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
24492 return tag_ptr(ret_conv, true);
24495 jboolean __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint64_t o) {
24496 LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(o);
24497 jboolean ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
24501 void __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint64_t _res) {
24502 if (!ptr_is_owned(_res)) return;
24503 void* _res_ptr = untag_ptr(_res);
24504 CHECK_ACCESS(_res_ptr);
24505 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
24506 FREE(untag_ptr(_res));
24507 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
24510 static inline uint64_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
24511 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
24512 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
24513 return tag_ptr(ret_conv, true);
24515 int64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
24516 LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(arg);
24517 int64_t ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
24521 uint64_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint64_t orig) {
24522 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)untag_ptr(orig);
24523 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
24524 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
24525 return tag_ptr(ret_conv, true);
24528 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint64_t o) {
24529 LDKUpdateFailMalformedHTLC o_conv;
24530 o_conv.inner = untag_ptr(o);
24531 o_conv.is_owned = ptr_is_owned(o);
24532 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24533 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
24534 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
24535 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
24536 return tag_ptr(ret_conv, true);
24539 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint64_t e) {
24540 void* e_ptr = untag_ptr(e);
24541 CHECK_ACCESS(e_ptr);
24542 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24543 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24544 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
24545 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
24546 return tag_ptr(ret_conv, true);
24549 jboolean __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint64_t o) {
24550 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(o);
24551 jboolean ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
24555 void __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint64_t _res) {
24556 if (!ptr_is_owned(_res)) return;
24557 void* _res_ptr = untag_ptr(_res);
24558 CHECK_ACCESS(_res_ptr);
24559 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
24560 FREE(untag_ptr(_res));
24561 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
24564 static inline uint64_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
24565 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
24566 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
24567 return tag_ptr(ret_conv, true);
24569 int64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
24570 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(arg);
24571 int64_t ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
24575 uint64_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint64_t orig) {
24576 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)untag_ptr(orig);
24577 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
24578 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
24579 return tag_ptr(ret_conv, true);
24582 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint64_t o) {
24583 LDKUpdateFee o_conv;
24584 o_conv.inner = untag_ptr(o);
24585 o_conv.is_owned = ptr_is_owned(o);
24586 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24587 o_conv = UpdateFee_clone(&o_conv);
24588 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
24589 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
24590 return tag_ptr(ret_conv, true);
24593 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_err"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint64_t e) {
24594 void* e_ptr = untag_ptr(e);
24595 CHECK_ACCESS(e_ptr);
24596 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24597 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24598 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
24599 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
24600 return tag_ptr(ret_conv, true);
24603 jboolean __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_is_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint64_t o) {
24604 LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(o);
24605 jboolean ret_conv = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
24609 void __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_free"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint64_t _res) {
24610 if (!ptr_is_owned(_res)) return;
24611 void* _res_ptr = untag_ptr(_res);
24612 CHECK_ACCESS(_res_ptr);
24613 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
24614 FREE(untag_ptr(_res));
24615 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
24618 static inline uint64_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
24619 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
24620 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
24621 return tag_ptr(ret_conv, true);
24623 int64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint64_t arg) {
24624 LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(arg);
24625 int64_t ret_conv = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
24629 uint64_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint64_t orig) {
24630 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)untag_ptr(orig);
24631 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
24632 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
24633 return tag_ptr(ret_conv, true);
24636 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint64_t o) {
24637 LDKUpdateFulfillHTLC o_conv;
24638 o_conv.inner = untag_ptr(o);
24639 o_conv.is_owned = ptr_is_owned(o);
24640 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24641 o_conv = UpdateFulfillHTLC_clone(&o_conv);
24642 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
24643 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
24644 return tag_ptr(ret_conv, true);
24647 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint64_t e) {
24648 void* e_ptr = untag_ptr(e);
24649 CHECK_ACCESS(e_ptr);
24650 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24651 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24652 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
24653 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
24654 return tag_ptr(ret_conv, true);
24657 jboolean __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint64_t o) {
24658 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(o);
24659 jboolean ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
24663 void __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint64_t _res) {
24664 if (!ptr_is_owned(_res)) return;
24665 void* _res_ptr = untag_ptr(_res);
24666 CHECK_ACCESS(_res_ptr);
24667 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
24668 FREE(untag_ptr(_res));
24669 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
24672 static inline uint64_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
24673 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
24674 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
24675 return tag_ptr(ret_conv, true);
24677 int64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
24678 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(arg);
24679 int64_t ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
24683 uint64_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint64_t orig) {
24684 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)untag_ptr(orig);
24685 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
24686 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
24687 return tag_ptr(ret_conv, true);
24690 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint64_t o) {
24691 LDKUpdateAddHTLC o_conv;
24692 o_conv.inner = untag_ptr(o);
24693 o_conv.is_owned = ptr_is_owned(o);
24694 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24695 o_conv = UpdateAddHTLC_clone(&o_conv);
24696 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
24697 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
24698 return tag_ptr(ret_conv, true);
24701 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint64_t e) {
24702 void* e_ptr = untag_ptr(e);
24703 CHECK_ACCESS(e_ptr);
24704 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24705 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24706 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
24707 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
24708 return tag_ptr(ret_conv, true);
24711 jboolean __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint64_t o) {
24712 LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(o);
24713 jboolean ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
24717 void __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_free"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint64_t _res) {
24718 if (!ptr_is_owned(_res)) return;
24719 void* _res_ptr = untag_ptr(_res);
24720 CHECK_ACCESS(_res_ptr);
24721 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
24722 FREE(untag_ptr(_res));
24723 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
24726 static inline uint64_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
24727 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
24728 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
24729 return tag_ptr(ret_conv, true);
24731 int64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
24732 LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(arg);
24733 int64_t ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
24737 uint64_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint64_t orig) {
24738 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)untag_ptr(orig);
24739 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
24740 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
24741 return tag_ptr(ret_conv, true);
24744 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_ok"))) TS_CResult_OnionMessageDecodeErrorZ_ok(uint64_t o) {
24745 LDKOnionMessage o_conv;
24746 o_conv.inner = untag_ptr(o);
24747 o_conv.is_owned = ptr_is_owned(o);
24748 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24749 o_conv = OnionMessage_clone(&o_conv);
24750 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
24751 *ret_conv = CResult_OnionMessageDecodeErrorZ_ok(o_conv);
24752 return tag_ptr(ret_conv, true);
24755 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_err"))) TS_CResult_OnionMessageDecodeErrorZ_err(uint64_t e) {
24756 void* e_ptr = untag_ptr(e);
24757 CHECK_ACCESS(e_ptr);
24758 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24759 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24760 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
24761 *ret_conv = CResult_OnionMessageDecodeErrorZ_err(e_conv);
24762 return tag_ptr(ret_conv, true);
24765 jboolean __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_is_ok"))) TS_CResult_OnionMessageDecodeErrorZ_is_ok(uint64_t o) {
24766 LDKCResult_OnionMessageDecodeErrorZ* o_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(o);
24767 jboolean ret_conv = CResult_OnionMessageDecodeErrorZ_is_ok(o_conv);
24771 void __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_free"))) TS_CResult_OnionMessageDecodeErrorZ_free(uint64_t _res) {
24772 if (!ptr_is_owned(_res)) return;
24773 void* _res_ptr = untag_ptr(_res);
24774 CHECK_ACCESS(_res_ptr);
24775 LDKCResult_OnionMessageDecodeErrorZ _res_conv = *(LDKCResult_OnionMessageDecodeErrorZ*)(_res_ptr);
24776 FREE(untag_ptr(_res));
24777 CResult_OnionMessageDecodeErrorZ_free(_res_conv);
24780 static inline uint64_t CResult_OnionMessageDecodeErrorZ_clone_ptr(LDKCResult_OnionMessageDecodeErrorZ *NONNULL_PTR arg) {
24781 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
24782 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(arg);
24783 return tag_ptr(ret_conv, true);
24785 int64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone_ptr"))) TS_CResult_OnionMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
24786 LDKCResult_OnionMessageDecodeErrorZ* arg_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(arg);
24787 int64_t ret_conv = CResult_OnionMessageDecodeErrorZ_clone_ptr(arg_conv);
24791 uint64_t __attribute__((export_name("TS_CResult_OnionMessageDecodeErrorZ_clone"))) TS_CResult_OnionMessageDecodeErrorZ_clone(uint64_t orig) {
24792 LDKCResult_OnionMessageDecodeErrorZ* orig_conv = (LDKCResult_OnionMessageDecodeErrorZ*)untag_ptr(orig);
24793 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
24794 *ret_conv = CResult_OnionMessageDecodeErrorZ_clone(orig_conv);
24795 return tag_ptr(ret_conv, true);
24798 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_ok"))) TS_CResult_PingDecodeErrorZ_ok(uint64_t o) {
24800 o_conv.inner = untag_ptr(o);
24801 o_conv.is_owned = ptr_is_owned(o);
24802 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24803 o_conv = Ping_clone(&o_conv);
24804 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
24805 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
24806 return tag_ptr(ret_conv, true);
24809 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_err"))) TS_CResult_PingDecodeErrorZ_err(uint64_t e) {
24810 void* e_ptr = untag_ptr(e);
24811 CHECK_ACCESS(e_ptr);
24812 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24813 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24814 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
24815 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
24816 return tag_ptr(ret_conv, true);
24819 jboolean __attribute__((export_name("TS_CResult_PingDecodeErrorZ_is_ok"))) TS_CResult_PingDecodeErrorZ_is_ok(uint64_t o) {
24820 LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(o);
24821 jboolean ret_conv = CResult_PingDecodeErrorZ_is_ok(o_conv);
24825 void __attribute__((export_name("TS_CResult_PingDecodeErrorZ_free"))) TS_CResult_PingDecodeErrorZ_free(uint64_t _res) {
24826 if (!ptr_is_owned(_res)) return;
24827 void* _res_ptr = untag_ptr(_res);
24828 CHECK_ACCESS(_res_ptr);
24829 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
24830 FREE(untag_ptr(_res));
24831 CResult_PingDecodeErrorZ_free(_res_conv);
24834 static inline uint64_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
24835 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
24836 *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
24837 return tag_ptr(ret_conv, true);
24839 int64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone_ptr"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint64_t arg) {
24840 LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(arg);
24841 int64_t ret_conv = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
24845 uint64_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone"))) TS_CResult_PingDecodeErrorZ_clone(uint64_t orig) {
24846 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)untag_ptr(orig);
24847 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
24848 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
24849 return tag_ptr(ret_conv, true);
24852 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_ok"))) TS_CResult_PongDecodeErrorZ_ok(uint64_t o) {
24854 o_conv.inner = untag_ptr(o);
24855 o_conv.is_owned = ptr_is_owned(o);
24856 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24857 o_conv = Pong_clone(&o_conv);
24858 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
24859 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
24860 return tag_ptr(ret_conv, true);
24863 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_err"))) TS_CResult_PongDecodeErrorZ_err(uint64_t e) {
24864 void* e_ptr = untag_ptr(e);
24865 CHECK_ACCESS(e_ptr);
24866 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24867 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24868 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
24869 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
24870 return tag_ptr(ret_conv, true);
24873 jboolean __attribute__((export_name("TS_CResult_PongDecodeErrorZ_is_ok"))) TS_CResult_PongDecodeErrorZ_is_ok(uint64_t o) {
24874 LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(o);
24875 jboolean ret_conv = CResult_PongDecodeErrorZ_is_ok(o_conv);
24879 void __attribute__((export_name("TS_CResult_PongDecodeErrorZ_free"))) TS_CResult_PongDecodeErrorZ_free(uint64_t _res) {
24880 if (!ptr_is_owned(_res)) return;
24881 void* _res_ptr = untag_ptr(_res);
24882 CHECK_ACCESS(_res_ptr);
24883 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
24884 FREE(untag_ptr(_res));
24885 CResult_PongDecodeErrorZ_free(_res_conv);
24888 static inline uint64_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
24889 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
24890 *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
24891 return tag_ptr(ret_conv, true);
24893 int64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone_ptr"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint64_t arg) {
24894 LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(arg);
24895 int64_t ret_conv = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
24899 uint64_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone"))) TS_CResult_PongDecodeErrorZ_clone(uint64_t orig) {
24900 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)untag_ptr(orig);
24901 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
24902 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
24903 return tag_ptr(ret_conv, true);
24906 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
24907 LDKUnsignedChannelAnnouncement o_conv;
24908 o_conv.inner = untag_ptr(o);
24909 o_conv.is_owned = ptr_is_owned(o);
24910 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24911 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
24912 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
24913 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
24914 return tag_ptr(ret_conv, true);
24917 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
24918 void* e_ptr = untag_ptr(e);
24919 CHECK_ACCESS(e_ptr);
24920 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24921 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24922 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
24923 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
24924 return tag_ptr(ret_conv, true);
24927 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
24928 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
24929 jboolean ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
24933 void __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
24934 if (!ptr_is_owned(_res)) return;
24935 void* _res_ptr = untag_ptr(_res);
24936 CHECK_ACCESS(_res_ptr);
24937 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
24938 FREE(untag_ptr(_res));
24939 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
24942 static inline uint64_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
24943 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
24944 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
24945 return tag_ptr(ret_conv, true);
24947 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
24948 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
24949 int64_t ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
24953 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
24954 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
24955 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
24956 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
24957 return tag_ptr(ret_conv, true);
24960 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint64_t o) {
24961 LDKChannelAnnouncement o_conv;
24962 o_conv.inner = untag_ptr(o);
24963 o_conv.is_owned = ptr_is_owned(o);
24964 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24965 o_conv = ChannelAnnouncement_clone(&o_conv);
24966 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
24967 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
24968 return tag_ptr(ret_conv, true);
24971 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint64_t e) {
24972 void* e_ptr = untag_ptr(e);
24973 CHECK_ACCESS(e_ptr);
24974 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
24975 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
24976 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
24977 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
24978 return tag_ptr(ret_conv, true);
24981 jboolean __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
24982 LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(o);
24983 jboolean ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
24987 void __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint64_t _res) {
24988 if (!ptr_is_owned(_res)) return;
24989 void* _res_ptr = untag_ptr(_res);
24990 CHECK_ACCESS(_res_ptr);
24991 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
24992 FREE(untag_ptr(_res));
24993 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
24996 static inline uint64_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
24997 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
24998 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
24999 return tag_ptr(ret_conv, true);
25001 int64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
25002 LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(arg);
25003 int64_t ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
25007 uint64_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint64_t orig) {
25008 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)untag_ptr(orig);
25009 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
25010 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
25011 return tag_ptr(ret_conv, true);
25014 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint64_t o) {
25015 LDKUnsignedChannelUpdate o_conv;
25016 o_conv.inner = untag_ptr(o);
25017 o_conv.is_owned = ptr_is_owned(o);
25018 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25019 o_conv = UnsignedChannelUpdate_clone(&o_conv);
25020 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
25021 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
25022 return tag_ptr(ret_conv, true);
25025 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint64_t e) {
25026 void* e_ptr = untag_ptr(e);
25027 CHECK_ACCESS(e_ptr);
25028 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25029 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25030 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
25031 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
25032 return tag_ptr(ret_conv, true);
25035 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
25036 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(o);
25037 jboolean ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
25041 void __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint64_t _res) {
25042 if (!ptr_is_owned(_res)) return;
25043 void* _res_ptr = untag_ptr(_res);
25044 CHECK_ACCESS(_res_ptr);
25045 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
25046 FREE(untag_ptr(_res));
25047 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
25050 static inline uint64_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
25051 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
25052 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
25053 return tag_ptr(ret_conv, true);
25055 int64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
25056 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(arg);
25057 int64_t ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
25061 uint64_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
25062 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)untag_ptr(orig);
25063 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
25064 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
25065 return tag_ptr(ret_conv, true);
25068 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint64_t o) {
25069 LDKChannelUpdate o_conv;
25070 o_conv.inner = untag_ptr(o);
25071 o_conv.is_owned = ptr_is_owned(o);
25072 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25073 o_conv = ChannelUpdate_clone(&o_conv);
25074 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
25075 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
25076 return tag_ptr(ret_conv, true);
25079 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint64_t e) {
25080 void* e_ptr = untag_ptr(e);
25081 CHECK_ACCESS(e_ptr);
25082 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25083 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25084 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
25085 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
25086 return tag_ptr(ret_conv, true);
25089 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint64_t o) {
25090 LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(o);
25091 jboolean ret_conv = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
25095 void __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_free"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint64_t _res) {
25096 if (!ptr_is_owned(_res)) return;
25097 void* _res_ptr = untag_ptr(_res);
25098 CHECK_ACCESS(_res_ptr);
25099 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
25100 FREE(untag_ptr(_res));
25101 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
25104 static inline uint64_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
25105 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
25106 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
25107 return tag_ptr(ret_conv, true);
25109 int64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint64_t arg) {
25110 LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(arg);
25111 int64_t ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
25115 uint64_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint64_t orig) {
25116 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)untag_ptr(orig);
25117 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
25118 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
25119 return tag_ptr(ret_conv, true);
25122 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint64_t o) {
25123 LDKErrorMessage o_conv;
25124 o_conv.inner = untag_ptr(o);
25125 o_conv.is_owned = ptr_is_owned(o);
25126 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25127 o_conv = ErrorMessage_clone(&o_conv);
25128 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
25129 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
25130 return tag_ptr(ret_conv, true);
25133 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_err"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint64_t e) {
25134 void* e_ptr = untag_ptr(e);
25135 CHECK_ACCESS(e_ptr);
25136 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25137 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25138 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
25139 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
25140 return tag_ptr(ret_conv, true);
25143 jboolean __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_is_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint64_t o) {
25144 LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(o);
25145 jboolean ret_conv = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
25149 void __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_free"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint64_t _res) {
25150 if (!ptr_is_owned(_res)) return;
25151 void* _res_ptr = untag_ptr(_res);
25152 CHECK_ACCESS(_res_ptr);
25153 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
25154 FREE(untag_ptr(_res));
25155 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
25158 static inline uint64_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
25159 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
25160 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
25161 return tag_ptr(ret_conv, true);
25163 int64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
25164 LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(arg);
25165 int64_t ret_conv = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
25169 uint64_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint64_t orig) {
25170 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)untag_ptr(orig);
25171 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
25172 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
25173 return tag_ptr(ret_conv, true);
25176 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_ok"))) TS_CResult_WarningMessageDecodeErrorZ_ok(uint64_t o) {
25177 LDKWarningMessage o_conv;
25178 o_conv.inner = untag_ptr(o);
25179 o_conv.is_owned = ptr_is_owned(o);
25180 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25181 o_conv = WarningMessage_clone(&o_conv);
25182 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
25183 *ret_conv = CResult_WarningMessageDecodeErrorZ_ok(o_conv);
25184 return tag_ptr(ret_conv, true);
25187 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_err"))) TS_CResult_WarningMessageDecodeErrorZ_err(uint64_t e) {
25188 void* e_ptr = untag_ptr(e);
25189 CHECK_ACCESS(e_ptr);
25190 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25191 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25192 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
25193 *ret_conv = CResult_WarningMessageDecodeErrorZ_err(e_conv);
25194 return tag_ptr(ret_conv, true);
25197 jboolean __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_is_ok"))) TS_CResult_WarningMessageDecodeErrorZ_is_ok(uint64_t o) {
25198 LDKCResult_WarningMessageDecodeErrorZ* o_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(o);
25199 jboolean ret_conv = CResult_WarningMessageDecodeErrorZ_is_ok(o_conv);
25203 void __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_free"))) TS_CResult_WarningMessageDecodeErrorZ_free(uint64_t _res) {
25204 if (!ptr_is_owned(_res)) return;
25205 void* _res_ptr = untag_ptr(_res);
25206 CHECK_ACCESS(_res_ptr);
25207 LDKCResult_WarningMessageDecodeErrorZ _res_conv = *(LDKCResult_WarningMessageDecodeErrorZ*)(_res_ptr);
25208 FREE(untag_ptr(_res));
25209 CResult_WarningMessageDecodeErrorZ_free(_res_conv);
25212 static inline uint64_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg) {
25213 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
25214 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(arg);
25215 return tag_ptr(ret_conv, true);
25217 int64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone_ptr"))) TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
25218 LDKCResult_WarningMessageDecodeErrorZ* arg_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(arg);
25219 int64_t ret_conv = CResult_WarningMessageDecodeErrorZ_clone_ptr(arg_conv);
25223 uint64_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone"))) TS_CResult_WarningMessageDecodeErrorZ_clone(uint64_t orig) {
25224 LDKCResult_WarningMessageDecodeErrorZ* orig_conv = (LDKCResult_WarningMessageDecodeErrorZ*)untag_ptr(orig);
25225 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
25226 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(orig_conv);
25227 return tag_ptr(ret_conv, true);
25230 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
25231 LDKUnsignedNodeAnnouncement o_conv;
25232 o_conv.inner = untag_ptr(o);
25233 o_conv.is_owned = ptr_is_owned(o);
25234 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25235 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
25236 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
25237 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
25238 return tag_ptr(ret_conv, true);
25241 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint64_t e) {
25242 void* e_ptr = untag_ptr(e);
25243 CHECK_ACCESS(e_ptr);
25244 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25245 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25246 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
25247 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
25248 return tag_ptr(ret_conv, true);
25251 jboolean __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
25252 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(o);
25253 jboolean ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
25257 void __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
25258 if (!ptr_is_owned(_res)) return;
25259 void* _res_ptr = untag_ptr(_res);
25260 CHECK_ACCESS(_res_ptr);
25261 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
25262 FREE(untag_ptr(_res));
25263 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
25266 static inline uint64_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
25267 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
25268 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
25269 return tag_ptr(ret_conv, true);
25271 int64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
25272 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
25273 int64_t ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
25277 uint64_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
25278 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
25279 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
25280 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
25281 return tag_ptr(ret_conv, true);
25284 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint64_t o) {
25285 LDKNodeAnnouncement o_conv;
25286 o_conv.inner = untag_ptr(o);
25287 o_conv.is_owned = ptr_is_owned(o);
25288 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25289 o_conv = NodeAnnouncement_clone(&o_conv);
25290 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
25291 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
25292 return tag_ptr(ret_conv, true);
25295 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint64_t e) {
25296 void* e_ptr = untag_ptr(e);
25297 CHECK_ACCESS(e_ptr);
25298 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25299 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25300 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
25301 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
25302 return tag_ptr(ret_conv, true);
25305 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint64_t o) {
25306 LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(o);
25307 jboolean ret_conv = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
25311 void __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint64_t _res) {
25312 if (!ptr_is_owned(_res)) return;
25313 void* _res_ptr = untag_ptr(_res);
25314 CHECK_ACCESS(_res_ptr);
25315 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
25316 FREE(untag_ptr(_res));
25317 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
25320 static inline uint64_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
25321 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
25322 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
25323 return tag_ptr(ret_conv, true);
25325 int64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint64_t arg) {
25326 LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(arg);
25327 int64_t ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
25331 uint64_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint64_t orig) {
25332 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)untag_ptr(orig);
25333 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
25334 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
25335 return tag_ptr(ret_conv, true);
25338 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint64_t o) {
25339 LDKQueryShortChannelIds o_conv;
25340 o_conv.inner = untag_ptr(o);
25341 o_conv.is_owned = ptr_is_owned(o);
25342 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25343 o_conv = QueryShortChannelIds_clone(&o_conv);
25344 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
25345 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
25346 return tag_ptr(ret_conv, true);
25349 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint64_t e) {
25350 void* e_ptr = untag_ptr(e);
25351 CHECK_ACCESS(e_ptr);
25352 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25353 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25354 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
25355 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
25356 return tag_ptr(ret_conv, true);
25359 jboolean __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint64_t o) {
25360 LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(o);
25361 jboolean ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
25365 void __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_free"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint64_t _res) {
25366 if (!ptr_is_owned(_res)) return;
25367 void* _res_ptr = untag_ptr(_res);
25368 CHECK_ACCESS(_res_ptr);
25369 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
25370 FREE(untag_ptr(_res));
25371 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
25374 static inline uint64_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
25375 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
25376 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
25377 return tag_ptr(ret_conv, true);
25379 int64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint64_t arg) {
25380 LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(arg);
25381 int64_t ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
25385 uint64_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint64_t orig) {
25386 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)untag_ptr(orig);
25387 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
25388 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
25389 return tag_ptr(ret_conv, true);
25392 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint64_t o) {
25393 LDKReplyShortChannelIdsEnd o_conv;
25394 o_conv.inner = untag_ptr(o);
25395 o_conv.is_owned = ptr_is_owned(o);
25396 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25397 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
25398 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
25399 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
25400 return tag_ptr(ret_conv, true);
25403 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint64_t e) {
25404 void* e_ptr = untag_ptr(e);
25405 CHECK_ACCESS(e_ptr);
25406 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25407 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25408 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
25409 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
25410 return tag_ptr(ret_conv, true);
25413 jboolean __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint64_t o) {
25414 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(o);
25415 jboolean ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
25419 void __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint64_t _res) {
25420 if (!ptr_is_owned(_res)) return;
25421 void* _res_ptr = untag_ptr(_res);
25422 CHECK_ACCESS(_res_ptr);
25423 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
25424 FREE(untag_ptr(_res));
25425 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
25428 static inline uint64_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
25429 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
25430 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
25431 return tag_ptr(ret_conv, true);
25433 int64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint64_t arg) {
25434 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(arg);
25435 int64_t ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
25439 uint64_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint64_t orig) {
25440 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)untag_ptr(orig);
25441 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
25442 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
25443 return tag_ptr(ret_conv, true);
25446 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint64_t o) {
25447 LDKQueryChannelRange o_conv;
25448 o_conv.inner = untag_ptr(o);
25449 o_conv.is_owned = ptr_is_owned(o);
25450 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25451 o_conv = QueryChannelRange_clone(&o_conv);
25452 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
25453 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
25454 return tag_ptr(ret_conv, true);
25457 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint64_t e) {
25458 void* e_ptr = untag_ptr(e);
25459 CHECK_ACCESS(e_ptr);
25460 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25461 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25462 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
25463 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
25464 return tag_ptr(ret_conv, true);
25467 jboolean __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
25468 LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(o);
25469 jboolean ret_conv = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
25473 void __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_free"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint64_t _res) {
25474 if (!ptr_is_owned(_res)) return;
25475 void* _res_ptr = untag_ptr(_res);
25476 CHECK_ACCESS(_res_ptr);
25477 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
25478 FREE(untag_ptr(_res));
25479 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
25482 static inline uint64_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
25483 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
25484 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
25485 return tag_ptr(ret_conv, true);
25487 int64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
25488 LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(arg);
25489 int64_t ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
25493 uint64_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint64_t orig) {
25494 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)untag_ptr(orig);
25495 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
25496 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
25497 return tag_ptr(ret_conv, true);
25500 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint64_t o) {
25501 LDKReplyChannelRange o_conv;
25502 o_conv.inner = untag_ptr(o);
25503 o_conv.is_owned = ptr_is_owned(o);
25504 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25505 o_conv = ReplyChannelRange_clone(&o_conv);
25506 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
25507 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
25508 return tag_ptr(ret_conv, true);
25511 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint64_t e) {
25512 void* e_ptr = untag_ptr(e);
25513 CHECK_ACCESS(e_ptr);
25514 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25515 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25516 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
25517 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
25518 return tag_ptr(ret_conv, true);
25521 jboolean __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint64_t o) {
25522 LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(o);
25523 jboolean ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
25527 void __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_free"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint64_t _res) {
25528 if (!ptr_is_owned(_res)) return;
25529 void* _res_ptr = untag_ptr(_res);
25530 CHECK_ACCESS(_res_ptr);
25531 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
25532 FREE(untag_ptr(_res));
25533 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
25536 static inline uint64_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
25537 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
25538 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
25539 return tag_ptr(ret_conv, true);
25541 int64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint64_t arg) {
25542 LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(arg);
25543 int64_t ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
25547 uint64_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint64_t orig) {
25548 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)untag_ptr(orig);
25549 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
25550 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
25551 return tag_ptr(ret_conv, true);
25554 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint64_t o) {
25555 LDKGossipTimestampFilter o_conv;
25556 o_conv.inner = untag_ptr(o);
25557 o_conv.is_owned = ptr_is_owned(o);
25558 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25559 o_conv = GossipTimestampFilter_clone(&o_conv);
25560 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
25561 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
25562 return tag_ptr(ret_conv, true);
25565 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint64_t e) {
25566 void* e_ptr = untag_ptr(e);
25567 CHECK_ACCESS(e_ptr);
25568 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25569 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25570 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
25571 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
25572 return tag_ptr(ret_conv, true);
25575 jboolean __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint64_t o) {
25576 LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(o);
25577 jboolean ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
25581 void __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_free"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint64_t _res) {
25582 if (!ptr_is_owned(_res)) return;
25583 void* _res_ptr = untag_ptr(_res);
25584 CHECK_ACCESS(_res_ptr);
25585 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
25586 FREE(untag_ptr(_res));
25587 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
25590 static inline uint64_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
25591 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
25592 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
25593 return tag_ptr(ret_conv, true);
25595 int64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint64_t arg) {
25596 LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(arg);
25597 int64_t ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
25601 uint64_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint64_t orig) {
25602 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)untag_ptr(orig);
25603 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
25604 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
25605 return tag_ptr(ret_conv, true);
25608 void __attribute__((export_name("TS_CVec_PhantomRouteHintsZ_free"))) TS_CVec_PhantomRouteHintsZ_free(uint64_tArray _res) {
25609 LDKCVec_PhantomRouteHintsZ _res_constr;
25610 _res_constr.datalen = _res->arr_len;
25611 if (_res_constr.datalen > 0)
25612 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
25614 _res_constr.data = NULL;
25615 uint64_t* _res_vals = _res->elems;
25616 for (size_t t = 0; t < _res_constr.datalen; t++) {
25617 uint64_t _res_conv_19 = _res_vals[t];
25618 LDKPhantomRouteHints _res_conv_19_conv;
25619 _res_conv_19_conv.inner = untag_ptr(_res_conv_19);
25620 _res_conv_19_conv.is_owned = ptr_is_owned(_res_conv_19);
25621 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
25622 _res_constr.data[t] = _res_conv_19_conv;
25625 CVec_PhantomRouteHintsZ_free(_res_constr);
25628 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(uint64_t o) {
25629 LDKBolt11Invoice o_conv;
25630 o_conv.inner = untag_ptr(o);
25631 o_conv.is_owned = ptr_is_owned(o);
25632 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25633 o_conv = Bolt11Invoice_clone(&o_conv);
25634 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
25635 *ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_ok(o_conv);
25636 return tag_ptr(ret_conv, true);
25639 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_err(uint64_t e) {
25640 void* e_ptr = untag_ptr(e);
25641 CHECK_ACCESS(e_ptr);
25642 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
25643 e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)untag_ptr(e));
25644 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
25645 *ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_err(e_conv);
25646 return tag_ptr(ret_conv, true);
25649 jboolean __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(uint64_t o) {
25650 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)untag_ptr(o);
25651 jboolean ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_is_ok(o_conv);
25655 void __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_free(uint64_t _res) {
25656 if (!ptr_is_owned(_res)) return;
25657 void* _res_ptr = untag_ptr(_res);
25658 CHECK_ACCESS(_res_ptr);
25659 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)(_res_ptr);
25660 FREE(untag_ptr(_res));
25661 CResult_Bolt11InvoiceSignOrCreationErrorZ_free(_res_conv);
25664 static inline uint64_t CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
25665 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
25666 *ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(arg);
25667 return tag_ptr(ret_conv, true);
25669 int64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(uint64_t arg) {
25670 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)untag_ptr(arg);
25671 int64_t ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
25675 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone"))) TS_CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(uint64_t orig) {
25676 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_Bolt11InvoiceSignOrCreationErrorZ*)untag_ptr(orig);
25677 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
25678 *ret_conv = CResult_Bolt11InvoiceSignOrCreationErrorZ_clone(orig_conv);
25679 return tag_ptr(ret_conv, true);
25682 uint64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_ok"))) TS_CResult_OffersMessageDecodeErrorZ_ok(uint64_t o) {
25683 void* o_ptr = untag_ptr(o);
25684 CHECK_ACCESS(o_ptr);
25685 LDKOffersMessage o_conv = *(LDKOffersMessage*)(o_ptr);
25686 o_conv = OffersMessage_clone((LDKOffersMessage*)untag_ptr(o));
25687 LDKCResult_OffersMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OffersMessageDecodeErrorZ), "LDKCResult_OffersMessageDecodeErrorZ");
25688 *ret_conv = CResult_OffersMessageDecodeErrorZ_ok(o_conv);
25689 return tag_ptr(ret_conv, true);
25692 uint64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_err"))) TS_CResult_OffersMessageDecodeErrorZ_err(uint64_t e) {
25693 void* e_ptr = untag_ptr(e);
25694 CHECK_ACCESS(e_ptr);
25695 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25696 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25697 LDKCResult_OffersMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OffersMessageDecodeErrorZ), "LDKCResult_OffersMessageDecodeErrorZ");
25698 *ret_conv = CResult_OffersMessageDecodeErrorZ_err(e_conv);
25699 return tag_ptr(ret_conv, true);
25702 jboolean __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_is_ok"))) TS_CResult_OffersMessageDecodeErrorZ_is_ok(uint64_t o) {
25703 LDKCResult_OffersMessageDecodeErrorZ* o_conv = (LDKCResult_OffersMessageDecodeErrorZ*)untag_ptr(o);
25704 jboolean ret_conv = CResult_OffersMessageDecodeErrorZ_is_ok(o_conv);
25708 void __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_free"))) TS_CResult_OffersMessageDecodeErrorZ_free(uint64_t _res) {
25709 if (!ptr_is_owned(_res)) return;
25710 void* _res_ptr = untag_ptr(_res);
25711 CHECK_ACCESS(_res_ptr);
25712 LDKCResult_OffersMessageDecodeErrorZ _res_conv = *(LDKCResult_OffersMessageDecodeErrorZ*)(_res_ptr);
25713 FREE(untag_ptr(_res));
25714 CResult_OffersMessageDecodeErrorZ_free(_res_conv);
25717 static inline uint64_t CResult_OffersMessageDecodeErrorZ_clone_ptr(LDKCResult_OffersMessageDecodeErrorZ *NONNULL_PTR arg) {
25718 LDKCResult_OffersMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OffersMessageDecodeErrorZ), "LDKCResult_OffersMessageDecodeErrorZ");
25719 *ret_conv = CResult_OffersMessageDecodeErrorZ_clone(arg);
25720 return tag_ptr(ret_conv, true);
25722 int64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_clone_ptr"))) TS_CResult_OffersMessageDecodeErrorZ_clone_ptr(uint64_t arg) {
25723 LDKCResult_OffersMessageDecodeErrorZ* arg_conv = (LDKCResult_OffersMessageDecodeErrorZ*)untag_ptr(arg);
25724 int64_t ret_conv = CResult_OffersMessageDecodeErrorZ_clone_ptr(arg_conv);
25728 uint64_t __attribute__((export_name("TS_CResult_OffersMessageDecodeErrorZ_clone"))) TS_CResult_OffersMessageDecodeErrorZ_clone(uint64_t orig) {
25729 LDKCResult_OffersMessageDecodeErrorZ* orig_conv = (LDKCResult_OffersMessageDecodeErrorZ*)untag_ptr(orig);
25730 LDKCResult_OffersMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OffersMessageDecodeErrorZ), "LDKCResult_OffersMessageDecodeErrorZ");
25731 *ret_conv = CResult_OffersMessageDecodeErrorZ_clone(orig_conv);
25732 return tag_ptr(ret_conv, true);
25735 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_some"))) TS_COption_HTLCClaimZ_some(uint32_t o) {
25736 LDKHTLCClaim o_conv = LDKHTLCClaim_from_js(o);
25737 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
25738 *ret_copy = COption_HTLCClaimZ_some(o_conv);
25739 uint64_t ret_ref = tag_ptr(ret_copy, true);
25743 uint64_t __attribute__((export_name("TS_COption_HTLCClaimZ_none"))) TS_COption_HTLCClaimZ_none() {
25744 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
25745 *ret_copy = COption_HTLCClaimZ_none();
25746 uint64_t ret_ref = tag_ptr(ret_copy, true);
25750 void __attribute__((export_name("TS_COption_HTLCClaimZ_free"))) TS_COption_HTLCClaimZ_free(uint64_t _res) {
25751 if (!ptr_is_owned(_res)) return;
25752 void* _res_ptr = untag_ptr(_res);
25753 CHECK_ACCESS(_res_ptr);
25754 LDKCOption_HTLCClaimZ _res_conv = *(LDKCOption_HTLCClaimZ*)(_res_ptr);
25755 FREE(untag_ptr(_res));
25756 COption_HTLCClaimZ_free(_res_conv);
25759 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(uint64_t o) {
25760 LDKCounterpartyCommitmentSecrets o_conv;
25761 o_conv.inner = untag_ptr(o);
25762 o_conv.is_owned = ptr_is_owned(o);
25763 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25764 o_conv = CounterpartyCommitmentSecrets_clone(&o_conv);
25765 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
25766 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o_conv);
25767 return tag_ptr(ret_conv, true);
25770 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(uint64_t e) {
25771 void* e_ptr = untag_ptr(e);
25772 CHECK_ACCESS(e_ptr);
25773 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25774 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25775 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
25776 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e_conv);
25777 return tag_ptr(ret_conv, true);
25780 jboolean __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(uint64_t o) {
25781 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* o_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(o);
25782 jboolean ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o_conv);
25786 void __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(uint64_t _res) {
25787 if (!ptr_is_owned(_res)) return;
25788 void* _res_ptr = untag_ptr(_res);
25789 CHECK_ACCESS(_res_ptr);
25790 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(_res_ptr);
25791 FREE(untag_ptr(_res));
25792 CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res_conv);
25795 static inline uint64_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg) {
25796 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
25797 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(arg);
25798 return tag_ptr(ret_conv, true);
25800 int64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(uint64_t arg) {
25801 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(arg);
25802 int64_t ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg_conv);
25806 uint64_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(uint64_t orig) {
25807 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)untag_ptr(orig);
25808 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
25809 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig_conv);
25810 return tag_ptr(ret_conv, true);
25813 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint64_t o) {
25814 LDKTxCreationKeys o_conv;
25815 o_conv.inner = untag_ptr(o);
25816 o_conv.is_owned = ptr_is_owned(o);
25817 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25818 o_conv = TxCreationKeys_clone(&o_conv);
25819 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
25820 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
25821 return tag_ptr(ret_conv, true);
25824 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint64_t e) {
25825 void* e_ptr = untag_ptr(e);
25826 CHECK_ACCESS(e_ptr);
25827 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25828 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25829 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
25830 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
25831 return tag_ptr(ret_conv, true);
25834 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_is_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint64_t o) {
25835 LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(o);
25836 jboolean ret_conv = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
25840 void __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_free"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint64_t _res) {
25841 if (!ptr_is_owned(_res)) return;
25842 void* _res_ptr = untag_ptr(_res);
25843 CHECK_ACCESS(_res_ptr);
25844 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(_res_ptr);
25845 FREE(untag_ptr(_res));
25846 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
25849 static inline uint64_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
25850 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
25851 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
25852 return tag_ptr(ret_conv, true);
25854 int64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
25855 LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(arg);
25856 int64_t ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
25860 uint64_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint64_t orig) {
25861 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)untag_ptr(orig);
25862 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
25863 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
25864 return tag_ptr(ret_conv, true);
25867 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint64_t o) {
25868 LDKChannelPublicKeys o_conv;
25869 o_conv.inner = untag_ptr(o);
25870 o_conv.is_owned = ptr_is_owned(o);
25871 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25872 o_conv = ChannelPublicKeys_clone(&o_conv);
25873 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
25874 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
25875 return tag_ptr(ret_conv, true);
25878 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint64_t e) {
25879 void* e_ptr = untag_ptr(e);
25880 CHECK_ACCESS(e_ptr);
25881 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25882 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25883 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
25884 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
25885 return tag_ptr(ret_conv, true);
25888 jboolean __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint64_t o) {
25889 LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(o);
25890 jboolean ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
25894 void __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_free"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint64_t _res) {
25895 if (!ptr_is_owned(_res)) return;
25896 void* _res_ptr = untag_ptr(_res);
25897 CHECK_ACCESS(_res_ptr);
25898 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(_res_ptr);
25899 FREE(untag_ptr(_res));
25900 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
25903 static inline uint64_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
25904 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
25905 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
25906 return tag_ptr(ret_conv, true);
25908 int64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint64_t arg) {
25909 LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(arg);
25910 int64_t ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
25914 uint64_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint64_t orig) {
25915 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)untag_ptr(orig);
25916 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
25917 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
25918 return tag_ptr(ret_conv, true);
25921 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint64_t o) {
25922 LDKHTLCOutputInCommitment o_conv;
25923 o_conv.inner = untag_ptr(o);
25924 o_conv.is_owned = ptr_is_owned(o);
25925 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25926 o_conv = HTLCOutputInCommitment_clone(&o_conv);
25927 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
25928 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
25929 return tag_ptr(ret_conv, true);
25932 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint64_t e) {
25933 void* e_ptr = untag_ptr(e);
25934 CHECK_ACCESS(e_ptr);
25935 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25936 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25937 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
25938 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
25939 return tag_ptr(ret_conv, true);
25942 jboolean __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint64_t o) {
25943 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(o);
25944 jboolean ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
25948 void __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint64_t _res) {
25949 if (!ptr_is_owned(_res)) return;
25950 void* _res_ptr = untag_ptr(_res);
25951 CHECK_ACCESS(_res_ptr);
25952 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(_res_ptr);
25953 FREE(untag_ptr(_res));
25954 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
25957 static inline uint64_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
25958 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
25959 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
25960 return tag_ptr(ret_conv, true);
25962 int64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint64_t arg) {
25963 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(arg);
25964 int64_t ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
25968 uint64_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint64_t orig) {
25969 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)untag_ptr(orig);
25970 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
25971 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
25972 return tag_ptr(ret_conv, true);
25975 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
25976 LDKCounterpartyChannelTransactionParameters o_conv;
25977 o_conv.inner = untag_ptr(o);
25978 o_conv.is_owned = ptr_is_owned(o);
25979 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
25980 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
25981 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
25982 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
25983 return tag_ptr(ret_conv, true);
25986 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
25987 void* e_ptr = untag_ptr(e);
25988 CHECK_ACCESS(e_ptr);
25989 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
25990 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
25991 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
25992 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
25993 return tag_ptr(ret_conv, true);
25996 jboolean __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
25997 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
25998 jboolean ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
26002 void __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
26003 if (!ptr_is_owned(_res)) return;
26004 void* _res_ptr = untag_ptr(_res);
26005 CHECK_ACCESS(_res_ptr);
26006 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
26007 FREE(untag_ptr(_res));
26008 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
26011 static inline uint64_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
26012 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
26013 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
26014 return tag_ptr(ret_conv, true);
26016 int64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
26017 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
26018 int64_t ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
26022 uint64_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
26023 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
26024 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
26025 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
26026 return tag_ptr(ret_conv, true);
26029 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint64_t o) {
26030 LDKChannelTransactionParameters o_conv;
26031 o_conv.inner = untag_ptr(o);
26032 o_conv.is_owned = ptr_is_owned(o);
26033 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26034 o_conv = ChannelTransactionParameters_clone(&o_conv);
26035 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
26036 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
26037 return tag_ptr(ret_conv, true);
26040 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint64_t e) {
26041 void* e_ptr = untag_ptr(e);
26042 CHECK_ACCESS(e_ptr);
26043 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26044 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26045 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
26046 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
26047 return tag_ptr(ret_conv, true);
26050 jboolean __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint64_t o) {
26051 LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(o);
26052 jboolean ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
26056 void __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint64_t _res) {
26057 if (!ptr_is_owned(_res)) return;
26058 void* _res_ptr = untag_ptr(_res);
26059 CHECK_ACCESS(_res_ptr);
26060 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
26061 FREE(untag_ptr(_res));
26062 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
26065 static inline uint64_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
26066 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
26067 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
26068 return tag_ptr(ret_conv, true);
26070 int64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint64_t arg) {
26071 LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(arg);
26072 int64_t ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
26076 uint64_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint64_t orig) {
26077 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)untag_ptr(orig);
26078 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
26079 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
26080 return tag_ptr(ret_conv, true);
26083 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
26084 LDKHolderCommitmentTransaction o_conv;
26085 o_conv.inner = untag_ptr(o);
26086 o_conv.is_owned = ptr_is_owned(o);
26087 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26088 o_conv = HolderCommitmentTransaction_clone(&o_conv);
26089 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
26090 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
26091 return tag_ptr(ret_conv, true);
26094 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
26095 void* e_ptr = untag_ptr(e);
26096 CHECK_ACCESS(e_ptr);
26097 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26098 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26099 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
26100 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
26101 return tag_ptr(ret_conv, true);
26104 jboolean __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
26105 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
26106 jboolean ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
26110 void __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
26111 if (!ptr_is_owned(_res)) return;
26112 void* _res_ptr = untag_ptr(_res);
26113 CHECK_ACCESS(_res_ptr);
26114 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(_res_ptr);
26115 FREE(untag_ptr(_res));
26116 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
26119 static inline uint64_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
26120 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
26121 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
26122 return tag_ptr(ret_conv, true);
26124 int64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
26125 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
26126 int64_t ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
26130 uint64_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
26131 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
26132 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
26133 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
26134 return tag_ptr(ret_conv, true);
26137 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
26138 LDKBuiltCommitmentTransaction o_conv;
26139 o_conv.inner = untag_ptr(o);
26140 o_conv.is_owned = ptr_is_owned(o);
26141 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26142 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
26143 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
26144 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
26145 return tag_ptr(ret_conv, true);
26148 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint64_t e) {
26149 void* e_ptr = untag_ptr(e);
26150 CHECK_ACCESS(e_ptr);
26151 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26152 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26153 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
26154 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
26155 return tag_ptr(ret_conv, true);
26158 jboolean __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
26159 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(o);
26160 jboolean ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
26164 void __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
26165 if (!ptr_is_owned(_res)) return;
26166 void* _res_ptr = untag_ptr(_res);
26167 CHECK_ACCESS(_res_ptr);
26168 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(_res_ptr);
26169 FREE(untag_ptr(_res));
26170 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
26173 static inline uint64_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
26174 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
26175 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
26176 return tag_ptr(ret_conv, true);
26178 int64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
26179 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
26180 int64_t ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
26184 uint64_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
26185 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
26186 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
26187 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
26188 return tag_ptr(ret_conv, true);
26191 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint64_t o) {
26192 LDKTrustedClosingTransaction o_conv;
26193 o_conv.inner = untag_ptr(o);
26194 o_conv.is_owned = ptr_is_owned(o);
26195 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26196 // WARNING: we need a move here but no clone is available for LDKTrustedClosingTransaction
26198 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
26199 *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
26200 return tag_ptr(ret_conv, true);
26203 uint64_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_err"))) TS_CResult_TrustedClosingTransactionNoneZ_err() {
26204 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
26205 *ret_conv = CResult_TrustedClosingTransactionNoneZ_err();
26206 return tag_ptr(ret_conv, true);
26209 jboolean __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_is_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint64_t o) {
26210 LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)untag_ptr(o);
26211 jboolean ret_conv = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
26215 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_free"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint64_t _res) {
26216 if (!ptr_is_owned(_res)) return;
26217 void* _res_ptr = untag_ptr(_res);
26218 CHECK_ACCESS(_res_ptr);
26219 LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(_res_ptr);
26220 FREE(untag_ptr(_res));
26221 CResult_TrustedClosingTransactionNoneZ_free(_res_conv);
26224 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint64_t o) {
26225 LDKCommitmentTransaction o_conv;
26226 o_conv.inner = untag_ptr(o);
26227 o_conv.is_owned = ptr_is_owned(o);
26228 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26229 o_conv = CommitmentTransaction_clone(&o_conv);
26230 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
26231 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
26232 return tag_ptr(ret_conv, true);
26235 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint64_t e) {
26236 void* e_ptr = untag_ptr(e);
26237 CHECK_ACCESS(e_ptr);
26238 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26239 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26240 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
26241 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
26242 return tag_ptr(ret_conv, true);
26245 jboolean __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint64_t o) {
26246 LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(o);
26247 jboolean ret_conv = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
26251 void __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_free"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint64_t _res) {
26252 if (!ptr_is_owned(_res)) return;
26253 void* _res_ptr = untag_ptr(_res);
26254 CHECK_ACCESS(_res_ptr);
26255 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(_res_ptr);
26256 FREE(untag_ptr(_res));
26257 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
26260 static inline uint64_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
26261 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
26262 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
26263 return tag_ptr(ret_conv, true);
26265 int64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint64_t arg) {
26266 LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(arg);
26267 int64_t ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
26271 uint64_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint64_t orig) {
26272 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)untag_ptr(orig);
26273 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
26274 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
26275 return tag_ptr(ret_conv, true);
26278 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint64_t o) {
26279 LDKTrustedCommitmentTransaction o_conv;
26280 o_conv.inner = untag_ptr(o);
26281 o_conv.is_owned = ptr_is_owned(o);
26282 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26283 // WARNING: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
26285 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
26286 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
26287 return tag_ptr(ret_conv, true);
26290 uint64_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
26291 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
26292 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
26293 return tag_ptr(ret_conv, true);
26296 jboolean __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint64_t o) {
26297 LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)untag_ptr(o);
26298 jboolean ret_conv = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
26302 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_free"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint64_t _res) {
26303 if (!ptr_is_owned(_res)) return;
26304 void* _res_ptr = untag_ptr(_res);
26305 CHECK_ACCESS(_res_ptr);
26306 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(_res_ptr);
26307 FREE(untag_ptr(_res));
26308 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
26311 uint64_t __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_ok"))) TS_CResult_CVec_ECDSASignatureZNoneZ_ok(ptrArray o) {
26312 LDKCVec_ECDSASignatureZ o_constr;
26313 o_constr.datalen = o->arr_len;
26314 if (o_constr.datalen > 0)
26315 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
26317 o_constr.data = NULL;
26318 int8_tArray* o_vals = (void*) o->elems;
26319 for (size_t m = 0; m < o_constr.datalen; m++) {
26320 int8_tArray o_conv_12 = o_vals[m];
26321 LDKECDSASignature o_conv_12_ref;
26322 CHECK(o_conv_12->arr_len == 64);
26323 memcpy(o_conv_12_ref.compact_form, o_conv_12->elems, 64); FREE(o_conv_12);
26324 o_constr.data[m] = o_conv_12_ref;
26327 LDKCResult_CVec_ECDSASignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ), "LDKCResult_CVec_ECDSASignatureZNoneZ");
26328 *ret_conv = CResult_CVec_ECDSASignatureZNoneZ_ok(o_constr);
26329 return tag_ptr(ret_conv, true);
26332 uint64_t __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_err"))) TS_CResult_CVec_ECDSASignatureZNoneZ_err() {
26333 LDKCResult_CVec_ECDSASignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ), "LDKCResult_CVec_ECDSASignatureZNoneZ");
26334 *ret_conv = CResult_CVec_ECDSASignatureZNoneZ_err();
26335 return tag_ptr(ret_conv, true);
26338 jboolean __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok"))) TS_CResult_CVec_ECDSASignatureZNoneZ_is_ok(uint64_t o) {
26339 LDKCResult_CVec_ECDSASignatureZNoneZ* o_conv = (LDKCResult_CVec_ECDSASignatureZNoneZ*)untag_ptr(o);
26340 jboolean ret_conv = CResult_CVec_ECDSASignatureZNoneZ_is_ok(o_conv);
26344 void __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_free"))) TS_CResult_CVec_ECDSASignatureZNoneZ_free(uint64_t _res) {
26345 if (!ptr_is_owned(_res)) return;
26346 void* _res_ptr = untag_ptr(_res);
26347 CHECK_ACCESS(_res_ptr);
26348 LDKCResult_CVec_ECDSASignatureZNoneZ _res_conv = *(LDKCResult_CVec_ECDSASignatureZNoneZ*)(_res_ptr);
26349 FREE(untag_ptr(_res));
26350 CResult_CVec_ECDSASignatureZNoneZ_free(_res_conv);
26353 static inline uint64_t CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(LDKCResult_CVec_ECDSASignatureZNoneZ *NONNULL_PTR arg) {
26354 LDKCResult_CVec_ECDSASignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ), "LDKCResult_CVec_ECDSASignatureZNoneZ");
26355 *ret_conv = CResult_CVec_ECDSASignatureZNoneZ_clone(arg);
26356 return tag_ptr(ret_conv, true);
26358 int64_t __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr"))) TS_CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(uint64_t arg) {
26359 LDKCResult_CVec_ECDSASignatureZNoneZ* arg_conv = (LDKCResult_CVec_ECDSASignatureZNoneZ*)untag_ptr(arg);
26360 int64_t ret_conv = CResult_CVec_ECDSASignatureZNoneZ_clone_ptr(arg_conv);
26364 uint64_t __attribute__((export_name("TS_CResult_CVec_ECDSASignatureZNoneZ_clone"))) TS_CResult_CVec_ECDSASignatureZNoneZ_clone(uint64_t orig) {
26365 LDKCResult_CVec_ECDSASignatureZNoneZ* orig_conv = (LDKCResult_CVec_ECDSASignatureZNoneZ*)untag_ptr(orig);
26366 LDKCResult_CVec_ECDSASignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ), "LDKCResult_CVec_ECDSASignatureZNoneZ");
26367 *ret_conv = CResult_CVec_ECDSASignatureZNoneZ_clone(orig_conv);
26368 return tag_ptr(ret_conv, true);
26371 uint64_t __attribute__((export_name("TS_COption_usizeZ_some"))) TS_COption_usizeZ_some(uint32_t o) {
26372 LDKCOption_usizeZ *ret_copy = MALLOC(sizeof(LDKCOption_usizeZ), "LDKCOption_usizeZ");
26373 *ret_copy = COption_usizeZ_some(o);
26374 uint64_t ret_ref = tag_ptr(ret_copy, true);
26378 uint64_t __attribute__((export_name("TS_COption_usizeZ_none"))) TS_COption_usizeZ_none() {
26379 LDKCOption_usizeZ *ret_copy = MALLOC(sizeof(LDKCOption_usizeZ), "LDKCOption_usizeZ");
26380 *ret_copy = COption_usizeZ_none();
26381 uint64_t ret_ref = tag_ptr(ret_copy, true);
26385 void __attribute__((export_name("TS_COption_usizeZ_free"))) TS_COption_usizeZ_free(uint64_t _res) {
26386 if (!ptr_is_owned(_res)) return;
26387 void* _res_ptr = untag_ptr(_res);
26388 CHECK_ACCESS(_res_ptr);
26389 LDKCOption_usizeZ _res_conv = *(LDKCOption_usizeZ*)(_res_ptr);
26390 FREE(untag_ptr(_res));
26391 COption_usizeZ_free(_res_conv);
26394 static inline uint64_t COption_usizeZ_clone_ptr(LDKCOption_usizeZ *NONNULL_PTR arg) {
26395 LDKCOption_usizeZ *ret_copy = MALLOC(sizeof(LDKCOption_usizeZ), "LDKCOption_usizeZ");
26396 *ret_copy = COption_usizeZ_clone(arg);
26397 uint64_t ret_ref = tag_ptr(ret_copy, true);
26400 int64_t __attribute__((export_name("TS_COption_usizeZ_clone_ptr"))) TS_COption_usizeZ_clone_ptr(uint64_t arg) {
26401 LDKCOption_usizeZ* arg_conv = (LDKCOption_usizeZ*)untag_ptr(arg);
26402 int64_t ret_conv = COption_usizeZ_clone_ptr(arg_conv);
26406 uint64_t __attribute__((export_name("TS_COption_usizeZ_clone"))) TS_COption_usizeZ_clone(uint64_t orig) {
26407 LDKCOption_usizeZ* orig_conv = (LDKCOption_usizeZ*)untag_ptr(orig);
26408 LDKCOption_usizeZ *ret_copy = MALLOC(sizeof(LDKCOption_usizeZ), "LDKCOption_usizeZ");
26409 *ret_copy = COption_usizeZ_clone(orig_conv);
26410 uint64_t ret_ref = tag_ptr(ret_copy, true);
26414 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_ok(uint64_t o) {
26415 LDKShutdownScript o_conv;
26416 o_conv.inner = untag_ptr(o);
26417 o_conv.is_owned = ptr_is_owned(o);
26418 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26419 o_conv = ShutdownScript_clone(&o_conv);
26420 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
26421 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
26422 return tag_ptr(ret_conv, true);
26425 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_err(uint64_t e) {
26426 void* e_ptr = untag_ptr(e);
26427 CHECK_ACCESS(e_ptr);
26428 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26429 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26430 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
26431 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
26432 return tag_ptr(ret_conv, true);
26435 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_is_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint64_t o) {
26436 LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(o);
26437 jboolean ret_conv = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
26441 void __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_free"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint64_t _res) {
26442 if (!ptr_is_owned(_res)) return;
26443 void* _res_ptr = untag_ptr(_res);
26444 CHECK_ACCESS(_res_ptr);
26445 LDKCResult_ShutdownScriptDecodeErrorZ _res_conv = *(LDKCResult_ShutdownScriptDecodeErrorZ*)(_res_ptr);
26446 FREE(untag_ptr(_res));
26447 CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
26450 static inline uint64_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
26451 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
26452 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
26453 return tag_ptr(ret_conv, true);
26455 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint64_t arg) {
26456 LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(arg);
26457 int64_t ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
26461 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint64_t orig) {
26462 LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)untag_ptr(orig);
26463 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
26464 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(orig_conv);
26465 return tag_ptr(ret_conv, true);
26468 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(uint64_t o) {
26469 LDKShutdownScript o_conv;
26470 o_conv.inner = untag_ptr(o);
26471 o_conv.is_owned = ptr_is_owned(o);
26472 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26473 o_conv = ShutdownScript_clone(&o_conv);
26474 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
26475 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
26476 return tag_ptr(ret_conv, true);
26479 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(uint64_t e) {
26480 LDKInvalidShutdownScript e_conv;
26481 e_conv.inner = untag_ptr(e);
26482 e_conv.is_owned = ptr_is_owned(e);
26483 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
26484 e_conv = InvalidShutdownScript_clone(&e_conv);
26485 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
26486 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
26487 return tag_ptr(ret_conv, true);
26490 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint64_t o) {
26491 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(o);
26492 jboolean ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
26496 void __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint64_t _res) {
26497 if (!ptr_is_owned(_res)) return;
26498 void* _res_ptr = untag_ptr(_res);
26499 CHECK_ACCESS(_res_ptr);
26500 LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res_conv = *(LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(_res_ptr);
26501 FREE(untag_ptr(_res));
26502 CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
26505 static inline uint64_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
26506 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
26507 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
26508 return tag_ptr(ret_conv, true);
26510 int64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint64_t arg) {
26511 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(arg);
26512 int64_t ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
26516 uint64_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint64_t orig) {
26517 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)untag_ptr(orig);
26518 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
26519 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig_conv);
26520 return tag_ptr(ret_conv, true);
26523 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_ok(uint64_t o) {
26524 void* o_ptr = untag_ptr(o);
26525 CHECK_ACCESS(o_ptr);
26526 LDKPaymentPurpose o_conv = *(LDKPaymentPurpose*)(o_ptr);
26527 o_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(o));
26528 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
26529 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_ok(o_conv);
26530 return tag_ptr(ret_conv, true);
26533 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_err(uint64_t e) {
26534 void* e_ptr = untag_ptr(e);
26535 CHECK_ACCESS(e_ptr);
26536 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26537 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26538 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
26539 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_err(e_conv);
26540 return tag_ptr(ret_conv, true);
26543 jboolean __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_is_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(uint64_t o) {
26544 LDKCResult_PaymentPurposeDecodeErrorZ* o_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(o);
26545 jboolean ret_conv = CResult_PaymentPurposeDecodeErrorZ_is_ok(o_conv);
26549 void __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_free"))) TS_CResult_PaymentPurposeDecodeErrorZ_free(uint64_t _res) {
26550 if (!ptr_is_owned(_res)) return;
26551 void* _res_ptr = untag_ptr(_res);
26552 CHECK_ACCESS(_res_ptr);
26553 LDKCResult_PaymentPurposeDecodeErrorZ _res_conv = *(LDKCResult_PaymentPurposeDecodeErrorZ*)(_res_ptr);
26554 FREE(untag_ptr(_res));
26555 CResult_PaymentPurposeDecodeErrorZ_free(_res_conv);
26558 static inline uint64_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg) {
26559 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
26560 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(arg);
26561 return tag_ptr(ret_conv, true);
26563 int64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(uint64_t arg) {
26564 LDKCResult_PaymentPurposeDecodeErrorZ* arg_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(arg);
26565 int64_t ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg_conv);
26569 uint64_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone(uint64_t orig) {
26570 LDKCResult_PaymentPurposeDecodeErrorZ* orig_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)untag_ptr(orig);
26571 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
26572 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(orig_conv);
26573 return tag_ptr(ret_conv, true);
26576 uint64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_ok"))) TS_CResult_ClaimedHTLCDecodeErrorZ_ok(uint64_t o) {
26577 LDKClaimedHTLC o_conv;
26578 o_conv.inner = untag_ptr(o);
26579 o_conv.is_owned = ptr_is_owned(o);
26580 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
26581 o_conv = ClaimedHTLC_clone(&o_conv);
26582 LDKCResult_ClaimedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ), "LDKCResult_ClaimedHTLCDecodeErrorZ");
26583 *ret_conv = CResult_ClaimedHTLCDecodeErrorZ_ok(o_conv);
26584 return tag_ptr(ret_conv, true);
26587 uint64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_err"))) TS_CResult_ClaimedHTLCDecodeErrorZ_err(uint64_t e) {
26588 void* e_ptr = untag_ptr(e);
26589 CHECK_ACCESS(e_ptr);
26590 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26591 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26592 LDKCResult_ClaimedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ), "LDKCResult_ClaimedHTLCDecodeErrorZ");
26593 *ret_conv = CResult_ClaimedHTLCDecodeErrorZ_err(e_conv);
26594 return tag_ptr(ret_conv, true);
26597 jboolean __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok"))) TS_CResult_ClaimedHTLCDecodeErrorZ_is_ok(uint64_t o) {
26598 LDKCResult_ClaimedHTLCDecodeErrorZ* o_conv = (LDKCResult_ClaimedHTLCDecodeErrorZ*)untag_ptr(o);
26599 jboolean ret_conv = CResult_ClaimedHTLCDecodeErrorZ_is_ok(o_conv);
26603 void __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_free"))) TS_CResult_ClaimedHTLCDecodeErrorZ_free(uint64_t _res) {
26604 if (!ptr_is_owned(_res)) return;
26605 void* _res_ptr = untag_ptr(_res);
26606 CHECK_ACCESS(_res_ptr);
26607 LDKCResult_ClaimedHTLCDecodeErrorZ _res_conv = *(LDKCResult_ClaimedHTLCDecodeErrorZ*)(_res_ptr);
26608 FREE(untag_ptr(_res));
26609 CResult_ClaimedHTLCDecodeErrorZ_free(_res_conv);
26612 static inline uint64_t CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(LDKCResult_ClaimedHTLCDecodeErrorZ *NONNULL_PTR arg) {
26613 LDKCResult_ClaimedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ), "LDKCResult_ClaimedHTLCDecodeErrorZ");
26614 *ret_conv = CResult_ClaimedHTLCDecodeErrorZ_clone(arg);
26615 return tag_ptr(ret_conv, true);
26617 int64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(uint64_t arg) {
26618 LDKCResult_ClaimedHTLCDecodeErrorZ* arg_conv = (LDKCResult_ClaimedHTLCDecodeErrorZ*)untag_ptr(arg);
26619 int64_t ret_conv = CResult_ClaimedHTLCDecodeErrorZ_clone_ptr(arg_conv);
26623 uint64_t __attribute__((export_name("TS_CResult_ClaimedHTLCDecodeErrorZ_clone"))) TS_CResult_ClaimedHTLCDecodeErrorZ_clone(uint64_t orig) {
26624 LDKCResult_ClaimedHTLCDecodeErrorZ* orig_conv = (LDKCResult_ClaimedHTLCDecodeErrorZ*)untag_ptr(orig);
26625 LDKCResult_ClaimedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ), "LDKCResult_ClaimedHTLCDecodeErrorZ");
26626 *ret_conv = CResult_ClaimedHTLCDecodeErrorZ_clone(orig_conv);
26627 return tag_ptr(ret_conv, true);
26630 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_some"))) TS_COption_PathFailureZ_some(uint64_t o) {
26631 void* o_ptr = untag_ptr(o);
26632 CHECK_ACCESS(o_ptr);
26633 LDKPathFailure o_conv = *(LDKPathFailure*)(o_ptr);
26634 o_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(o));
26635 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
26636 *ret_copy = COption_PathFailureZ_some(o_conv);
26637 uint64_t ret_ref = tag_ptr(ret_copy, true);
26641 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_none"))) TS_COption_PathFailureZ_none() {
26642 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
26643 *ret_copy = COption_PathFailureZ_none();
26644 uint64_t ret_ref = tag_ptr(ret_copy, true);
26648 void __attribute__((export_name("TS_COption_PathFailureZ_free"))) TS_COption_PathFailureZ_free(uint64_t _res) {
26649 if (!ptr_is_owned(_res)) return;
26650 void* _res_ptr = untag_ptr(_res);
26651 CHECK_ACCESS(_res_ptr);
26652 LDKCOption_PathFailureZ _res_conv = *(LDKCOption_PathFailureZ*)(_res_ptr);
26653 FREE(untag_ptr(_res));
26654 COption_PathFailureZ_free(_res_conv);
26657 static inline uint64_t COption_PathFailureZ_clone_ptr(LDKCOption_PathFailureZ *NONNULL_PTR arg) {
26658 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
26659 *ret_copy = COption_PathFailureZ_clone(arg);
26660 uint64_t ret_ref = tag_ptr(ret_copy, true);
26663 int64_t __attribute__((export_name("TS_COption_PathFailureZ_clone_ptr"))) TS_COption_PathFailureZ_clone_ptr(uint64_t arg) {
26664 LDKCOption_PathFailureZ* arg_conv = (LDKCOption_PathFailureZ*)untag_ptr(arg);
26665 int64_t ret_conv = COption_PathFailureZ_clone_ptr(arg_conv);
26669 uint64_t __attribute__((export_name("TS_COption_PathFailureZ_clone"))) TS_COption_PathFailureZ_clone(uint64_t orig) {
26670 LDKCOption_PathFailureZ* orig_conv = (LDKCOption_PathFailureZ*)untag_ptr(orig);
26671 LDKCOption_PathFailureZ *ret_copy = MALLOC(sizeof(LDKCOption_PathFailureZ), "LDKCOption_PathFailureZ");
26672 *ret_copy = COption_PathFailureZ_clone(orig_conv);
26673 uint64_t ret_ref = tag_ptr(ret_copy, true);
26677 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_ok(uint64_t o) {
26678 void* o_ptr = untag_ptr(o);
26679 CHECK_ACCESS(o_ptr);
26680 LDKCOption_PathFailureZ o_conv = *(LDKCOption_PathFailureZ*)(o_ptr);
26681 o_conv = COption_PathFailureZ_clone((LDKCOption_PathFailureZ*)untag_ptr(o));
26682 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
26683 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_ok(o_conv);
26684 return tag_ptr(ret_conv, true);
26687 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_err"))) TS_CResult_COption_PathFailureZDecodeErrorZ_err(uint64_t e) {
26688 void* e_ptr = untag_ptr(e);
26689 CHECK_ACCESS(e_ptr);
26690 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26691 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26692 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
26693 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_err(e_conv);
26694 return tag_ptr(ret_conv, true);
26697 jboolean __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok"))) TS_CResult_COption_PathFailureZDecodeErrorZ_is_ok(uint64_t o) {
26698 LDKCResult_COption_PathFailureZDecodeErrorZ* o_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(o);
26699 jboolean ret_conv = CResult_COption_PathFailureZDecodeErrorZ_is_ok(o_conv);
26703 void __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_free"))) TS_CResult_COption_PathFailureZDecodeErrorZ_free(uint64_t _res) {
26704 if (!ptr_is_owned(_res)) return;
26705 void* _res_ptr = untag_ptr(_res);
26706 CHECK_ACCESS(_res_ptr);
26707 LDKCResult_COption_PathFailureZDecodeErrorZ _res_conv = *(LDKCResult_COption_PathFailureZDecodeErrorZ*)(_res_ptr);
26708 FREE(untag_ptr(_res));
26709 CResult_COption_PathFailureZDecodeErrorZ_free(_res_conv);
26712 static inline uint64_t CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(LDKCResult_COption_PathFailureZDecodeErrorZ *NONNULL_PTR arg) {
26713 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
26714 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(arg);
26715 return tag_ptr(ret_conv, true);
26717 int64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(uint64_t arg) {
26718 LDKCResult_COption_PathFailureZDecodeErrorZ* arg_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(arg);
26719 int64_t ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone_ptr(arg_conv);
26723 uint64_t __attribute__((export_name("TS_CResult_COption_PathFailureZDecodeErrorZ_clone"))) TS_CResult_COption_PathFailureZDecodeErrorZ_clone(uint64_t orig) {
26724 LDKCResult_COption_PathFailureZDecodeErrorZ* orig_conv = (LDKCResult_COption_PathFailureZDecodeErrorZ*)untag_ptr(orig);
26725 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
26726 *ret_conv = CResult_COption_PathFailureZDecodeErrorZ_clone(orig_conv);
26727 return tag_ptr(ret_conv, true);
26730 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_some"))) TS_COption_ClosureReasonZ_some(uint64_t o) {
26731 void* o_ptr = untag_ptr(o);
26732 CHECK_ACCESS(o_ptr);
26733 LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
26734 o_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(o));
26735 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
26736 *ret_copy = COption_ClosureReasonZ_some(o_conv);
26737 uint64_t ret_ref = tag_ptr(ret_copy, true);
26741 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_none"))) TS_COption_ClosureReasonZ_none() {
26742 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
26743 *ret_copy = COption_ClosureReasonZ_none();
26744 uint64_t ret_ref = tag_ptr(ret_copy, true);
26748 void __attribute__((export_name("TS_COption_ClosureReasonZ_free"))) TS_COption_ClosureReasonZ_free(uint64_t _res) {
26749 if (!ptr_is_owned(_res)) return;
26750 void* _res_ptr = untag_ptr(_res);
26751 CHECK_ACCESS(_res_ptr);
26752 LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
26753 FREE(untag_ptr(_res));
26754 COption_ClosureReasonZ_free(_res_conv);
26757 static inline uint64_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
26758 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
26759 *ret_copy = COption_ClosureReasonZ_clone(arg);
26760 uint64_t ret_ref = tag_ptr(ret_copy, true);
26763 int64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone_ptr"))) TS_COption_ClosureReasonZ_clone_ptr(uint64_t arg) {
26764 LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(arg);
26765 int64_t ret_conv = COption_ClosureReasonZ_clone_ptr(arg_conv);
26769 uint64_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone"))) TS_COption_ClosureReasonZ_clone(uint64_t orig) {
26770 LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)untag_ptr(orig);
26771 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
26772 *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
26773 uint64_t ret_ref = tag_ptr(ret_copy, true);
26777 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint64_t o) {
26778 void* o_ptr = untag_ptr(o);
26779 CHECK_ACCESS(o_ptr);
26780 LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
26781 o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)untag_ptr(o));
26782 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
26783 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
26784 return tag_ptr(ret_conv, true);
26787 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint64_t e) {
26788 void* e_ptr = untag_ptr(e);
26789 CHECK_ACCESS(e_ptr);
26790 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26791 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26792 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
26793 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
26794 return tag_ptr(ret_conv, true);
26797 jboolean __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint64_t o) {
26798 LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(o);
26799 jboolean ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
26803 void __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_free"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint64_t _res) {
26804 if (!ptr_is_owned(_res)) return;
26805 void* _res_ptr = untag_ptr(_res);
26806 CHECK_ACCESS(_res_ptr);
26807 LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
26808 FREE(untag_ptr(_res));
26809 CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
26812 static inline uint64_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
26813 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
26814 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
26815 return tag_ptr(ret_conv, true);
26817 int64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint64_t arg) {
26818 LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(arg);
26819 int64_t ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
26823 uint64_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint64_t orig) {
26824 LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)untag_ptr(orig);
26825 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
26826 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
26827 return tag_ptr(ret_conv, true);
26830 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_some"))) TS_COption_HTLCDestinationZ_some(uint64_t o) {
26831 void* o_ptr = untag_ptr(o);
26832 CHECK_ACCESS(o_ptr);
26833 LDKHTLCDestination o_conv = *(LDKHTLCDestination*)(o_ptr);
26834 o_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(o));
26835 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
26836 *ret_copy = COption_HTLCDestinationZ_some(o_conv);
26837 uint64_t ret_ref = tag_ptr(ret_copy, true);
26841 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_none"))) TS_COption_HTLCDestinationZ_none() {
26842 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
26843 *ret_copy = COption_HTLCDestinationZ_none();
26844 uint64_t ret_ref = tag_ptr(ret_copy, true);
26848 void __attribute__((export_name("TS_COption_HTLCDestinationZ_free"))) TS_COption_HTLCDestinationZ_free(uint64_t _res) {
26849 if (!ptr_is_owned(_res)) return;
26850 void* _res_ptr = untag_ptr(_res);
26851 CHECK_ACCESS(_res_ptr);
26852 LDKCOption_HTLCDestinationZ _res_conv = *(LDKCOption_HTLCDestinationZ*)(_res_ptr);
26853 FREE(untag_ptr(_res));
26854 COption_HTLCDestinationZ_free(_res_conv);
26857 static inline uint64_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg) {
26858 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
26859 *ret_copy = COption_HTLCDestinationZ_clone(arg);
26860 uint64_t ret_ref = tag_ptr(ret_copy, true);
26863 int64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone_ptr"))) TS_COption_HTLCDestinationZ_clone_ptr(uint64_t arg) {
26864 LDKCOption_HTLCDestinationZ* arg_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(arg);
26865 int64_t ret_conv = COption_HTLCDestinationZ_clone_ptr(arg_conv);
26869 uint64_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone"))) TS_COption_HTLCDestinationZ_clone(uint64_t orig) {
26870 LDKCOption_HTLCDestinationZ* orig_conv = (LDKCOption_HTLCDestinationZ*)untag_ptr(orig);
26871 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
26872 *ret_copy = COption_HTLCDestinationZ_clone(orig_conv);
26873 uint64_t ret_ref = tag_ptr(ret_copy, true);
26877 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(uint64_t o) {
26878 void* o_ptr = untag_ptr(o);
26879 CHECK_ACCESS(o_ptr);
26880 LDKCOption_HTLCDestinationZ o_conv = *(LDKCOption_HTLCDestinationZ*)(o_ptr);
26881 o_conv = COption_HTLCDestinationZ_clone((LDKCOption_HTLCDestinationZ*)untag_ptr(o));
26882 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
26883 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o_conv);
26884 return tag_ptr(ret_conv, true);
26887 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(uint64_t e) {
26888 void* e_ptr = untag_ptr(e);
26889 CHECK_ACCESS(e_ptr);
26890 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26891 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26892 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
26893 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_err(e_conv);
26894 return tag_ptr(ret_conv, true);
26897 jboolean __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(uint64_t o) {
26898 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* o_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(o);
26899 jboolean ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o_conv);
26903 void __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(uint64_t _res) {
26904 if (!ptr_is_owned(_res)) return;
26905 void* _res_ptr = untag_ptr(_res);
26906 CHECK_ACCESS(_res_ptr);
26907 LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res_conv = *(LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(_res_ptr);
26908 FREE(untag_ptr(_res));
26909 CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res_conv);
26912 static inline uint64_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg) {
26913 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
26914 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(arg);
26915 return tag_ptr(ret_conv, true);
26917 int64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(uint64_t arg) {
26918 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* arg_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(arg);
26919 int64_t ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg_conv);
26923 uint64_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(uint64_t orig) {
26924 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* orig_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)untag_ptr(orig);
26925 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
26926 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig_conv);
26927 return tag_ptr(ret_conv, true);
26930 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_ok(uint32_t o) {
26931 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
26932 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
26933 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_ok(o_conv);
26934 return tag_ptr(ret_conv, true);
26937 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_err"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_err(uint64_t e) {
26938 void* e_ptr = untag_ptr(e);
26939 CHECK_ACCESS(e_ptr);
26940 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
26941 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
26942 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
26943 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_err(e_conv);
26944 return tag_ptr(ret_conv, true);
26947 jboolean __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_is_ok(uint64_t o) {
26948 LDKCResult_PaymentFailureReasonDecodeErrorZ* o_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(o);
26949 jboolean ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_is_ok(o_conv);
26953 void __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_free"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_free(uint64_t _res) {
26954 if (!ptr_is_owned(_res)) return;
26955 void* _res_ptr = untag_ptr(_res);
26956 CHECK_ACCESS(_res_ptr);
26957 LDKCResult_PaymentFailureReasonDecodeErrorZ _res_conv = *(LDKCResult_PaymentFailureReasonDecodeErrorZ*)(_res_ptr);
26958 FREE(untag_ptr(_res));
26959 CResult_PaymentFailureReasonDecodeErrorZ_free(_res_conv);
26962 static inline uint64_t CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(LDKCResult_PaymentFailureReasonDecodeErrorZ *NONNULL_PTR arg) {
26963 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
26964 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(arg);
26965 return tag_ptr(ret_conv, true);
26967 int64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(uint64_t arg) {
26968 LDKCResult_PaymentFailureReasonDecodeErrorZ* arg_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(arg);
26969 int64_t ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone_ptr(arg_conv);
26973 uint64_t __attribute__((export_name("TS_CResult_PaymentFailureReasonDecodeErrorZ_clone"))) TS_CResult_PaymentFailureReasonDecodeErrorZ_clone(uint64_t orig) {
26974 LDKCResult_PaymentFailureReasonDecodeErrorZ* orig_conv = (LDKCResult_PaymentFailureReasonDecodeErrorZ*)untag_ptr(orig);
26975 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
26976 *ret_conv = CResult_PaymentFailureReasonDecodeErrorZ_clone(orig_conv);
26977 return tag_ptr(ret_conv, true);
26980 uint64_t __attribute__((export_name("TS_COption_U128Z_some"))) TS_COption_U128Z_some(int8_tArray o) {
26982 CHECK(o->arr_len == 16);
26983 memcpy(o_ref.le_bytes, o->elems, 16); FREE(o);
26984 LDKCOption_U128Z *ret_copy = MALLOC(sizeof(LDKCOption_U128Z), "LDKCOption_U128Z");
26985 *ret_copy = COption_U128Z_some(o_ref);
26986 uint64_t ret_ref = tag_ptr(ret_copy, true);
26990 uint64_t __attribute__((export_name("TS_COption_U128Z_none"))) TS_COption_U128Z_none() {
26991 LDKCOption_U128Z *ret_copy = MALLOC(sizeof(LDKCOption_U128Z), "LDKCOption_U128Z");
26992 *ret_copy = COption_U128Z_none();
26993 uint64_t ret_ref = tag_ptr(ret_copy, true);
26997 void __attribute__((export_name("TS_COption_U128Z_free"))) TS_COption_U128Z_free(uint64_t _res) {
26998 if (!ptr_is_owned(_res)) return;
26999 void* _res_ptr = untag_ptr(_res);
27000 CHECK_ACCESS(_res_ptr);
27001 LDKCOption_U128Z _res_conv = *(LDKCOption_U128Z*)(_res_ptr);
27002 FREE(untag_ptr(_res));
27003 COption_U128Z_free(_res_conv);
27006 static inline uint64_t COption_U128Z_clone_ptr(LDKCOption_U128Z *NONNULL_PTR arg) {
27007 LDKCOption_U128Z *ret_copy = MALLOC(sizeof(LDKCOption_U128Z), "LDKCOption_U128Z");
27008 *ret_copy = COption_U128Z_clone(arg);
27009 uint64_t ret_ref = tag_ptr(ret_copy, true);
27012 int64_t __attribute__((export_name("TS_COption_U128Z_clone_ptr"))) TS_COption_U128Z_clone_ptr(uint64_t arg) {
27013 LDKCOption_U128Z* arg_conv = (LDKCOption_U128Z*)untag_ptr(arg);
27014 int64_t ret_conv = COption_U128Z_clone_ptr(arg_conv);
27018 uint64_t __attribute__((export_name("TS_COption_U128Z_clone"))) TS_COption_U128Z_clone(uint64_t orig) {
27019 LDKCOption_U128Z* orig_conv = (LDKCOption_U128Z*)untag_ptr(orig);
27020 LDKCOption_U128Z *ret_copy = MALLOC(sizeof(LDKCOption_U128Z), "LDKCOption_U128Z");
27021 *ret_copy = COption_U128Z_clone(orig_conv);
27022 uint64_t ret_ref = tag_ptr(ret_copy, true);
27026 void __attribute__((export_name("TS_CVec_ClaimedHTLCZ_free"))) TS_CVec_ClaimedHTLCZ_free(uint64_tArray _res) {
27027 LDKCVec_ClaimedHTLCZ _res_constr;
27028 _res_constr.datalen = _res->arr_len;
27029 if (_res_constr.datalen > 0)
27030 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKClaimedHTLC), "LDKCVec_ClaimedHTLCZ Elements");
27032 _res_constr.data = NULL;
27033 uint64_t* _res_vals = _res->elems;
27034 for (size_t n = 0; n < _res_constr.datalen; n++) {
27035 uint64_t _res_conv_13 = _res_vals[n];
27036 LDKClaimedHTLC _res_conv_13_conv;
27037 _res_conv_13_conv.inner = untag_ptr(_res_conv_13);
27038 _res_conv_13_conv.is_owned = ptr_is_owned(_res_conv_13);
27039 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_13_conv);
27040 _res_constr.data[n] = _res_conv_13_conv;
27043 CVec_ClaimedHTLCZ_free(_res_constr);
27046 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_some"))) TS_COption_PaymentFailureReasonZ_some(uint32_t o) {
27047 LDKPaymentFailureReason o_conv = LDKPaymentFailureReason_from_js(o);
27048 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
27049 *ret_copy = COption_PaymentFailureReasonZ_some(o_conv);
27050 uint64_t ret_ref = tag_ptr(ret_copy, true);
27054 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_none"))) TS_COption_PaymentFailureReasonZ_none() {
27055 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
27056 *ret_copy = COption_PaymentFailureReasonZ_none();
27057 uint64_t ret_ref = tag_ptr(ret_copy, true);
27061 void __attribute__((export_name("TS_COption_PaymentFailureReasonZ_free"))) TS_COption_PaymentFailureReasonZ_free(uint64_t _res) {
27062 if (!ptr_is_owned(_res)) return;
27063 void* _res_ptr = untag_ptr(_res);
27064 CHECK_ACCESS(_res_ptr);
27065 LDKCOption_PaymentFailureReasonZ _res_conv = *(LDKCOption_PaymentFailureReasonZ*)(_res_ptr);
27066 FREE(untag_ptr(_res));
27067 COption_PaymentFailureReasonZ_free(_res_conv);
27070 static inline uint64_t COption_PaymentFailureReasonZ_clone_ptr(LDKCOption_PaymentFailureReasonZ *NONNULL_PTR arg) {
27071 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
27072 *ret_copy = COption_PaymentFailureReasonZ_clone(arg);
27073 uint64_t ret_ref = tag_ptr(ret_copy, true);
27076 int64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone_ptr"))) TS_COption_PaymentFailureReasonZ_clone_ptr(uint64_t arg) {
27077 LDKCOption_PaymentFailureReasonZ* arg_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(arg);
27078 int64_t ret_conv = COption_PaymentFailureReasonZ_clone_ptr(arg_conv);
27082 uint64_t __attribute__((export_name("TS_COption_PaymentFailureReasonZ_clone"))) TS_COption_PaymentFailureReasonZ_clone(uint64_t orig) {
27083 LDKCOption_PaymentFailureReasonZ* orig_conv = (LDKCOption_PaymentFailureReasonZ*)untag_ptr(orig);
27084 LDKCOption_PaymentFailureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_PaymentFailureReasonZ), "LDKCOption_PaymentFailureReasonZ");
27085 *ret_copy = COption_PaymentFailureReasonZ_clone(orig_conv);
27086 uint64_t ret_ref = tag_ptr(ret_copy, true);
27090 uint64_t __attribute__((export_name("TS_COption_EventZ_some"))) TS_COption_EventZ_some(uint64_t o) {
27091 void* o_ptr = untag_ptr(o);
27092 CHECK_ACCESS(o_ptr);
27093 LDKEvent o_conv = *(LDKEvent*)(o_ptr);
27094 o_conv = Event_clone((LDKEvent*)untag_ptr(o));
27095 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
27096 *ret_copy = COption_EventZ_some(o_conv);
27097 uint64_t ret_ref = tag_ptr(ret_copy, true);
27101 uint64_t __attribute__((export_name("TS_COption_EventZ_none"))) TS_COption_EventZ_none() {
27102 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
27103 *ret_copy = COption_EventZ_none();
27104 uint64_t ret_ref = tag_ptr(ret_copy, true);
27108 void __attribute__((export_name("TS_COption_EventZ_free"))) TS_COption_EventZ_free(uint64_t _res) {
27109 if (!ptr_is_owned(_res)) return;
27110 void* _res_ptr = untag_ptr(_res);
27111 CHECK_ACCESS(_res_ptr);
27112 LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
27113 FREE(untag_ptr(_res));
27114 COption_EventZ_free(_res_conv);
27117 static inline uint64_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
27118 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
27119 *ret_copy = COption_EventZ_clone(arg);
27120 uint64_t ret_ref = tag_ptr(ret_copy, true);
27123 int64_t __attribute__((export_name("TS_COption_EventZ_clone_ptr"))) TS_COption_EventZ_clone_ptr(uint64_t arg) {
27124 LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)untag_ptr(arg);
27125 int64_t ret_conv = COption_EventZ_clone_ptr(arg_conv);
27129 uint64_t __attribute__((export_name("TS_COption_EventZ_clone"))) TS_COption_EventZ_clone(uint64_t orig) {
27130 LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)untag_ptr(orig);
27131 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
27132 *ret_copy = COption_EventZ_clone(orig_conv);
27133 uint64_t ret_ref = tag_ptr(ret_copy, true);
27137 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_ok"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint64_t o) {
27138 void* o_ptr = untag_ptr(o);
27139 CHECK_ACCESS(o_ptr);
27140 LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
27141 o_conv = COption_EventZ_clone((LDKCOption_EventZ*)untag_ptr(o));
27142 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
27143 *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
27144 return tag_ptr(ret_conv, true);
27147 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_err"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint64_t e) {
27148 void* e_ptr = untag_ptr(e);
27149 CHECK_ACCESS(e_ptr);
27150 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27151 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27152 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
27153 *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
27154 return tag_ptr(ret_conv, true);
27157 jboolean __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_is_ok"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint64_t o) {
27158 LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(o);
27159 jboolean ret_conv = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
27163 void __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_free"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint64_t _res) {
27164 if (!ptr_is_owned(_res)) return;
27165 void* _res_ptr = untag_ptr(_res);
27166 CHECK_ACCESS(_res_ptr);
27167 LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
27168 FREE(untag_ptr(_res));
27169 CResult_COption_EventZDecodeErrorZ_free(_res_conv);
27172 static inline uint64_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
27173 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
27174 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
27175 return tag_ptr(ret_conv, true);
27177 int64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint64_t arg) {
27178 LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(arg);
27179 int64_t ret_conv = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
27183 uint64_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint64_t orig) {
27184 LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)untag_ptr(orig);
27185 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
27186 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
27187 return tag_ptr(ret_conv, true);
27190 uint64_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_ok"))) TS_CResult_SiPrefixBolt11ParseErrorZ_ok(uint32_t o) {
27191 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
27192 LDKCResult_SiPrefixBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ), "LDKCResult_SiPrefixBolt11ParseErrorZ");
27193 *ret_conv = CResult_SiPrefixBolt11ParseErrorZ_ok(o_conv);
27194 return tag_ptr(ret_conv, true);
27197 uint64_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_err"))) TS_CResult_SiPrefixBolt11ParseErrorZ_err(uint64_t e) {
27198 void* e_ptr = untag_ptr(e);
27199 CHECK_ACCESS(e_ptr);
27200 LDKBolt11ParseError e_conv = *(LDKBolt11ParseError*)(e_ptr);
27201 e_conv = Bolt11ParseError_clone((LDKBolt11ParseError*)untag_ptr(e));
27202 LDKCResult_SiPrefixBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ), "LDKCResult_SiPrefixBolt11ParseErrorZ");
27203 *ret_conv = CResult_SiPrefixBolt11ParseErrorZ_err(e_conv);
27204 return tag_ptr(ret_conv, true);
27207 jboolean __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok"))) TS_CResult_SiPrefixBolt11ParseErrorZ_is_ok(uint64_t o) {
27208 LDKCResult_SiPrefixBolt11ParseErrorZ* o_conv = (LDKCResult_SiPrefixBolt11ParseErrorZ*)untag_ptr(o);
27209 jboolean ret_conv = CResult_SiPrefixBolt11ParseErrorZ_is_ok(o_conv);
27213 void __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_free"))) TS_CResult_SiPrefixBolt11ParseErrorZ_free(uint64_t _res) {
27214 if (!ptr_is_owned(_res)) return;
27215 void* _res_ptr = untag_ptr(_res);
27216 CHECK_ACCESS(_res_ptr);
27217 LDKCResult_SiPrefixBolt11ParseErrorZ _res_conv = *(LDKCResult_SiPrefixBolt11ParseErrorZ*)(_res_ptr);
27218 FREE(untag_ptr(_res));
27219 CResult_SiPrefixBolt11ParseErrorZ_free(_res_conv);
27222 static inline uint64_t CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(LDKCResult_SiPrefixBolt11ParseErrorZ *NONNULL_PTR arg) {
27223 LDKCResult_SiPrefixBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ), "LDKCResult_SiPrefixBolt11ParseErrorZ");
27224 *ret_conv = CResult_SiPrefixBolt11ParseErrorZ_clone(arg);
27225 return tag_ptr(ret_conv, true);
27227 int64_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr"))) TS_CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(uint64_t arg) {
27228 LDKCResult_SiPrefixBolt11ParseErrorZ* arg_conv = (LDKCResult_SiPrefixBolt11ParseErrorZ*)untag_ptr(arg);
27229 int64_t ret_conv = CResult_SiPrefixBolt11ParseErrorZ_clone_ptr(arg_conv);
27233 uint64_t __attribute__((export_name("TS_CResult_SiPrefixBolt11ParseErrorZ_clone"))) TS_CResult_SiPrefixBolt11ParseErrorZ_clone(uint64_t orig) {
27234 LDKCResult_SiPrefixBolt11ParseErrorZ* orig_conv = (LDKCResult_SiPrefixBolt11ParseErrorZ*)untag_ptr(orig);
27235 LDKCResult_SiPrefixBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ), "LDKCResult_SiPrefixBolt11ParseErrorZ");
27236 *ret_conv = CResult_SiPrefixBolt11ParseErrorZ_clone(orig_conv);
27237 return tag_ptr(ret_conv, true);
27240 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(uint64_t o) {
27241 LDKBolt11Invoice o_conv;
27242 o_conv.inner = untag_ptr(o);
27243 o_conv.is_owned = ptr_is_owned(o);
27244 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27245 o_conv = Bolt11Invoice_clone(&o_conv);
27246 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ), "LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ");
27247 *ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_ok(o_conv);
27248 return tag_ptr(ret_conv, true);
27251 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(uint64_t e) {
27252 void* e_ptr = untag_ptr(e);
27253 CHECK_ACCESS(e_ptr);
27254 LDKParseOrSemanticError e_conv = *(LDKParseOrSemanticError*)(e_ptr);
27255 e_conv = ParseOrSemanticError_clone((LDKParseOrSemanticError*)untag_ptr(e));
27256 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ), "LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ");
27257 *ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_err(e_conv);
27258 return tag_ptr(ret_conv, true);
27261 jboolean __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(uint64_t o) {
27262 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* o_conv = (LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)untag_ptr(o);
27263 jboolean ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_is_ok(o_conv);
27267 void __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(uint64_t _res) {
27268 if (!ptr_is_owned(_res)) return;
27269 void* _res_ptr = untag_ptr(_res);
27270 CHECK_ACCESS(_res_ptr);
27271 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ _res_conv = *(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)(_res_ptr);
27272 FREE(untag_ptr(_res));
27273 CResult_Bolt11InvoiceParseOrSemanticErrorZ_free(_res_conv);
27276 static inline uint64_t CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg) {
27277 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ), "LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ");
27278 *ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(arg);
27279 return tag_ptr(ret_conv, true);
27281 int64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(uint64_t arg) {
27282 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* arg_conv = (LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)untag_ptr(arg);
27283 int64_t ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone_ptr(arg_conv);
27287 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone"))) TS_CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(uint64_t orig) {
27288 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* orig_conv = (LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ*)untag_ptr(orig);
27289 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ), "LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ");
27290 *ret_conv = CResult_Bolt11InvoiceParseOrSemanticErrorZ_clone(orig_conv);
27291 return tag_ptr(ret_conv, true);
27294 uint64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(uint64_t o) {
27295 LDKSignedRawBolt11Invoice o_conv;
27296 o_conv.inner = untag_ptr(o);
27297 o_conv.is_owned = ptr_is_owned(o);
27298 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27299 o_conv = SignedRawBolt11Invoice_clone(&o_conv);
27300 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ), "LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ");
27301 *ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_ok(o_conv);
27302 return tag_ptr(ret_conv, true);
27305 uint64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(uint64_t e) {
27306 void* e_ptr = untag_ptr(e);
27307 CHECK_ACCESS(e_ptr);
27308 LDKBolt11ParseError e_conv = *(LDKBolt11ParseError*)(e_ptr);
27309 e_conv = Bolt11ParseError_clone((LDKBolt11ParseError*)untag_ptr(e));
27310 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ), "LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ");
27311 *ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_err(e_conv);
27312 return tag_ptr(ret_conv, true);
27315 jboolean __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(uint64_t o) {
27316 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* o_conv = (LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)untag_ptr(o);
27317 jboolean ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_is_ok(o_conv);
27321 void __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(uint64_t _res) {
27322 if (!ptr_is_owned(_res)) return;
27323 void* _res_ptr = untag_ptr(_res);
27324 CHECK_ACCESS(_res_ptr);
27325 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ _res_conv = *(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)(_res_ptr);
27326 FREE(untag_ptr(_res));
27327 CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_free(_res_conv);
27330 static inline uint64_t CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ *NONNULL_PTR arg) {
27331 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ), "LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ");
27332 *ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(arg);
27333 return tag_ptr(ret_conv, true);
27335 int64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(uint64_t arg) {
27336 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* arg_conv = (LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)untag_ptr(arg);
27337 int64_t ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone_ptr(arg_conv);
27341 uint64_t __attribute__((export_name("TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone"))) TS_CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(uint64_t orig) {
27342 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* orig_conv = (LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ*)untag_ptr(orig);
27343 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ), "LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ");
27344 *ret_conv = CResult_SignedRawBolt11InvoiceBolt11ParseErrorZ_clone(orig_conv);
27345 return tag_ptr(ret_conv, true);
27348 static inline uint64_t C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ *NONNULL_PTR arg) {
27349 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ), "LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ");
27350 *ret_conv = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(arg);
27351 return tag_ptr(ret_conv, true);
27353 int64_t __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(uint64_t arg) {
27354 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)untag_ptr(arg);
27355 int64_t ret_conv = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone_ptr(arg_conv);
27359 uint64_t __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(uint64_t orig) {
27360 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)untag_ptr(orig);
27361 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ), "LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ");
27362 *ret_conv = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_clone(orig_conv);
27363 return tag_ptr(ret_conv, true);
27366 uint64_t __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(uint64_t a, int8_tArray b, uint64_t c) {
27367 LDKRawBolt11Invoice a_conv;
27368 a_conv.inner = untag_ptr(a);
27369 a_conv.is_owned = ptr_is_owned(a);
27370 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
27371 a_conv = RawBolt11Invoice_clone(&a_conv);
27372 LDKThirtyTwoBytes b_ref;
27373 CHECK(b->arr_len == 32);
27374 memcpy(b_ref.data, b->elems, 32); FREE(b);
27375 LDKBolt11InvoiceSignature c_conv;
27376 c_conv.inner = untag_ptr(c);
27377 c_conv.is_owned = ptr_is_owned(c);
27378 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
27379 c_conv = Bolt11InvoiceSignature_clone(&c_conv);
27380 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ), "LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ");
27381 *ret_conv = C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
27382 return tag_ptr(ret_conv, true);
27385 void __attribute__((export_name("TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free"))) TS_C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(uint64_t _res) {
27386 if (!ptr_is_owned(_res)) return;
27387 void* _res_ptr = untag_ptr(_res);
27388 CHECK_ACCESS(_res_ptr);
27389 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ*)(_res_ptr);
27390 FREE(untag_ptr(_res));
27391 C3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ_free(_res_conv);
27394 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_ok"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_ok(uint64_t o) {
27395 LDKPayeePubKey o_conv;
27396 o_conv.inner = untag_ptr(o);
27397 o_conv.is_owned = ptr_is_owned(o);
27398 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27399 o_conv = PayeePubKey_clone(&o_conv);
27400 LDKCResult_PayeePubKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ), "LDKCResult_PayeePubKeySecp256k1ErrorZ");
27401 *ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_ok(o_conv);
27402 return tag_ptr(ret_conv, true);
27405 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_err"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_err(uint32_t e) {
27406 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
27407 LDKCResult_PayeePubKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ), "LDKCResult_PayeePubKeySecp256k1ErrorZ");
27408 *ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_err(e_conv);
27409 return tag_ptr(ret_conv, true);
27412 jboolean __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_is_ok(uint64_t o) {
27413 LDKCResult_PayeePubKeySecp256k1ErrorZ* o_conv = (LDKCResult_PayeePubKeySecp256k1ErrorZ*)untag_ptr(o);
27414 jboolean ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_is_ok(o_conv);
27418 void __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_free"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_free(uint64_t _res) {
27419 if (!ptr_is_owned(_res)) return;
27420 void* _res_ptr = untag_ptr(_res);
27421 CHECK_ACCESS(_res_ptr);
27422 LDKCResult_PayeePubKeySecp256k1ErrorZ _res_conv = *(LDKCResult_PayeePubKeySecp256k1ErrorZ*)(_res_ptr);
27423 FREE(untag_ptr(_res));
27424 CResult_PayeePubKeySecp256k1ErrorZ_free(_res_conv);
27427 static inline uint64_t CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(LDKCResult_PayeePubKeySecp256k1ErrorZ *NONNULL_PTR arg) {
27428 LDKCResult_PayeePubKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ), "LDKCResult_PayeePubKeySecp256k1ErrorZ");
27429 *ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_clone(arg);
27430 return tag_ptr(ret_conv, true);
27432 int64_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(uint64_t arg) {
27433 LDKCResult_PayeePubKeySecp256k1ErrorZ* arg_conv = (LDKCResult_PayeePubKeySecp256k1ErrorZ*)untag_ptr(arg);
27434 int64_t ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_clone_ptr(arg_conv);
27438 uint64_t __attribute__((export_name("TS_CResult_PayeePubKeySecp256k1ErrorZ_clone"))) TS_CResult_PayeePubKeySecp256k1ErrorZ_clone(uint64_t orig) {
27439 LDKCResult_PayeePubKeySecp256k1ErrorZ* orig_conv = (LDKCResult_PayeePubKeySecp256k1ErrorZ*)untag_ptr(orig);
27440 LDKCResult_PayeePubKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ), "LDKCResult_PayeePubKeySecp256k1ErrorZ");
27441 *ret_conv = CResult_PayeePubKeySecp256k1ErrorZ_clone(orig_conv);
27442 return tag_ptr(ret_conv, true);
27445 void __attribute__((export_name("TS_CVec_PrivateRouteZ_free"))) TS_CVec_PrivateRouteZ_free(uint64_tArray _res) {
27446 LDKCVec_PrivateRouteZ _res_constr;
27447 _res_constr.datalen = _res->arr_len;
27448 if (_res_constr.datalen > 0)
27449 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
27451 _res_constr.data = NULL;
27452 uint64_t* _res_vals = _res->elems;
27453 for (size_t o = 0; o < _res_constr.datalen; o++) {
27454 uint64_t _res_conv_14 = _res_vals[o];
27455 LDKPrivateRoute _res_conv_14_conv;
27456 _res_conv_14_conv.inner = untag_ptr(_res_conv_14);
27457 _res_conv_14_conv.is_owned = ptr_is_owned(_res_conv_14);
27458 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
27459 _res_constr.data[o] = _res_conv_14_conv;
27462 CVec_PrivateRouteZ_free(_res_constr);
27465 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint64_t o) {
27466 LDKPositiveTimestamp o_conv;
27467 o_conv.inner = untag_ptr(o);
27468 o_conv.is_owned = ptr_is_owned(o);
27469 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27470 o_conv = PositiveTimestamp_clone(&o_conv);
27471 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
27472 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
27473 return tag_ptr(ret_conv, true);
27476 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_err"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
27477 LDKCreationError e_conv = LDKCreationError_from_js(e);
27478 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
27479 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
27480 return tag_ptr(ret_conv, true);
27483 jboolean __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_is_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint64_t o) {
27484 LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(o);
27485 jboolean ret_conv = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
27489 void __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_free"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint64_t _res) {
27490 if (!ptr_is_owned(_res)) return;
27491 void* _res_ptr = untag_ptr(_res);
27492 CHECK_ACCESS(_res_ptr);
27493 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
27494 FREE(untag_ptr(_res));
27495 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
27498 static inline uint64_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
27499 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
27500 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
27501 return tag_ptr(ret_conv, true);
27503 int64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint64_t arg) {
27504 LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(arg);
27505 int64_t ret_conv = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
27509 uint64_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint64_t orig) {
27510 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)untag_ptr(orig);
27511 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
27512 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
27513 return tag_ptr(ret_conv, true);
27516 uint64_t __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_ok"))) TS_CResult_NoneBolt11SemanticErrorZ_ok() {
27517 LDKCResult_NoneBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneBolt11SemanticErrorZ), "LDKCResult_NoneBolt11SemanticErrorZ");
27518 *ret_conv = CResult_NoneBolt11SemanticErrorZ_ok();
27519 return tag_ptr(ret_conv, true);
27522 uint64_t __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_err"))) TS_CResult_NoneBolt11SemanticErrorZ_err(uint32_t e) {
27523 LDKBolt11SemanticError e_conv = LDKBolt11SemanticError_from_js(e);
27524 LDKCResult_NoneBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneBolt11SemanticErrorZ), "LDKCResult_NoneBolt11SemanticErrorZ");
27525 *ret_conv = CResult_NoneBolt11SemanticErrorZ_err(e_conv);
27526 return tag_ptr(ret_conv, true);
27529 jboolean __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_is_ok"))) TS_CResult_NoneBolt11SemanticErrorZ_is_ok(uint64_t o) {
27530 LDKCResult_NoneBolt11SemanticErrorZ* o_conv = (LDKCResult_NoneBolt11SemanticErrorZ*)untag_ptr(o);
27531 jboolean ret_conv = CResult_NoneBolt11SemanticErrorZ_is_ok(o_conv);
27535 void __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_free"))) TS_CResult_NoneBolt11SemanticErrorZ_free(uint64_t _res) {
27536 if (!ptr_is_owned(_res)) return;
27537 void* _res_ptr = untag_ptr(_res);
27538 CHECK_ACCESS(_res_ptr);
27539 LDKCResult_NoneBolt11SemanticErrorZ _res_conv = *(LDKCResult_NoneBolt11SemanticErrorZ*)(_res_ptr);
27540 FREE(untag_ptr(_res));
27541 CResult_NoneBolt11SemanticErrorZ_free(_res_conv);
27544 static inline uint64_t CResult_NoneBolt11SemanticErrorZ_clone_ptr(LDKCResult_NoneBolt11SemanticErrorZ *NONNULL_PTR arg) {
27545 LDKCResult_NoneBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneBolt11SemanticErrorZ), "LDKCResult_NoneBolt11SemanticErrorZ");
27546 *ret_conv = CResult_NoneBolt11SemanticErrorZ_clone(arg);
27547 return tag_ptr(ret_conv, true);
27549 int64_t __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr"))) TS_CResult_NoneBolt11SemanticErrorZ_clone_ptr(uint64_t arg) {
27550 LDKCResult_NoneBolt11SemanticErrorZ* arg_conv = (LDKCResult_NoneBolt11SemanticErrorZ*)untag_ptr(arg);
27551 int64_t ret_conv = CResult_NoneBolt11SemanticErrorZ_clone_ptr(arg_conv);
27555 uint64_t __attribute__((export_name("TS_CResult_NoneBolt11SemanticErrorZ_clone"))) TS_CResult_NoneBolt11SemanticErrorZ_clone(uint64_t orig) {
27556 LDKCResult_NoneBolt11SemanticErrorZ* orig_conv = (LDKCResult_NoneBolt11SemanticErrorZ*)untag_ptr(orig);
27557 LDKCResult_NoneBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneBolt11SemanticErrorZ), "LDKCResult_NoneBolt11SemanticErrorZ");
27558 *ret_conv = CResult_NoneBolt11SemanticErrorZ_clone(orig_conv);
27559 return tag_ptr(ret_conv, true);
27562 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(uint64_t o) {
27563 LDKBolt11Invoice o_conv;
27564 o_conv.inner = untag_ptr(o);
27565 o_conv.is_owned = ptr_is_owned(o);
27566 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27567 o_conv = Bolt11Invoice_clone(&o_conv);
27568 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ), "LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ");
27569 *ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_ok(o_conv);
27570 return tag_ptr(ret_conv, true);
27573 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(uint32_t e) {
27574 LDKBolt11SemanticError e_conv = LDKBolt11SemanticError_from_js(e);
27575 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ), "LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ");
27576 *ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_err(e_conv);
27577 return tag_ptr(ret_conv, true);
27580 jboolean __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(uint64_t o) {
27581 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* o_conv = (LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)untag_ptr(o);
27582 jboolean ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_is_ok(o_conv);
27586 void __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(uint64_t _res) {
27587 if (!ptr_is_owned(_res)) return;
27588 void* _res_ptr = untag_ptr(_res);
27589 CHECK_ACCESS(_res_ptr);
27590 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ _res_conv = *(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)(_res_ptr);
27591 FREE(untag_ptr(_res));
27592 CResult_Bolt11InvoiceBolt11SemanticErrorZ_free(_res_conv);
27595 static inline uint64_t CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ *NONNULL_PTR arg) {
27596 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ), "LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ");
27597 *ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(arg);
27598 return tag_ptr(ret_conv, true);
27600 int64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(uint64_t arg) {
27601 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* arg_conv = (LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)untag_ptr(arg);
27602 int64_t ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone_ptr(arg_conv);
27606 uint64_t __attribute__((export_name("TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone"))) TS_CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(uint64_t orig) {
27607 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* orig_conv = (LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ*)untag_ptr(orig);
27608 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ), "LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ");
27609 *ret_conv = CResult_Bolt11InvoiceBolt11SemanticErrorZ_clone(orig_conv);
27610 return tag_ptr(ret_conv, true);
27613 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_ok"))) TS_CResult_DescriptionCreationErrorZ_ok(uint64_t o) {
27614 LDKDescription o_conv;
27615 o_conv.inner = untag_ptr(o);
27616 o_conv.is_owned = ptr_is_owned(o);
27617 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27618 o_conv = Description_clone(&o_conv);
27619 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
27620 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
27621 return tag_ptr(ret_conv, true);
27624 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_err"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
27625 LDKCreationError e_conv = LDKCreationError_from_js(e);
27626 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
27627 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
27628 return tag_ptr(ret_conv, true);
27631 jboolean __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_is_ok"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint64_t o) {
27632 LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(o);
27633 jboolean ret_conv = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
27637 void __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_free"))) TS_CResult_DescriptionCreationErrorZ_free(uint64_t _res) {
27638 if (!ptr_is_owned(_res)) return;
27639 void* _res_ptr = untag_ptr(_res);
27640 CHECK_ACCESS(_res_ptr);
27641 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
27642 FREE(untag_ptr(_res));
27643 CResult_DescriptionCreationErrorZ_free(_res_conv);
27646 static inline uint64_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
27647 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
27648 *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
27649 return tag_ptr(ret_conv, true);
27651 int64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone_ptr"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint64_t arg) {
27652 LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(arg);
27653 int64_t ret_conv = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
27657 uint64_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone"))) TS_CResult_DescriptionCreationErrorZ_clone(uint64_t orig) {
27658 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)untag_ptr(orig);
27659 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
27660 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
27661 return tag_ptr(ret_conv, true);
27664 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_ok"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint64_t o) {
27665 LDKPrivateRoute o_conv;
27666 o_conv.inner = untag_ptr(o);
27667 o_conv.is_owned = ptr_is_owned(o);
27668 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27669 o_conv = PrivateRoute_clone(&o_conv);
27670 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
27671 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
27672 return tag_ptr(ret_conv, true);
27675 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_err"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
27676 LDKCreationError e_conv = LDKCreationError_from_js(e);
27677 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
27678 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
27679 return tag_ptr(ret_conv, true);
27682 jboolean __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_is_ok"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint64_t o) {
27683 LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(o);
27684 jboolean ret_conv = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
27688 void __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_free"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint64_t _res) {
27689 if (!ptr_is_owned(_res)) return;
27690 void* _res_ptr = untag_ptr(_res);
27691 CHECK_ACCESS(_res_ptr);
27692 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
27693 FREE(untag_ptr(_res));
27694 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
27697 static inline uint64_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
27698 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
27699 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
27700 return tag_ptr(ret_conv, true);
27702 int64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone_ptr"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint64_t arg) {
27703 LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(arg);
27704 int64_t ret_conv = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
27708 uint64_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint64_t orig) {
27709 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)untag_ptr(orig);
27710 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
27711 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
27712 return tag_ptr(ret_conv, true);
27715 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_ok"))) TS_CResult_OutPointDecodeErrorZ_ok(uint64_t o) {
27716 LDKOutPoint o_conv;
27717 o_conv.inner = untag_ptr(o);
27718 o_conv.is_owned = ptr_is_owned(o);
27719 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27720 o_conv = OutPoint_clone(&o_conv);
27721 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
27722 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
27723 return tag_ptr(ret_conv, true);
27726 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_err"))) TS_CResult_OutPointDecodeErrorZ_err(uint64_t e) {
27727 void* e_ptr = untag_ptr(e);
27728 CHECK_ACCESS(e_ptr);
27729 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27730 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27731 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
27732 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
27733 return tag_ptr(ret_conv, true);
27736 jboolean __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_is_ok"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint64_t o) {
27737 LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(o);
27738 jboolean ret_conv = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
27742 void __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_free"))) TS_CResult_OutPointDecodeErrorZ_free(uint64_t _res) {
27743 if (!ptr_is_owned(_res)) return;
27744 void* _res_ptr = untag_ptr(_res);
27745 CHECK_ACCESS(_res_ptr);
27746 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
27747 FREE(untag_ptr(_res));
27748 CResult_OutPointDecodeErrorZ_free(_res_conv);
27751 static inline uint64_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
27752 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
27753 *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
27754 return tag_ptr(ret_conv, true);
27756 int64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone_ptr"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint64_t arg) {
27757 LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(arg);
27758 int64_t ret_conv = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
27762 uint64_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone"))) TS_CResult_OutPointDecodeErrorZ_clone(uint64_t orig) {
27763 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)untag_ptr(orig);
27764 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
27765 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
27766 return tag_ptr(ret_conv, true);
27769 uint64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_ok"))) TS_CResult_BigSizeDecodeErrorZ_ok(uint64_t o) {
27771 o_conv.inner = untag_ptr(o);
27772 o_conv.is_owned = ptr_is_owned(o);
27773 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27774 o_conv = BigSize_clone(&o_conv);
27775 LDKCResult_BigSizeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BigSizeDecodeErrorZ), "LDKCResult_BigSizeDecodeErrorZ");
27776 *ret_conv = CResult_BigSizeDecodeErrorZ_ok(o_conv);
27777 return tag_ptr(ret_conv, true);
27780 uint64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_err"))) TS_CResult_BigSizeDecodeErrorZ_err(uint64_t e) {
27781 void* e_ptr = untag_ptr(e);
27782 CHECK_ACCESS(e_ptr);
27783 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27784 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27785 LDKCResult_BigSizeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BigSizeDecodeErrorZ), "LDKCResult_BigSizeDecodeErrorZ");
27786 *ret_conv = CResult_BigSizeDecodeErrorZ_err(e_conv);
27787 return tag_ptr(ret_conv, true);
27790 jboolean __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_is_ok"))) TS_CResult_BigSizeDecodeErrorZ_is_ok(uint64_t o) {
27791 LDKCResult_BigSizeDecodeErrorZ* o_conv = (LDKCResult_BigSizeDecodeErrorZ*)untag_ptr(o);
27792 jboolean ret_conv = CResult_BigSizeDecodeErrorZ_is_ok(o_conv);
27796 void __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_free"))) TS_CResult_BigSizeDecodeErrorZ_free(uint64_t _res) {
27797 if (!ptr_is_owned(_res)) return;
27798 void* _res_ptr = untag_ptr(_res);
27799 CHECK_ACCESS(_res_ptr);
27800 LDKCResult_BigSizeDecodeErrorZ _res_conv = *(LDKCResult_BigSizeDecodeErrorZ*)(_res_ptr);
27801 FREE(untag_ptr(_res));
27802 CResult_BigSizeDecodeErrorZ_free(_res_conv);
27805 static inline uint64_t CResult_BigSizeDecodeErrorZ_clone_ptr(LDKCResult_BigSizeDecodeErrorZ *NONNULL_PTR arg) {
27806 LDKCResult_BigSizeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BigSizeDecodeErrorZ), "LDKCResult_BigSizeDecodeErrorZ");
27807 *ret_conv = CResult_BigSizeDecodeErrorZ_clone(arg);
27808 return tag_ptr(ret_conv, true);
27810 int64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_clone_ptr"))) TS_CResult_BigSizeDecodeErrorZ_clone_ptr(uint64_t arg) {
27811 LDKCResult_BigSizeDecodeErrorZ* arg_conv = (LDKCResult_BigSizeDecodeErrorZ*)untag_ptr(arg);
27812 int64_t ret_conv = CResult_BigSizeDecodeErrorZ_clone_ptr(arg_conv);
27816 uint64_t __attribute__((export_name("TS_CResult_BigSizeDecodeErrorZ_clone"))) TS_CResult_BigSizeDecodeErrorZ_clone(uint64_t orig) {
27817 LDKCResult_BigSizeDecodeErrorZ* orig_conv = (LDKCResult_BigSizeDecodeErrorZ*)untag_ptr(orig);
27818 LDKCResult_BigSizeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BigSizeDecodeErrorZ), "LDKCResult_BigSizeDecodeErrorZ");
27819 *ret_conv = CResult_BigSizeDecodeErrorZ_clone(orig_conv);
27820 return tag_ptr(ret_conv, true);
27823 uint64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_ok"))) TS_CResult_HostnameDecodeErrorZ_ok(uint64_t o) {
27824 LDKHostname o_conv;
27825 o_conv.inner = untag_ptr(o);
27826 o_conv.is_owned = ptr_is_owned(o);
27827 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27828 o_conv = Hostname_clone(&o_conv);
27829 LDKCResult_HostnameDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HostnameDecodeErrorZ), "LDKCResult_HostnameDecodeErrorZ");
27830 *ret_conv = CResult_HostnameDecodeErrorZ_ok(o_conv);
27831 return tag_ptr(ret_conv, true);
27834 uint64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_err"))) TS_CResult_HostnameDecodeErrorZ_err(uint64_t e) {
27835 void* e_ptr = untag_ptr(e);
27836 CHECK_ACCESS(e_ptr);
27837 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27838 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27839 LDKCResult_HostnameDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HostnameDecodeErrorZ), "LDKCResult_HostnameDecodeErrorZ");
27840 *ret_conv = CResult_HostnameDecodeErrorZ_err(e_conv);
27841 return tag_ptr(ret_conv, true);
27844 jboolean __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_is_ok"))) TS_CResult_HostnameDecodeErrorZ_is_ok(uint64_t o) {
27845 LDKCResult_HostnameDecodeErrorZ* o_conv = (LDKCResult_HostnameDecodeErrorZ*)untag_ptr(o);
27846 jboolean ret_conv = CResult_HostnameDecodeErrorZ_is_ok(o_conv);
27850 void __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_free"))) TS_CResult_HostnameDecodeErrorZ_free(uint64_t _res) {
27851 if (!ptr_is_owned(_res)) return;
27852 void* _res_ptr = untag_ptr(_res);
27853 CHECK_ACCESS(_res_ptr);
27854 LDKCResult_HostnameDecodeErrorZ _res_conv = *(LDKCResult_HostnameDecodeErrorZ*)(_res_ptr);
27855 FREE(untag_ptr(_res));
27856 CResult_HostnameDecodeErrorZ_free(_res_conv);
27859 static inline uint64_t CResult_HostnameDecodeErrorZ_clone_ptr(LDKCResult_HostnameDecodeErrorZ *NONNULL_PTR arg) {
27860 LDKCResult_HostnameDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HostnameDecodeErrorZ), "LDKCResult_HostnameDecodeErrorZ");
27861 *ret_conv = CResult_HostnameDecodeErrorZ_clone(arg);
27862 return tag_ptr(ret_conv, true);
27864 int64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_clone_ptr"))) TS_CResult_HostnameDecodeErrorZ_clone_ptr(uint64_t arg) {
27865 LDKCResult_HostnameDecodeErrorZ* arg_conv = (LDKCResult_HostnameDecodeErrorZ*)untag_ptr(arg);
27866 int64_t ret_conv = CResult_HostnameDecodeErrorZ_clone_ptr(arg_conv);
27870 uint64_t __attribute__((export_name("TS_CResult_HostnameDecodeErrorZ_clone"))) TS_CResult_HostnameDecodeErrorZ_clone(uint64_t orig) {
27871 LDKCResult_HostnameDecodeErrorZ* orig_conv = (LDKCResult_HostnameDecodeErrorZ*)untag_ptr(orig);
27872 LDKCResult_HostnameDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HostnameDecodeErrorZ), "LDKCResult_HostnameDecodeErrorZ");
27873 *ret_conv = CResult_HostnameDecodeErrorZ_clone(orig_conv);
27874 return tag_ptr(ret_conv, true);
27877 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_ok"))) TS_CResult_TransactionU16LenLimitedNoneZ_ok(uint64_t o) {
27878 LDKTransactionU16LenLimited o_conv;
27879 o_conv.inner = untag_ptr(o);
27880 o_conv.is_owned = ptr_is_owned(o);
27881 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27882 o_conv = TransactionU16LenLimited_clone(&o_conv);
27883 LDKCResult_TransactionU16LenLimitedNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedNoneZ), "LDKCResult_TransactionU16LenLimitedNoneZ");
27884 *ret_conv = CResult_TransactionU16LenLimitedNoneZ_ok(o_conv);
27885 return tag_ptr(ret_conv, true);
27888 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_err"))) TS_CResult_TransactionU16LenLimitedNoneZ_err() {
27889 LDKCResult_TransactionU16LenLimitedNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedNoneZ), "LDKCResult_TransactionU16LenLimitedNoneZ");
27890 *ret_conv = CResult_TransactionU16LenLimitedNoneZ_err();
27891 return tag_ptr(ret_conv, true);
27894 jboolean __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_is_ok"))) TS_CResult_TransactionU16LenLimitedNoneZ_is_ok(uint64_t o) {
27895 LDKCResult_TransactionU16LenLimitedNoneZ* o_conv = (LDKCResult_TransactionU16LenLimitedNoneZ*)untag_ptr(o);
27896 jboolean ret_conv = CResult_TransactionU16LenLimitedNoneZ_is_ok(o_conv);
27900 void __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_free"))) TS_CResult_TransactionU16LenLimitedNoneZ_free(uint64_t _res) {
27901 if (!ptr_is_owned(_res)) return;
27902 void* _res_ptr = untag_ptr(_res);
27903 CHECK_ACCESS(_res_ptr);
27904 LDKCResult_TransactionU16LenLimitedNoneZ _res_conv = *(LDKCResult_TransactionU16LenLimitedNoneZ*)(_res_ptr);
27905 FREE(untag_ptr(_res));
27906 CResult_TransactionU16LenLimitedNoneZ_free(_res_conv);
27909 static inline uint64_t CResult_TransactionU16LenLimitedNoneZ_clone_ptr(LDKCResult_TransactionU16LenLimitedNoneZ *NONNULL_PTR arg) {
27910 LDKCResult_TransactionU16LenLimitedNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedNoneZ), "LDKCResult_TransactionU16LenLimitedNoneZ");
27911 *ret_conv = CResult_TransactionU16LenLimitedNoneZ_clone(arg);
27912 return tag_ptr(ret_conv, true);
27914 int64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr"))) TS_CResult_TransactionU16LenLimitedNoneZ_clone_ptr(uint64_t arg) {
27915 LDKCResult_TransactionU16LenLimitedNoneZ* arg_conv = (LDKCResult_TransactionU16LenLimitedNoneZ*)untag_ptr(arg);
27916 int64_t ret_conv = CResult_TransactionU16LenLimitedNoneZ_clone_ptr(arg_conv);
27920 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedNoneZ_clone"))) TS_CResult_TransactionU16LenLimitedNoneZ_clone(uint64_t orig) {
27921 LDKCResult_TransactionU16LenLimitedNoneZ* orig_conv = (LDKCResult_TransactionU16LenLimitedNoneZ*)untag_ptr(orig);
27922 LDKCResult_TransactionU16LenLimitedNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedNoneZ), "LDKCResult_TransactionU16LenLimitedNoneZ");
27923 *ret_conv = CResult_TransactionU16LenLimitedNoneZ_clone(orig_conv);
27924 return tag_ptr(ret_conv, true);
27927 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_ok(uint64_t o) {
27928 LDKTransactionU16LenLimited o_conv;
27929 o_conv.inner = untag_ptr(o);
27930 o_conv.is_owned = ptr_is_owned(o);
27931 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27932 o_conv = TransactionU16LenLimited_clone(&o_conv);
27933 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ), "LDKCResult_TransactionU16LenLimitedDecodeErrorZ");
27934 *ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_ok(o_conv);
27935 return tag_ptr(ret_conv, true);
27938 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_err(uint64_t e) {
27939 void* e_ptr = untag_ptr(e);
27940 CHECK_ACCESS(e_ptr);
27941 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27942 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27943 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ), "LDKCResult_TransactionU16LenLimitedDecodeErrorZ");
27944 *ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_err(e_conv);
27945 return tag_ptr(ret_conv, true);
27948 jboolean __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(uint64_t o) {
27949 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* o_conv = (LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)untag_ptr(o);
27950 jboolean ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_is_ok(o_conv);
27954 void __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_free(uint64_t _res) {
27955 if (!ptr_is_owned(_res)) return;
27956 void* _res_ptr = untag_ptr(_res);
27957 CHECK_ACCESS(_res_ptr);
27958 LDKCResult_TransactionU16LenLimitedDecodeErrorZ _res_conv = *(LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)(_res_ptr);
27959 FREE(untag_ptr(_res));
27960 CResult_TransactionU16LenLimitedDecodeErrorZ_free(_res_conv);
27963 static inline uint64_t CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(LDKCResult_TransactionU16LenLimitedDecodeErrorZ *NONNULL_PTR arg) {
27964 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ), "LDKCResult_TransactionU16LenLimitedDecodeErrorZ");
27965 *ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_clone(arg);
27966 return tag_ptr(ret_conv, true);
27968 int64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(uint64_t arg) {
27969 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* arg_conv = (LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)untag_ptr(arg);
27970 int64_t ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_clone_ptr(arg_conv);
27974 uint64_t __attribute__((export_name("TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone"))) TS_CResult_TransactionU16LenLimitedDecodeErrorZ_clone(uint64_t orig) {
27975 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* orig_conv = (LDKCResult_TransactionU16LenLimitedDecodeErrorZ*)untag_ptr(orig);
27976 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ), "LDKCResult_TransactionU16LenLimitedDecodeErrorZ");
27977 *ret_conv = CResult_TransactionU16LenLimitedDecodeErrorZ_clone(orig_conv);
27978 return tag_ptr(ret_conv, true);
27981 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_ok(uint64_t o) {
27982 LDKUntrustedString o_conv;
27983 o_conv.inner = untag_ptr(o);
27984 o_conv.is_owned = ptr_is_owned(o);
27985 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
27986 o_conv = UntrustedString_clone(&o_conv);
27987 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
27988 *ret_conv = CResult_UntrustedStringDecodeErrorZ_ok(o_conv);
27989 return tag_ptr(ret_conv, true);
27992 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_err"))) TS_CResult_UntrustedStringDecodeErrorZ_err(uint64_t e) {
27993 void* e_ptr = untag_ptr(e);
27994 CHECK_ACCESS(e_ptr);
27995 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
27996 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
27997 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
27998 *ret_conv = CResult_UntrustedStringDecodeErrorZ_err(e_conv);
27999 return tag_ptr(ret_conv, true);
28002 jboolean __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_is_ok"))) TS_CResult_UntrustedStringDecodeErrorZ_is_ok(uint64_t o) {
28003 LDKCResult_UntrustedStringDecodeErrorZ* o_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(o);
28004 jboolean ret_conv = CResult_UntrustedStringDecodeErrorZ_is_ok(o_conv);
28008 void __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_free"))) TS_CResult_UntrustedStringDecodeErrorZ_free(uint64_t _res) {
28009 if (!ptr_is_owned(_res)) return;
28010 void* _res_ptr = untag_ptr(_res);
28011 CHECK_ACCESS(_res_ptr);
28012 LDKCResult_UntrustedStringDecodeErrorZ _res_conv = *(LDKCResult_UntrustedStringDecodeErrorZ*)(_res_ptr);
28013 FREE(untag_ptr(_res));
28014 CResult_UntrustedStringDecodeErrorZ_free(_res_conv);
28017 static inline uint64_t CResult_UntrustedStringDecodeErrorZ_clone_ptr(LDKCResult_UntrustedStringDecodeErrorZ *NONNULL_PTR arg) {
28018 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
28019 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(arg);
28020 return tag_ptr(ret_conv, true);
28022 int64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr"))) TS_CResult_UntrustedStringDecodeErrorZ_clone_ptr(uint64_t arg) {
28023 LDKCResult_UntrustedStringDecodeErrorZ* arg_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(arg);
28024 int64_t ret_conv = CResult_UntrustedStringDecodeErrorZ_clone_ptr(arg_conv);
28028 uint64_t __attribute__((export_name("TS_CResult_UntrustedStringDecodeErrorZ_clone"))) TS_CResult_UntrustedStringDecodeErrorZ_clone(uint64_t orig) {
28029 LDKCResult_UntrustedStringDecodeErrorZ* orig_conv = (LDKCResult_UntrustedStringDecodeErrorZ*)untag_ptr(orig);
28030 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
28031 *ret_conv = CResult_UntrustedStringDecodeErrorZ_clone(orig_conv);
28032 return tag_ptr(ret_conv, true);
28035 uint64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_ok"))) TS_CResult_ReceiveTlvsDecodeErrorZ_ok(uint64_t o) {
28036 LDKReceiveTlvs o_conv;
28037 o_conv.inner = untag_ptr(o);
28038 o_conv.is_owned = ptr_is_owned(o);
28039 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28040 o_conv = ReceiveTlvs_clone(&o_conv);
28041 LDKCResult_ReceiveTlvsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ), "LDKCResult_ReceiveTlvsDecodeErrorZ");
28042 *ret_conv = CResult_ReceiveTlvsDecodeErrorZ_ok(o_conv);
28043 return tag_ptr(ret_conv, true);
28046 uint64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_err"))) TS_CResult_ReceiveTlvsDecodeErrorZ_err(uint64_t e) {
28047 void* e_ptr = untag_ptr(e);
28048 CHECK_ACCESS(e_ptr);
28049 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28050 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28051 LDKCResult_ReceiveTlvsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ), "LDKCResult_ReceiveTlvsDecodeErrorZ");
28052 *ret_conv = CResult_ReceiveTlvsDecodeErrorZ_err(e_conv);
28053 return tag_ptr(ret_conv, true);
28056 jboolean __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_is_ok"))) TS_CResult_ReceiveTlvsDecodeErrorZ_is_ok(uint64_t o) {
28057 LDKCResult_ReceiveTlvsDecodeErrorZ* o_conv = (LDKCResult_ReceiveTlvsDecodeErrorZ*)untag_ptr(o);
28058 jboolean ret_conv = CResult_ReceiveTlvsDecodeErrorZ_is_ok(o_conv);
28062 void __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_free"))) TS_CResult_ReceiveTlvsDecodeErrorZ_free(uint64_t _res) {
28063 if (!ptr_is_owned(_res)) return;
28064 void* _res_ptr = untag_ptr(_res);
28065 CHECK_ACCESS(_res_ptr);
28066 LDKCResult_ReceiveTlvsDecodeErrorZ _res_conv = *(LDKCResult_ReceiveTlvsDecodeErrorZ*)(_res_ptr);
28067 FREE(untag_ptr(_res));
28068 CResult_ReceiveTlvsDecodeErrorZ_free(_res_conv);
28071 static inline uint64_t CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(LDKCResult_ReceiveTlvsDecodeErrorZ *NONNULL_PTR arg) {
28072 LDKCResult_ReceiveTlvsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ), "LDKCResult_ReceiveTlvsDecodeErrorZ");
28073 *ret_conv = CResult_ReceiveTlvsDecodeErrorZ_clone(arg);
28074 return tag_ptr(ret_conv, true);
28076 int64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_clone_ptr"))) TS_CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(uint64_t arg) {
28077 LDKCResult_ReceiveTlvsDecodeErrorZ* arg_conv = (LDKCResult_ReceiveTlvsDecodeErrorZ*)untag_ptr(arg);
28078 int64_t ret_conv = CResult_ReceiveTlvsDecodeErrorZ_clone_ptr(arg_conv);
28082 uint64_t __attribute__((export_name("TS_CResult_ReceiveTlvsDecodeErrorZ_clone"))) TS_CResult_ReceiveTlvsDecodeErrorZ_clone(uint64_t orig) {
28083 LDKCResult_ReceiveTlvsDecodeErrorZ* orig_conv = (LDKCResult_ReceiveTlvsDecodeErrorZ*)untag_ptr(orig);
28084 LDKCResult_ReceiveTlvsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ), "LDKCResult_ReceiveTlvsDecodeErrorZ");
28085 *ret_conv = CResult_ReceiveTlvsDecodeErrorZ_clone(orig_conv);
28086 return tag_ptr(ret_conv, true);
28089 uint64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_ok"))) TS_CResult_PaymentRelayDecodeErrorZ_ok(uint64_t o) {
28090 LDKPaymentRelay o_conv;
28091 o_conv.inner = untag_ptr(o);
28092 o_conv.is_owned = ptr_is_owned(o);
28093 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28094 o_conv = PaymentRelay_clone(&o_conv);
28095 LDKCResult_PaymentRelayDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentRelayDecodeErrorZ), "LDKCResult_PaymentRelayDecodeErrorZ");
28096 *ret_conv = CResult_PaymentRelayDecodeErrorZ_ok(o_conv);
28097 return tag_ptr(ret_conv, true);
28100 uint64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_err"))) TS_CResult_PaymentRelayDecodeErrorZ_err(uint64_t e) {
28101 void* e_ptr = untag_ptr(e);
28102 CHECK_ACCESS(e_ptr);
28103 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28104 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28105 LDKCResult_PaymentRelayDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentRelayDecodeErrorZ), "LDKCResult_PaymentRelayDecodeErrorZ");
28106 *ret_conv = CResult_PaymentRelayDecodeErrorZ_err(e_conv);
28107 return tag_ptr(ret_conv, true);
28110 jboolean __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_is_ok"))) TS_CResult_PaymentRelayDecodeErrorZ_is_ok(uint64_t o) {
28111 LDKCResult_PaymentRelayDecodeErrorZ* o_conv = (LDKCResult_PaymentRelayDecodeErrorZ*)untag_ptr(o);
28112 jboolean ret_conv = CResult_PaymentRelayDecodeErrorZ_is_ok(o_conv);
28116 void __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_free"))) TS_CResult_PaymentRelayDecodeErrorZ_free(uint64_t _res) {
28117 if (!ptr_is_owned(_res)) return;
28118 void* _res_ptr = untag_ptr(_res);
28119 CHECK_ACCESS(_res_ptr);
28120 LDKCResult_PaymentRelayDecodeErrorZ _res_conv = *(LDKCResult_PaymentRelayDecodeErrorZ*)(_res_ptr);
28121 FREE(untag_ptr(_res));
28122 CResult_PaymentRelayDecodeErrorZ_free(_res_conv);
28125 static inline uint64_t CResult_PaymentRelayDecodeErrorZ_clone_ptr(LDKCResult_PaymentRelayDecodeErrorZ *NONNULL_PTR arg) {
28126 LDKCResult_PaymentRelayDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentRelayDecodeErrorZ), "LDKCResult_PaymentRelayDecodeErrorZ");
28127 *ret_conv = CResult_PaymentRelayDecodeErrorZ_clone(arg);
28128 return tag_ptr(ret_conv, true);
28130 int64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentRelayDecodeErrorZ_clone_ptr(uint64_t arg) {
28131 LDKCResult_PaymentRelayDecodeErrorZ* arg_conv = (LDKCResult_PaymentRelayDecodeErrorZ*)untag_ptr(arg);
28132 int64_t ret_conv = CResult_PaymentRelayDecodeErrorZ_clone_ptr(arg_conv);
28136 uint64_t __attribute__((export_name("TS_CResult_PaymentRelayDecodeErrorZ_clone"))) TS_CResult_PaymentRelayDecodeErrorZ_clone(uint64_t orig) {
28137 LDKCResult_PaymentRelayDecodeErrorZ* orig_conv = (LDKCResult_PaymentRelayDecodeErrorZ*)untag_ptr(orig);
28138 LDKCResult_PaymentRelayDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentRelayDecodeErrorZ), "LDKCResult_PaymentRelayDecodeErrorZ");
28139 *ret_conv = CResult_PaymentRelayDecodeErrorZ_clone(orig_conv);
28140 return tag_ptr(ret_conv, true);
28143 uint64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_ok"))) TS_CResult_PaymentConstraintsDecodeErrorZ_ok(uint64_t o) {
28144 LDKPaymentConstraints o_conv;
28145 o_conv.inner = untag_ptr(o);
28146 o_conv.is_owned = ptr_is_owned(o);
28147 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28148 o_conv = PaymentConstraints_clone(&o_conv);
28149 LDKCResult_PaymentConstraintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ), "LDKCResult_PaymentConstraintsDecodeErrorZ");
28150 *ret_conv = CResult_PaymentConstraintsDecodeErrorZ_ok(o_conv);
28151 return tag_ptr(ret_conv, true);
28154 uint64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_err"))) TS_CResult_PaymentConstraintsDecodeErrorZ_err(uint64_t e) {
28155 void* e_ptr = untag_ptr(e);
28156 CHECK_ACCESS(e_ptr);
28157 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28158 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28159 LDKCResult_PaymentConstraintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ), "LDKCResult_PaymentConstraintsDecodeErrorZ");
28160 *ret_conv = CResult_PaymentConstraintsDecodeErrorZ_err(e_conv);
28161 return tag_ptr(ret_conv, true);
28164 jboolean __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok"))) TS_CResult_PaymentConstraintsDecodeErrorZ_is_ok(uint64_t o) {
28165 LDKCResult_PaymentConstraintsDecodeErrorZ* o_conv = (LDKCResult_PaymentConstraintsDecodeErrorZ*)untag_ptr(o);
28166 jboolean ret_conv = CResult_PaymentConstraintsDecodeErrorZ_is_ok(o_conv);
28170 void __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_free"))) TS_CResult_PaymentConstraintsDecodeErrorZ_free(uint64_t _res) {
28171 if (!ptr_is_owned(_res)) return;
28172 void* _res_ptr = untag_ptr(_res);
28173 CHECK_ACCESS(_res_ptr);
28174 LDKCResult_PaymentConstraintsDecodeErrorZ _res_conv = *(LDKCResult_PaymentConstraintsDecodeErrorZ*)(_res_ptr);
28175 FREE(untag_ptr(_res));
28176 CResult_PaymentConstraintsDecodeErrorZ_free(_res_conv);
28179 static inline uint64_t CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(LDKCResult_PaymentConstraintsDecodeErrorZ *NONNULL_PTR arg) {
28180 LDKCResult_PaymentConstraintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ), "LDKCResult_PaymentConstraintsDecodeErrorZ");
28181 *ret_conv = CResult_PaymentConstraintsDecodeErrorZ_clone(arg);
28182 return tag_ptr(ret_conv, true);
28184 int64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(uint64_t arg) {
28185 LDKCResult_PaymentConstraintsDecodeErrorZ* arg_conv = (LDKCResult_PaymentConstraintsDecodeErrorZ*)untag_ptr(arg);
28186 int64_t ret_conv = CResult_PaymentConstraintsDecodeErrorZ_clone_ptr(arg_conv);
28190 uint64_t __attribute__((export_name("TS_CResult_PaymentConstraintsDecodeErrorZ_clone"))) TS_CResult_PaymentConstraintsDecodeErrorZ_clone(uint64_t orig) {
28191 LDKCResult_PaymentConstraintsDecodeErrorZ* orig_conv = (LDKCResult_PaymentConstraintsDecodeErrorZ*)untag_ptr(orig);
28192 LDKCResult_PaymentConstraintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ), "LDKCResult_PaymentConstraintsDecodeErrorZ");
28193 *ret_conv = CResult_PaymentConstraintsDecodeErrorZ_clone(orig_conv);
28194 return tag_ptr(ret_conv, true);
28197 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_ok"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_ok(int8_tArray o) {
28198 LDKThirtyTwoBytes o_ref;
28199 CHECK(o->arr_len == 32);
28200 memcpy(o_ref.data, o->elems, 32); FREE(o);
28201 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
28202 *ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_ok(o_ref);
28203 return tag_ptr(ret_conv, true);
28206 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_err"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_err(uint64_t e) {
28207 void* e_ptr = untag_ptr(e);
28208 CHECK_ACCESS(e_ptr);
28209 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
28210 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
28211 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
28212 *ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_err(e_conv);
28213 return tag_ptr(ret_conv, true);
28216 jboolean __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_is_ok"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(uint64_t o) {
28217 LDKCResult_ThirtyTwoBytesPaymentErrorZ* o_conv = (LDKCResult_ThirtyTwoBytesPaymentErrorZ*)untag_ptr(o);
28218 jboolean ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_is_ok(o_conv);
28222 void __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_free"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_free(uint64_t _res) {
28223 if (!ptr_is_owned(_res)) return;
28224 void* _res_ptr = untag_ptr(_res);
28225 CHECK_ACCESS(_res_ptr);
28226 LDKCResult_ThirtyTwoBytesPaymentErrorZ _res_conv = *(LDKCResult_ThirtyTwoBytesPaymentErrorZ*)(_res_ptr);
28227 FREE(untag_ptr(_res));
28228 CResult_ThirtyTwoBytesPaymentErrorZ_free(_res_conv);
28231 static inline uint64_t CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(LDKCResult_ThirtyTwoBytesPaymentErrorZ *NONNULL_PTR arg) {
28232 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
28233 *ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_clone(arg);
28234 return tag_ptr(ret_conv, true);
28236 int64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(uint64_t arg) {
28237 LDKCResult_ThirtyTwoBytesPaymentErrorZ* arg_conv = (LDKCResult_ThirtyTwoBytesPaymentErrorZ*)untag_ptr(arg);
28238 int64_t ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_clone_ptr(arg_conv);
28242 uint64_t __attribute__((export_name("TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone"))) TS_CResult_ThirtyTwoBytesPaymentErrorZ_clone(uint64_t orig) {
28243 LDKCResult_ThirtyTwoBytesPaymentErrorZ* orig_conv = (LDKCResult_ThirtyTwoBytesPaymentErrorZ*)untag_ptr(orig);
28244 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
28245 *ret_conv = CResult_ThirtyTwoBytesPaymentErrorZ_clone(orig_conv);
28246 return tag_ptr(ret_conv, true);
28249 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_ok"))) TS_CResult_NonePaymentErrorZ_ok() {
28250 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
28251 *ret_conv = CResult_NonePaymentErrorZ_ok();
28252 return tag_ptr(ret_conv, true);
28255 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_err"))) TS_CResult_NonePaymentErrorZ_err(uint64_t e) {
28256 void* e_ptr = untag_ptr(e);
28257 CHECK_ACCESS(e_ptr);
28258 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
28259 e_conv = PaymentError_clone((LDKPaymentError*)untag_ptr(e));
28260 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
28261 *ret_conv = CResult_NonePaymentErrorZ_err(e_conv);
28262 return tag_ptr(ret_conv, true);
28265 jboolean __attribute__((export_name("TS_CResult_NonePaymentErrorZ_is_ok"))) TS_CResult_NonePaymentErrorZ_is_ok(uint64_t o) {
28266 LDKCResult_NonePaymentErrorZ* o_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(o);
28267 jboolean ret_conv = CResult_NonePaymentErrorZ_is_ok(o_conv);
28271 void __attribute__((export_name("TS_CResult_NonePaymentErrorZ_free"))) TS_CResult_NonePaymentErrorZ_free(uint64_t _res) {
28272 if (!ptr_is_owned(_res)) return;
28273 void* _res_ptr = untag_ptr(_res);
28274 CHECK_ACCESS(_res_ptr);
28275 LDKCResult_NonePaymentErrorZ _res_conv = *(LDKCResult_NonePaymentErrorZ*)(_res_ptr);
28276 FREE(untag_ptr(_res));
28277 CResult_NonePaymentErrorZ_free(_res_conv);
28280 static inline uint64_t CResult_NonePaymentErrorZ_clone_ptr(LDKCResult_NonePaymentErrorZ *NONNULL_PTR arg) {
28281 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
28282 *ret_conv = CResult_NonePaymentErrorZ_clone(arg);
28283 return tag_ptr(ret_conv, true);
28285 int64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone_ptr"))) TS_CResult_NonePaymentErrorZ_clone_ptr(uint64_t arg) {
28286 LDKCResult_NonePaymentErrorZ* arg_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(arg);
28287 int64_t ret_conv = CResult_NonePaymentErrorZ_clone_ptr(arg_conv);
28291 uint64_t __attribute__((export_name("TS_CResult_NonePaymentErrorZ_clone"))) TS_CResult_NonePaymentErrorZ_clone(uint64_t orig) {
28292 LDKCResult_NonePaymentErrorZ* orig_conv = (LDKCResult_NonePaymentErrorZ*)untag_ptr(orig);
28293 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
28294 *ret_conv = CResult_NonePaymentErrorZ_clone(orig_conv);
28295 return tag_ptr(ret_conv, true);
28298 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(uint64_tArray o) {
28299 LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ o_constr;
28300 o_constr.datalen = o->arr_len;
28301 if (o_constr.datalen > 0)
28302 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ), "LDKCVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZ Elements");
28304 o_constr.data = NULL;
28305 uint64_t* o_vals = o->elems;
28306 for (size_t o = 0; o < o_constr.datalen; o++) {
28307 uint64_t o_conv_40 = o_vals[o];
28308 void* o_conv_40_ptr = untag_ptr(o_conv_40);
28309 CHECK_ACCESS(o_conv_40_ptr);
28310 LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ o_conv_40_conv = *(LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)(o_conv_40_ptr);
28311 o_conv_40_conv = C2Tuple_ThirtyTwoBytesThirtyTwoBytesZ_clone((LDKC2Tuple_ThirtyTwoBytesThirtyTwoBytesZ*)untag_ptr(o_conv_40));
28312 o_constr.data[o] = o_conv_40_conv;
28315 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
28316 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_ok(o_constr);
28317 return tag_ptr(ret_conv, true);
28320 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(uint64_t e) {
28321 void* e_ptr = untag_ptr(e);
28322 CHECK_ACCESS(e_ptr);
28323 LDKProbingError e_conv = *(LDKProbingError*)(e_ptr);
28324 e_conv = ProbingError_clone((LDKProbingError*)untag_ptr(e));
28325 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
28326 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_err(e_conv);
28327 return tag_ptr(ret_conv, true);
28330 jboolean __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(uint64_t o) {
28331 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* o_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)untag_ptr(o);
28332 jboolean ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_is_ok(o_conv);
28336 void __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(uint64_t _res) {
28337 if (!ptr_is_owned(_res)) return;
28338 void* _res_ptr = untag_ptr(_res);
28339 CHECK_ACCESS(_res_ptr);
28340 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ _res_conv = *(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)(_res_ptr);
28341 FREE(untag_ptr(_res));
28342 CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_free(_res_conv);
28345 static inline uint64_t CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ *NONNULL_PTR arg) {
28346 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
28347 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(arg);
28348 return tag_ptr(ret_conv, true);
28350 int64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(uint64_t arg) {
28351 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* arg_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)untag_ptr(arg);
28352 int64_t ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone_ptr(arg_conv);
28356 uint64_t __attribute__((export_name("TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone"))) TS_CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(uint64_t orig) {
28357 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ*)untag_ptr(orig);
28358 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
28359 *ret_conv = CResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ_clone(orig_conv);
28360 return tag_ptr(ret_conv, true);
28363 uint64_t __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_ok"))) TS_CResult_StrSecp256k1ErrorZ_ok(jstring o) {
28364 LDKStr o_conv = str_ref_to_owned_c(o);
28365 LDKCResult_StrSecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StrSecp256k1ErrorZ), "LDKCResult_StrSecp256k1ErrorZ");
28366 *ret_conv = CResult_StrSecp256k1ErrorZ_ok(o_conv);
28367 return tag_ptr(ret_conv, true);
28370 uint64_t __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_err"))) TS_CResult_StrSecp256k1ErrorZ_err(uint32_t e) {
28371 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
28372 LDKCResult_StrSecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StrSecp256k1ErrorZ), "LDKCResult_StrSecp256k1ErrorZ");
28373 *ret_conv = CResult_StrSecp256k1ErrorZ_err(e_conv);
28374 return tag_ptr(ret_conv, true);
28377 jboolean __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_is_ok"))) TS_CResult_StrSecp256k1ErrorZ_is_ok(uint64_t o) {
28378 LDKCResult_StrSecp256k1ErrorZ* o_conv = (LDKCResult_StrSecp256k1ErrorZ*)untag_ptr(o);
28379 jboolean ret_conv = CResult_StrSecp256k1ErrorZ_is_ok(o_conv);
28383 void __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_free"))) TS_CResult_StrSecp256k1ErrorZ_free(uint64_t _res) {
28384 if (!ptr_is_owned(_res)) return;
28385 void* _res_ptr = untag_ptr(_res);
28386 CHECK_ACCESS(_res_ptr);
28387 LDKCResult_StrSecp256k1ErrorZ _res_conv = *(LDKCResult_StrSecp256k1ErrorZ*)(_res_ptr);
28388 FREE(untag_ptr(_res));
28389 CResult_StrSecp256k1ErrorZ_free(_res_conv);
28392 static inline uint64_t CResult_StrSecp256k1ErrorZ_clone_ptr(LDKCResult_StrSecp256k1ErrorZ *NONNULL_PTR arg) {
28393 LDKCResult_StrSecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StrSecp256k1ErrorZ), "LDKCResult_StrSecp256k1ErrorZ");
28394 *ret_conv = CResult_StrSecp256k1ErrorZ_clone(arg);
28395 return tag_ptr(ret_conv, true);
28397 int64_t __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_clone_ptr"))) TS_CResult_StrSecp256k1ErrorZ_clone_ptr(uint64_t arg) {
28398 LDKCResult_StrSecp256k1ErrorZ* arg_conv = (LDKCResult_StrSecp256k1ErrorZ*)untag_ptr(arg);
28399 int64_t ret_conv = CResult_StrSecp256k1ErrorZ_clone_ptr(arg_conv);
28403 uint64_t __attribute__((export_name("TS_CResult_StrSecp256k1ErrorZ_clone"))) TS_CResult_StrSecp256k1ErrorZ_clone(uint64_t orig) {
28404 LDKCResult_StrSecp256k1ErrorZ* orig_conv = (LDKCResult_StrSecp256k1ErrorZ*)untag_ptr(orig);
28405 LDKCResult_StrSecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StrSecp256k1ErrorZ), "LDKCResult_StrSecp256k1ErrorZ");
28406 *ret_conv = CResult_StrSecp256k1ErrorZ_clone(orig_conv);
28407 return tag_ptr(ret_conv, true);
28410 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_ok(uint64_t o) {
28411 void* o_ptr = untag_ptr(o);
28412 CHECK_ACCESS(o_ptr);
28413 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
28414 o_conv = TxOut_clone((LDKTxOut*)untag_ptr(o));
28415 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
28416 *ret_conv = CResult_TxOutUtxoLookupErrorZ_ok(o_conv);
28417 return tag_ptr(ret_conv, true);
28420 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_err"))) TS_CResult_TxOutUtxoLookupErrorZ_err(uint32_t e) {
28421 LDKUtxoLookupError e_conv = LDKUtxoLookupError_from_js(e);
28422 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
28423 *ret_conv = CResult_TxOutUtxoLookupErrorZ_err(e_conv);
28424 return tag_ptr(ret_conv, true);
28427 jboolean __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_is_ok"))) TS_CResult_TxOutUtxoLookupErrorZ_is_ok(uint64_t o) {
28428 LDKCResult_TxOutUtxoLookupErrorZ* o_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(o);
28429 jboolean ret_conv = CResult_TxOutUtxoLookupErrorZ_is_ok(o_conv);
28433 void __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_free"))) TS_CResult_TxOutUtxoLookupErrorZ_free(uint64_t _res) {
28434 if (!ptr_is_owned(_res)) return;
28435 void* _res_ptr = untag_ptr(_res);
28436 CHECK_ACCESS(_res_ptr);
28437 LDKCResult_TxOutUtxoLookupErrorZ _res_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(_res_ptr);
28438 FREE(untag_ptr(_res));
28439 CResult_TxOutUtxoLookupErrorZ_free(_res_conv);
28442 static inline uint64_t CResult_TxOutUtxoLookupErrorZ_clone_ptr(LDKCResult_TxOutUtxoLookupErrorZ *NONNULL_PTR arg) {
28443 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
28444 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(arg);
28445 return tag_ptr(ret_conv, true);
28447 int64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr"))) TS_CResult_TxOutUtxoLookupErrorZ_clone_ptr(uint64_t arg) {
28448 LDKCResult_TxOutUtxoLookupErrorZ* arg_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(arg);
28449 int64_t ret_conv = CResult_TxOutUtxoLookupErrorZ_clone_ptr(arg_conv);
28453 uint64_t __attribute__((export_name("TS_CResult_TxOutUtxoLookupErrorZ_clone"))) TS_CResult_TxOutUtxoLookupErrorZ_clone(uint64_t orig) {
28454 LDKCResult_TxOutUtxoLookupErrorZ* orig_conv = (LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(orig);
28455 LDKCResult_TxOutUtxoLookupErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutUtxoLookupErrorZ), "LDKCResult_TxOutUtxoLookupErrorZ");
28456 *ret_conv = CResult_TxOutUtxoLookupErrorZ_clone(orig_conv);
28457 return tag_ptr(ret_conv, true);
28460 uint64_t __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_ok"))) TS_CResult_OnionMessagePathNoneZ_ok(uint64_t o) {
28461 LDKOnionMessagePath o_conv;
28462 o_conv.inner = untag_ptr(o);
28463 o_conv.is_owned = ptr_is_owned(o);
28464 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28465 o_conv = OnionMessagePath_clone(&o_conv);
28466 LDKCResult_OnionMessagePathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessagePathNoneZ), "LDKCResult_OnionMessagePathNoneZ");
28467 *ret_conv = CResult_OnionMessagePathNoneZ_ok(o_conv);
28468 return tag_ptr(ret_conv, true);
28471 uint64_t __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_err"))) TS_CResult_OnionMessagePathNoneZ_err() {
28472 LDKCResult_OnionMessagePathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessagePathNoneZ), "LDKCResult_OnionMessagePathNoneZ");
28473 *ret_conv = CResult_OnionMessagePathNoneZ_err();
28474 return tag_ptr(ret_conv, true);
28477 jboolean __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_is_ok"))) TS_CResult_OnionMessagePathNoneZ_is_ok(uint64_t o) {
28478 LDKCResult_OnionMessagePathNoneZ* o_conv = (LDKCResult_OnionMessagePathNoneZ*)untag_ptr(o);
28479 jboolean ret_conv = CResult_OnionMessagePathNoneZ_is_ok(o_conv);
28483 void __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_free"))) TS_CResult_OnionMessagePathNoneZ_free(uint64_t _res) {
28484 if (!ptr_is_owned(_res)) return;
28485 void* _res_ptr = untag_ptr(_res);
28486 CHECK_ACCESS(_res_ptr);
28487 LDKCResult_OnionMessagePathNoneZ _res_conv = *(LDKCResult_OnionMessagePathNoneZ*)(_res_ptr);
28488 FREE(untag_ptr(_res));
28489 CResult_OnionMessagePathNoneZ_free(_res_conv);
28492 static inline uint64_t CResult_OnionMessagePathNoneZ_clone_ptr(LDKCResult_OnionMessagePathNoneZ *NONNULL_PTR arg) {
28493 LDKCResult_OnionMessagePathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessagePathNoneZ), "LDKCResult_OnionMessagePathNoneZ");
28494 *ret_conv = CResult_OnionMessagePathNoneZ_clone(arg);
28495 return tag_ptr(ret_conv, true);
28497 int64_t __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_clone_ptr"))) TS_CResult_OnionMessagePathNoneZ_clone_ptr(uint64_t arg) {
28498 LDKCResult_OnionMessagePathNoneZ* arg_conv = (LDKCResult_OnionMessagePathNoneZ*)untag_ptr(arg);
28499 int64_t ret_conv = CResult_OnionMessagePathNoneZ_clone_ptr(arg_conv);
28503 uint64_t __attribute__((export_name("TS_CResult_OnionMessagePathNoneZ_clone"))) TS_CResult_OnionMessagePathNoneZ_clone(uint64_t orig) {
28504 LDKCResult_OnionMessagePathNoneZ* orig_conv = (LDKCResult_OnionMessagePathNoneZ*)untag_ptr(orig);
28505 LDKCResult_OnionMessagePathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessagePathNoneZ), "LDKCResult_OnionMessagePathNoneZ");
28506 *ret_conv = CResult_OnionMessagePathNoneZ_clone(orig_conv);
28507 return tag_ptr(ret_conv, true);
28510 static inline uint64_t C2Tuple_PublicKeyOnionMessageZ_clone_ptr(LDKC2Tuple_PublicKeyOnionMessageZ *NONNULL_PTR arg) {
28511 LDKC2Tuple_PublicKeyOnionMessageZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyOnionMessageZ), "LDKC2Tuple_PublicKeyOnionMessageZ");
28512 *ret_conv = C2Tuple_PublicKeyOnionMessageZ_clone(arg);
28513 return tag_ptr(ret_conv, true);
28515 int64_t __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_clone_ptr"))) TS_C2Tuple_PublicKeyOnionMessageZ_clone_ptr(uint64_t arg) {
28516 LDKC2Tuple_PublicKeyOnionMessageZ* arg_conv = (LDKC2Tuple_PublicKeyOnionMessageZ*)untag_ptr(arg);
28517 int64_t ret_conv = C2Tuple_PublicKeyOnionMessageZ_clone_ptr(arg_conv);
28521 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_clone"))) TS_C2Tuple_PublicKeyOnionMessageZ_clone(uint64_t orig) {
28522 LDKC2Tuple_PublicKeyOnionMessageZ* orig_conv = (LDKC2Tuple_PublicKeyOnionMessageZ*)untag_ptr(orig);
28523 LDKC2Tuple_PublicKeyOnionMessageZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyOnionMessageZ), "LDKC2Tuple_PublicKeyOnionMessageZ");
28524 *ret_conv = C2Tuple_PublicKeyOnionMessageZ_clone(orig_conv);
28525 return tag_ptr(ret_conv, true);
28528 uint64_t __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_new"))) TS_C2Tuple_PublicKeyOnionMessageZ_new(int8_tArray a, uint64_t b) {
28529 LDKPublicKey a_ref;
28530 CHECK(a->arr_len == 33);
28531 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
28532 LDKOnionMessage b_conv;
28533 b_conv.inner = untag_ptr(b);
28534 b_conv.is_owned = ptr_is_owned(b);
28535 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
28536 b_conv = OnionMessage_clone(&b_conv);
28537 LDKC2Tuple_PublicKeyOnionMessageZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyOnionMessageZ), "LDKC2Tuple_PublicKeyOnionMessageZ");
28538 *ret_conv = C2Tuple_PublicKeyOnionMessageZ_new(a_ref, b_conv);
28539 return tag_ptr(ret_conv, true);
28542 void __attribute__((export_name("TS_C2Tuple_PublicKeyOnionMessageZ_free"))) TS_C2Tuple_PublicKeyOnionMessageZ_free(uint64_t _res) {
28543 if (!ptr_is_owned(_res)) return;
28544 void* _res_ptr = untag_ptr(_res);
28545 CHECK_ACCESS(_res_ptr);
28546 LDKC2Tuple_PublicKeyOnionMessageZ _res_conv = *(LDKC2Tuple_PublicKeyOnionMessageZ*)(_res_ptr);
28547 FREE(untag_ptr(_res));
28548 C2Tuple_PublicKeyOnionMessageZ_free(_res_conv);
28551 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(uint64_t o) {
28552 void* o_ptr = untag_ptr(o);
28553 CHECK_ACCESS(o_ptr);
28554 LDKC2Tuple_PublicKeyOnionMessageZ o_conv = *(LDKC2Tuple_PublicKeyOnionMessageZ*)(o_ptr);
28555 o_conv = C2Tuple_PublicKeyOnionMessageZ_clone((LDKC2Tuple_PublicKeyOnionMessageZ*)untag_ptr(o));
28556 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ), "LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ");
28557 *ret_conv = CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_ok(o_conv);
28558 return tag_ptr(ret_conv, true);
28561 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(uint64_t e) {
28562 void* e_ptr = untag_ptr(e);
28563 CHECK_ACCESS(e_ptr);
28564 LDKSendError e_conv = *(LDKSendError*)(e_ptr);
28565 e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
28566 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ), "LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ");
28567 *ret_conv = CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_err(e_conv);
28568 return tag_ptr(ret_conv, true);
28571 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(uint64_t o) {
28572 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* o_conv = (LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ*)untag_ptr(o);
28573 jboolean ret_conv = CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_is_ok(o_conv);
28577 void __attribute__((export_name("TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free"))) TS_CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(uint64_t _res) {
28578 if (!ptr_is_owned(_res)) return;
28579 void* _res_ptr = untag_ptr(_res);
28580 CHECK_ACCESS(_res_ptr);
28581 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ _res_conv = *(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ*)(_res_ptr);
28582 FREE(untag_ptr(_res));
28583 CResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ_free(_res_conv);
28586 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_ok"))) TS_CResult_NoneSendErrorZ_ok() {
28587 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
28588 *ret_conv = CResult_NoneSendErrorZ_ok();
28589 return tag_ptr(ret_conv, true);
28592 uint64_t __attribute__((export_name("TS_CResult_NoneSendErrorZ_err"))) TS_CResult_NoneSendErrorZ_err(uint64_t e) {
28593 void* e_ptr = untag_ptr(e);
28594 CHECK_ACCESS(e_ptr);
28595 LDKSendError e_conv = *(LDKSendError*)(e_ptr);
28596 e_conv = SendError_clone((LDKSendError*)untag_ptr(e));
28597 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
28598 *ret_conv = CResult_NoneSendErrorZ_err(e_conv);
28599 return tag_ptr(ret_conv, true);
28602 jboolean __attribute__((export_name("TS_CResult_NoneSendErrorZ_is_ok"))) TS_CResult_NoneSendErrorZ_is_ok(uint64_t o) {
28603 LDKCResult_NoneSendErrorZ* o_conv = (LDKCResult_NoneSendErrorZ*)untag_ptr(o);
28604 jboolean ret_conv = CResult_NoneSendErrorZ_is_ok(o_conv);
28608 void __attribute__((export_name("TS_CResult_NoneSendErrorZ_free"))) TS_CResult_NoneSendErrorZ_free(uint64_t _res) {
28609 if (!ptr_is_owned(_res)) return;
28610 void* _res_ptr = untag_ptr(_res);
28611 CHECK_ACCESS(_res_ptr);
28612 LDKCResult_NoneSendErrorZ _res_conv = *(LDKCResult_NoneSendErrorZ*)(_res_ptr);
28613 FREE(untag_ptr(_res));
28614 CResult_NoneSendErrorZ_free(_res_conv);
28617 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_ok"))) TS_CResult_BlindedPathNoneZ_ok(uint64_t o) {
28618 LDKBlindedPath o_conv;
28619 o_conv.inner = untag_ptr(o);
28620 o_conv.is_owned = ptr_is_owned(o);
28621 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28622 o_conv = BlindedPath_clone(&o_conv);
28623 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
28624 *ret_conv = CResult_BlindedPathNoneZ_ok(o_conv);
28625 return tag_ptr(ret_conv, true);
28628 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_err"))) TS_CResult_BlindedPathNoneZ_err() {
28629 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
28630 *ret_conv = CResult_BlindedPathNoneZ_err();
28631 return tag_ptr(ret_conv, true);
28634 jboolean __attribute__((export_name("TS_CResult_BlindedPathNoneZ_is_ok"))) TS_CResult_BlindedPathNoneZ_is_ok(uint64_t o) {
28635 LDKCResult_BlindedPathNoneZ* o_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(o);
28636 jboolean ret_conv = CResult_BlindedPathNoneZ_is_ok(o_conv);
28640 void __attribute__((export_name("TS_CResult_BlindedPathNoneZ_free"))) TS_CResult_BlindedPathNoneZ_free(uint64_t _res) {
28641 if (!ptr_is_owned(_res)) return;
28642 void* _res_ptr = untag_ptr(_res);
28643 CHECK_ACCESS(_res_ptr);
28644 LDKCResult_BlindedPathNoneZ _res_conv = *(LDKCResult_BlindedPathNoneZ*)(_res_ptr);
28645 FREE(untag_ptr(_res));
28646 CResult_BlindedPathNoneZ_free(_res_conv);
28649 static inline uint64_t CResult_BlindedPathNoneZ_clone_ptr(LDKCResult_BlindedPathNoneZ *NONNULL_PTR arg) {
28650 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
28651 *ret_conv = CResult_BlindedPathNoneZ_clone(arg);
28652 return tag_ptr(ret_conv, true);
28654 int64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone_ptr"))) TS_CResult_BlindedPathNoneZ_clone_ptr(uint64_t arg) {
28655 LDKCResult_BlindedPathNoneZ* arg_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(arg);
28656 int64_t ret_conv = CResult_BlindedPathNoneZ_clone_ptr(arg_conv);
28660 uint64_t __attribute__((export_name("TS_CResult_BlindedPathNoneZ_clone"))) TS_CResult_BlindedPathNoneZ_clone(uint64_t orig) {
28661 LDKCResult_BlindedPathNoneZ* orig_conv = (LDKCResult_BlindedPathNoneZ*)untag_ptr(orig);
28662 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
28663 *ret_conv = CResult_BlindedPathNoneZ_clone(orig_conv);
28664 return tag_ptr(ret_conv, true);
28667 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(uint64_t o) {
28668 void* o_ptr = untag_ptr(o);
28669 CHECK_ACCESS(o_ptr);
28670 LDKC2Tuple_BlindedPayInfoBlindedPathZ o_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(o_ptr);
28671 o_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone((LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(o));
28672 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ), "LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ");
28673 *ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_ok(o_conv);
28674 return tag_ptr(ret_conv, true);
28677 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err() {
28678 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ), "LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ");
28679 *ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_err();
28680 return tag_ptr(ret_conv, true);
28683 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(uint64_t o) {
28684 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* o_conv = (LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)untag_ptr(o);
28685 jboolean ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_is_ok(o_conv);
28689 void __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(uint64_t _res) {
28690 if (!ptr_is_owned(_res)) return;
28691 void* _res_ptr = untag_ptr(_res);
28692 CHECK_ACCESS(_res_ptr);
28693 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ _res_conv = *(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)(_res_ptr);
28694 FREE(untag_ptr(_res));
28695 CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_free(_res_conv);
28698 static inline uint64_t CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ *NONNULL_PTR arg) {
28699 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ), "LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ");
28700 *ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(arg);
28701 return tag_ptr(ret_conv, true);
28703 int64_t __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(uint64_t arg) {
28704 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* arg_conv = (LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)untag_ptr(arg);
28705 int64_t ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone_ptr(arg_conv);
28709 uint64_t __attribute__((export_name("TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone"))) TS_CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(uint64_t orig) {
28710 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* orig_conv = (LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ*)untag_ptr(orig);
28711 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ), "LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ");
28712 *ret_conv = CResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ_clone(orig_conv);
28713 return tag_ptr(ret_conv, true);
28716 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_ok"))) TS_CResult_BlindedPathDecodeErrorZ_ok(uint64_t o) {
28717 LDKBlindedPath o_conv;
28718 o_conv.inner = untag_ptr(o);
28719 o_conv.is_owned = ptr_is_owned(o);
28720 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28721 o_conv = BlindedPath_clone(&o_conv);
28722 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
28723 *ret_conv = CResult_BlindedPathDecodeErrorZ_ok(o_conv);
28724 return tag_ptr(ret_conv, true);
28727 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_err"))) TS_CResult_BlindedPathDecodeErrorZ_err(uint64_t e) {
28728 void* e_ptr = untag_ptr(e);
28729 CHECK_ACCESS(e_ptr);
28730 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28731 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28732 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
28733 *ret_conv = CResult_BlindedPathDecodeErrorZ_err(e_conv);
28734 return tag_ptr(ret_conv, true);
28737 jboolean __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_is_ok"))) TS_CResult_BlindedPathDecodeErrorZ_is_ok(uint64_t o) {
28738 LDKCResult_BlindedPathDecodeErrorZ* o_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(o);
28739 jboolean ret_conv = CResult_BlindedPathDecodeErrorZ_is_ok(o_conv);
28743 void __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_free"))) TS_CResult_BlindedPathDecodeErrorZ_free(uint64_t _res) {
28744 if (!ptr_is_owned(_res)) return;
28745 void* _res_ptr = untag_ptr(_res);
28746 CHECK_ACCESS(_res_ptr);
28747 LDKCResult_BlindedPathDecodeErrorZ _res_conv = *(LDKCResult_BlindedPathDecodeErrorZ*)(_res_ptr);
28748 FREE(untag_ptr(_res));
28749 CResult_BlindedPathDecodeErrorZ_free(_res_conv);
28752 static inline uint64_t CResult_BlindedPathDecodeErrorZ_clone_ptr(LDKCResult_BlindedPathDecodeErrorZ *NONNULL_PTR arg) {
28753 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
28754 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(arg);
28755 return tag_ptr(ret_conv, true);
28757 int64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedPathDecodeErrorZ_clone_ptr(uint64_t arg) {
28758 LDKCResult_BlindedPathDecodeErrorZ* arg_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(arg);
28759 int64_t ret_conv = CResult_BlindedPathDecodeErrorZ_clone_ptr(arg_conv);
28763 uint64_t __attribute__((export_name("TS_CResult_BlindedPathDecodeErrorZ_clone"))) TS_CResult_BlindedPathDecodeErrorZ_clone(uint64_t orig) {
28764 LDKCResult_BlindedPathDecodeErrorZ* orig_conv = (LDKCResult_BlindedPathDecodeErrorZ*)untag_ptr(orig);
28765 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
28766 *ret_conv = CResult_BlindedPathDecodeErrorZ_clone(orig_conv);
28767 return tag_ptr(ret_conv, true);
28770 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_ok"))) TS_CResult_BlindedHopDecodeErrorZ_ok(uint64_t o) {
28771 LDKBlindedHop o_conv;
28772 o_conv.inner = untag_ptr(o);
28773 o_conv.is_owned = ptr_is_owned(o);
28774 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28775 o_conv = BlindedHop_clone(&o_conv);
28776 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
28777 *ret_conv = CResult_BlindedHopDecodeErrorZ_ok(o_conv);
28778 return tag_ptr(ret_conv, true);
28781 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_err"))) TS_CResult_BlindedHopDecodeErrorZ_err(uint64_t e) {
28782 void* e_ptr = untag_ptr(e);
28783 CHECK_ACCESS(e_ptr);
28784 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28785 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28786 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
28787 *ret_conv = CResult_BlindedHopDecodeErrorZ_err(e_conv);
28788 return tag_ptr(ret_conv, true);
28791 jboolean __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_is_ok"))) TS_CResult_BlindedHopDecodeErrorZ_is_ok(uint64_t o) {
28792 LDKCResult_BlindedHopDecodeErrorZ* o_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(o);
28793 jboolean ret_conv = CResult_BlindedHopDecodeErrorZ_is_ok(o_conv);
28797 void __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_free"))) TS_CResult_BlindedHopDecodeErrorZ_free(uint64_t _res) {
28798 if (!ptr_is_owned(_res)) return;
28799 void* _res_ptr = untag_ptr(_res);
28800 CHECK_ACCESS(_res_ptr);
28801 LDKCResult_BlindedHopDecodeErrorZ _res_conv = *(LDKCResult_BlindedHopDecodeErrorZ*)(_res_ptr);
28802 FREE(untag_ptr(_res));
28803 CResult_BlindedHopDecodeErrorZ_free(_res_conv);
28806 static inline uint64_t CResult_BlindedHopDecodeErrorZ_clone_ptr(LDKCResult_BlindedHopDecodeErrorZ *NONNULL_PTR arg) {
28807 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
28808 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(arg);
28809 return tag_ptr(ret_conv, true);
28811 int64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone_ptr"))) TS_CResult_BlindedHopDecodeErrorZ_clone_ptr(uint64_t arg) {
28812 LDKCResult_BlindedHopDecodeErrorZ* arg_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(arg);
28813 int64_t ret_conv = CResult_BlindedHopDecodeErrorZ_clone_ptr(arg_conv);
28817 uint64_t __attribute__((export_name("TS_CResult_BlindedHopDecodeErrorZ_clone"))) TS_CResult_BlindedHopDecodeErrorZ_clone(uint64_t orig) {
28818 LDKCResult_BlindedHopDecodeErrorZ* orig_conv = (LDKCResult_BlindedHopDecodeErrorZ*)untag_ptr(orig);
28819 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
28820 *ret_conv = CResult_BlindedHopDecodeErrorZ_clone(orig_conv);
28821 return tag_ptr(ret_conv, true);
28824 uint64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_ok"))) TS_CResult_InvoiceErrorDecodeErrorZ_ok(uint64_t o) {
28825 LDKInvoiceError o_conv;
28826 o_conv.inner = untag_ptr(o);
28827 o_conv.is_owned = ptr_is_owned(o);
28828 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28829 o_conv = InvoiceError_clone(&o_conv);
28830 LDKCResult_InvoiceErrorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceErrorDecodeErrorZ), "LDKCResult_InvoiceErrorDecodeErrorZ");
28831 *ret_conv = CResult_InvoiceErrorDecodeErrorZ_ok(o_conv);
28832 return tag_ptr(ret_conv, true);
28835 uint64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_err"))) TS_CResult_InvoiceErrorDecodeErrorZ_err(uint64_t e) {
28836 void* e_ptr = untag_ptr(e);
28837 CHECK_ACCESS(e_ptr);
28838 LDKDecodeError e_conv = *(LDKDecodeError*)(e_ptr);
28839 e_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(e));
28840 LDKCResult_InvoiceErrorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceErrorDecodeErrorZ), "LDKCResult_InvoiceErrorDecodeErrorZ");
28841 *ret_conv = CResult_InvoiceErrorDecodeErrorZ_err(e_conv);
28842 return tag_ptr(ret_conv, true);
28845 jboolean __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_is_ok"))) TS_CResult_InvoiceErrorDecodeErrorZ_is_ok(uint64_t o) {
28846 LDKCResult_InvoiceErrorDecodeErrorZ* o_conv = (LDKCResult_InvoiceErrorDecodeErrorZ*)untag_ptr(o);
28847 jboolean ret_conv = CResult_InvoiceErrorDecodeErrorZ_is_ok(o_conv);
28851 void __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_free"))) TS_CResult_InvoiceErrorDecodeErrorZ_free(uint64_t _res) {
28852 if (!ptr_is_owned(_res)) return;
28853 void* _res_ptr = untag_ptr(_res);
28854 CHECK_ACCESS(_res_ptr);
28855 LDKCResult_InvoiceErrorDecodeErrorZ _res_conv = *(LDKCResult_InvoiceErrorDecodeErrorZ*)(_res_ptr);
28856 FREE(untag_ptr(_res));
28857 CResult_InvoiceErrorDecodeErrorZ_free(_res_conv);
28860 static inline uint64_t CResult_InvoiceErrorDecodeErrorZ_clone_ptr(LDKCResult_InvoiceErrorDecodeErrorZ *NONNULL_PTR arg) {
28861 LDKCResult_InvoiceErrorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceErrorDecodeErrorZ), "LDKCResult_InvoiceErrorDecodeErrorZ");
28862 *ret_conv = CResult_InvoiceErrorDecodeErrorZ_clone(arg);
28863 return tag_ptr(ret_conv, true);
28865 int64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceErrorDecodeErrorZ_clone_ptr(uint64_t arg) {
28866 LDKCResult_InvoiceErrorDecodeErrorZ* arg_conv = (LDKCResult_InvoiceErrorDecodeErrorZ*)untag_ptr(arg);
28867 int64_t ret_conv = CResult_InvoiceErrorDecodeErrorZ_clone_ptr(arg_conv);
28871 uint64_t __attribute__((export_name("TS_CResult_InvoiceErrorDecodeErrorZ_clone"))) TS_CResult_InvoiceErrorDecodeErrorZ_clone(uint64_t orig) {
28872 LDKCResult_InvoiceErrorDecodeErrorZ* orig_conv = (LDKCResult_InvoiceErrorDecodeErrorZ*)untag_ptr(orig);
28873 LDKCResult_InvoiceErrorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceErrorDecodeErrorZ), "LDKCResult_InvoiceErrorDecodeErrorZ");
28874 *ret_conv = CResult_InvoiceErrorDecodeErrorZ_clone(orig_conv);
28875 return tag_ptr(ret_conv, true);
28878 uint64_t __attribute__((export_name("TS_COption_FilterZ_some"))) TS_COption_FilterZ_some(uint64_t o) {
28879 void* o_ptr = untag_ptr(o);
28880 CHECK_ACCESS(o_ptr);
28881 LDKFilter o_conv = *(LDKFilter*)(o_ptr);
28882 if (o_conv.free == LDKFilter_JCalls_free) {
28883 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28884 LDKFilter_JCalls_cloned(&o_conv);
28886 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
28887 *ret_copy = COption_FilterZ_some(o_conv);
28888 uint64_t ret_ref = tag_ptr(ret_copy, true);
28892 uint64_t __attribute__((export_name("TS_COption_FilterZ_none"))) TS_COption_FilterZ_none() {
28893 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
28894 *ret_copy = COption_FilterZ_none();
28895 uint64_t ret_ref = tag_ptr(ret_copy, true);
28899 void __attribute__((export_name("TS_COption_FilterZ_free"))) TS_COption_FilterZ_free(uint64_t _res) {
28900 if (!ptr_is_owned(_res)) return;
28901 void* _res_ptr = untag_ptr(_res);
28902 CHECK_ACCESS(_res_ptr);
28903 LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
28904 FREE(untag_ptr(_res));
28905 COption_FilterZ_free(_res_conv);
28908 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_ok"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint64_t o) {
28909 LDKLockedChannelMonitor o_conv;
28910 o_conv.inner = untag_ptr(o);
28911 o_conv.is_owned = ptr_is_owned(o);
28912 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
28913 // WARNING: we need a move here but no clone is available for LDKLockedChannelMonitor
28915 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
28916 *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
28917 return tag_ptr(ret_conv, true);
28920 uint64_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_err"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
28921 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
28922 *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
28923 return tag_ptr(ret_conv, true);
28926 jboolean __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_is_ok"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint64_t o) {
28927 LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)untag_ptr(o);
28928 jboolean ret_conv = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
28932 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_free"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint64_t _res) {
28933 if (!ptr_is_owned(_res)) return;
28934 void* _res_ptr = untag_ptr(_res);
28935 CHECK_ACCESS(_res_ptr);
28936 LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
28937 FREE(untag_ptr(_res));
28938 CResult_LockedChannelMonitorNoneZ_free(_res_conv);
28941 void __attribute__((export_name("TS_CVec_OutPointZ_free"))) TS_CVec_OutPointZ_free(uint64_tArray _res) {
28942 LDKCVec_OutPointZ _res_constr;
28943 _res_constr.datalen = _res->arr_len;
28944 if (_res_constr.datalen > 0)
28945 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
28947 _res_constr.data = NULL;
28948 uint64_t* _res_vals = _res->elems;
28949 for (size_t k = 0; k < _res_constr.datalen; k++) {
28950 uint64_t _res_conv_10 = _res_vals[k];
28951 LDKOutPoint _res_conv_10_conv;
28952 _res_conv_10_conv.inner = untag_ptr(_res_conv_10);
28953 _res_conv_10_conv.is_owned = ptr_is_owned(_res_conv_10);
28954 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
28955 _res_constr.data[k] = _res_conv_10_conv;
28958 CVec_OutPointZ_free(_res_constr);
28961 void __attribute__((export_name("TS_CVec_MonitorUpdateIdZ_free"))) TS_CVec_MonitorUpdateIdZ_free(uint64_tArray _res) {
28962 LDKCVec_MonitorUpdateIdZ _res_constr;
28963 _res_constr.datalen = _res->arr_len;
28964 if (_res_constr.datalen > 0)
28965 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
28967 _res_constr.data = NULL;
28968 uint64_t* _res_vals = _res->elems;
28969 for (size_t r = 0; r < _res_constr.datalen; r++) {
28970 uint64_t _res_conv_17 = _res_vals[r];
28971 LDKMonitorUpdateId _res_conv_17_conv;
28972 _res_conv_17_conv.inner = untag_ptr(_res_conv_17);
28973 _res_conv_17_conv.is_owned = ptr_is_owned(_res_conv_17);
28974 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_17_conv);
28975 _res_constr.data[r] = _res_conv_17_conv;
28978 CVec_MonitorUpdateIdZ_free(_res_constr);
28981 static inline uint64_t C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ *NONNULL_PTR arg) {
28982 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
28983 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(arg);
28984 return tag_ptr(ret_conv, true);
28986 int64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(uint64_t arg) {
28987 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* arg_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(arg);
28988 int64_t ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone_ptr(arg_conv);
28992 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(uint64_t orig) {
28993 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* orig_conv = (LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)untag_ptr(orig);
28994 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
28995 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_clone(orig_conv);
28996 return tag_ptr(ret_conv, true);
28999 uint64_t __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(uint64_t a, uint64_tArray b) {
29000 LDKOutPoint a_conv;
29001 a_conv.inner = untag_ptr(a);
29002 a_conv.is_owned = ptr_is_owned(a);
29003 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29004 a_conv = OutPoint_clone(&a_conv);
29005 LDKCVec_MonitorUpdateIdZ b_constr;
29006 b_constr.datalen = b->arr_len;
29007 if (b_constr.datalen > 0)
29008 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorUpdateId), "LDKCVec_MonitorUpdateIdZ Elements");
29010 b_constr.data = NULL;
29011 uint64_t* b_vals = b->elems;
29012 for (size_t r = 0; r < b_constr.datalen; r++) {
29013 uint64_t b_conv_17 = b_vals[r];
29014 LDKMonitorUpdateId b_conv_17_conv;
29015 b_conv_17_conv.inner = untag_ptr(b_conv_17);
29016 b_conv_17_conv.is_owned = ptr_is_owned(b_conv_17);
29017 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv_17_conv);
29018 b_conv_17_conv = MonitorUpdateId_clone(&b_conv_17_conv);
29019 b_constr.data[r] = b_conv_17_conv;
29022 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
29023 *ret_conv = C2Tuple_OutPointCVec_MonitorUpdateIdZZ_new(a_conv, b_constr);
29024 return tag_ptr(ret_conv, true);
29027 void __attribute__((export_name("TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free"))) TS_C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(uint64_t _res) {
29028 if (!ptr_is_owned(_res)) return;
29029 void* _res_ptr = untag_ptr(_res);
29030 CHECK_ACCESS(_res_ptr);
29031 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_ptr);
29032 FREE(untag_ptr(_res));
29033 C2Tuple_OutPointCVec_MonitorUpdateIdZZ_free(_res_conv);
29036 void __attribute__((export_name("TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free"))) TS_CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(uint64_tArray _res) {
29037 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ _res_constr;
29038 _res_constr.datalen = _res->arr_len;
29039 if (_res_constr.datalen > 0)
29040 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ Elements");
29042 _res_constr.data = NULL;
29043 uint64_t* _res_vals = _res->elems;
29044 for (size_t p = 0; p < _res_constr.datalen; p++) {
29045 uint64_t _res_conv_41 = _res_vals[p];
29046 void* _res_conv_41_ptr = untag_ptr(_res_conv_41);
29047 CHECK_ACCESS(_res_conv_41_ptr);
29048 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ _res_conv_41_conv = *(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ*)(_res_conv_41_ptr);
29049 FREE(untag_ptr(_res_conv_41));
29050 _res_constr.data[p] = _res_conv_41_conv;
29053 CVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ_free(_res_constr);
29056 void __attribute__((export_name("TS_APIError_free"))) TS_APIError_free(uint64_t this_ptr) {
29057 if (!ptr_is_owned(this_ptr)) return;
29058 void* this_ptr_ptr = untag_ptr(this_ptr);
29059 CHECK_ACCESS(this_ptr_ptr);
29060 LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
29061 FREE(untag_ptr(this_ptr));
29062 APIError_free(this_ptr_conv);
29065 static inline uint64_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
29066 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29067 *ret_copy = APIError_clone(arg);
29068 uint64_t ret_ref = tag_ptr(ret_copy, true);
29071 int64_t __attribute__((export_name("TS_APIError_clone_ptr"))) TS_APIError_clone_ptr(uint64_t arg) {
29072 LDKAPIError* arg_conv = (LDKAPIError*)untag_ptr(arg);
29073 int64_t ret_conv = APIError_clone_ptr(arg_conv);
29077 uint64_t __attribute__((export_name("TS_APIError_clone"))) TS_APIError_clone(uint64_t orig) {
29078 LDKAPIError* orig_conv = (LDKAPIError*)untag_ptr(orig);
29079 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29080 *ret_copy = APIError_clone(orig_conv);
29081 uint64_t ret_ref = tag_ptr(ret_copy, true);
29085 uint64_t __attribute__((export_name("TS_APIError_apimisuse_error"))) TS_APIError_apimisuse_error(jstring err) {
29086 LDKStr err_conv = str_ref_to_owned_c(err);
29087 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29088 *ret_copy = APIError_apimisuse_error(err_conv);
29089 uint64_t ret_ref = tag_ptr(ret_copy, true);
29093 uint64_t __attribute__((export_name("TS_APIError_fee_rate_too_high"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
29094 LDKStr err_conv = str_ref_to_owned_c(err);
29095 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29096 *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
29097 uint64_t ret_ref = tag_ptr(ret_copy, true);
29101 uint64_t __attribute__((export_name("TS_APIError_invalid_route"))) TS_APIError_invalid_route(jstring err) {
29102 LDKStr err_conv = str_ref_to_owned_c(err);
29103 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29104 *ret_copy = APIError_invalid_route(err_conv);
29105 uint64_t ret_ref = tag_ptr(ret_copy, true);
29109 uint64_t __attribute__((export_name("TS_APIError_channel_unavailable"))) TS_APIError_channel_unavailable(jstring err) {
29110 LDKStr err_conv = str_ref_to_owned_c(err);
29111 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29112 *ret_copy = APIError_channel_unavailable(err_conv);
29113 uint64_t ret_ref = tag_ptr(ret_copy, true);
29117 uint64_t __attribute__((export_name("TS_APIError_monitor_update_in_progress"))) TS_APIError_monitor_update_in_progress() {
29118 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29119 *ret_copy = APIError_monitor_update_in_progress();
29120 uint64_t ret_ref = tag_ptr(ret_copy, true);
29124 uint64_t __attribute__((export_name("TS_APIError_incompatible_shutdown_script"))) TS_APIError_incompatible_shutdown_script(uint64_t script) {
29125 LDKShutdownScript script_conv;
29126 script_conv.inner = untag_ptr(script);
29127 script_conv.is_owned = ptr_is_owned(script);
29128 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
29129 script_conv = ShutdownScript_clone(&script_conv);
29130 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
29131 *ret_copy = APIError_incompatible_shutdown_script(script_conv);
29132 uint64_t ret_ref = tag_ptr(ret_copy, true);
29136 jboolean __attribute__((export_name("TS_APIError_eq"))) TS_APIError_eq(uint64_t a, uint64_t b) {
29137 LDKAPIError* a_conv = (LDKAPIError*)untag_ptr(a);
29138 LDKAPIError* b_conv = (LDKAPIError*)untag_ptr(b);
29139 jboolean ret_conv = APIError_eq(a_conv, b_conv);
29143 int8_tArray __attribute__((export_name("TS_APIError_write"))) TS_APIError_write(uint64_t obj) {
29144 LDKAPIError* obj_conv = (LDKAPIError*)untag_ptr(obj);
29145 LDKCVec_u8Z ret_var = APIError_write(obj_conv);
29146 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29147 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29148 CVec_u8Z_free(ret_var);
29152 uint64_t __attribute__((export_name("TS_APIError_read"))) TS_APIError_read(int8_tArray ser) {
29153 LDKu8slice ser_ref;
29154 ser_ref.datalen = ser->arr_len;
29155 ser_ref.data = ser->elems;
29156 LDKCResult_COption_APIErrorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_APIErrorZDecodeErrorZ), "LDKCResult_COption_APIErrorZDecodeErrorZ");
29157 *ret_conv = APIError_read(ser_ref);
29159 return tag_ptr(ret_conv, true);
29162 void __attribute__((export_name("TS_BigSize_free"))) TS_BigSize_free(uint64_t this_obj) {
29163 LDKBigSize this_obj_conv;
29164 this_obj_conv.inner = untag_ptr(this_obj);
29165 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29167 BigSize_free(this_obj_conv);
29170 int64_t __attribute__((export_name("TS_BigSize_get_a"))) TS_BigSize_get_a(uint64_t this_ptr) {
29171 LDKBigSize this_ptr_conv;
29172 this_ptr_conv.inner = untag_ptr(this_ptr);
29173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29175 this_ptr_conv.is_owned = false;
29176 int64_t ret_conv = BigSize_get_a(&this_ptr_conv);
29180 void __attribute__((export_name("TS_BigSize_set_a"))) TS_BigSize_set_a(uint64_t this_ptr, int64_t val) {
29181 LDKBigSize this_ptr_conv;
29182 this_ptr_conv.inner = untag_ptr(this_ptr);
29183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29185 this_ptr_conv.is_owned = false;
29186 BigSize_set_a(&this_ptr_conv, val);
29189 uint64_t __attribute__((export_name("TS_BigSize_new"))) TS_BigSize_new(int64_t a_arg) {
29190 LDKBigSize ret_var = BigSize_new(a_arg);
29191 uint64_t ret_ref = 0;
29192 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29193 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29197 static inline uint64_t BigSize_clone_ptr(LDKBigSize *NONNULL_PTR arg) {
29198 LDKBigSize ret_var = BigSize_clone(arg);
29199 uint64_t ret_ref = 0;
29200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29204 int64_t __attribute__((export_name("TS_BigSize_clone_ptr"))) TS_BigSize_clone_ptr(uint64_t arg) {
29205 LDKBigSize arg_conv;
29206 arg_conv.inner = untag_ptr(arg);
29207 arg_conv.is_owned = ptr_is_owned(arg);
29208 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29209 arg_conv.is_owned = false;
29210 int64_t ret_conv = BigSize_clone_ptr(&arg_conv);
29214 uint64_t __attribute__((export_name("TS_BigSize_clone"))) TS_BigSize_clone(uint64_t orig) {
29215 LDKBigSize orig_conv;
29216 orig_conv.inner = untag_ptr(orig);
29217 orig_conv.is_owned = ptr_is_owned(orig);
29218 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29219 orig_conv.is_owned = false;
29220 LDKBigSize ret_var = BigSize_clone(&orig_conv);
29221 uint64_t ret_ref = 0;
29222 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29223 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29227 int64_t __attribute__((export_name("TS_BigSize_hash"))) TS_BigSize_hash(uint64_t o) {
29229 o_conv.inner = untag_ptr(o);
29230 o_conv.is_owned = ptr_is_owned(o);
29231 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
29232 o_conv.is_owned = false;
29233 int64_t ret_conv = BigSize_hash(&o_conv);
29237 jboolean __attribute__((export_name("TS_BigSize_eq"))) TS_BigSize_eq(uint64_t a, uint64_t b) {
29239 a_conv.inner = untag_ptr(a);
29240 a_conv.is_owned = ptr_is_owned(a);
29241 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29242 a_conv.is_owned = false;
29244 b_conv.inner = untag_ptr(b);
29245 b_conv.is_owned = ptr_is_owned(b);
29246 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29247 b_conv.is_owned = false;
29248 jboolean ret_conv = BigSize_eq(&a_conv, &b_conv);
29252 int8_tArray __attribute__((export_name("TS_BigSize_write"))) TS_BigSize_write(uint64_t obj) {
29253 LDKBigSize obj_conv;
29254 obj_conv.inner = untag_ptr(obj);
29255 obj_conv.is_owned = ptr_is_owned(obj);
29256 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29257 obj_conv.is_owned = false;
29258 LDKCVec_u8Z ret_var = BigSize_write(&obj_conv);
29259 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29260 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29261 CVec_u8Z_free(ret_var);
29265 uint64_t __attribute__((export_name("TS_BigSize_read"))) TS_BigSize_read(int8_tArray ser) {
29266 LDKu8slice ser_ref;
29267 ser_ref.datalen = ser->arr_len;
29268 ser_ref.data = ser->elems;
29269 LDKCResult_BigSizeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BigSizeDecodeErrorZ), "LDKCResult_BigSizeDecodeErrorZ");
29270 *ret_conv = BigSize_read(ser_ref);
29272 return tag_ptr(ret_conv, true);
29275 void __attribute__((export_name("TS_Hostname_free"))) TS_Hostname_free(uint64_t this_obj) {
29276 LDKHostname this_obj_conv;
29277 this_obj_conv.inner = untag_ptr(this_obj);
29278 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29280 Hostname_free(this_obj_conv);
29283 static inline uint64_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg) {
29284 LDKHostname ret_var = Hostname_clone(arg);
29285 uint64_t ret_ref = 0;
29286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29287 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29290 int64_t __attribute__((export_name("TS_Hostname_clone_ptr"))) TS_Hostname_clone_ptr(uint64_t arg) {
29291 LDKHostname arg_conv;
29292 arg_conv.inner = untag_ptr(arg);
29293 arg_conv.is_owned = ptr_is_owned(arg);
29294 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29295 arg_conv.is_owned = false;
29296 int64_t ret_conv = Hostname_clone_ptr(&arg_conv);
29300 uint64_t __attribute__((export_name("TS_Hostname_clone"))) TS_Hostname_clone(uint64_t orig) {
29301 LDKHostname orig_conv;
29302 orig_conv.inner = untag_ptr(orig);
29303 orig_conv.is_owned = ptr_is_owned(orig);
29304 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29305 orig_conv.is_owned = false;
29306 LDKHostname ret_var = Hostname_clone(&orig_conv);
29307 uint64_t ret_ref = 0;
29308 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29309 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29313 jboolean __attribute__((export_name("TS_Hostname_eq"))) TS_Hostname_eq(uint64_t a, uint64_t b) {
29314 LDKHostname a_conv;
29315 a_conv.inner = untag_ptr(a);
29316 a_conv.is_owned = ptr_is_owned(a);
29317 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29318 a_conv.is_owned = false;
29319 LDKHostname b_conv;
29320 b_conv.inner = untag_ptr(b);
29321 b_conv.is_owned = ptr_is_owned(b);
29322 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29323 b_conv.is_owned = false;
29324 jboolean ret_conv = Hostname_eq(&a_conv, &b_conv);
29328 int8_t __attribute__((export_name("TS_Hostname_len"))) TS_Hostname_len(uint64_t this_arg) {
29329 LDKHostname this_arg_conv;
29330 this_arg_conv.inner = untag_ptr(this_arg);
29331 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29332 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29333 this_arg_conv.is_owned = false;
29334 int8_t ret_conv = Hostname_len(&this_arg_conv);
29338 int8_tArray __attribute__((export_name("TS_Hostname_write"))) TS_Hostname_write(uint64_t obj) {
29339 LDKHostname obj_conv;
29340 obj_conv.inner = untag_ptr(obj);
29341 obj_conv.is_owned = ptr_is_owned(obj);
29342 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29343 obj_conv.is_owned = false;
29344 LDKCVec_u8Z ret_var = Hostname_write(&obj_conv);
29345 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29346 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29347 CVec_u8Z_free(ret_var);
29351 uint64_t __attribute__((export_name("TS_Hostname_read"))) TS_Hostname_read(int8_tArray ser) {
29352 LDKu8slice ser_ref;
29353 ser_ref.datalen = ser->arr_len;
29354 ser_ref.data = ser->elems;
29355 LDKCResult_HostnameDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HostnameDecodeErrorZ), "LDKCResult_HostnameDecodeErrorZ");
29356 *ret_conv = Hostname_read(ser_ref);
29358 return tag_ptr(ret_conv, true);
29361 void __attribute__((export_name("TS_TransactionU16LenLimited_free"))) TS_TransactionU16LenLimited_free(uint64_t this_obj) {
29362 LDKTransactionU16LenLimited this_obj_conv;
29363 this_obj_conv.inner = untag_ptr(this_obj);
29364 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29366 TransactionU16LenLimited_free(this_obj_conv);
29369 static inline uint64_t TransactionU16LenLimited_clone_ptr(LDKTransactionU16LenLimited *NONNULL_PTR arg) {
29370 LDKTransactionU16LenLimited ret_var = TransactionU16LenLimited_clone(arg);
29371 uint64_t ret_ref = 0;
29372 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29373 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29376 int64_t __attribute__((export_name("TS_TransactionU16LenLimited_clone_ptr"))) TS_TransactionU16LenLimited_clone_ptr(uint64_t arg) {
29377 LDKTransactionU16LenLimited arg_conv;
29378 arg_conv.inner = untag_ptr(arg);
29379 arg_conv.is_owned = ptr_is_owned(arg);
29380 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29381 arg_conv.is_owned = false;
29382 int64_t ret_conv = TransactionU16LenLimited_clone_ptr(&arg_conv);
29386 uint64_t __attribute__((export_name("TS_TransactionU16LenLimited_clone"))) TS_TransactionU16LenLimited_clone(uint64_t orig) {
29387 LDKTransactionU16LenLimited orig_conv;
29388 orig_conv.inner = untag_ptr(orig);
29389 orig_conv.is_owned = ptr_is_owned(orig);
29390 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29391 orig_conv.is_owned = false;
29392 LDKTransactionU16LenLimited ret_var = TransactionU16LenLimited_clone(&orig_conv);
29393 uint64_t ret_ref = 0;
29394 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29395 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29399 jboolean __attribute__((export_name("TS_TransactionU16LenLimited_eq"))) TS_TransactionU16LenLimited_eq(uint64_t a, uint64_t b) {
29400 LDKTransactionU16LenLimited a_conv;
29401 a_conv.inner = untag_ptr(a);
29402 a_conv.is_owned = ptr_is_owned(a);
29403 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29404 a_conv.is_owned = false;
29405 LDKTransactionU16LenLimited b_conv;
29406 b_conv.inner = untag_ptr(b);
29407 b_conv.is_owned = ptr_is_owned(b);
29408 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29409 b_conv.is_owned = false;
29410 jboolean ret_conv = TransactionU16LenLimited_eq(&a_conv, &b_conv);
29414 uint64_t __attribute__((export_name("TS_TransactionU16LenLimited_new"))) TS_TransactionU16LenLimited_new(int8_tArray transaction) {
29415 LDKTransaction transaction_ref;
29416 transaction_ref.datalen = transaction->arr_len;
29417 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
29418 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
29419 transaction_ref.data_is_owned = true;
29420 LDKCResult_TransactionU16LenLimitedNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedNoneZ), "LDKCResult_TransactionU16LenLimitedNoneZ");
29421 *ret_conv = TransactionU16LenLimited_new(transaction_ref);
29422 return tag_ptr(ret_conv, true);
29425 int8_tArray __attribute__((export_name("TS_TransactionU16LenLimited_into_transaction"))) TS_TransactionU16LenLimited_into_transaction(uint64_t this_arg) {
29426 LDKTransactionU16LenLimited this_arg_conv;
29427 this_arg_conv.inner = untag_ptr(this_arg);
29428 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29429 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29430 this_arg_conv = TransactionU16LenLimited_clone(&this_arg_conv);
29431 LDKTransaction ret_var = TransactionU16LenLimited_into_transaction(this_arg_conv);
29432 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29433 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29434 Transaction_free(ret_var);
29438 int8_tArray __attribute__((export_name("TS_TransactionU16LenLimited_write"))) TS_TransactionU16LenLimited_write(uint64_t obj) {
29439 LDKTransactionU16LenLimited obj_conv;
29440 obj_conv.inner = untag_ptr(obj);
29441 obj_conv.is_owned = ptr_is_owned(obj);
29442 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29443 obj_conv.is_owned = false;
29444 LDKCVec_u8Z ret_var = TransactionU16LenLimited_write(&obj_conv);
29445 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29446 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29447 CVec_u8Z_free(ret_var);
29451 uint64_t __attribute__((export_name("TS_TransactionU16LenLimited_read"))) TS_TransactionU16LenLimited_read(int8_tArray ser) {
29452 LDKu8slice ser_ref;
29453 ser_ref.datalen = ser->arr_len;
29454 ser_ref.data = ser->elems;
29455 LDKCResult_TransactionU16LenLimitedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionU16LenLimitedDecodeErrorZ), "LDKCResult_TransactionU16LenLimitedDecodeErrorZ");
29456 *ret_conv = TransactionU16LenLimited_read(ser_ref);
29458 return tag_ptr(ret_conv, true);
29461 uint64_t __attribute__((export_name("TS_sign"))) TS_sign(int8_tArray msg, int8_tArray sk) {
29462 LDKu8slice msg_ref;
29463 msg_ref.datalen = msg->arr_len;
29464 msg_ref.data = msg->elems;
29465 uint8_t sk_arr[32];
29466 CHECK(sk->arr_len == 32);
29467 memcpy(sk_arr, sk->elems, 32); FREE(sk);
29468 uint8_t (*sk_ref)[32] = &sk_arr;
29469 LDKCResult_StrSecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StrSecp256k1ErrorZ), "LDKCResult_StrSecp256k1ErrorZ");
29470 *ret_conv = sign(msg_ref, sk_ref);
29472 return tag_ptr(ret_conv, true);
29475 uint64_t __attribute__((export_name("TS_recover_pk"))) TS_recover_pk(int8_tArray msg, jstring sig) {
29476 LDKu8slice msg_ref;
29477 msg_ref.datalen = msg->arr_len;
29478 msg_ref.data = msg->elems;
29479 LDKStr sig_conv = str_ref_to_owned_c(sig);
29480 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
29481 *ret_conv = recover_pk(msg_ref, sig_conv);
29483 return tag_ptr(ret_conv, true);
29486 jboolean __attribute__((export_name("TS_verify"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
29487 LDKu8slice msg_ref;
29488 msg_ref.datalen = msg->arr_len;
29489 msg_ref.data = msg->elems;
29490 LDKStr sig_conv = str_ref_to_owned_c(sig);
29491 LDKPublicKey pk_ref;
29492 CHECK(pk->arr_len == 33);
29493 memcpy(pk_ref.compressed_form, pk->elems, 33); FREE(pk);
29494 jboolean ret_conv = verify(msg_ref, sig_conv, pk_ref);
29499 int8_tArray __attribute__((export_name("TS_construct_invoice_preimage"))) TS_construct_invoice_preimage(int8_tArray hrp_bytes, ptrArray data_without_signature) {
29500 LDKu8slice hrp_bytes_ref;
29501 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
29502 hrp_bytes_ref.data = hrp_bytes->elems;
29503 LDKCVec_U5Z data_without_signature_constr;
29504 data_without_signature_constr.datalen = data_without_signature->arr_len;
29505 if (data_without_signature_constr.datalen > 0)
29506 data_without_signature_constr.data = MALLOC(data_without_signature_constr.datalen * sizeof(LDKU5), "LDKCVec_U5Z Elements");
29508 data_without_signature_constr.data = NULL;
29509 int8_t* data_without_signature_vals = (void*) data_without_signature->elems;
29510 for (size_t h = 0; h < data_without_signature_constr.datalen; h++) {
29511 int8_t data_without_signature_conv_7 = data_without_signature_vals[h];
29513 data_without_signature_constr.data[h] = (LDKU5){ ._0 = data_without_signature_conv_7 };
29515 FREE(data_without_signature);
29516 LDKCVec_u8Z ret_var = construct_invoice_preimage(hrp_bytes_ref, data_without_signature_constr);
29517 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29518 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29519 CVec_u8Z_free(ret_var);
29524 void __attribute__((export_name("TS_KVStore_free"))) TS_KVStore_free(uint64_t this_ptr) {
29525 if (!ptr_is_owned(this_ptr)) return;
29526 void* this_ptr_ptr = untag_ptr(this_ptr);
29527 CHECK_ACCESS(this_ptr_ptr);
29528 LDKKVStore this_ptr_conv = *(LDKKVStore*)(this_ptr_ptr);
29529 FREE(untag_ptr(this_ptr));
29530 KVStore_free(this_ptr_conv);
29533 void __attribute__((export_name("TS_Persister_free"))) TS_Persister_free(uint64_t this_ptr) {
29534 if (!ptr_is_owned(this_ptr)) return;
29535 void* this_ptr_ptr = untag_ptr(this_ptr);
29536 CHECK_ACCESS(this_ptr_ptr);
29537 LDKPersister this_ptr_conv = *(LDKPersister*)(this_ptr_ptr);
29538 FREE(untag_ptr(this_ptr));
29539 Persister_free(this_ptr_conv);
29542 uint64_t __attribute__((export_name("TS_read_channel_monitors"))) TS_read_channel_monitors(uint64_t kv_store, uint64_t entropy_source, uint64_t signer_provider) {
29543 void* kv_store_ptr = untag_ptr(kv_store);
29544 CHECK_ACCESS(kv_store_ptr);
29545 LDKKVStore kv_store_conv = *(LDKKVStore*)(kv_store_ptr);
29546 if (kv_store_conv.free == LDKKVStore_JCalls_free) {
29547 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29548 LDKKVStore_JCalls_cloned(&kv_store_conv);
29550 void* entropy_source_ptr = untag_ptr(entropy_source);
29551 CHECK_ACCESS(entropy_source_ptr);
29552 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
29553 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
29554 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29555 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
29557 void* signer_provider_ptr = untag_ptr(signer_provider);
29558 CHECK_ACCESS(signer_provider_ptr);
29559 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
29560 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
29561 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29562 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
29564 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
29565 *ret_conv = read_channel_monitors(kv_store_conv, entropy_source_conv, signer_provider_conv);
29566 return tag_ptr(ret_conv, true);
29569 void __attribute__((export_name("TS_MonitorUpdatingPersister_free"))) TS_MonitorUpdatingPersister_free(uint64_t this_obj) {
29570 LDKMonitorUpdatingPersister this_obj_conv;
29571 this_obj_conv.inner = untag_ptr(this_obj);
29572 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29574 MonitorUpdatingPersister_free(this_obj_conv);
29577 uint64_t __attribute__((export_name("TS_MonitorUpdatingPersister_new"))) TS_MonitorUpdatingPersister_new(uint64_t kv_store, uint64_t logger, int64_t maximum_pending_updates, uint64_t entropy_source, uint64_t signer_provider) {
29578 void* kv_store_ptr = untag_ptr(kv_store);
29579 CHECK_ACCESS(kv_store_ptr);
29580 LDKKVStore kv_store_conv = *(LDKKVStore*)(kv_store_ptr);
29581 if (kv_store_conv.free == LDKKVStore_JCalls_free) {
29582 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29583 LDKKVStore_JCalls_cloned(&kv_store_conv);
29585 void* logger_ptr = untag_ptr(logger);
29586 CHECK_ACCESS(logger_ptr);
29587 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
29588 if (logger_conv.free == LDKLogger_JCalls_free) {
29589 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29590 LDKLogger_JCalls_cloned(&logger_conv);
29592 void* entropy_source_ptr = untag_ptr(entropy_source);
29593 CHECK_ACCESS(entropy_source_ptr);
29594 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
29595 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
29596 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29597 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
29599 void* signer_provider_ptr = untag_ptr(signer_provider);
29600 CHECK_ACCESS(signer_provider_ptr);
29601 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
29602 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
29603 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29604 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
29606 LDKMonitorUpdatingPersister ret_var = MonitorUpdatingPersister_new(kv_store_conv, logger_conv, maximum_pending_updates, entropy_source_conv, signer_provider_conv);
29607 uint64_t ret_ref = 0;
29608 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29609 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29613 uint64_t __attribute__((export_name("TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates"))) TS_MonitorUpdatingPersister_read_all_channel_monitors_with_updates(uint64_t this_arg, uint64_t broadcaster, uint64_t fee_estimator) {
29614 LDKMonitorUpdatingPersister this_arg_conv;
29615 this_arg_conv.inner = untag_ptr(this_arg);
29616 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29618 this_arg_conv.is_owned = false;
29619 void* broadcaster_ptr = untag_ptr(broadcaster);
29620 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
29621 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
29622 void* fee_estimator_ptr = untag_ptr(fee_estimator);
29623 if (ptr_is_owned(fee_estimator)) { CHECK_ACCESS(fee_estimator_ptr); }
29624 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)fee_estimator_ptr;
29625 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesChannelMonitorZZIOErrorZ");
29626 *ret_conv = MonitorUpdatingPersister_read_all_channel_monitors_with_updates(&this_arg_conv, broadcaster_conv, fee_estimator_conv);
29627 return tag_ptr(ret_conv, true);
29630 uint64_t __attribute__((export_name("TS_MonitorUpdatingPersister_read_channel_monitor_with_updates"))) TS_MonitorUpdatingPersister_read_channel_monitor_with_updates(uint64_t this_arg, uint64_t broadcaster, uint64_t fee_estimator, jstring monitor_key) {
29631 LDKMonitorUpdatingPersister this_arg_conv;
29632 this_arg_conv.inner = untag_ptr(this_arg);
29633 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29635 this_arg_conv.is_owned = false;
29636 void* broadcaster_ptr = untag_ptr(broadcaster);
29637 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
29638 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
29639 void* fee_estimator_ptr = untag_ptr(fee_estimator);
29640 if (ptr_is_owned(fee_estimator)) { CHECK_ACCESS(fee_estimator_ptr); }
29641 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)fee_estimator_ptr;
29642 LDKStr monitor_key_conv = str_ref_to_owned_c(monitor_key);
29643 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZIOErrorZ");
29644 *ret_conv = MonitorUpdatingPersister_read_channel_monitor_with_updates(&this_arg_conv, broadcaster_conv, fee_estimator_conv, monitor_key_conv);
29645 return tag_ptr(ret_conv, true);
29648 uint64_t __attribute__((export_name("TS_MonitorUpdatingPersister_cleanup_stale_updates"))) TS_MonitorUpdatingPersister_cleanup_stale_updates(uint64_t this_arg, jboolean lazy) {
29649 LDKMonitorUpdatingPersister this_arg_conv;
29650 this_arg_conv.inner = untag_ptr(this_arg);
29651 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29653 this_arg_conv.is_owned = false;
29654 LDKCResult_NoneIOErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneIOErrorZ), "LDKCResult_NoneIOErrorZ");
29655 *ret_conv = MonitorUpdatingPersister_cleanup_stale_updates(&this_arg_conv, lazy);
29656 return tag_ptr(ret_conv, true);
29659 uint64_t __attribute__((export_name("TS_MonitorUpdatingPersister_as_Persist"))) TS_MonitorUpdatingPersister_as_Persist(uint64_t this_arg) {
29660 LDKMonitorUpdatingPersister this_arg_conv;
29661 this_arg_conv.inner = untag_ptr(this_arg);
29662 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29664 this_arg_conv.is_owned = false;
29665 LDKPersist* ret_ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
29666 *ret_ret = MonitorUpdatingPersister_as_Persist(&this_arg_conv);
29667 return tag_ptr(ret_ret, true);
29670 void __attribute__((export_name("TS_UntrustedString_free"))) TS_UntrustedString_free(uint64_t this_obj) {
29671 LDKUntrustedString this_obj_conv;
29672 this_obj_conv.inner = untag_ptr(this_obj);
29673 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29675 UntrustedString_free(this_obj_conv);
29678 jstring __attribute__((export_name("TS_UntrustedString_get_a"))) TS_UntrustedString_get_a(uint64_t this_ptr) {
29679 LDKUntrustedString this_ptr_conv;
29680 this_ptr_conv.inner = untag_ptr(this_ptr);
29681 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29683 this_ptr_conv.is_owned = false;
29684 LDKStr ret_str = UntrustedString_get_a(&this_ptr_conv);
29685 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29690 void __attribute__((export_name("TS_UntrustedString_set_a"))) TS_UntrustedString_set_a(uint64_t this_ptr, jstring val) {
29691 LDKUntrustedString this_ptr_conv;
29692 this_ptr_conv.inner = untag_ptr(this_ptr);
29693 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29695 this_ptr_conv.is_owned = false;
29696 LDKStr val_conv = str_ref_to_owned_c(val);
29697 UntrustedString_set_a(&this_ptr_conv, val_conv);
29700 uint64_t __attribute__((export_name("TS_UntrustedString_new"))) TS_UntrustedString_new(jstring a_arg) {
29701 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
29702 LDKUntrustedString ret_var = UntrustedString_new(a_arg_conv);
29703 uint64_t ret_ref = 0;
29704 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29705 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29709 static inline uint64_t UntrustedString_clone_ptr(LDKUntrustedString *NONNULL_PTR arg) {
29710 LDKUntrustedString ret_var = UntrustedString_clone(arg);
29711 uint64_t ret_ref = 0;
29712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29713 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29716 int64_t __attribute__((export_name("TS_UntrustedString_clone_ptr"))) TS_UntrustedString_clone_ptr(uint64_t arg) {
29717 LDKUntrustedString arg_conv;
29718 arg_conv.inner = untag_ptr(arg);
29719 arg_conv.is_owned = ptr_is_owned(arg);
29720 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29721 arg_conv.is_owned = false;
29722 int64_t ret_conv = UntrustedString_clone_ptr(&arg_conv);
29726 uint64_t __attribute__((export_name("TS_UntrustedString_clone"))) TS_UntrustedString_clone(uint64_t orig) {
29727 LDKUntrustedString orig_conv;
29728 orig_conv.inner = untag_ptr(orig);
29729 orig_conv.is_owned = ptr_is_owned(orig);
29730 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29731 orig_conv.is_owned = false;
29732 LDKUntrustedString ret_var = UntrustedString_clone(&orig_conv);
29733 uint64_t ret_ref = 0;
29734 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29735 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29739 jboolean __attribute__((export_name("TS_UntrustedString_eq"))) TS_UntrustedString_eq(uint64_t a, uint64_t b) {
29740 LDKUntrustedString a_conv;
29741 a_conv.inner = untag_ptr(a);
29742 a_conv.is_owned = ptr_is_owned(a);
29743 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
29744 a_conv.is_owned = false;
29745 LDKUntrustedString b_conv;
29746 b_conv.inner = untag_ptr(b);
29747 b_conv.is_owned = ptr_is_owned(b);
29748 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
29749 b_conv.is_owned = false;
29750 jboolean ret_conv = UntrustedString_eq(&a_conv, &b_conv);
29754 int8_tArray __attribute__((export_name("TS_UntrustedString_write"))) TS_UntrustedString_write(uint64_t obj) {
29755 LDKUntrustedString obj_conv;
29756 obj_conv.inner = untag_ptr(obj);
29757 obj_conv.is_owned = ptr_is_owned(obj);
29758 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
29759 obj_conv.is_owned = false;
29760 LDKCVec_u8Z ret_var = UntrustedString_write(&obj_conv);
29761 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29762 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29763 CVec_u8Z_free(ret_var);
29767 uint64_t __attribute__((export_name("TS_UntrustedString_read"))) TS_UntrustedString_read(int8_tArray ser) {
29768 LDKu8slice ser_ref;
29769 ser_ref.datalen = ser->arr_len;
29770 ser_ref.data = ser->elems;
29771 LDKCResult_UntrustedStringDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UntrustedStringDecodeErrorZ), "LDKCResult_UntrustedStringDecodeErrorZ");
29772 *ret_conv = UntrustedString_read(ser_ref);
29774 return tag_ptr(ret_conv, true);
29777 void __attribute__((export_name("TS_PrintableString_free"))) TS_PrintableString_free(uint64_t this_obj) {
29778 LDKPrintableString this_obj_conv;
29779 this_obj_conv.inner = untag_ptr(this_obj);
29780 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29782 PrintableString_free(this_obj_conv);
29785 jstring __attribute__((export_name("TS_PrintableString_get_a"))) TS_PrintableString_get_a(uint64_t this_ptr) {
29786 LDKPrintableString this_ptr_conv;
29787 this_ptr_conv.inner = untag_ptr(this_ptr);
29788 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29790 this_ptr_conv.is_owned = false;
29791 LDKStr ret_str = PrintableString_get_a(&this_ptr_conv);
29792 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29797 void __attribute__((export_name("TS_PrintableString_set_a"))) TS_PrintableString_set_a(uint64_t this_ptr, jstring val) {
29798 LDKPrintableString this_ptr_conv;
29799 this_ptr_conv.inner = untag_ptr(this_ptr);
29800 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29802 this_ptr_conv.is_owned = false;
29803 LDKStr val_conv = str_ref_to_owned_c(val);
29804 PrintableString_set_a(&this_ptr_conv, val_conv);
29807 uint64_t __attribute__((export_name("TS_PrintableString_new"))) TS_PrintableString_new(jstring a_arg) {
29808 LDKStr a_arg_conv = str_ref_to_owned_c(a_arg);
29809 LDKPrintableString ret_var = PrintableString_new(a_arg_conv);
29810 uint64_t ret_ref = 0;
29811 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29812 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29816 void __attribute__((export_name("TS_FutureCallback_free"))) TS_FutureCallback_free(uint64_t this_ptr) {
29817 if (!ptr_is_owned(this_ptr)) return;
29818 void* this_ptr_ptr = untag_ptr(this_ptr);
29819 CHECK_ACCESS(this_ptr_ptr);
29820 LDKFutureCallback this_ptr_conv = *(LDKFutureCallback*)(this_ptr_ptr);
29821 FREE(untag_ptr(this_ptr));
29822 FutureCallback_free(this_ptr_conv);
29825 void __attribute__((export_name("TS_Future_free"))) TS_Future_free(uint64_t this_obj) {
29826 LDKFuture this_obj_conv;
29827 this_obj_conv.inner = untag_ptr(this_obj);
29828 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29829 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29830 Future_free(this_obj_conv);
29833 static inline uint64_t Future_clone_ptr(LDKFuture *NONNULL_PTR arg) {
29834 LDKFuture ret_var = Future_clone(arg);
29835 uint64_t ret_ref = 0;
29836 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29837 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29840 int64_t __attribute__((export_name("TS_Future_clone_ptr"))) TS_Future_clone_ptr(uint64_t arg) {
29841 LDKFuture arg_conv;
29842 arg_conv.inner = untag_ptr(arg);
29843 arg_conv.is_owned = ptr_is_owned(arg);
29844 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29845 arg_conv.is_owned = false;
29846 int64_t ret_conv = Future_clone_ptr(&arg_conv);
29850 uint64_t __attribute__((export_name("TS_Future_clone"))) TS_Future_clone(uint64_t orig) {
29851 LDKFuture orig_conv;
29852 orig_conv.inner = untag_ptr(orig);
29853 orig_conv.is_owned = ptr_is_owned(orig);
29854 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29855 orig_conv.is_owned = false;
29856 LDKFuture ret_var = Future_clone(&orig_conv);
29857 uint64_t ret_ref = 0;
29858 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29859 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
29863 void __attribute__((export_name("TS_Future_register_callback_fn"))) TS_Future_register_callback_fn(uint64_t this_arg, uint64_t callback) {
29864 LDKFuture this_arg_conv;
29865 this_arg_conv.inner = untag_ptr(this_arg);
29866 this_arg_conv.is_owned = ptr_is_owned(this_arg);
29867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
29868 this_arg_conv.is_owned = false;
29869 void* callback_ptr = untag_ptr(callback);
29870 CHECK_ACCESS(callback_ptr);
29871 LDKFutureCallback callback_conv = *(LDKFutureCallback*)(callback_ptr);
29872 if (callback_conv.free == LDKFutureCallback_JCalls_free) {
29873 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
29874 LDKFutureCallback_JCalls_cloned(&callback_conv);
29876 Future_register_callback_fn(&this_arg_conv, callback_conv);
29879 uint32_t __attribute__((export_name("TS_Level_clone"))) TS_Level_clone(uint64_t orig) {
29880 LDKLevel* orig_conv = (LDKLevel*)untag_ptr(orig);
29881 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
29885 uint32_t __attribute__((export_name("TS_Level_gossip"))) TS_Level_gossip() {
29886 uint32_t ret_conv = LDKLevel_to_js(Level_gossip());
29890 uint32_t __attribute__((export_name("TS_Level_trace"))) TS_Level_trace() {
29891 uint32_t ret_conv = LDKLevel_to_js(Level_trace());
29895 uint32_t __attribute__((export_name("TS_Level_debug"))) TS_Level_debug() {
29896 uint32_t ret_conv = LDKLevel_to_js(Level_debug());
29900 uint32_t __attribute__((export_name("TS_Level_info"))) TS_Level_info() {
29901 uint32_t ret_conv = LDKLevel_to_js(Level_info());
29905 uint32_t __attribute__((export_name("TS_Level_warn"))) TS_Level_warn() {
29906 uint32_t ret_conv = LDKLevel_to_js(Level_warn());
29910 uint32_t __attribute__((export_name("TS_Level_error"))) TS_Level_error() {
29911 uint32_t ret_conv = LDKLevel_to_js(Level_error());
29915 jboolean __attribute__((export_name("TS_Level_eq"))) TS_Level_eq(uint64_t a, uint64_t b) {
29916 LDKLevel* a_conv = (LDKLevel*)untag_ptr(a);
29917 LDKLevel* b_conv = (LDKLevel*)untag_ptr(b);
29918 jboolean ret_conv = Level_eq(a_conv, b_conv);
29922 int64_t __attribute__((export_name("TS_Level_hash"))) TS_Level_hash(uint64_t o) {
29923 LDKLevel* o_conv = (LDKLevel*)untag_ptr(o);
29924 int64_t ret_conv = Level_hash(o_conv);
29928 uint32_t __attribute__((export_name("TS_Level_max"))) TS_Level_max() {
29929 uint32_t ret_conv = LDKLevel_to_js(Level_max());
29933 void __attribute__((export_name("TS_Record_free"))) TS_Record_free(uint64_t this_obj) {
29934 LDKRecord this_obj_conv;
29935 this_obj_conv.inner = untag_ptr(this_obj);
29936 this_obj_conv.is_owned = ptr_is_owned(this_obj);
29937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29938 Record_free(this_obj_conv);
29941 uint32_t __attribute__((export_name("TS_Record_get_level"))) TS_Record_get_level(uint64_t this_ptr) {
29942 LDKRecord this_ptr_conv;
29943 this_ptr_conv.inner = untag_ptr(this_ptr);
29944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29946 this_ptr_conv.is_owned = false;
29947 uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
29951 void __attribute__((export_name("TS_Record_set_level"))) TS_Record_set_level(uint64_t this_ptr, uint32_t val) {
29952 LDKRecord this_ptr_conv;
29953 this_ptr_conv.inner = untag_ptr(this_ptr);
29954 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29956 this_ptr_conv.is_owned = false;
29957 LDKLevel val_conv = LDKLevel_from_js(val);
29958 Record_set_level(&this_ptr_conv, val_conv);
29961 jstring __attribute__((export_name("TS_Record_get_args"))) TS_Record_get_args(uint64_t this_ptr) {
29962 LDKRecord this_ptr_conv;
29963 this_ptr_conv.inner = untag_ptr(this_ptr);
29964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29966 this_ptr_conv.is_owned = false;
29967 LDKStr ret_str = Record_get_args(&this_ptr_conv);
29968 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29973 void __attribute__((export_name("TS_Record_set_args"))) TS_Record_set_args(uint64_t this_ptr, jstring val) {
29974 LDKRecord this_ptr_conv;
29975 this_ptr_conv.inner = untag_ptr(this_ptr);
29976 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29978 this_ptr_conv.is_owned = false;
29979 LDKStr val_conv = str_ref_to_owned_c(val);
29980 Record_set_args(&this_ptr_conv, val_conv);
29983 jstring __attribute__((export_name("TS_Record_get_module_path"))) TS_Record_get_module_path(uint64_t this_ptr) {
29984 LDKRecord this_ptr_conv;
29985 this_ptr_conv.inner = untag_ptr(this_ptr);
29986 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29988 this_ptr_conv.is_owned = false;
29989 LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
29990 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
29995 void __attribute__((export_name("TS_Record_set_module_path"))) TS_Record_set_module_path(uint64_t this_ptr, jstring val) {
29996 LDKRecord this_ptr_conv;
29997 this_ptr_conv.inner = untag_ptr(this_ptr);
29998 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
29999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30000 this_ptr_conv.is_owned = false;
30001 LDKStr val_conv = str_ref_to_owned_c(val);
30002 Record_set_module_path(&this_ptr_conv, val_conv);
30005 jstring __attribute__((export_name("TS_Record_get_file"))) TS_Record_get_file(uint64_t this_ptr) {
30006 LDKRecord this_ptr_conv;
30007 this_ptr_conv.inner = untag_ptr(this_ptr);
30008 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30009 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30010 this_ptr_conv.is_owned = false;
30011 LDKStr ret_str = Record_get_file(&this_ptr_conv);
30012 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
30017 void __attribute__((export_name("TS_Record_set_file"))) TS_Record_set_file(uint64_t this_ptr, jstring val) {
30018 LDKRecord this_ptr_conv;
30019 this_ptr_conv.inner = untag_ptr(this_ptr);
30020 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30021 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30022 this_ptr_conv.is_owned = false;
30023 LDKStr val_conv = str_ref_to_owned_c(val);
30024 Record_set_file(&this_ptr_conv, val_conv);
30027 int32_t __attribute__((export_name("TS_Record_get_line"))) TS_Record_get_line(uint64_t this_ptr) {
30028 LDKRecord this_ptr_conv;
30029 this_ptr_conv.inner = untag_ptr(this_ptr);
30030 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30032 this_ptr_conv.is_owned = false;
30033 int32_t ret_conv = Record_get_line(&this_ptr_conv);
30037 void __attribute__((export_name("TS_Record_set_line"))) TS_Record_set_line(uint64_t this_ptr, int32_t val) {
30038 LDKRecord this_ptr_conv;
30039 this_ptr_conv.inner = untag_ptr(this_ptr);
30040 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30042 this_ptr_conv.is_owned = false;
30043 Record_set_line(&this_ptr_conv, val);
30046 static inline uint64_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
30047 LDKRecord ret_var = Record_clone(arg);
30048 uint64_t ret_ref = 0;
30049 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30050 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30053 int64_t __attribute__((export_name("TS_Record_clone_ptr"))) TS_Record_clone_ptr(uint64_t arg) {
30054 LDKRecord arg_conv;
30055 arg_conv.inner = untag_ptr(arg);
30056 arg_conv.is_owned = ptr_is_owned(arg);
30057 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30058 arg_conv.is_owned = false;
30059 int64_t ret_conv = Record_clone_ptr(&arg_conv);
30063 uint64_t __attribute__((export_name("TS_Record_clone"))) TS_Record_clone(uint64_t orig) {
30064 LDKRecord orig_conv;
30065 orig_conv.inner = untag_ptr(orig);
30066 orig_conv.is_owned = ptr_is_owned(orig);
30067 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30068 orig_conv.is_owned = false;
30069 LDKRecord ret_var = Record_clone(&orig_conv);
30070 uint64_t ret_ref = 0;
30071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30076 void __attribute__((export_name("TS_Logger_free"))) TS_Logger_free(uint64_t this_ptr) {
30077 if (!ptr_is_owned(this_ptr)) return;
30078 void* this_ptr_ptr = untag_ptr(this_ptr);
30079 CHECK_ACCESS(this_ptr_ptr);
30080 LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
30081 FREE(untag_ptr(this_ptr));
30082 Logger_free(this_ptr_conv);
30085 void __attribute__((export_name("TS_ChannelHandshakeConfig_free"))) TS_ChannelHandshakeConfig_free(uint64_t this_obj) {
30086 LDKChannelHandshakeConfig this_obj_conv;
30087 this_obj_conv.inner = untag_ptr(this_obj);
30088 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30090 ChannelHandshakeConfig_free(this_obj_conv);
30093 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_minimum_depth"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint64_t this_ptr) {
30094 LDKChannelHandshakeConfig this_ptr_conv;
30095 this_ptr_conv.inner = untag_ptr(this_ptr);
30096 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30098 this_ptr_conv.is_owned = false;
30099 int32_t ret_conv = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
30103 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_minimum_depth"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint64_t this_ptr, int32_t val) {
30104 LDKChannelHandshakeConfig this_ptr_conv;
30105 this_ptr_conv.inner = untag_ptr(this_ptr);
30106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30108 this_ptr_conv.is_owned = false;
30109 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
30112 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_to_self_delay"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint64_t this_ptr) {
30113 LDKChannelHandshakeConfig this_ptr_conv;
30114 this_ptr_conv.inner = untag_ptr(this_ptr);
30115 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30117 this_ptr_conv.is_owned = false;
30118 int16_t ret_conv = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
30122 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) {
30123 LDKChannelHandshakeConfig this_ptr_conv;
30124 this_ptr_conv.inner = untag_ptr(this_ptr);
30125 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30126 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30127 this_ptr_conv.is_owned = false;
30128 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
30131 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint64_t this_ptr) {
30132 LDKChannelHandshakeConfig this_ptr_conv;
30133 this_ptr_conv.inner = untag_ptr(this_ptr);
30134 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30135 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30136 this_ptr_conv.is_owned = false;
30137 int64_t ret_conv = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
30141 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) {
30142 LDKChannelHandshakeConfig this_ptr_conv;
30143 this_ptr_conv.inner = untag_ptr(this_ptr);
30144 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30146 this_ptr_conv.is_owned = false;
30147 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
30150 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) {
30151 LDKChannelHandshakeConfig this_ptr_conv;
30152 this_ptr_conv.inner = untag_ptr(this_ptr);
30153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30155 this_ptr_conv.is_owned = false;
30156 int8_t ret_conv = ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv);
30160 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) {
30161 LDKChannelHandshakeConfig this_ptr_conv;
30162 this_ptr_conv.inner = untag_ptr(this_ptr);
30163 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30164 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30165 this_ptr_conv.is_owned = false;
30166 ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv, val);
30169 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(uint64_t this_ptr) {
30170 LDKChannelHandshakeConfig this_ptr_conv;
30171 this_ptr_conv.inner = untag_ptr(this_ptr);
30172 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30174 this_ptr_conv.is_owned = false;
30175 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_scid_privacy(&this_ptr_conv);
30179 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(uint64_t this_ptr, jboolean val) {
30180 LDKChannelHandshakeConfig this_ptr_conv;
30181 this_ptr_conv.inner = untag_ptr(this_ptr);
30182 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30184 this_ptr_conv.is_owned = false;
30185 ChannelHandshakeConfig_set_negotiate_scid_privacy(&this_ptr_conv, val);
30188 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_announced_channel"))) TS_ChannelHandshakeConfig_get_announced_channel(uint64_t this_ptr) {
30189 LDKChannelHandshakeConfig this_ptr_conv;
30190 this_ptr_conv.inner = untag_ptr(this_ptr);
30191 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30193 this_ptr_conv.is_owned = false;
30194 jboolean ret_conv = ChannelHandshakeConfig_get_announced_channel(&this_ptr_conv);
30198 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_announced_channel"))) TS_ChannelHandshakeConfig_set_announced_channel(uint64_t this_ptr, jboolean val) {
30199 LDKChannelHandshakeConfig this_ptr_conv;
30200 this_ptr_conv.inner = untag_ptr(this_ptr);
30201 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30202 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30203 this_ptr_conv.is_owned = false;
30204 ChannelHandshakeConfig_set_announced_channel(&this_ptr_conv, val);
30207 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(uint64_t this_ptr) {
30208 LDKChannelHandshakeConfig this_ptr_conv;
30209 this_ptr_conv.inner = untag_ptr(this_ptr);
30210 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30212 this_ptr_conv.is_owned = false;
30213 jboolean ret_conv = ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
30217 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(uint64_t this_ptr, jboolean val) {
30218 LDKChannelHandshakeConfig this_ptr_conv;
30219 this_ptr_conv.inner = untag_ptr(this_ptr);
30220 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30222 this_ptr_conv.is_owned = false;
30223 ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
30226 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) {
30227 LDKChannelHandshakeConfig this_ptr_conv;
30228 this_ptr_conv.inner = untag_ptr(this_ptr);
30229 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30231 this_ptr_conv.is_owned = false;
30232 int32_t ret_conv = ChannelHandshakeConfig_get_their_channel_reserve_proportional_millionths(&this_ptr_conv);
30236 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) {
30237 LDKChannelHandshakeConfig this_ptr_conv;
30238 this_ptr_conv.inner = untag_ptr(this_ptr);
30239 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30241 this_ptr_conv.is_owned = false;
30242 ChannelHandshakeConfig_set_their_channel_reserve_proportional_millionths(&this_ptr_conv, val);
30245 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx"))) TS_ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(uint64_t this_ptr) {
30246 LDKChannelHandshakeConfig this_ptr_conv;
30247 this_ptr_conv.inner = untag_ptr(this_ptr);
30248 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30250 this_ptr_conv.is_owned = false;
30251 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_anchors_zero_fee_htlc_tx(&this_ptr_conv);
30255 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx"))) TS_ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(uint64_t this_ptr, jboolean val) {
30256 LDKChannelHandshakeConfig this_ptr_conv;
30257 this_ptr_conv.inner = untag_ptr(this_ptr);
30258 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30259 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30260 this_ptr_conv.is_owned = false;
30261 ChannelHandshakeConfig_set_negotiate_anchors_zero_fee_htlc_tx(&this_ptr_conv, val);
30264 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs"))) TS_ChannelHandshakeConfig_get_our_max_accepted_htlcs(uint64_t this_ptr) {
30265 LDKChannelHandshakeConfig this_ptr_conv;
30266 this_ptr_conv.inner = untag_ptr(this_ptr);
30267 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30269 this_ptr_conv.is_owned = false;
30270 int16_t ret_conv = ChannelHandshakeConfig_get_our_max_accepted_htlcs(&this_ptr_conv);
30274 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) {
30275 LDKChannelHandshakeConfig this_ptr_conv;
30276 this_ptr_conv.inner = untag_ptr(this_ptr);
30277 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30279 this_ptr_conv.is_owned = false;
30280 ChannelHandshakeConfig_set_our_max_accepted_htlcs(&this_ptr_conv, val);
30283 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, jboolean negotiate_anchors_zero_fee_htlc_tx_arg, int16_t our_max_accepted_htlcs_arg) {
30284 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, negotiate_anchors_zero_fee_htlc_tx_arg, our_max_accepted_htlcs_arg);
30285 uint64_t ret_ref = 0;
30286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30287 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30291 static inline uint64_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
30292 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
30293 uint64_t ret_ref = 0;
30294 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30295 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30298 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone_ptr"))) TS_ChannelHandshakeConfig_clone_ptr(uint64_t arg) {
30299 LDKChannelHandshakeConfig arg_conv;
30300 arg_conv.inner = untag_ptr(arg);
30301 arg_conv.is_owned = ptr_is_owned(arg);
30302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30303 arg_conv.is_owned = false;
30304 int64_t ret_conv = ChannelHandshakeConfig_clone_ptr(&arg_conv);
30308 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone"))) TS_ChannelHandshakeConfig_clone(uint64_t orig) {
30309 LDKChannelHandshakeConfig orig_conv;
30310 orig_conv.inner = untag_ptr(orig);
30311 orig_conv.is_owned = ptr_is_owned(orig);
30312 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30313 orig_conv.is_owned = false;
30314 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
30315 uint64_t ret_ref = 0;
30316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30321 uint64_t __attribute__((export_name("TS_ChannelHandshakeConfig_default"))) TS_ChannelHandshakeConfig_default() {
30322 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
30323 uint64_t ret_ref = 0;
30324 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30325 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30329 void __attribute__((export_name("TS_ChannelHandshakeLimits_free"))) TS_ChannelHandshakeLimits_free(uint64_t this_obj) {
30330 LDKChannelHandshakeLimits this_obj_conv;
30331 this_obj_conv.inner = untag_ptr(this_obj);
30332 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30334 ChannelHandshakeLimits_free(this_obj_conv);
30337 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_funding_satoshis"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint64_t this_ptr) {
30338 LDKChannelHandshakeLimits this_ptr_conv;
30339 this_ptr_conv.inner = untag_ptr(this_ptr);
30340 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30342 this_ptr_conv.is_owned = false;
30343 int64_t ret_conv = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
30347 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_funding_satoshis"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint64_t this_ptr, int64_t val) {
30348 LDKChannelHandshakeLimits this_ptr_conv;
30349 this_ptr_conv.inner = untag_ptr(this_ptr);
30350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30352 this_ptr_conv.is_owned = false;
30353 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
30356 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_funding_satoshis"))) TS_ChannelHandshakeLimits_get_max_funding_satoshis(uint64_t this_ptr) {
30357 LDKChannelHandshakeLimits this_ptr_conv;
30358 this_ptr_conv.inner = untag_ptr(this_ptr);
30359 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30361 this_ptr_conv.is_owned = false;
30362 int64_t ret_conv = ChannelHandshakeLimits_get_max_funding_satoshis(&this_ptr_conv);
30366 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_funding_satoshis"))) TS_ChannelHandshakeLimits_set_max_funding_satoshis(uint64_t this_ptr, int64_t val) {
30367 LDKChannelHandshakeLimits this_ptr_conv;
30368 this_ptr_conv.inner = untag_ptr(this_ptr);
30369 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30371 this_ptr_conv.is_owned = false;
30372 ChannelHandshakeLimits_set_max_funding_satoshis(&this_ptr_conv, val);
30375 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint64_t this_ptr) {
30376 LDKChannelHandshakeLimits this_ptr_conv;
30377 this_ptr_conv.inner = untag_ptr(this_ptr);
30378 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30379 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30380 this_ptr_conv.is_owned = false;
30381 int64_t ret_conv = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
30385 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) {
30386 LDKChannelHandshakeLimits this_ptr_conv;
30387 this_ptr_conv.inner = untag_ptr(this_ptr);
30388 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30390 this_ptr_conv.is_owned = false;
30391 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
30394 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) {
30395 LDKChannelHandshakeLimits this_ptr_conv;
30396 this_ptr_conv.inner = untag_ptr(this_ptr);
30397 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30399 this_ptr_conv.is_owned = false;
30400 int64_t ret_conv = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
30404 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) {
30405 LDKChannelHandshakeLimits this_ptr_conv;
30406 this_ptr_conv.inner = untag_ptr(this_ptr);
30407 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30408 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30409 this_ptr_conv.is_owned = false;
30410 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
30413 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint64_t this_ptr) {
30414 LDKChannelHandshakeLimits this_ptr_conv;
30415 this_ptr_conv.inner = untag_ptr(this_ptr);
30416 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30418 this_ptr_conv.is_owned = false;
30419 int64_t ret_conv = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
30423 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) {
30424 LDKChannelHandshakeLimits this_ptr_conv;
30425 this_ptr_conv.inner = untag_ptr(this_ptr);
30426 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30427 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30428 this_ptr_conv.is_owned = false;
30429 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
30432 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint64_t this_ptr) {
30433 LDKChannelHandshakeLimits this_ptr_conv;
30434 this_ptr_conv.inner = untag_ptr(this_ptr);
30435 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30436 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30437 this_ptr_conv.is_owned = false;
30438 int16_t ret_conv = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
30442 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) {
30443 LDKChannelHandshakeLimits this_ptr_conv;
30444 this_ptr_conv.inner = untag_ptr(this_ptr);
30445 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30447 this_ptr_conv.is_owned = false;
30448 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
30451 int32_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_minimum_depth"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint64_t this_ptr) {
30452 LDKChannelHandshakeLimits this_ptr_conv;
30453 this_ptr_conv.inner = untag_ptr(this_ptr);
30454 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30456 this_ptr_conv.is_owned = false;
30457 int32_t ret_conv = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
30461 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_minimum_depth"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint64_t this_ptr, int32_t val) {
30462 LDKChannelHandshakeLimits 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 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
30470 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(uint64_t this_ptr) {
30471 LDKChannelHandshakeLimits this_ptr_conv;
30472 this_ptr_conv.inner = untag_ptr(this_ptr);
30473 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30475 this_ptr_conv.is_owned = false;
30476 jboolean ret_conv = ChannelHandshakeLimits_get_trust_own_funding_0conf(&this_ptr_conv);
30480 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(uint64_t this_ptr, jboolean val) {
30481 LDKChannelHandshakeLimits this_ptr_conv;
30482 this_ptr_conv.inner = untag_ptr(this_ptr);
30483 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30485 this_ptr_conv.is_owned = false;
30486 ChannelHandshakeLimits_set_trust_own_funding_0conf(&this_ptr_conv, val);
30489 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint64_t this_ptr) {
30490 LDKChannelHandshakeLimits this_ptr_conv;
30491 this_ptr_conv.inner = untag_ptr(this_ptr);
30492 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30494 this_ptr_conv.is_owned = false;
30495 jboolean ret_conv = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
30499 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint64_t this_ptr, jboolean val) {
30500 LDKChannelHandshakeLimits this_ptr_conv;
30501 this_ptr_conv.inner = untag_ptr(this_ptr);
30502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30504 this_ptr_conv.is_owned = false;
30505 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
30508 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_their_to_self_delay"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint64_t this_ptr) {
30509 LDKChannelHandshakeLimits this_ptr_conv;
30510 this_ptr_conv.inner = untag_ptr(this_ptr);
30511 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30512 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30513 this_ptr_conv.is_owned = false;
30514 int16_t ret_conv = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
30518 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) {
30519 LDKChannelHandshakeLimits this_ptr_conv;
30520 this_ptr_conv.inner = untag_ptr(this_ptr);
30521 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30523 this_ptr_conv.is_owned = false;
30524 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
30527 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) {
30528 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);
30529 uint64_t ret_ref = 0;
30530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30535 static inline uint64_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
30536 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
30537 uint64_t ret_ref = 0;
30538 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30539 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30542 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone_ptr"))) TS_ChannelHandshakeLimits_clone_ptr(uint64_t arg) {
30543 LDKChannelHandshakeLimits arg_conv;
30544 arg_conv.inner = untag_ptr(arg);
30545 arg_conv.is_owned = ptr_is_owned(arg);
30546 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30547 arg_conv.is_owned = false;
30548 int64_t ret_conv = ChannelHandshakeLimits_clone_ptr(&arg_conv);
30552 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone"))) TS_ChannelHandshakeLimits_clone(uint64_t orig) {
30553 LDKChannelHandshakeLimits orig_conv;
30554 orig_conv.inner = untag_ptr(orig);
30555 orig_conv.is_owned = ptr_is_owned(orig);
30556 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30557 orig_conv.is_owned = false;
30558 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
30559 uint64_t ret_ref = 0;
30560 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30561 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30565 uint64_t __attribute__((export_name("TS_ChannelHandshakeLimits_default"))) TS_ChannelHandshakeLimits_default() {
30566 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
30567 uint64_t ret_ref = 0;
30568 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30569 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30573 void __attribute__((export_name("TS_MaxDustHTLCExposure_free"))) TS_MaxDustHTLCExposure_free(uint64_t this_ptr) {
30574 if (!ptr_is_owned(this_ptr)) return;
30575 void* this_ptr_ptr = untag_ptr(this_ptr);
30576 CHECK_ACCESS(this_ptr_ptr);
30577 LDKMaxDustHTLCExposure this_ptr_conv = *(LDKMaxDustHTLCExposure*)(this_ptr_ptr);
30578 FREE(untag_ptr(this_ptr));
30579 MaxDustHTLCExposure_free(this_ptr_conv);
30582 static inline uint64_t MaxDustHTLCExposure_clone_ptr(LDKMaxDustHTLCExposure *NONNULL_PTR arg) {
30583 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
30584 *ret_copy = MaxDustHTLCExposure_clone(arg);
30585 uint64_t ret_ref = tag_ptr(ret_copy, true);
30588 int64_t __attribute__((export_name("TS_MaxDustHTLCExposure_clone_ptr"))) TS_MaxDustHTLCExposure_clone_ptr(uint64_t arg) {
30589 LDKMaxDustHTLCExposure* arg_conv = (LDKMaxDustHTLCExposure*)untag_ptr(arg);
30590 int64_t ret_conv = MaxDustHTLCExposure_clone_ptr(arg_conv);
30594 uint64_t __attribute__((export_name("TS_MaxDustHTLCExposure_clone"))) TS_MaxDustHTLCExposure_clone(uint64_t orig) {
30595 LDKMaxDustHTLCExposure* orig_conv = (LDKMaxDustHTLCExposure*)untag_ptr(orig);
30596 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
30597 *ret_copy = MaxDustHTLCExposure_clone(orig_conv);
30598 uint64_t ret_ref = tag_ptr(ret_copy, true);
30602 uint64_t __attribute__((export_name("TS_MaxDustHTLCExposure_fixed_limit_msat"))) TS_MaxDustHTLCExposure_fixed_limit_msat(int64_t a) {
30603 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
30604 *ret_copy = MaxDustHTLCExposure_fixed_limit_msat(a);
30605 uint64_t ret_ref = tag_ptr(ret_copy, true);
30609 uint64_t __attribute__((export_name("TS_MaxDustHTLCExposure_fee_rate_multiplier"))) TS_MaxDustHTLCExposure_fee_rate_multiplier(int64_t a) {
30610 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
30611 *ret_copy = MaxDustHTLCExposure_fee_rate_multiplier(a);
30612 uint64_t ret_ref = tag_ptr(ret_copy, true);
30616 jboolean __attribute__((export_name("TS_MaxDustHTLCExposure_eq"))) TS_MaxDustHTLCExposure_eq(uint64_t a, uint64_t b) {
30617 LDKMaxDustHTLCExposure* a_conv = (LDKMaxDustHTLCExposure*)untag_ptr(a);
30618 LDKMaxDustHTLCExposure* b_conv = (LDKMaxDustHTLCExposure*)untag_ptr(b);
30619 jboolean ret_conv = MaxDustHTLCExposure_eq(a_conv, b_conv);
30623 int8_tArray __attribute__((export_name("TS_MaxDustHTLCExposure_write"))) TS_MaxDustHTLCExposure_write(uint64_t obj) {
30624 LDKMaxDustHTLCExposure* obj_conv = (LDKMaxDustHTLCExposure*)untag_ptr(obj);
30625 LDKCVec_u8Z ret_var = MaxDustHTLCExposure_write(obj_conv);
30626 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
30627 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
30628 CVec_u8Z_free(ret_var);
30632 uint64_t __attribute__((export_name("TS_MaxDustHTLCExposure_read"))) TS_MaxDustHTLCExposure_read(int8_tArray ser) {
30633 LDKu8slice ser_ref;
30634 ser_ref.datalen = ser->arr_len;
30635 ser_ref.data = ser->elems;
30636 LDKCResult_MaxDustHTLCExposureDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_MaxDustHTLCExposureDecodeErrorZ), "LDKCResult_MaxDustHTLCExposureDecodeErrorZ");
30637 *ret_conv = MaxDustHTLCExposure_read(ser_ref);
30639 return tag_ptr(ret_conv, true);
30642 void __attribute__((export_name("TS_ChannelConfig_free"))) TS_ChannelConfig_free(uint64_t this_obj) {
30643 LDKChannelConfig this_obj_conv;
30644 this_obj_conv.inner = untag_ptr(this_obj);
30645 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30647 ChannelConfig_free(this_obj_conv);
30650 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint64_t this_ptr) {
30651 LDKChannelConfig this_ptr_conv;
30652 this_ptr_conv.inner = untag_ptr(this_ptr);
30653 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30654 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30655 this_ptr_conv.is_owned = false;
30656 int32_t ret_conv = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
30660 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) {
30661 LDKChannelConfig this_ptr_conv;
30662 this_ptr_conv.inner = untag_ptr(this_ptr);
30663 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30665 this_ptr_conv.is_owned = false;
30666 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
30669 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_base_msat"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint64_t this_ptr) {
30670 LDKChannelConfig this_ptr_conv;
30671 this_ptr_conv.inner = untag_ptr(this_ptr);
30672 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30674 this_ptr_conv.is_owned = false;
30675 int32_t ret_conv = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
30679 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) {
30680 LDKChannelConfig this_ptr_conv;
30681 this_ptr_conv.inner = untag_ptr(this_ptr);
30682 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30683 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30684 this_ptr_conv.is_owned = false;
30685 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
30688 int16_t __attribute__((export_name("TS_ChannelConfig_get_cltv_expiry_delta"))) TS_ChannelConfig_get_cltv_expiry_delta(uint64_t this_ptr) {
30689 LDKChannelConfig this_ptr_conv;
30690 this_ptr_conv.inner = untag_ptr(this_ptr);
30691 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30693 this_ptr_conv.is_owned = false;
30694 int16_t ret_conv = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
30698 void __attribute__((export_name("TS_ChannelConfig_set_cltv_expiry_delta"))) TS_ChannelConfig_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
30699 LDKChannelConfig this_ptr_conv;
30700 this_ptr_conv.inner = untag_ptr(this_ptr);
30701 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30703 this_ptr_conv.is_owned = false;
30704 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
30707 uint64_t __attribute__((export_name("TS_ChannelConfig_get_max_dust_htlc_exposure"))) TS_ChannelConfig_get_max_dust_htlc_exposure(uint64_t this_ptr) {
30708 LDKChannelConfig this_ptr_conv;
30709 this_ptr_conv.inner = untag_ptr(this_ptr);
30710 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30712 this_ptr_conv.is_owned = false;
30713 LDKMaxDustHTLCExposure *ret_copy = MALLOC(sizeof(LDKMaxDustHTLCExposure), "LDKMaxDustHTLCExposure");
30714 *ret_copy = ChannelConfig_get_max_dust_htlc_exposure(&this_ptr_conv);
30715 uint64_t ret_ref = tag_ptr(ret_copy, true);
30719 void __attribute__((export_name("TS_ChannelConfig_set_max_dust_htlc_exposure"))) TS_ChannelConfig_set_max_dust_htlc_exposure(uint64_t this_ptr, uint64_t val) {
30720 LDKChannelConfig this_ptr_conv;
30721 this_ptr_conv.inner = untag_ptr(this_ptr);
30722 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30724 this_ptr_conv.is_owned = false;
30725 void* val_ptr = untag_ptr(val);
30726 CHECK_ACCESS(val_ptr);
30727 LDKMaxDustHTLCExposure val_conv = *(LDKMaxDustHTLCExposure*)(val_ptr);
30728 val_conv = MaxDustHTLCExposure_clone((LDKMaxDustHTLCExposure*)untag_ptr(val));
30729 ChannelConfig_set_max_dust_htlc_exposure(&this_ptr_conv, val_conv);
30732 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) {
30733 LDKChannelConfig this_ptr_conv;
30734 this_ptr_conv.inner = untag_ptr(this_ptr);
30735 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30737 this_ptr_conv.is_owned = false;
30738 int64_t ret_conv = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
30742 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) {
30743 LDKChannelConfig this_ptr_conv;
30744 this_ptr_conv.inner = untag_ptr(this_ptr);
30745 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30747 this_ptr_conv.is_owned = false;
30748 ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
30751 jboolean __attribute__((export_name("TS_ChannelConfig_get_accept_underpaying_htlcs"))) TS_ChannelConfig_get_accept_underpaying_htlcs(uint64_t this_ptr) {
30752 LDKChannelConfig this_ptr_conv;
30753 this_ptr_conv.inner = untag_ptr(this_ptr);
30754 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30756 this_ptr_conv.is_owned = false;
30757 jboolean ret_conv = ChannelConfig_get_accept_underpaying_htlcs(&this_ptr_conv);
30761 void __attribute__((export_name("TS_ChannelConfig_set_accept_underpaying_htlcs"))) TS_ChannelConfig_set_accept_underpaying_htlcs(uint64_t this_ptr, jboolean val) {
30762 LDKChannelConfig 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 ChannelConfig_set_accept_underpaying_htlcs(&this_ptr_conv, val);
30770 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, uint64_t max_dust_htlc_exposure_arg, int64_t force_close_avoidance_max_fee_satoshis_arg, jboolean accept_underpaying_htlcs_arg) {
30771 void* max_dust_htlc_exposure_arg_ptr = untag_ptr(max_dust_htlc_exposure_arg);
30772 CHECK_ACCESS(max_dust_htlc_exposure_arg_ptr);
30773 LDKMaxDustHTLCExposure max_dust_htlc_exposure_arg_conv = *(LDKMaxDustHTLCExposure*)(max_dust_htlc_exposure_arg_ptr);
30774 max_dust_htlc_exposure_arg_conv = MaxDustHTLCExposure_clone((LDKMaxDustHTLCExposure*)untag_ptr(max_dust_htlc_exposure_arg));
30775 LDKChannelConfig ret_var = ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_arg_conv, force_close_avoidance_max_fee_satoshis_arg, accept_underpaying_htlcs_arg);
30776 uint64_t ret_ref = 0;
30777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30782 static inline uint64_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
30783 LDKChannelConfig ret_var = ChannelConfig_clone(arg);
30784 uint64_t ret_ref = 0;
30785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30786 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30789 int64_t __attribute__((export_name("TS_ChannelConfig_clone_ptr"))) TS_ChannelConfig_clone_ptr(uint64_t arg) {
30790 LDKChannelConfig arg_conv;
30791 arg_conv.inner = untag_ptr(arg);
30792 arg_conv.is_owned = ptr_is_owned(arg);
30793 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30794 arg_conv.is_owned = false;
30795 int64_t ret_conv = ChannelConfig_clone_ptr(&arg_conv);
30799 uint64_t __attribute__((export_name("TS_ChannelConfig_clone"))) TS_ChannelConfig_clone(uint64_t orig) {
30800 LDKChannelConfig orig_conv;
30801 orig_conv.inner = untag_ptr(orig);
30802 orig_conv.is_owned = ptr_is_owned(orig);
30803 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30804 orig_conv.is_owned = false;
30805 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
30806 uint64_t ret_ref = 0;
30807 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30808 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30812 jboolean __attribute__((export_name("TS_ChannelConfig_eq"))) TS_ChannelConfig_eq(uint64_t a, uint64_t b) {
30813 LDKChannelConfig a_conv;
30814 a_conv.inner = untag_ptr(a);
30815 a_conv.is_owned = ptr_is_owned(a);
30816 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
30817 a_conv.is_owned = false;
30818 LDKChannelConfig b_conv;
30819 b_conv.inner = untag_ptr(b);
30820 b_conv.is_owned = ptr_is_owned(b);
30821 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
30822 b_conv.is_owned = false;
30823 jboolean ret_conv = ChannelConfig_eq(&a_conv, &b_conv);
30827 void __attribute__((export_name("TS_ChannelConfig_apply"))) TS_ChannelConfig_apply(uint64_t this_arg, uint64_t update) {
30828 LDKChannelConfig this_arg_conv;
30829 this_arg_conv.inner = untag_ptr(this_arg);
30830 this_arg_conv.is_owned = ptr_is_owned(this_arg);
30831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
30832 this_arg_conv.is_owned = false;
30833 LDKChannelConfigUpdate update_conv;
30834 update_conv.inner = untag_ptr(update);
30835 update_conv.is_owned = ptr_is_owned(update);
30836 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
30837 update_conv.is_owned = false;
30838 ChannelConfig_apply(&this_arg_conv, &update_conv);
30841 uint64_t __attribute__((export_name("TS_ChannelConfig_default"))) TS_ChannelConfig_default() {
30842 LDKChannelConfig ret_var = ChannelConfig_default();
30843 uint64_t ret_ref = 0;
30844 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30845 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
30849 int8_tArray __attribute__((export_name("TS_ChannelConfig_write"))) TS_ChannelConfig_write(uint64_t obj) {
30850 LDKChannelConfig obj_conv;
30851 obj_conv.inner = untag_ptr(obj);
30852 obj_conv.is_owned = ptr_is_owned(obj);
30853 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
30854 obj_conv.is_owned = false;
30855 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
30856 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
30857 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
30858 CVec_u8Z_free(ret_var);
30862 uint64_t __attribute__((export_name("TS_ChannelConfig_read"))) TS_ChannelConfig_read(int8_tArray ser) {
30863 LDKu8slice ser_ref;
30864 ser_ref.datalen = ser->arr_len;
30865 ser_ref.data = ser->elems;
30866 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
30867 *ret_conv = ChannelConfig_read(ser_ref);
30869 return tag_ptr(ret_conv, true);
30872 void __attribute__((export_name("TS_ChannelConfigUpdate_free"))) TS_ChannelConfigUpdate_free(uint64_t this_obj) {
30873 LDKChannelConfigUpdate this_obj_conv;
30874 this_obj_conv.inner = untag_ptr(this_obj);
30875 this_obj_conv.is_owned = ptr_is_owned(this_obj);
30876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30877 ChannelConfigUpdate_free(this_obj_conv);
30880 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(uint64_t this_ptr) {
30881 LDKChannelConfigUpdate this_ptr_conv;
30882 this_ptr_conv.inner = untag_ptr(this_ptr);
30883 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30885 this_ptr_conv.is_owned = false;
30886 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
30887 *ret_copy = ChannelConfigUpdate_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
30888 uint64_t ret_ref = tag_ptr(ret_copy, true);
30892 void __attribute__((export_name("TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths"))) TS_ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(uint64_t this_ptr, uint64_t val) {
30893 LDKChannelConfigUpdate this_ptr_conv;
30894 this_ptr_conv.inner = untag_ptr(this_ptr);
30895 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30897 this_ptr_conv.is_owned = false;
30898 void* val_ptr = untag_ptr(val);
30899 CHECK_ACCESS(val_ptr);
30900 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
30901 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
30902 ChannelConfigUpdate_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val_conv);
30905 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_get_forwarding_fee_base_msat"))) TS_ChannelConfigUpdate_get_forwarding_fee_base_msat(uint64_t this_ptr) {
30906 LDKChannelConfigUpdate this_ptr_conv;
30907 this_ptr_conv.inner = untag_ptr(this_ptr);
30908 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30910 this_ptr_conv.is_owned = false;
30911 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
30912 *ret_copy = ChannelConfigUpdate_get_forwarding_fee_base_msat(&this_ptr_conv);
30913 uint64_t ret_ref = tag_ptr(ret_copy, true);
30917 void __attribute__((export_name("TS_ChannelConfigUpdate_set_forwarding_fee_base_msat"))) TS_ChannelConfigUpdate_set_forwarding_fee_base_msat(uint64_t this_ptr, uint64_t val) {
30918 LDKChannelConfigUpdate this_ptr_conv;
30919 this_ptr_conv.inner = untag_ptr(this_ptr);
30920 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30921 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30922 this_ptr_conv.is_owned = false;
30923 void* val_ptr = untag_ptr(val);
30924 CHECK_ACCESS(val_ptr);
30925 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
30926 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
30927 ChannelConfigUpdate_set_forwarding_fee_base_msat(&this_ptr_conv, val_conv);
30930 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_get_cltv_expiry_delta"))) TS_ChannelConfigUpdate_get_cltv_expiry_delta(uint64_t this_ptr) {
30931 LDKChannelConfigUpdate this_ptr_conv;
30932 this_ptr_conv.inner = untag_ptr(this_ptr);
30933 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30935 this_ptr_conv.is_owned = false;
30936 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
30937 *ret_copy = ChannelConfigUpdate_get_cltv_expiry_delta(&this_ptr_conv);
30938 uint64_t ret_ref = tag_ptr(ret_copy, true);
30942 void __attribute__((export_name("TS_ChannelConfigUpdate_set_cltv_expiry_delta"))) TS_ChannelConfigUpdate_set_cltv_expiry_delta(uint64_t this_ptr, uint64_t val) {
30943 LDKChannelConfigUpdate this_ptr_conv;
30944 this_ptr_conv.inner = untag_ptr(this_ptr);
30945 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30947 this_ptr_conv.is_owned = false;
30948 void* val_ptr = untag_ptr(val);
30949 CHECK_ACCESS(val_ptr);
30950 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
30951 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(val));
30952 ChannelConfigUpdate_set_cltv_expiry_delta(&this_ptr_conv, val_conv);
30955 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat"))) TS_ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(uint64_t this_ptr) {
30956 LDKChannelConfigUpdate this_ptr_conv;
30957 this_ptr_conv.inner = untag_ptr(this_ptr);
30958 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30960 this_ptr_conv.is_owned = false;
30961 LDKCOption_MaxDustHTLCExposureZ *ret_copy = MALLOC(sizeof(LDKCOption_MaxDustHTLCExposureZ), "LDKCOption_MaxDustHTLCExposureZ");
30962 *ret_copy = ChannelConfigUpdate_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
30963 uint64_t ret_ref = tag_ptr(ret_copy, true);
30967 void __attribute__((export_name("TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat"))) TS_ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(uint64_t this_ptr, uint64_t val) {
30968 LDKChannelConfigUpdate 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 void* val_ptr = untag_ptr(val);
30974 CHECK_ACCESS(val_ptr);
30975 LDKCOption_MaxDustHTLCExposureZ val_conv = *(LDKCOption_MaxDustHTLCExposureZ*)(val_ptr);
30976 val_conv = COption_MaxDustHTLCExposureZ_clone((LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(val));
30977 ChannelConfigUpdate_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val_conv);
30980 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(uint64_t this_ptr) {
30981 LDKChannelConfigUpdate this_ptr_conv;
30982 this_ptr_conv.inner = untag_ptr(this_ptr);
30983 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30985 this_ptr_conv.is_owned = false;
30986 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
30987 *ret_copy = ChannelConfigUpdate_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
30988 uint64_t ret_ref = tag_ptr(ret_copy, true);
30992 void __attribute__((export_name("TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(uint64_t this_ptr, uint64_t val) {
30993 LDKChannelConfigUpdate this_ptr_conv;
30994 this_ptr_conv.inner = untag_ptr(this_ptr);
30995 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
30996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30997 this_ptr_conv.is_owned = false;
30998 void* val_ptr = untag_ptr(val);
30999 CHECK_ACCESS(val_ptr);
31000 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
31001 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
31002 ChannelConfigUpdate_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val_conv);
31005 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_new"))) TS_ChannelConfigUpdate_new(uint64_t forwarding_fee_proportional_millionths_arg, uint64_t forwarding_fee_base_msat_arg, uint64_t cltv_expiry_delta_arg, uint64_t max_dust_htlc_exposure_msat_arg, uint64_t force_close_avoidance_max_fee_satoshis_arg) {
31006 void* forwarding_fee_proportional_millionths_arg_ptr = untag_ptr(forwarding_fee_proportional_millionths_arg);
31007 CHECK_ACCESS(forwarding_fee_proportional_millionths_arg_ptr);
31008 LDKCOption_u32Z forwarding_fee_proportional_millionths_arg_conv = *(LDKCOption_u32Z*)(forwarding_fee_proportional_millionths_arg_ptr);
31009 forwarding_fee_proportional_millionths_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(forwarding_fee_proportional_millionths_arg));
31010 void* forwarding_fee_base_msat_arg_ptr = untag_ptr(forwarding_fee_base_msat_arg);
31011 CHECK_ACCESS(forwarding_fee_base_msat_arg_ptr);
31012 LDKCOption_u32Z forwarding_fee_base_msat_arg_conv = *(LDKCOption_u32Z*)(forwarding_fee_base_msat_arg_ptr);
31013 forwarding_fee_base_msat_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(forwarding_fee_base_msat_arg));
31014 void* cltv_expiry_delta_arg_ptr = untag_ptr(cltv_expiry_delta_arg);
31015 CHECK_ACCESS(cltv_expiry_delta_arg_ptr);
31016 LDKCOption_u16Z cltv_expiry_delta_arg_conv = *(LDKCOption_u16Z*)(cltv_expiry_delta_arg_ptr);
31017 cltv_expiry_delta_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(cltv_expiry_delta_arg));
31018 void* max_dust_htlc_exposure_msat_arg_ptr = untag_ptr(max_dust_htlc_exposure_msat_arg);
31019 CHECK_ACCESS(max_dust_htlc_exposure_msat_arg_ptr);
31020 LDKCOption_MaxDustHTLCExposureZ max_dust_htlc_exposure_msat_arg_conv = *(LDKCOption_MaxDustHTLCExposureZ*)(max_dust_htlc_exposure_msat_arg_ptr);
31021 max_dust_htlc_exposure_msat_arg_conv = COption_MaxDustHTLCExposureZ_clone((LDKCOption_MaxDustHTLCExposureZ*)untag_ptr(max_dust_htlc_exposure_msat_arg));
31022 void* force_close_avoidance_max_fee_satoshis_arg_ptr = untag_ptr(force_close_avoidance_max_fee_satoshis_arg);
31023 CHECK_ACCESS(force_close_avoidance_max_fee_satoshis_arg_ptr);
31024 LDKCOption_u64Z force_close_avoidance_max_fee_satoshis_arg_conv = *(LDKCOption_u64Z*)(force_close_avoidance_max_fee_satoshis_arg_ptr);
31025 force_close_avoidance_max_fee_satoshis_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(force_close_avoidance_max_fee_satoshis_arg));
31026 LDKChannelConfigUpdate ret_var = ChannelConfigUpdate_new(forwarding_fee_proportional_millionths_arg_conv, forwarding_fee_base_msat_arg_conv, cltv_expiry_delta_arg_conv, max_dust_htlc_exposure_msat_arg_conv, force_close_avoidance_max_fee_satoshis_arg_conv);
31027 uint64_t ret_ref = 0;
31028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31033 uint64_t __attribute__((export_name("TS_ChannelConfigUpdate_default"))) TS_ChannelConfigUpdate_default() {
31034 LDKChannelConfigUpdate ret_var = ChannelConfigUpdate_default();
31035 uint64_t ret_ref = 0;
31036 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31037 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31041 void __attribute__((export_name("TS_UserConfig_free"))) TS_UserConfig_free(uint64_t this_obj) {
31042 LDKUserConfig this_obj_conv;
31043 this_obj_conv.inner = untag_ptr(this_obj);
31044 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31046 UserConfig_free(this_obj_conv);
31049 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_config"))) TS_UserConfig_get_channel_handshake_config(uint64_t this_ptr) {
31050 LDKUserConfig this_ptr_conv;
31051 this_ptr_conv.inner = untag_ptr(this_ptr);
31052 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31053 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31054 this_ptr_conv.is_owned = false;
31055 LDKChannelHandshakeConfig ret_var = UserConfig_get_channel_handshake_config(&this_ptr_conv);
31056 uint64_t ret_ref = 0;
31057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31062 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_config"))) TS_UserConfig_set_channel_handshake_config(uint64_t this_ptr, uint64_t val) {
31063 LDKUserConfig this_ptr_conv;
31064 this_ptr_conv.inner = untag_ptr(this_ptr);
31065 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31067 this_ptr_conv.is_owned = false;
31068 LDKChannelHandshakeConfig val_conv;
31069 val_conv.inner = untag_ptr(val);
31070 val_conv.is_owned = ptr_is_owned(val);
31071 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31072 val_conv = ChannelHandshakeConfig_clone(&val_conv);
31073 UserConfig_set_channel_handshake_config(&this_ptr_conv, val_conv);
31076 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_limits"))) TS_UserConfig_get_channel_handshake_limits(uint64_t this_ptr) {
31077 LDKUserConfig this_ptr_conv;
31078 this_ptr_conv.inner = untag_ptr(this_ptr);
31079 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31081 this_ptr_conv.is_owned = false;
31082 LDKChannelHandshakeLimits ret_var = UserConfig_get_channel_handshake_limits(&this_ptr_conv);
31083 uint64_t ret_ref = 0;
31084 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31085 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31089 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_limits"))) TS_UserConfig_set_channel_handshake_limits(uint64_t this_ptr, uint64_t val) {
31090 LDKUserConfig this_ptr_conv;
31091 this_ptr_conv.inner = untag_ptr(this_ptr);
31092 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31093 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31094 this_ptr_conv.is_owned = false;
31095 LDKChannelHandshakeLimits val_conv;
31096 val_conv.inner = untag_ptr(val);
31097 val_conv.is_owned = ptr_is_owned(val);
31098 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31099 val_conv = ChannelHandshakeLimits_clone(&val_conv);
31100 UserConfig_set_channel_handshake_limits(&this_ptr_conv, val_conv);
31103 uint64_t __attribute__((export_name("TS_UserConfig_get_channel_config"))) TS_UserConfig_get_channel_config(uint64_t this_ptr) {
31104 LDKUserConfig this_ptr_conv;
31105 this_ptr_conv.inner = untag_ptr(this_ptr);
31106 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31108 this_ptr_conv.is_owned = false;
31109 LDKChannelConfig ret_var = UserConfig_get_channel_config(&this_ptr_conv);
31110 uint64_t ret_ref = 0;
31111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31112 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31116 void __attribute__((export_name("TS_UserConfig_set_channel_config"))) TS_UserConfig_set_channel_config(uint64_t this_ptr, uint64_t val) {
31117 LDKUserConfig this_ptr_conv;
31118 this_ptr_conv.inner = untag_ptr(this_ptr);
31119 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31121 this_ptr_conv.is_owned = false;
31122 LDKChannelConfig val_conv;
31123 val_conv.inner = untag_ptr(val);
31124 val_conv.is_owned = ptr_is_owned(val);
31125 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31126 val_conv = ChannelConfig_clone(&val_conv);
31127 UserConfig_set_channel_config(&this_ptr_conv, val_conv);
31130 jboolean __attribute__((export_name("TS_UserConfig_get_accept_forwards_to_priv_channels"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint64_t this_ptr) {
31131 LDKUserConfig this_ptr_conv;
31132 this_ptr_conv.inner = untag_ptr(this_ptr);
31133 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31134 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31135 this_ptr_conv.is_owned = false;
31136 jboolean ret_conv = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
31140 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) {
31141 LDKUserConfig this_ptr_conv;
31142 this_ptr_conv.inner = untag_ptr(this_ptr);
31143 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31144 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31145 this_ptr_conv.is_owned = false;
31146 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
31149 jboolean __attribute__((export_name("TS_UserConfig_get_accept_inbound_channels"))) TS_UserConfig_get_accept_inbound_channels(uint64_t this_ptr) {
31150 LDKUserConfig this_ptr_conv;
31151 this_ptr_conv.inner = untag_ptr(this_ptr);
31152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31154 this_ptr_conv.is_owned = false;
31155 jboolean ret_conv = UserConfig_get_accept_inbound_channels(&this_ptr_conv);
31159 void __attribute__((export_name("TS_UserConfig_set_accept_inbound_channels"))) TS_UserConfig_set_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
31160 LDKUserConfig this_ptr_conv;
31161 this_ptr_conv.inner = untag_ptr(this_ptr);
31162 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31164 this_ptr_conv.is_owned = false;
31165 UserConfig_set_accept_inbound_channels(&this_ptr_conv, val);
31168 jboolean __attribute__((export_name("TS_UserConfig_get_manually_accept_inbound_channels"))) TS_UserConfig_get_manually_accept_inbound_channels(uint64_t this_ptr) {
31169 LDKUserConfig this_ptr_conv;
31170 this_ptr_conv.inner = untag_ptr(this_ptr);
31171 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31172 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31173 this_ptr_conv.is_owned = false;
31174 jboolean ret_conv = UserConfig_get_manually_accept_inbound_channels(&this_ptr_conv);
31178 void __attribute__((export_name("TS_UserConfig_set_manually_accept_inbound_channels"))) TS_UserConfig_set_manually_accept_inbound_channels(uint64_t this_ptr, jboolean val) {
31179 LDKUserConfig this_ptr_conv;
31180 this_ptr_conv.inner = untag_ptr(this_ptr);
31181 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31183 this_ptr_conv.is_owned = false;
31184 UserConfig_set_manually_accept_inbound_channels(&this_ptr_conv, val);
31187 jboolean __attribute__((export_name("TS_UserConfig_get_accept_intercept_htlcs"))) TS_UserConfig_get_accept_intercept_htlcs(uint64_t this_ptr) {
31188 LDKUserConfig this_ptr_conv;
31189 this_ptr_conv.inner = untag_ptr(this_ptr);
31190 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31191 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31192 this_ptr_conv.is_owned = false;
31193 jboolean ret_conv = UserConfig_get_accept_intercept_htlcs(&this_ptr_conv);
31197 void __attribute__((export_name("TS_UserConfig_set_accept_intercept_htlcs"))) TS_UserConfig_set_accept_intercept_htlcs(uint64_t this_ptr, jboolean val) {
31198 LDKUserConfig this_ptr_conv;
31199 this_ptr_conv.inner = untag_ptr(this_ptr);
31200 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31202 this_ptr_conv.is_owned = false;
31203 UserConfig_set_accept_intercept_htlcs(&this_ptr_conv, val);
31206 jboolean __attribute__((export_name("TS_UserConfig_get_accept_mpp_keysend"))) TS_UserConfig_get_accept_mpp_keysend(uint64_t this_ptr) {
31207 LDKUserConfig this_ptr_conv;
31208 this_ptr_conv.inner = untag_ptr(this_ptr);
31209 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31211 this_ptr_conv.is_owned = false;
31212 jboolean ret_conv = UserConfig_get_accept_mpp_keysend(&this_ptr_conv);
31216 void __attribute__((export_name("TS_UserConfig_set_accept_mpp_keysend"))) TS_UserConfig_set_accept_mpp_keysend(uint64_t this_ptr, jboolean val) {
31217 LDKUserConfig this_ptr_conv;
31218 this_ptr_conv.inner = untag_ptr(this_ptr);
31219 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31221 this_ptr_conv.is_owned = false;
31222 UserConfig_set_accept_mpp_keysend(&this_ptr_conv, val);
31225 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, jboolean accept_mpp_keysend_arg) {
31226 LDKChannelHandshakeConfig channel_handshake_config_arg_conv;
31227 channel_handshake_config_arg_conv.inner = untag_ptr(channel_handshake_config_arg);
31228 channel_handshake_config_arg_conv.is_owned = ptr_is_owned(channel_handshake_config_arg);
31229 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_config_arg_conv);
31230 channel_handshake_config_arg_conv = ChannelHandshakeConfig_clone(&channel_handshake_config_arg_conv);
31231 LDKChannelHandshakeLimits channel_handshake_limits_arg_conv;
31232 channel_handshake_limits_arg_conv.inner = untag_ptr(channel_handshake_limits_arg);
31233 channel_handshake_limits_arg_conv.is_owned = ptr_is_owned(channel_handshake_limits_arg);
31234 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_limits_arg_conv);
31235 channel_handshake_limits_arg_conv = ChannelHandshakeLimits_clone(&channel_handshake_limits_arg_conv);
31236 LDKChannelConfig channel_config_arg_conv;
31237 channel_config_arg_conv.inner = untag_ptr(channel_config_arg);
31238 channel_config_arg_conv.is_owned = ptr_is_owned(channel_config_arg);
31239 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_config_arg_conv);
31240 channel_config_arg_conv = ChannelConfig_clone(&channel_config_arg_conv);
31241 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, accept_mpp_keysend_arg);
31242 uint64_t ret_ref = 0;
31243 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31244 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31248 static inline uint64_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
31249 LDKUserConfig ret_var = UserConfig_clone(arg);
31250 uint64_t ret_ref = 0;
31251 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31252 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31255 int64_t __attribute__((export_name("TS_UserConfig_clone_ptr"))) TS_UserConfig_clone_ptr(uint64_t arg) {
31256 LDKUserConfig arg_conv;
31257 arg_conv.inner = untag_ptr(arg);
31258 arg_conv.is_owned = ptr_is_owned(arg);
31259 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31260 arg_conv.is_owned = false;
31261 int64_t ret_conv = UserConfig_clone_ptr(&arg_conv);
31265 uint64_t __attribute__((export_name("TS_UserConfig_clone"))) TS_UserConfig_clone(uint64_t orig) {
31266 LDKUserConfig orig_conv;
31267 orig_conv.inner = untag_ptr(orig);
31268 orig_conv.is_owned = ptr_is_owned(orig);
31269 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31270 orig_conv.is_owned = false;
31271 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
31272 uint64_t ret_ref = 0;
31273 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31274 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31278 uint64_t __attribute__((export_name("TS_UserConfig_default"))) TS_UserConfig_default() {
31279 LDKUserConfig ret_var = UserConfig_default();
31280 uint64_t ret_ref = 0;
31281 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31282 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31286 void __attribute__((export_name("TS_BestBlock_free"))) TS_BestBlock_free(uint64_t this_obj) {
31287 LDKBestBlock this_obj_conv;
31288 this_obj_conv.inner = untag_ptr(this_obj);
31289 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31291 BestBlock_free(this_obj_conv);
31294 static inline uint64_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
31295 LDKBestBlock ret_var = BestBlock_clone(arg);
31296 uint64_t ret_ref = 0;
31297 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31298 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31301 int64_t __attribute__((export_name("TS_BestBlock_clone_ptr"))) TS_BestBlock_clone_ptr(uint64_t arg) {
31302 LDKBestBlock arg_conv;
31303 arg_conv.inner = untag_ptr(arg);
31304 arg_conv.is_owned = ptr_is_owned(arg);
31305 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31306 arg_conv.is_owned = false;
31307 int64_t ret_conv = BestBlock_clone_ptr(&arg_conv);
31311 uint64_t __attribute__((export_name("TS_BestBlock_clone"))) TS_BestBlock_clone(uint64_t orig) {
31312 LDKBestBlock orig_conv;
31313 orig_conv.inner = untag_ptr(orig);
31314 orig_conv.is_owned = ptr_is_owned(orig);
31315 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31316 orig_conv.is_owned = false;
31317 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
31318 uint64_t ret_ref = 0;
31319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31320 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31324 jboolean __attribute__((export_name("TS_BestBlock_eq"))) TS_BestBlock_eq(uint64_t a, uint64_t b) {
31325 LDKBestBlock a_conv;
31326 a_conv.inner = untag_ptr(a);
31327 a_conv.is_owned = ptr_is_owned(a);
31328 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31329 a_conv.is_owned = false;
31330 LDKBestBlock b_conv;
31331 b_conv.inner = untag_ptr(b);
31332 b_conv.is_owned = ptr_is_owned(b);
31333 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31334 b_conv.is_owned = false;
31335 jboolean ret_conv = BestBlock_eq(&a_conv, &b_conv);
31339 uint64_t __attribute__((export_name("TS_BestBlock_from_network"))) TS_BestBlock_from_network(uint32_t network) {
31340 LDKNetwork network_conv = LDKNetwork_from_js(network);
31341 LDKBestBlock ret_var = BestBlock_from_network(network_conv);
31342 uint64_t ret_ref = 0;
31343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31348 uint64_t __attribute__((export_name("TS_BestBlock_new"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
31349 LDKThirtyTwoBytes block_hash_ref;
31350 CHECK(block_hash->arr_len == 32);
31351 memcpy(block_hash_ref.data, block_hash->elems, 32); FREE(block_hash);
31352 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
31353 uint64_t ret_ref = 0;
31354 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31355 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31359 int8_tArray __attribute__((export_name("TS_BestBlock_block_hash"))) TS_BestBlock_block_hash(uint64_t this_arg) {
31360 LDKBestBlock this_arg_conv;
31361 this_arg_conv.inner = untag_ptr(this_arg);
31362 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31364 this_arg_conv.is_owned = false;
31365 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31366 memcpy(ret_arr->elems, BestBlock_block_hash(&this_arg_conv).data, 32);
31370 int32_t __attribute__((export_name("TS_BestBlock_height"))) TS_BestBlock_height(uint64_t this_arg) {
31371 LDKBestBlock this_arg_conv;
31372 this_arg_conv.inner = untag_ptr(this_arg);
31373 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31375 this_arg_conv.is_owned = false;
31376 int32_t ret_conv = BestBlock_height(&this_arg_conv);
31380 void __attribute__((export_name("TS_Listen_free"))) TS_Listen_free(uint64_t this_ptr) {
31381 if (!ptr_is_owned(this_ptr)) return;
31382 void* this_ptr_ptr = untag_ptr(this_ptr);
31383 CHECK_ACCESS(this_ptr_ptr);
31384 LDKListen this_ptr_conv = *(LDKListen*)(this_ptr_ptr);
31385 FREE(untag_ptr(this_ptr));
31386 Listen_free(this_ptr_conv);
31389 void __attribute__((export_name("TS_Confirm_free"))) TS_Confirm_free(uint64_t this_ptr) {
31390 if (!ptr_is_owned(this_ptr)) return;
31391 void* this_ptr_ptr = untag_ptr(this_ptr);
31392 CHECK_ACCESS(this_ptr_ptr);
31393 LDKConfirm this_ptr_conv = *(LDKConfirm*)(this_ptr_ptr);
31394 FREE(untag_ptr(this_ptr));
31395 Confirm_free(this_ptr_conv);
31398 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_clone"))) TS_ChannelMonitorUpdateStatus_clone(uint64_t orig) {
31399 LDKChannelMonitorUpdateStatus* orig_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(orig);
31400 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_clone(orig_conv));
31404 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_completed"))) TS_ChannelMonitorUpdateStatus_completed() {
31405 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_completed());
31409 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_in_progress"))) TS_ChannelMonitorUpdateStatus_in_progress() {
31410 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_in_progress());
31414 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateStatus_unrecoverable_error"))) TS_ChannelMonitorUpdateStatus_unrecoverable_error() {
31415 uint32_t ret_conv = LDKChannelMonitorUpdateStatus_to_js(ChannelMonitorUpdateStatus_unrecoverable_error());
31419 jboolean __attribute__((export_name("TS_ChannelMonitorUpdateStatus_eq"))) TS_ChannelMonitorUpdateStatus_eq(uint64_t a, uint64_t b) {
31420 LDKChannelMonitorUpdateStatus* a_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(a);
31421 LDKChannelMonitorUpdateStatus* b_conv = (LDKChannelMonitorUpdateStatus*)untag_ptr(b);
31422 jboolean ret_conv = ChannelMonitorUpdateStatus_eq(a_conv, b_conv);
31426 void __attribute__((export_name("TS_Watch_free"))) TS_Watch_free(uint64_t this_ptr) {
31427 if (!ptr_is_owned(this_ptr)) return;
31428 void* this_ptr_ptr = untag_ptr(this_ptr);
31429 CHECK_ACCESS(this_ptr_ptr);
31430 LDKWatch this_ptr_conv = *(LDKWatch*)(this_ptr_ptr);
31431 FREE(untag_ptr(this_ptr));
31432 Watch_free(this_ptr_conv);
31435 void __attribute__((export_name("TS_Filter_free"))) TS_Filter_free(uint64_t this_ptr) {
31436 if (!ptr_is_owned(this_ptr)) return;
31437 void* this_ptr_ptr = untag_ptr(this_ptr);
31438 CHECK_ACCESS(this_ptr_ptr);
31439 LDKFilter this_ptr_conv = *(LDKFilter*)(this_ptr_ptr);
31440 FREE(untag_ptr(this_ptr));
31441 Filter_free(this_ptr_conv);
31444 void __attribute__((export_name("TS_WatchedOutput_free"))) TS_WatchedOutput_free(uint64_t this_obj) {
31445 LDKWatchedOutput this_obj_conv;
31446 this_obj_conv.inner = untag_ptr(this_obj);
31447 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31448 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31449 WatchedOutput_free(this_obj_conv);
31452 uint64_t __attribute__((export_name("TS_WatchedOutput_get_block_hash"))) TS_WatchedOutput_get_block_hash(uint64_t this_ptr) {
31453 LDKWatchedOutput 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 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
31459 *ret_copy = WatchedOutput_get_block_hash(&this_ptr_conv);
31460 uint64_t ret_ref = tag_ptr(ret_copy, true);
31464 void __attribute__((export_name("TS_WatchedOutput_set_block_hash"))) TS_WatchedOutput_set_block_hash(uint64_t this_ptr, uint64_t val) {
31465 LDKWatchedOutput this_ptr_conv;
31466 this_ptr_conv.inner = untag_ptr(this_ptr);
31467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31469 this_ptr_conv.is_owned = false;
31470 void* val_ptr = untag_ptr(val);
31471 CHECK_ACCESS(val_ptr);
31472 LDKCOption_ThirtyTwoBytesZ val_conv = *(LDKCOption_ThirtyTwoBytesZ*)(val_ptr);
31473 val_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(val));
31474 WatchedOutput_set_block_hash(&this_ptr_conv, val_conv);
31477 uint64_t __attribute__((export_name("TS_WatchedOutput_get_outpoint"))) TS_WatchedOutput_get_outpoint(uint64_t this_ptr) {
31478 LDKWatchedOutput this_ptr_conv;
31479 this_ptr_conv.inner = untag_ptr(this_ptr);
31480 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31482 this_ptr_conv.is_owned = false;
31483 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
31484 uint64_t ret_ref = 0;
31485 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31486 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31490 void __attribute__((export_name("TS_WatchedOutput_set_outpoint"))) TS_WatchedOutput_set_outpoint(uint64_t this_ptr, uint64_t val) {
31491 LDKWatchedOutput this_ptr_conv;
31492 this_ptr_conv.inner = untag_ptr(this_ptr);
31493 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31495 this_ptr_conv.is_owned = false;
31496 LDKOutPoint val_conv;
31497 val_conv.inner = untag_ptr(val);
31498 val_conv.is_owned = ptr_is_owned(val);
31499 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31500 val_conv = OutPoint_clone(&val_conv);
31501 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
31504 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_script_pubkey"))) TS_WatchedOutput_get_script_pubkey(uint64_t this_ptr) {
31505 LDKWatchedOutput this_ptr_conv;
31506 this_ptr_conv.inner = untag_ptr(this_ptr);
31507 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31508 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31509 this_ptr_conv.is_owned = false;
31510 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
31511 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
31512 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
31516 void __attribute__((export_name("TS_WatchedOutput_set_script_pubkey"))) TS_WatchedOutput_set_script_pubkey(uint64_t this_ptr, int8_tArray val) {
31517 LDKWatchedOutput this_ptr_conv;
31518 this_ptr_conv.inner = untag_ptr(this_ptr);
31519 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31521 this_ptr_conv.is_owned = false;
31522 LDKCVec_u8Z val_ref;
31523 val_ref.datalen = val->arr_len;
31524 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
31525 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
31526 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
31529 uint64_t __attribute__((export_name("TS_WatchedOutput_new"))) TS_WatchedOutput_new(uint64_t block_hash_arg, uint64_t outpoint_arg, int8_tArray script_pubkey_arg) {
31530 void* block_hash_arg_ptr = untag_ptr(block_hash_arg);
31531 CHECK_ACCESS(block_hash_arg_ptr);
31532 LDKCOption_ThirtyTwoBytesZ block_hash_arg_conv = *(LDKCOption_ThirtyTwoBytesZ*)(block_hash_arg_ptr);
31533 block_hash_arg_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(block_hash_arg));
31534 LDKOutPoint outpoint_arg_conv;
31535 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
31536 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
31537 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
31538 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
31539 LDKCVec_u8Z script_pubkey_arg_ref;
31540 script_pubkey_arg_ref.datalen = script_pubkey_arg->arr_len;
31541 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
31542 memcpy(script_pubkey_arg_ref.data, script_pubkey_arg->elems, script_pubkey_arg_ref.datalen); FREE(script_pubkey_arg);
31543 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_conv, outpoint_arg_conv, script_pubkey_arg_ref);
31544 uint64_t ret_ref = 0;
31545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31546 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31550 static inline uint64_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
31551 LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
31552 uint64_t ret_ref = 0;
31553 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31554 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31557 int64_t __attribute__((export_name("TS_WatchedOutput_clone_ptr"))) TS_WatchedOutput_clone_ptr(uint64_t arg) {
31558 LDKWatchedOutput arg_conv;
31559 arg_conv.inner = untag_ptr(arg);
31560 arg_conv.is_owned = ptr_is_owned(arg);
31561 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31562 arg_conv.is_owned = false;
31563 int64_t ret_conv = WatchedOutput_clone_ptr(&arg_conv);
31567 uint64_t __attribute__((export_name("TS_WatchedOutput_clone"))) TS_WatchedOutput_clone(uint64_t orig) {
31568 LDKWatchedOutput orig_conv;
31569 orig_conv.inner = untag_ptr(orig);
31570 orig_conv.is_owned = ptr_is_owned(orig);
31571 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31572 orig_conv.is_owned = false;
31573 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
31574 uint64_t ret_ref = 0;
31575 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31576 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31580 jboolean __attribute__((export_name("TS_WatchedOutput_eq"))) TS_WatchedOutput_eq(uint64_t a, uint64_t b) {
31581 LDKWatchedOutput a_conv;
31582 a_conv.inner = untag_ptr(a);
31583 a_conv.is_owned = ptr_is_owned(a);
31584 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31585 a_conv.is_owned = false;
31586 LDKWatchedOutput b_conv;
31587 b_conv.inner = untag_ptr(b);
31588 b_conv.is_owned = ptr_is_owned(b);
31589 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31590 b_conv.is_owned = false;
31591 jboolean ret_conv = WatchedOutput_eq(&a_conv, &b_conv);
31595 int64_t __attribute__((export_name("TS_WatchedOutput_hash"))) TS_WatchedOutput_hash(uint64_t o) {
31596 LDKWatchedOutput o_conv;
31597 o_conv.inner = untag_ptr(o);
31598 o_conv.is_owned = ptr_is_owned(o);
31599 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
31600 o_conv.is_owned = false;
31601 int64_t ret_conv = WatchedOutput_hash(&o_conv);
31605 void __attribute__((export_name("TS_BroadcasterInterface_free"))) TS_BroadcasterInterface_free(uint64_t this_ptr) {
31606 if (!ptr_is_owned(this_ptr)) return;
31607 void* this_ptr_ptr = untag_ptr(this_ptr);
31608 CHECK_ACCESS(this_ptr_ptr);
31609 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(this_ptr_ptr);
31610 FREE(untag_ptr(this_ptr));
31611 BroadcasterInterface_free(this_ptr_conv);
31614 uint32_t __attribute__((export_name("TS_ConfirmationTarget_clone"))) TS_ConfirmationTarget_clone(uint64_t orig) {
31615 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)untag_ptr(orig);
31616 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
31620 uint32_t __attribute__((export_name("TS_ConfirmationTarget_mempool_minimum"))) TS_ConfirmationTarget_mempool_minimum() {
31621 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_mempool_minimum());
31625 uint32_t __attribute__((export_name("TS_ConfirmationTarget_background"))) TS_ConfirmationTarget_background() {
31626 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_background());
31630 uint32_t __attribute__((export_name("TS_ConfirmationTarget_normal"))) TS_ConfirmationTarget_normal() {
31631 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_normal());
31635 uint32_t __attribute__((export_name("TS_ConfirmationTarget_high_priority"))) TS_ConfirmationTarget_high_priority() {
31636 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_high_priority());
31640 int64_t __attribute__((export_name("TS_ConfirmationTarget_hash"))) TS_ConfirmationTarget_hash(uint64_t o) {
31641 LDKConfirmationTarget* o_conv = (LDKConfirmationTarget*)untag_ptr(o);
31642 int64_t ret_conv = ConfirmationTarget_hash(o_conv);
31646 jboolean __attribute__((export_name("TS_ConfirmationTarget_eq"))) TS_ConfirmationTarget_eq(uint64_t a, uint64_t b) {
31647 LDKConfirmationTarget* a_conv = (LDKConfirmationTarget*)untag_ptr(a);
31648 LDKConfirmationTarget* b_conv = (LDKConfirmationTarget*)untag_ptr(b);
31649 jboolean ret_conv = ConfirmationTarget_eq(a_conv, b_conv);
31653 void __attribute__((export_name("TS_FeeEstimator_free"))) TS_FeeEstimator_free(uint64_t this_ptr) {
31654 if (!ptr_is_owned(this_ptr)) return;
31655 void* this_ptr_ptr = untag_ptr(this_ptr);
31656 CHECK_ACCESS(this_ptr_ptr);
31657 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(this_ptr_ptr);
31658 FREE(untag_ptr(this_ptr));
31659 FeeEstimator_free(this_ptr_conv);
31662 void __attribute__((export_name("TS_MonitorUpdateId_free"))) TS_MonitorUpdateId_free(uint64_t this_obj) {
31663 LDKMonitorUpdateId this_obj_conv;
31664 this_obj_conv.inner = untag_ptr(this_obj);
31665 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31666 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31667 MonitorUpdateId_free(this_obj_conv);
31670 static inline uint64_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
31671 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
31672 uint64_t ret_ref = 0;
31673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31674 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31677 int64_t __attribute__((export_name("TS_MonitorUpdateId_clone_ptr"))) TS_MonitorUpdateId_clone_ptr(uint64_t arg) {
31678 LDKMonitorUpdateId arg_conv;
31679 arg_conv.inner = untag_ptr(arg);
31680 arg_conv.is_owned = ptr_is_owned(arg);
31681 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31682 arg_conv.is_owned = false;
31683 int64_t ret_conv = MonitorUpdateId_clone_ptr(&arg_conv);
31687 uint64_t __attribute__((export_name("TS_MonitorUpdateId_clone"))) TS_MonitorUpdateId_clone(uint64_t orig) {
31688 LDKMonitorUpdateId orig_conv;
31689 orig_conv.inner = untag_ptr(orig);
31690 orig_conv.is_owned = ptr_is_owned(orig);
31691 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31692 orig_conv.is_owned = false;
31693 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
31694 uint64_t ret_ref = 0;
31695 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31696 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31700 int64_t __attribute__((export_name("TS_MonitorUpdateId_hash"))) TS_MonitorUpdateId_hash(uint64_t o) {
31701 LDKMonitorUpdateId o_conv;
31702 o_conv.inner = untag_ptr(o);
31703 o_conv.is_owned = ptr_is_owned(o);
31704 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
31705 o_conv.is_owned = false;
31706 int64_t ret_conv = MonitorUpdateId_hash(&o_conv);
31710 jboolean __attribute__((export_name("TS_MonitorUpdateId_eq"))) TS_MonitorUpdateId_eq(uint64_t a, uint64_t b) {
31711 LDKMonitorUpdateId a_conv;
31712 a_conv.inner = untag_ptr(a);
31713 a_conv.is_owned = ptr_is_owned(a);
31714 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
31715 a_conv.is_owned = false;
31716 LDKMonitorUpdateId b_conv;
31717 b_conv.inner = untag_ptr(b);
31718 b_conv.is_owned = ptr_is_owned(b);
31719 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
31720 b_conv.is_owned = false;
31721 jboolean ret_conv = MonitorUpdateId_eq(&a_conv, &b_conv);
31725 void __attribute__((export_name("TS_Persist_free"))) TS_Persist_free(uint64_t this_ptr) {
31726 if (!ptr_is_owned(this_ptr)) return;
31727 void* this_ptr_ptr = untag_ptr(this_ptr);
31728 CHECK_ACCESS(this_ptr_ptr);
31729 LDKPersist this_ptr_conv = *(LDKPersist*)(this_ptr_ptr);
31730 FREE(untag_ptr(this_ptr));
31731 Persist_free(this_ptr_conv);
31734 void __attribute__((export_name("TS_LockedChannelMonitor_free"))) TS_LockedChannelMonitor_free(uint64_t this_obj) {
31735 LDKLockedChannelMonitor this_obj_conv;
31736 this_obj_conv.inner = untag_ptr(this_obj);
31737 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31738 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31739 LockedChannelMonitor_free(this_obj_conv);
31742 void __attribute__((export_name("TS_ChainMonitor_free"))) TS_ChainMonitor_free(uint64_t this_obj) {
31743 LDKChainMonitor this_obj_conv;
31744 this_obj_conv.inner = untag_ptr(this_obj);
31745 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31747 ChainMonitor_free(this_obj_conv);
31750 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) {
31751 void* chain_source_ptr = untag_ptr(chain_source);
31752 CHECK_ACCESS(chain_source_ptr);
31753 LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(chain_source_ptr);
31754 // WARNING: we may need a move here but no clone is available for LDKCOption_FilterZ
31755 if (chain_source_conv.tag == LDKCOption_FilterZ_Some) {
31756 // Manually implement clone for Java trait instances
31757 if (chain_source_conv.some.free == LDKFilter_JCalls_free) {
31758 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
31759 LDKFilter_JCalls_cloned(&chain_source_conv.some);
31762 void* broadcaster_ptr = untag_ptr(broadcaster);
31763 CHECK_ACCESS(broadcaster_ptr);
31764 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
31765 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
31766 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
31767 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
31769 void* logger_ptr = untag_ptr(logger);
31770 CHECK_ACCESS(logger_ptr);
31771 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
31772 if (logger_conv.free == LDKLogger_JCalls_free) {
31773 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
31774 LDKLogger_JCalls_cloned(&logger_conv);
31776 void* feeest_ptr = untag_ptr(feeest);
31777 CHECK_ACCESS(feeest_ptr);
31778 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(feeest_ptr);
31779 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
31780 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
31781 LDKFeeEstimator_JCalls_cloned(&feeest_conv);
31783 void* persister_ptr = untag_ptr(persister);
31784 CHECK_ACCESS(persister_ptr);
31785 LDKPersist persister_conv = *(LDKPersist*)(persister_ptr);
31786 if (persister_conv.free == LDKPersist_JCalls_free) {
31787 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
31788 LDKPersist_JCalls_cloned(&persister_conv);
31790 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
31791 uint64_t ret_ref = 0;
31792 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31793 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31797 uint64_tArray __attribute__((export_name("TS_ChainMonitor_get_claimable_balances"))) TS_ChainMonitor_get_claimable_balances(uint64_t this_arg, uint64_tArray ignored_channels) {
31798 LDKChainMonitor this_arg_conv;
31799 this_arg_conv.inner = untag_ptr(this_arg);
31800 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31802 this_arg_conv.is_owned = false;
31803 LDKCVec_ChannelDetailsZ ignored_channels_constr;
31804 ignored_channels_constr.datalen = ignored_channels->arr_len;
31805 if (ignored_channels_constr.datalen > 0)
31806 ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
31808 ignored_channels_constr.data = NULL;
31809 uint64_t* ignored_channels_vals = ignored_channels->elems;
31810 for (size_t q = 0; q < ignored_channels_constr.datalen; q++) {
31811 uint64_t ignored_channels_conv_16 = ignored_channels_vals[q];
31812 LDKChannelDetails ignored_channels_conv_16_conv;
31813 ignored_channels_conv_16_conv.inner = untag_ptr(ignored_channels_conv_16);
31814 ignored_channels_conv_16_conv.is_owned = ptr_is_owned(ignored_channels_conv_16);
31815 CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
31816 ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
31817 ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
31819 FREE(ignored_channels);
31820 LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr);
31821 uint64_tArray ret_arr = NULL;
31822 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
31823 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
31824 for (size_t j = 0; j < ret_var.datalen; j++) {
31825 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
31826 *ret_conv_9_copy = ret_var.data[j];
31827 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
31828 ret_arr_ptr[j] = ret_conv_9_ref;
31831 FREE(ret_var.data);
31835 uint64_t __attribute__((export_name("TS_ChainMonitor_get_monitor"))) TS_ChainMonitor_get_monitor(uint64_t this_arg, uint64_t funding_txo) {
31836 LDKChainMonitor this_arg_conv;
31837 this_arg_conv.inner = untag_ptr(this_arg);
31838 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31840 this_arg_conv.is_owned = false;
31841 LDKOutPoint funding_txo_conv;
31842 funding_txo_conv.inner = untag_ptr(funding_txo);
31843 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
31844 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
31845 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
31846 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
31847 *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
31848 return tag_ptr(ret_conv, true);
31851 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_monitors"))) TS_ChainMonitor_list_monitors(uint64_t this_arg) {
31852 LDKChainMonitor this_arg_conv;
31853 this_arg_conv.inner = untag_ptr(this_arg);
31854 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31856 this_arg_conv.is_owned = false;
31857 LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
31858 uint64_tArray ret_arr = NULL;
31859 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
31860 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
31861 for (size_t k = 0; k < ret_var.datalen; k++) {
31862 LDKOutPoint ret_conv_10_var = ret_var.data[k];
31863 uint64_t ret_conv_10_ref = 0;
31864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
31865 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
31866 ret_arr_ptr[k] = ret_conv_10_ref;
31869 FREE(ret_var.data);
31873 uint64_tArray __attribute__((export_name("TS_ChainMonitor_list_pending_monitor_updates"))) TS_ChainMonitor_list_pending_monitor_updates(uint64_t this_arg) {
31874 LDKChainMonitor this_arg_conv;
31875 this_arg_conv.inner = untag_ptr(this_arg);
31876 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31878 this_arg_conv.is_owned = false;
31879 LDKCVec_C2Tuple_OutPointCVec_MonitorUpdateIdZZZ ret_var = ChainMonitor_list_pending_monitor_updates(&this_arg_conv);
31880 uint64_tArray ret_arr = NULL;
31881 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
31882 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
31883 for (size_t p = 0; p < ret_var.datalen; p++) {
31884 LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ* ret_conv_41_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ), "LDKC2Tuple_OutPointCVec_MonitorUpdateIdZZ");
31885 *ret_conv_41_conv = ret_var.data[p];
31886 ret_arr_ptr[p] = tag_ptr(ret_conv_41_conv, true);
31889 FREE(ret_var.data);
31893 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) {
31894 LDKChainMonitor this_arg_conv;
31895 this_arg_conv.inner = untag_ptr(this_arg);
31896 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31898 this_arg_conv.is_owned = false;
31899 LDKOutPoint funding_txo_conv;
31900 funding_txo_conv.inner = untag_ptr(funding_txo);
31901 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
31902 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
31903 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
31904 LDKMonitorUpdateId completed_update_id_conv;
31905 completed_update_id_conv.inner = untag_ptr(completed_update_id);
31906 completed_update_id_conv.is_owned = ptr_is_owned(completed_update_id);
31907 CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
31908 completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
31909 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
31910 *ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
31911 return tag_ptr(ret_conv, true);
31914 uint64_t __attribute__((export_name("TS_ChainMonitor_get_update_future"))) TS_ChainMonitor_get_update_future(uint64_t this_arg) {
31915 LDKChainMonitor this_arg_conv;
31916 this_arg_conv.inner = untag_ptr(this_arg);
31917 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31919 this_arg_conv.is_owned = false;
31920 LDKFuture ret_var = ChainMonitor_get_update_future(&this_arg_conv);
31921 uint64_t ret_ref = 0;
31922 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31923 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
31927 void __attribute__((export_name("TS_ChainMonitor_rebroadcast_pending_claims"))) TS_ChainMonitor_rebroadcast_pending_claims(uint64_t this_arg) {
31928 LDKChainMonitor this_arg_conv;
31929 this_arg_conv.inner = untag_ptr(this_arg);
31930 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31932 this_arg_conv.is_owned = false;
31933 ChainMonitor_rebroadcast_pending_claims(&this_arg_conv);
31936 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Listen"))) TS_ChainMonitor_as_Listen(uint64_t this_arg) {
31937 LDKChainMonitor this_arg_conv;
31938 this_arg_conv.inner = untag_ptr(this_arg);
31939 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31941 this_arg_conv.is_owned = false;
31942 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
31943 *ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
31944 return tag_ptr(ret_ret, true);
31947 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Confirm"))) TS_ChainMonitor_as_Confirm(uint64_t this_arg) {
31948 LDKChainMonitor this_arg_conv;
31949 this_arg_conv.inner = untag_ptr(this_arg);
31950 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31952 this_arg_conv.is_owned = false;
31953 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
31954 *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
31955 return tag_ptr(ret_ret, true);
31958 uint64_t __attribute__((export_name("TS_ChainMonitor_as_Watch"))) TS_ChainMonitor_as_Watch(uint64_t this_arg) {
31959 LDKChainMonitor this_arg_conv;
31960 this_arg_conv.inner = untag_ptr(this_arg);
31961 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31963 this_arg_conv.is_owned = false;
31964 LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
31965 *ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
31966 return tag_ptr(ret_ret, true);
31969 uint64_t __attribute__((export_name("TS_ChainMonitor_as_EventsProvider"))) TS_ChainMonitor_as_EventsProvider(uint64_t this_arg) {
31970 LDKChainMonitor this_arg_conv;
31971 this_arg_conv.inner = untag_ptr(this_arg);
31972 this_arg_conv.is_owned = ptr_is_owned(this_arg);
31973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
31974 this_arg_conv.is_owned = false;
31975 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
31976 *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
31977 return tag_ptr(ret_ret, true);
31980 void __attribute__((export_name("TS_ChannelMonitorUpdate_free"))) TS_ChannelMonitorUpdate_free(uint64_t this_obj) {
31981 LDKChannelMonitorUpdate this_obj_conv;
31982 this_obj_conv.inner = untag_ptr(this_obj);
31983 this_obj_conv.is_owned = ptr_is_owned(this_obj);
31984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31985 ChannelMonitorUpdate_free(this_obj_conv);
31988 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_get_update_id"))) TS_ChannelMonitorUpdate_get_update_id(uint64_t this_ptr) {
31989 LDKChannelMonitorUpdate this_ptr_conv;
31990 this_ptr_conv.inner = untag_ptr(this_ptr);
31991 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
31992 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31993 this_ptr_conv.is_owned = false;
31994 int64_t ret_conv = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
31998 void __attribute__((export_name("TS_ChannelMonitorUpdate_set_update_id"))) TS_ChannelMonitorUpdate_set_update_id(uint64_t this_ptr, int64_t val) {
31999 LDKChannelMonitorUpdate this_ptr_conv;
32000 this_ptr_conv.inner = untag_ptr(this_ptr);
32001 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32003 this_ptr_conv.is_owned = false;
32004 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
32007 static inline uint64_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
32008 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
32009 uint64_t ret_ref = 0;
32010 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32011 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32014 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone_ptr"))) TS_ChannelMonitorUpdate_clone_ptr(uint64_t arg) {
32015 LDKChannelMonitorUpdate arg_conv;
32016 arg_conv.inner = untag_ptr(arg);
32017 arg_conv.is_owned = ptr_is_owned(arg);
32018 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32019 arg_conv.is_owned = false;
32020 int64_t ret_conv = ChannelMonitorUpdate_clone_ptr(&arg_conv);
32024 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone"))) TS_ChannelMonitorUpdate_clone(uint64_t orig) {
32025 LDKChannelMonitorUpdate orig_conv;
32026 orig_conv.inner = untag_ptr(orig);
32027 orig_conv.is_owned = ptr_is_owned(orig);
32028 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32029 orig_conv.is_owned = false;
32030 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
32031 uint64_t ret_ref = 0;
32032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32033 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32037 jboolean __attribute__((export_name("TS_ChannelMonitorUpdate_eq"))) TS_ChannelMonitorUpdate_eq(uint64_t a, uint64_t b) {
32038 LDKChannelMonitorUpdate a_conv;
32039 a_conv.inner = untag_ptr(a);
32040 a_conv.is_owned = ptr_is_owned(a);
32041 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32042 a_conv.is_owned = false;
32043 LDKChannelMonitorUpdate b_conv;
32044 b_conv.inner = untag_ptr(b);
32045 b_conv.is_owned = ptr_is_owned(b);
32046 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32047 b_conv.is_owned = false;
32048 jboolean ret_conv = ChannelMonitorUpdate_eq(&a_conv, &b_conv);
32052 int8_tArray __attribute__((export_name("TS_ChannelMonitorUpdate_write"))) TS_ChannelMonitorUpdate_write(uint64_t obj) {
32053 LDKChannelMonitorUpdate obj_conv;
32054 obj_conv.inner = untag_ptr(obj);
32055 obj_conv.is_owned = ptr_is_owned(obj);
32056 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
32057 obj_conv.is_owned = false;
32058 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
32059 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32060 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32061 CVec_u8Z_free(ret_var);
32065 uint64_t __attribute__((export_name("TS_ChannelMonitorUpdate_read"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
32066 LDKu8slice ser_ref;
32067 ser_ref.datalen = ser->arr_len;
32068 ser_ref.data = ser->elems;
32069 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
32070 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
32072 return tag_ptr(ret_conv, true);
32075 void __attribute__((export_name("TS_MonitorEvent_free"))) TS_MonitorEvent_free(uint64_t this_ptr) {
32076 if (!ptr_is_owned(this_ptr)) return;
32077 void* this_ptr_ptr = untag_ptr(this_ptr);
32078 CHECK_ACCESS(this_ptr_ptr);
32079 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(this_ptr_ptr);
32080 FREE(untag_ptr(this_ptr));
32081 MonitorEvent_free(this_ptr_conv);
32084 static inline uint64_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
32085 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32086 *ret_copy = MonitorEvent_clone(arg);
32087 uint64_t ret_ref = tag_ptr(ret_copy, true);
32090 int64_t __attribute__((export_name("TS_MonitorEvent_clone_ptr"))) TS_MonitorEvent_clone_ptr(uint64_t arg) {
32091 LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)untag_ptr(arg);
32092 int64_t ret_conv = MonitorEvent_clone_ptr(arg_conv);
32096 uint64_t __attribute__((export_name("TS_MonitorEvent_clone"))) TS_MonitorEvent_clone(uint64_t orig) {
32097 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)untag_ptr(orig);
32098 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32099 *ret_copy = MonitorEvent_clone(orig_conv);
32100 uint64_t ret_ref = tag_ptr(ret_copy, true);
32104 uint64_t __attribute__((export_name("TS_MonitorEvent_htlcevent"))) TS_MonitorEvent_htlcevent(uint64_t a) {
32105 LDKHTLCUpdate a_conv;
32106 a_conv.inner = untag_ptr(a);
32107 a_conv.is_owned = ptr_is_owned(a);
32108 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32109 a_conv = HTLCUpdate_clone(&a_conv);
32110 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32111 *ret_copy = MonitorEvent_htlcevent(a_conv);
32112 uint64_t ret_ref = tag_ptr(ret_copy, true);
32116 uint64_t __attribute__((export_name("TS_MonitorEvent_holder_force_closed"))) TS_MonitorEvent_holder_force_closed(uint64_t a) {
32117 LDKOutPoint a_conv;
32118 a_conv.inner = untag_ptr(a);
32119 a_conv.is_owned = ptr_is_owned(a);
32120 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32121 a_conv = OutPoint_clone(&a_conv);
32122 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32123 *ret_copy = MonitorEvent_holder_force_closed(a_conv);
32124 uint64_t ret_ref = tag_ptr(ret_copy, true);
32128 uint64_t __attribute__((export_name("TS_MonitorEvent_completed"))) TS_MonitorEvent_completed(uint64_t funding_txo, int64_t monitor_update_id) {
32129 LDKOutPoint funding_txo_conv;
32130 funding_txo_conv.inner = untag_ptr(funding_txo);
32131 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
32132 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
32133 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
32134 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32135 *ret_copy = MonitorEvent_completed(funding_txo_conv, monitor_update_id);
32136 uint64_t ret_ref = tag_ptr(ret_copy, true);
32140 jboolean __attribute__((export_name("TS_MonitorEvent_eq"))) TS_MonitorEvent_eq(uint64_t a, uint64_t b) {
32141 LDKMonitorEvent* a_conv = (LDKMonitorEvent*)untag_ptr(a);
32142 LDKMonitorEvent* b_conv = (LDKMonitorEvent*)untag_ptr(b);
32143 jboolean ret_conv = MonitorEvent_eq(a_conv, b_conv);
32147 int8_tArray __attribute__((export_name("TS_MonitorEvent_write"))) TS_MonitorEvent_write(uint64_t obj) {
32148 LDKMonitorEvent* obj_conv = (LDKMonitorEvent*)untag_ptr(obj);
32149 LDKCVec_u8Z ret_var = MonitorEvent_write(obj_conv);
32150 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32151 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32152 CVec_u8Z_free(ret_var);
32156 uint64_t __attribute__((export_name("TS_MonitorEvent_read"))) TS_MonitorEvent_read(int8_tArray ser) {
32157 LDKu8slice ser_ref;
32158 ser_ref.datalen = ser->arr_len;
32159 ser_ref.data = ser->elems;
32160 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
32161 *ret_conv = MonitorEvent_read(ser_ref);
32163 return tag_ptr(ret_conv, true);
32166 void __attribute__((export_name("TS_HTLCUpdate_free"))) TS_HTLCUpdate_free(uint64_t this_obj) {
32167 LDKHTLCUpdate this_obj_conv;
32168 this_obj_conv.inner = untag_ptr(this_obj);
32169 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32170 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32171 HTLCUpdate_free(this_obj_conv);
32174 static inline uint64_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
32175 LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
32176 uint64_t ret_ref = 0;
32177 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32178 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32181 int64_t __attribute__((export_name("TS_HTLCUpdate_clone_ptr"))) TS_HTLCUpdate_clone_ptr(uint64_t arg) {
32182 LDKHTLCUpdate arg_conv;
32183 arg_conv.inner = untag_ptr(arg);
32184 arg_conv.is_owned = ptr_is_owned(arg);
32185 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32186 arg_conv.is_owned = false;
32187 int64_t ret_conv = HTLCUpdate_clone_ptr(&arg_conv);
32191 uint64_t __attribute__((export_name("TS_HTLCUpdate_clone"))) TS_HTLCUpdate_clone(uint64_t orig) {
32192 LDKHTLCUpdate orig_conv;
32193 orig_conv.inner = untag_ptr(orig);
32194 orig_conv.is_owned = ptr_is_owned(orig);
32195 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32196 orig_conv.is_owned = false;
32197 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
32198 uint64_t ret_ref = 0;
32199 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32200 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32204 jboolean __attribute__((export_name("TS_HTLCUpdate_eq"))) TS_HTLCUpdate_eq(uint64_t a, uint64_t b) {
32205 LDKHTLCUpdate a_conv;
32206 a_conv.inner = untag_ptr(a);
32207 a_conv.is_owned = ptr_is_owned(a);
32208 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
32209 a_conv.is_owned = false;
32210 LDKHTLCUpdate b_conv;
32211 b_conv.inner = untag_ptr(b);
32212 b_conv.is_owned = ptr_is_owned(b);
32213 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
32214 b_conv.is_owned = false;
32215 jboolean ret_conv = HTLCUpdate_eq(&a_conv, &b_conv);
32219 int8_tArray __attribute__((export_name("TS_HTLCUpdate_write"))) TS_HTLCUpdate_write(uint64_t obj) {
32220 LDKHTLCUpdate obj_conv;
32221 obj_conv.inner = untag_ptr(obj);
32222 obj_conv.is_owned = ptr_is_owned(obj);
32223 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
32224 obj_conv.is_owned = false;
32225 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
32226 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32227 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32228 CVec_u8Z_free(ret_var);
32232 uint64_t __attribute__((export_name("TS_HTLCUpdate_read"))) TS_HTLCUpdate_read(int8_tArray ser) {
32233 LDKu8slice ser_ref;
32234 ser_ref.datalen = ser->arr_len;
32235 ser_ref.data = ser->elems;
32236 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
32237 *ret_conv = HTLCUpdate_read(ser_ref);
32239 return tag_ptr(ret_conv, true);
32242 void __attribute__((export_name("TS_Balance_free"))) TS_Balance_free(uint64_t this_ptr) {
32243 if (!ptr_is_owned(this_ptr)) return;
32244 void* this_ptr_ptr = untag_ptr(this_ptr);
32245 CHECK_ACCESS(this_ptr_ptr);
32246 LDKBalance this_ptr_conv = *(LDKBalance*)(this_ptr_ptr);
32247 FREE(untag_ptr(this_ptr));
32248 Balance_free(this_ptr_conv);
32251 static inline uint64_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
32252 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32253 *ret_copy = Balance_clone(arg);
32254 uint64_t ret_ref = tag_ptr(ret_copy, true);
32257 int64_t __attribute__((export_name("TS_Balance_clone_ptr"))) TS_Balance_clone_ptr(uint64_t arg) {
32258 LDKBalance* arg_conv = (LDKBalance*)untag_ptr(arg);
32259 int64_t ret_conv = Balance_clone_ptr(arg_conv);
32263 uint64_t __attribute__((export_name("TS_Balance_clone"))) TS_Balance_clone(uint64_t orig) {
32264 LDKBalance* orig_conv = (LDKBalance*)untag_ptr(orig);
32265 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32266 *ret_copy = Balance_clone(orig_conv);
32267 uint64_t ret_ref = tag_ptr(ret_copy, true);
32271 uint64_t __attribute__((export_name("TS_Balance_claimable_on_channel_close"))) TS_Balance_claimable_on_channel_close(int64_t amount_satoshis) {
32272 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32273 *ret_copy = Balance_claimable_on_channel_close(amount_satoshis);
32274 uint64_t ret_ref = tag_ptr(ret_copy, true);
32278 uint64_t __attribute__((export_name("TS_Balance_claimable_awaiting_confirmations"))) TS_Balance_claimable_awaiting_confirmations(int64_t amount_satoshis, int32_t confirmation_height) {
32279 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32280 *ret_copy = Balance_claimable_awaiting_confirmations(amount_satoshis, confirmation_height);
32281 uint64_t ret_ref = tag_ptr(ret_copy, true);
32285 uint64_t __attribute__((export_name("TS_Balance_contentious_claimable"))) TS_Balance_contentious_claimable(int64_t amount_satoshis, int32_t timeout_height, int8_tArray payment_hash, int8_tArray payment_preimage) {
32286 LDKThirtyTwoBytes payment_hash_ref;
32287 CHECK(payment_hash->arr_len == 32);
32288 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
32289 LDKThirtyTwoBytes payment_preimage_ref;
32290 CHECK(payment_preimage->arr_len == 32);
32291 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
32292 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32293 *ret_copy = Balance_contentious_claimable(amount_satoshis, timeout_height, payment_hash_ref, payment_preimage_ref);
32294 uint64_t ret_ref = tag_ptr(ret_copy, true);
32298 uint64_t __attribute__((export_name("TS_Balance_maybe_timeout_claimable_htlc"))) TS_Balance_maybe_timeout_claimable_htlc(int64_t amount_satoshis, int32_t claimable_height, int8_tArray payment_hash) {
32299 LDKThirtyTwoBytes payment_hash_ref;
32300 CHECK(payment_hash->arr_len == 32);
32301 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
32302 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32303 *ret_copy = Balance_maybe_timeout_claimable_htlc(amount_satoshis, claimable_height, payment_hash_ref);
32304 uint64_t ret_ref = tag_ptr(ret_copy, true);
32308 uint64_t __attribute__((export_name("TS_Balance_maybe_preimage_claimable_htlc"))) TS_Balance_maybe_preimage_claimable_htlc(int64_t amount_satoshis, int32_t expiry_height, int8_tArray payment_hash) {
32309 LDKThirtyTwoBytes payment_hash_ref;
32310 CHECK(payment_hash->arr_len == 32);
32311 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
32312 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32313 *ret_copy = Balance_maybe_preimage_claimable_htlc(amount_satoshis, expiry_height, payment_hash_ref);
32314 uint64_t ret_ref = tag_ptr(ret_copy, true);
32318 uint64_t __attribute__((export_name("TS_Balance_counterparty_revoked_output_claimable"))) TS_Balance_counterparty_revoked_output_claimable(int64_t amount_satoshis) {
32319 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32320 *ret_copy = Balance_counterparty_revoked_output_claimable(amount_satoshis);
32321 uint64_t ret_ref = tag_ptr(ret_copy, true);
32325 jboolean __attribute__((export_name("TS_Balance_eq"))) TS_Balance_eq(uint64_t a, uint64_t b) {
32326 LDKBalance* a_conv = (LDKBalance*)untag_ptr(a);
32327 LDKBalance* b_conv = (LDKBalance*)untag_ptr(b);
32328 jboolean ret_conv = Balance_eq(a_conv, b_conv);
32332 int64_t __attribute__((export_name("TS_Balance_claimable_amount_satoshis"))) TS_Balance_claimable_amount_satoshis(uint64_t this_arg) {
32333 LDKBalance* this_arg_conv = (LDKBalance*)untag_ptr(this_arg);
32334 int64_t ret_conv = Balance_claimable_amount_satoshis(this_arg_conv);
32338 void __attribute__((export_name("TS_ChannelMonitor_free"))) TS_ChannelMonitor_free(uint64_t this_obj) {
32339 LDKChannelMonitor this_obj_conv;
32340 this_obj_conv.inner = untag_ptr(this_obj);
32341 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32342 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32343 ChannelMonitor_free(this_obj_conv);
32346 static inline uint64_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
32347 LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
32348 uint64_t ret_ref = 0;
32349 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32350 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32353 int64_t __attribute__((export_name("TS_ChannelMonitor_clone_ptr"))) TS_ChannelMonitor_clone_ptr(uint64_t arg) {
32354 LDKChannelMonitor arg_conv;
32355 arg_conv.inner = untag_ptr(arg);
32356 arg_conv.is_owned = ptr_is_owned(arg);
32357 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32358 arg_conv.is_owned = false;
32359 int64_t ret_conv = ChannelMonitor_clone_ptr(&arg_conv);
32363 uint64_t __attribute__((export_name("TS_ChannelMonitor_clone"))) TS_ChannelMonitor_clone(uint64_t orig) {
32364 LDKChannelMonitor orig_conv;
32365 orig_conv.inner = untag_ptr(orig);
32366 orig_conv.is_owned = ptr_is_owned(orig);
32367 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32368 orig_conv.is_owned = false;
32369 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
32370 uint64_t ret_ref = 0;
32371 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32372 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32376 int8_tArray __attribute__((export_name("TS_ChannelMonitor_write"))) TS_ChannelMonitor_write(uint64_t obj) {
32377 LDKChannelMonitor obj_conv;
32378 obj_conv.inner = untag_ptr(obj);
32379 obj_conv.is_owned = ptr_is_owned(obj);
32380 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
32381 obj_conv.is_owned = false;
32382 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
32383 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
32384 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
32385 CVec_u8Z_free(ret_var);
32389 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) {
32390 LDKChannelMonitor this_arg_conv;
32391 this_arg_conv.inner = untag_ptr(this_arg);
32392 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32393 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32394 this_arg_conv.is_owned = false;
32395 LDKChannelMonitorUpdate updates_conv;
32396 updates_conv.inner = untag_ptr(updates);
32397 updates_conv.is_owned = ptr_is_owned(updates);
32398 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
32399 updates_conv.is_owned = false;
32400 void* broadcaster_ptr = untag_ptr(broadcaster);
32401 if (ptr_is_owned(broadcaster)) { CHECK_ACCESS(broadcaster_ptr); }
32402 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
32403 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32404 if (ptr_is_owned(fee_estimator)) { CHECK_ACCESS(fee_estimator_ptr); }
32405 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)fee_estimator_ptr;
32406 void* logger_ptr = untag_ptr(logger);
32407 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
32408 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
32409 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
32410 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
32411 return tag_ptr(ret_conv, true);
32414 int64_t __attribute__((export_name("TS_ChannelMonitor_get_latest_update_id"))) TS_ChannelMonitor_get_latest_update_id(uint64_t this_arg) {
32415 LDKChannelMonitor this_arg_conv;
32416 this_arg_conv.inner = untag_ptr(this_arg);
32417 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32419 this_arg_conv.is_owned = false;
32420 int64_t ret_conv = ChannelMonitor_get_latest_update_id(&this_arg_conv);
32424 uint64_t __attribute__((export_name("TS_ChannelMonitor_get_funding_txo"))) TS_ChannelMonitor_get_funding_txo(uint64_t this_arg) {
32425 LDKChannelMonitor this_arg_conv;
32426 this_arg_conv.inner = untag_ptr(this_arg);
32427 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32429 this_arg_conv.is_owned = false;
32430 LDKC2Tuple_OutPointCVec_u8ZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointCVec_u8ZZ), "LDKC2Tuple_OutPointCVec_u8ZZ");
32431 *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
32432 return tag_ptr(ret_conv, true);
32435 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_outputs_to_watch"))) TS_ChannelMonitor_get_outputs_to_watch(uint64_t this_arg) {
32436 LDKChannelMonitor this_arg_conv;
32437 this_arg_conv.inner = untag_ptr(this_arg);
32438 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32440 this_arg_conv.is_owned = false;
32441 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
32442 uint64_tArray ret_arr = NULL;
32443 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32444 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32445 for (size_t a = 0; a < ret_var.datalen; a++) {
32446 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ* ret_conv_52_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32CVec_u8ZZZZ");
32447 *ret_conv_52_conv = ret_var.data[a];
32448 ret_arr_ptr[a] = tag_ptr(ret_conv_52_conv, true);
32451 FREE(ret_var.data);
32455 void __attribute__((export_name("TS_ChannelMonitor_load_outputs_to_watch"))) TS_ChannelMonitor_load_outputs_to_watch(uint64_t this_arg, uint64_t filter) {
32456 LDKChannelMonitor this_arg_conv;
32457 this_arg_conv.inner = untag_ptr(this_arg);
32458 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32460 this_arg_conv.is_owned = false;
32461 void* filter_ptr = untag_ptr(filter);
32462 if (ptr_is_owned(filter)) { CHECK_ACCESS(filter_ptr); }
32463 LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
32464 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
32467 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) {
32468 LDKChannelMonitor this_arg_conv;
32469 this_arg_conv.inner = untag_ptr(this_arg);
32470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32472 this_arg_conv.is_owned = false;
32473 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
32474 uint64_tArray ret_arr = NULL;
32475 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32476 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32477 for (size_t o = 0; o < ret_var.datalen; o++) {
32478 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
32479 *ret_conv_14_copy = ret_var.data[o];
32480 uint64_t ret_conv_14_ref = tag_ptr(ret_conv_14_copy, true);
32481 ret_arr_ptr[o] = ret_conv_14_ref;
32484 FREE(ret_var.data);
32488 void __attribute__((export_name("TS_ChannelMonitor_process_pending_events"))) TS_ChannelMonitor_process_pending_events(uint64_t this_arg, uint64_t handler) {
32489 LDKChannelMonitor this_arg_conv;
32490 this_arg_conv.inner = untag_ptr(this_arg);
32491 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32493 this_arg_conv.is_owned = false;
32494 void* handler_ptr = untag_ptr(handler);
32495 if (ptr_is_owned(handler)) { CHECK_ACCESS(handler_ptr); }
32496 LDKEventHandler* handler_conv = (LDKEventHandler*)handler_ptr;
32497 ChannelMonitor_process_pending_events(&this_arg_conv, handler_conv);
32500 uint64_t __attribute__((export_name("TS_ChannelMonitor_initial_counterparty_commitment_tx"))) TS_ChannelMonitor_initial_counterparty_commitment_tx(uint64_t this_arg) {
32501 LDKChannelMonitor this_arg_conv;
32502 this_arg_conv.inner = untag_ptr(this_arg);
32503 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32505 this_arg_conv.is_owned = false;
32506 LDKCommitmentTransaction ret_var = ChannelMonitor_initial_counterparty_commitment_tx(&this_arg_conv);
32507 uint64_t ret_ref = 0;
32508 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32509 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32513 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_counterparty_commitment_txs_from_update"))) TS_ChannelMonitor_counterparty_commitment_txs_from_update(uint64_t this_arg, uint64_t update) {
32514 LDKChannelMonitor this_arg_conv;
32515 this_arg_conv.inner = untag_ptr(this_arg);
32516 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32518 this_arg_conv.is_owned = false;
32519 LDKChannelMonitorUpdate update_conv;
32520 update_conv.inner = untag_ptr(update);
32521 update_conv.is_owned = ptr_is_owned(update);
32522 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
32523 update_conv.is_owned = false;
32524 LDKCVec_CommitmentTransactionZ ret_var = ChannelMonitor_counterparty_commitment_txs_from_update(&this_arg_conv, &update_conv);
32525 uint64_tArray ret_arr = NULL;
32526 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32527 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32528 for (size_t x = 0; x < ret_var.datalen; x++) {
32529 LDKCommitmentTransaction ret_conv_23_var = ret_var.data[x];
32530 uint64_t ret_conv_23_ref = 0;
32531 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_23_var);
32532 ret_conv_23_ref = tag_ptr(ret_conv_23_var.inner, ret_conv_23_var.is_owned);
32533 ret_arr_ptr[x] = ret_conv_23_ref;
32536 FREE(ret_var.data);
32540 uint64_t __attribute__((export_name("TS_ChannelMonitor_sign_to_local_justice_tx"))) TS_ChannelMonitor_sign_to_local_justice_tx(uint64_t this_arg, int8_tArray justice_tx, uint32_t input_idx, int64_t value, int64_t commitment_number) {
32541 LDKChannelMonitor this_arg_conv;
32542 this_arg_conv.inner = untag_ptr(this_arg);
32543 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32545 this_arg_conv.is_owned = false;
32546 LDKTransaction justice_tx_ref;
32547 justice_tx_ref.datalen = justice_tx->arr_len;
32548 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
32549 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
32550 justice_tx_ref.data_is_owned = true;
32551 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
32552 *ret_conv = ChannelMonitor_sign_to_local_justice_tx(&this_arg_conv, justice_tx_ref, input_idx, value, commitment_number);
32553 return tag_ptr(ret_conv, true);
32556 int8_tArray __attribute__((export_name("TS_ChannelMonitor_get_counterparty_node_id"))) TS_ChannelMonitor_get_counterparty_node_id(uint64_t this_arg) {
32557 LDKChannelMonitor this_arg_conv;
32558 this_arg_conv.inner = untag_ptr(this_arg);
32559 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32560 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32561 this_arg_conv.is_owned = false;
32562 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
32563 memcpy(ret_arr->elems, ChannelMonitor_get_counterparty_node_id(&this_arg_conv).compressed_form, 33);
32567 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) {
32568 LDKChannelMonitor this_arg_conv;
32569 this_arg_conv.inner = untag_ptr(this_arg);
32570 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32572 this_arg_conv.is_owned = false;
32573 void* logger_ptr = untag_ptr(logger);
32574 if (ptr_is_owned(logger)) { CHECK_ACCESS(logger_ptr); }
32575 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
32576 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
32577 ptrArray ret_arr = NULL;
32578 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
32579 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
32580 for (size_t m = 0; m < ret_var.datalen; m++) {
32581 LDKTransaction ret_conv_12_var = ret_var.data[m];
32582 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
32583 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
32584 Transaction_free(ret_conv_12_var);
32585 ret_arr_ptr[m] = ret_conv_12_arr;
32588 FREE(ret_var.data);
32592 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) {
32593 LDKChannelMonitor this_arg_conv;
32594 this_arg_conv.inner = untag_ptr(this_arg);
32595 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32597 this_arg_conv.is_owned = false;
32598 uint8_t header_arr[80];
32599 CHECK(header->arr_len == 80);
32600 memcpy(header_arr, header->elems, 80); FREE(header);
32601 uint8_t (*header_ref)[80] = &header_arr;
32602 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
32603 txdata_constr.datalen = txdata->arr_len;
32604 if (txdata_constr.datalen > 0)
32605 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
32607 txdata_constr.data = NULL;
32608 uint64_t* txdata_vals = txdata->elems;
32609 for (size_t c = 0; c < txdata_constr.datalen; c++) {
32610 uint64_t txdata_conv_28 = txdata_vals[c];
32611 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
32612 CHECK_ACCESS(txdata_conv_28_ptr);
32613 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
32614 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
32615 txdata_constr.data[c] = txdata_conv_28_conv;
32618 void* broadcaster_ptr = untag_ptr(broadcaster);
32619 CHECK_ACCESS(broadcaster_ptr);
32620 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32621 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32622 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32623 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32625 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32626 CHECK_ACCESS(fee_estimator_ptr);
32627 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32628 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32629 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32630 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32632 void* logger_ptr = untag_ptr(logger);
32633 CHECK_ACCESS(logger_ptr);
32634 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32635 if (logger_conv.free == LDKLogger_JCalls_free) {
32636 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32637 LDKLogger_JCalls_cloned(&logger_conv);
32639 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_block_connected(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
32640 uint64_tArray ret_arr = NULL;
32641 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32642 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32643 for (size_t x = 0; x < ret_var.datalen; x++) {
32644 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
32645 *ret_conv_49_conv = ret_var.data[x];
32646 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
32649 FREE(ret_var.data);
32653 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) {
32654 LDKChannelMonitor this_arg_conv;
32655 this_arg_conv.inner = untag_ptr(this_arg);
32656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32658 this_arg_conv.is_owned = false;
32659 uint8_t header_arr[80];
32660 CHECK(header->arr_len == 80);
32661 memcpy(header_arr, header->elems, 80); FREE(header);
32662 uint8_t (*header_ref)[80] = &header_arr;
32663 void* broadcaster_ptr = untag_ptr(broadcaster);
32664 CHECK_ACCESS(broadcaster_ptr);
32665 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32666 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32667 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32668 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32670 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32671 CHECK_ACCESS(fee_estimator_ptr);
32672 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32673 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32674 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32675 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32677 void* logger_ptr = untag_ptr(logger);
32678 CHECK_ACCESS(logger_ptr);
32679 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32680 if (logger_conv.free == LDKLogger_JCalls_free) {
32681 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32682 LDKLogger_JCalls_cloned(&logger_conv);
32684 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
32687 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) {
32688 LDKChannelMonitor this_arg_conv;
32689 this_arg_conv.inner = untag_ptr(this_arg);
32690 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32692 this_arg_conv.is_owned = false;
32693 uint8_t header_arr[80];
32694 CHECK(header->arr_len == 80);
32695 memcpy(header_arr, header->elems, 80); FREE(header);
32696 uint8_t (*header_ref)[80] = &header_arr;
32697 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
32698 txdata_constr.datalen = txdata->arr_len;
32699 if (txdata_constr.datalen > 0)
32700 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
32702 txdata_constr.data = NULL;
32703 uint64_t* txdata_vals = txdata->elems;
32704 for (size_t c = 0; c < txdata_constr.datalen; c++) {
32705 uint64_t txdata_conv_28 = txdata_vals[c];
32706 void* txdata_conv_28_ptr = untag_ptr(txdata_conv_28);
32707 CHECK_ACCESS(txdata_conv_28_ptr);
32708 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
32709 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)untag_ptr(txdata_conv_28));
32710 txdata_constr.data[c] = txdata_conv_28_conv;
32713 void* broadcaster_ptr = untag_ptr(broadcaster);
32714 CHECK_ACCESS(broadcaster_ptr);
32715 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32716 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32717 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32718 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32720 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32721 CHECK_ACCESS(fee_estimator_ptr);
32722 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32723 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32724 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32725 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32727 void* logger_ptr = untag_ptr(logger);
32728 CHECK_ACCESS(logger_ptr);
32729 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32730 if (logger_conv.free == LDKLogger_JCalls_free) {
32731 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32732 LDKLogger_JCalls_cloned(&logger_conv);
32734 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_transactions_confirmed(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
32735 uint64_tArray ret_arr = NULL;
32736 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32737 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32738 for (size_t x = 0; x < ret_var.datalen; x++) {
32739 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
32740 *ret_conv_49_conv = ret_var.data[x];
32741 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
32744 FREE(ret_var.data);
32748 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) {
32749 LDKChannelMonitor this_arg_conv;
32750 this_arg_conv.inner = untag_ptr(this_arg);
32751 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32753 this_arg_conv.is_owned = false;
32754 uint8_t txid_arr[32];
32755 CHECK(txid->arr_len == 32);
32756 memcpy(txid_arr, txid->elems, 32); FREE(txid);
32757 uint8_t (*txid_ref)[32] = &txid_arr;
32758 void* broadcaster_ptr = untag_ptr(broadcaster);
32759 CHECK_ACCESS(broadcaster_ptr);
32760 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32761 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32762 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32763 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32765 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32766 CHECK_ACCESS(fee_estimator_ptr);
32767 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32768 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32769 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32770 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32772 void* logger_ptr = untag_ptr(logger);
32773 CHECK_ACCESS(logger_ptr);
32774 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32775 if (logger_conv.free == LDKLogger_JCalls_free) {
32776 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32777 LDKLogger_JCalls_cloned(&logger_conv);
32779 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
32782 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) {
32783 LDKChannelMonitor this_arg_conv;
32784 this_arg_conv.inner = untag_ptr(this_arg);
32785 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32787 this_arg_conv.is_owned = false;
32788 uint8_t header_arr[80];
32789 CHECK(header->arr_len == 80);
32790 memcpy(header_arr, header->elems, 80); FREE(header);
32791 uint8_t (*header_ref)[80] = &header_arr;
32792 void* broadcaster_ptr = untag_ptr(broadcaster);
32793 CHECK_ACCESS(broadcaster_ptr);
32794 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32795 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32796 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32797 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32799 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32800 CHECK_ACCESS(fee_estimator_ptr);
32801 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32802 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32803 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32804 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32806 void* logger_ptr = untag_ptr(logger);
32807 CHECK_ACCESS(logger_ptr);
32808 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32809 if (logger_conv.free == LDKLogger_JCalls_free) {
32810 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32811 LDKLogger_JCalls_cloned(&logger_conv);
32813 LDKCVec_C2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
32814 uint64_tArray ret_arr = NULL;
32815 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32816 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32817 for (size_t x = 0; x < ret_var.datalen; x++) {
32818 LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_ThirtyTwoBytesCVec_C2Tuple_u32TxOutZZZ");
32819 *ret_conv_49_conv = ret_var.data[x];
32820 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
32823 FREE(ret_var.data);
32827 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_relevant_txids"))) TS_ChannelMonitor_get_relevant_txids(uint64_t this_arg) {
32828 LDKChannelMonitor this_arg_conv;
32829 this_arg_conv.inner = untag_ptr(this_arg);
32830 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32832 this_arg_conv.is_owned = false;
32833 LDKCVec_C2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
32834 uint64_tArray ret_arr = NULL;
32835 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32836 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32837 for (size_t x = 0; x < ret_var.datalen; x++) {
32838 LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ* ret_conv_49_conv = MALLOC(sizeof(LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ), "LDKC2Tuple_ThirtyTwoBytesCOption_ThirtyTwoBytesZZ");
32839 *ret_conv_49_conv = ret_var.data[x];
32840 ret_arr_ptr[x] = tag_ptr(ret_conv_49_conv, true);
32843 FREE(ret_var.data);
32847 uint64_t __attribute__((export_name("TS_ChannelMonitor_current_best_block"))) TS_ChannelMonitor_current_best_block(uint64_t this_arg) {
32848 LDKChannelMonitor this_arg_conv;
32849 this_arg_conv.inner = untag_ptr(this_arg);
32850 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32852 this_arg_conv.is_owned = false;
32853 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
32854 uint64_t ret_ref = 0;
32855 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32856 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
32860 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) {
32861 LDKChannelMonitor this_arg_conv;
32862 this_arg_conv.inner = untag_ptr(this_arg);
32863 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32865 this_arg_conv.is_owned = false;
32866 void* broadcaster_ptr = untag_ptr(broadcaster);
32867 CHECK_ACCESS(broadcaster_ptr);
32868 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
32869 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
32870 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32871 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
32873 void* fee_estimator_ptr = untag_ptr(fee_estimator);
32874 CHECK_ACCESS(fee_estimator_ptr);
32875 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
32876 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
32877 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32878 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
32880 void* logger_ptr = untag_ptr(logger);
32881 CHECK_ACCESS(logger_ptr);
32882 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
32883 if (logger_conv.free == LDKLogger_JCalls_free) {
32884 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
32885 LDKLogger_JCalls_cloned(&logger_conv);
32887 ChannelMonitor_rebroadcast_pending_claims(&this_arg_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
32890 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_spendable_outputs"))) TS_ChannelMonitor_get_spendable_outputs(uint64_t this_arg, int8_tArray tx, int32_t confirmation_height) {
32891 LDKChannelMonitor this_arg_conv;
32892 this_arg_conv.inner = untag_ptr(this_arg);
32893 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32895 this_arg_conv.is_owned = false;
32896 LDKTransaction tx_ref;
32897 tx_ref.datalen = tx->arr_len;
32898 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
32899 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
32900 tx_ref.data_is_owned = true;
32901 LDKCVec_SpendableOutputDescriptorZ ret_var = ChannelMonitor_get_spendable_outputs(&this_arg_conv, tx_ref, confirmation_height);
32902 uint64_tArray ret_arr = NULL;
32903 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32904 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32905 for (size_t b = 0; b < ret_var.datalen; b++) {
32906 LDKSpendableOutputDescriptor *ret_conv_27_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
32907 *ret_conv_27_copy = ret_var.data[b];
32908 uint64_t ret_conv_27_ref = tag_ptr(ret_conv_27_copy, true);
32909 ret_arr_ptr[b] = ret_conv_27_ref;
32912 FREE(ret_var.data);
32916 uint64_tArray __attribute__((export_name("TS_ChannelMonitor_get_claimable_balances"))) TS_ChannelMonitor_get_claimable_balances(uint64_t this_arg) {
32917 LDKChannelMonitor this_arg_conv;
32918 this_arg_conv.inner = untag_ptr(this_arg);
32919 this_arg_conv.is_owned = ptr_is_owned(this_arg);
32920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
32921 this_arg_conv.is_owned = false;
32922 LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
32923 uint64_tArray ret_arr = NULL;
32924 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
32925 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
32926 for (size_t j = 0; j < ret_var.datalen; j++) {
32927 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
32928 *ret_conv_9_copy = ret_var.data[j];
32929 uint64_t ret_conv_9_ref = tag_ptr(ret_conv_9_copy, true);
32930 ret_arr_ptr[j] = ret_conv_9_ref;
32933 FREE(ret_var.data);
32937 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read"))) TS_C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(int8_tArray ser, uint64_t arg_a, uint64_t arg_b) {
32938 LDKu8slice ser_ref;
32939 ser_ref.datalen = ser->arr_len;
32940 ser_ref.data = ser->elems;
32941 void* arg_a_ptr = untag_ptr(arg_a);
32942 if (ptr_is_owned(arg_a)) { CHECK_ACCESS(arg_a_ptr); }
32943 LDKEntropySource* arg_a_conv = (LDKEntropySource*)arg_a_ptr;
32944 void* arg_b_ptr = untag_ptr(arg_b);
32945 if (ptr_is_owned(arg_b)) { CHECK_ACCESS(arg_b_ptr); }
32946 LDKSignerProvider* arg_b_conv = (LDKSignerProvider*)arg_b_ptr;
32947 LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelMonitorZDecodeErrorZ");
32948 *ret_conv = C2Tuple_ThirtyTwoBytesChannelMonitorZ_read(ser_ref, arg_a_conv, arg_b_conv);
32950 return tag_ptr(ret_conv, true);
32953 void __attribute__((export_name("TS_OutPoint_free"))) TS_OutPoint_free(uint64_t this_obj) {
32954 LDKOutPoint this_obj_conv;
32955 this_obj_conv.inner = untag_ptr(this_obj);
32956 this_obj_conv.is_owned = ptr_is_owned(this_obj);
32957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32958 OutPoint_free(this_obj_conv);
32961 int8_tArray __attribute__((export_name("TS_OutPoint_get_txid"))) TS_OutPoint_get_txid(uint64_t this_ptr) {
32962 LDKOutPoint this_ptr_conv;
32963 this_ptr_conv.inner = untag_ptr(this_ptr);
32964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32966 this_ptr_conv.is_owned = false;
32967 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32968 memcpy(ret_arr->elems, *OutPoint_get_txid(&this_ptr_conv), 32);
32972 void __attribute__((export_name("TS_OutPoint_set_txid"))) TS_OutPoint_set_txid(uint64_t this_ptr, int8_tArray val) {
32973 LDKOutPoint this_ptr_conv;
32974 this_ptr_conv.inner = untag_ptr(this_ptr);
32975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32977 this_ptr_conv.is_owned = false;
32978 LDKThirtyTwoBytes val_ref;
32979 CHECK(val->arr_len == 32);
32980 memcpy(val_ref.data, val->elems, 32); FREE(val);
32981 OutPoint_set_txid(&this_ptr_conv, val_ref);
32984 int16_t __attribute__((export_name("TS_OutPoint_get_index"))) TS_OutPoint_get_index(uint64_t this_ptr) {
32985 LDKOutPoint this_ptr_conv;
32986 this_ptr_conv.inner = untag_ptr(this_ptr);
32987 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32988 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32989 this_ptr_conv.is_owned = false;
32990 int16_t ret_conv = OutPoint_get_index(&this_ptr_conv);
32994 void __attribute__((export_name("TS_OutPoint_set_index"))) TS_OutPoint_set_index(uint64_t this_ptr, int16_t val) {
32995 LDKOutPoint this_ptr_conv;
32996 this_ptr_conv.inner = untag_ptr(this_ptr);
32997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
32998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32999 this_ptr_conv.is_owned = false;
33000 OutPoint_set_index(&this_ptr_conv, val);
33003 uint64_t __attribute__((export_name("TS_OutPoint_new"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
33004 LDKThirtyTwoBytes txid_arg_ref;
33005 CHECK(txid_arg->arr_len == 32);
33006 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
33007 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
33008 uint64_t ret_ref = 0;
33009 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33010 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33014 static inline uint64_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
33015 LDKOutPoint ret_var = OutPoint_clone(arg);
33016 uint64_t ret_ref = 0;
33017 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33018 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33021 int64_t __attribute__((export_name("TS_OutPoint_clone_ptr"))) TS_OutPoint_clone_ptr(uint64_t arg) {
33022 LDKOutPoint arg_conv;
33023 arg_conv.inner = untag_ptr(arg);
33024 arg_conv.is_owned = ptr_is_owned(arg);
33025 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33026 arg_conv.is_owned = false;
33027 int64_t ret_conv = OutPoint_clone_ptr(&arg_conv);
33031 uint64_t __attribute__((export_name("TS_OutPoint_clone"))) TS_OutPoint_clone(uint64_t orig) {
33032 LDKOutPoint orig_conv;
33033 orig_conv.inner = untag_ptr(orig);
33034 orig_conv.is_owned = ptr_is_owned(orig);
33035 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33036 orig_conv.is_owned = false;
33037 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
33038 uint64_t ret_ref = 0;
33039 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33040 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33044 jboolean __attribute__((export_name("TS_OutPoint_eq"))) TS_OutPoint_eq(uint64_t a, uint64_t b) {
33045 LDKOutPoint a_conv;
33046 a_conv.inner = untag_ptr(a);
33047 a_conv.is_owned = ptr_is_owned(a);
33048 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
33049 a_conv.is_owned = false;
33050 LDKOutPoint b_conv;
33051 b_conv.inner = untag_ptr(b);
33052 b_conv.is_owned = ptr_is_owned(b);
33053 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
33054 b_conv.is_owned = false;
33055 jboolean ret_conv = OutPoint_eq(&a_conv, &b_conv);
33059 int64_t __attribute__((export_name("TS_OutPoint_hash"))) TS_OutPoint_hash(uint64_t o) {
33060 LDKOutPoint o_conv;
33061 o_conv.inner = untag_ptr(o);
33062 o_conv.is_owned = ptr_is_owned(o);
33063 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
33064 o_conv.is_owned = false;
33065 int64_t ret_conv = OutPoint_hash(&o_conv);
33069 int8_tArray __attribute__((export_name("TS_OutPoint_to_channel_id"))) TS_OutPoint_to_channel_id(uint64_t this_arg) {
33070 LDKOutPoint this_arg_conv;
33071 this_arg_conv.inner = untag_ptr(this_arg);
33072 this_arg_conv.is_owned = ptr_is_owned(this_arg);
33073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
33074 this_arg_conv.is_owned = false;
33075 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33076 memcpy(ret_arr->elems, OutPoint_to_channel_id(&this_arg_conv).data, 32);
33080 int8_tArray __attribute__((export_name("TS_OutPoint_write"))) TS_OutPoint_write(uint64_t obj) {
33081 LDKOutPoint obj_conv;
33082 obj_conv.inner = untag_ptr(obj);
33083 obj_conv.is_owned = ptr_is_owned(obj);
33084 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33085 obj_conv.is_owned = false;
33086 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
33087 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33088 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33089 CVec_u8Z_free(ret_var);
33093 uint64_t __attribute__((export_name("TS_OutPoint_read"))) TS_OutPoint_read(int8_tArray ser) {
33094 LDKu8slice ser_ref;
33095 ser_ref.datalen = ser->arr_len;
33096 ser_ref.data = ser->elems;
33097 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
33098 *ret_conv = OutPoint_read(ser_ref);
33100 return tag_ptr(ret_conv, true);
33103 void __attribute__((export_name("TS_FailureCode_free"))) TS_FailureCode_free(uint64_t this_ptr) {
33104 if (!ptr_is_owned(this_ptr)) return;
33105 void* this_ptr_ptr = untag_ptr(this_ptr);
33106 CHECK_ACCESS(this_ptr_ptr);
33107 LDKFailureCode this_ptr_conv = *(LDKFailureCode*)(this_ptr_ptr);
33108 FREE(untag_ptr(this_ptr));
33109 FailureCode_free(this_ptr_conv);
33112 static inline uint64_t FailureCode_clone_ptr(LDKFailureCode *NONNULL_PTR arg) {
33113 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33114 *ret_copy = FailureCode_clone(arg);
33115 uint64_t ret_ref = tag_ptr(ret_copy, true);
33118 int64_t __attribute__((export_name("TS_FailureCode_clone_ptr"))) TS_FailureCode_clone_ptr(uint64_t arg) {
33119 LDKFailureCode* arg_conv = (LDKFailureCode*)untag_ptr(arg);
33120 int64_t ret_conv = FailureCode_clone_ptr(arg_conv);
33124 uint64_t __attribute__((export_name("TS_FailureCode_clone"))) TS_FailureCode_clone(uint64_t orig) {
33125 LDKFailureCode* orig_conv = (LDKFailureCode*)untag_ptr(orig);
33126 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33127 *ret_copy = FailureCode_clone(orig_conv);
33128 uint64_t ret_ref = tag_ptr(ret_copy, true);
33132 uint64_t __attribute__((export_name("TS_FailureCode_temporary_node_failure"))) TS_FailureCode_temporary_node_failure() {
33133 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33134 *ret_copy = FailureCode_temporary_node_failure();
33135 uint64_t ret_ref = tag_ptr(ret_copy, true);
33139 uint64_t __attribute__((export_name("TS_FailureCode_required_node_feature_missing"))) TS_FailureCode_required_node_feature_missing() {
33140 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33141 *ret_copy = FailureCode_required_node_feature_missing();
33142 uint64_t ret_ref = tag_ptr(ret_copy, true);
33146 uint64_t __attribute__((export_name("TS_FailureCode_incorrect_or_unknown_payment_details"))) TS_FailureCode_incorrect_or_unknown_payment_details() {
33147 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33148 *ret_copy = FailureCode_incorrect_or_unknown_payment_details();
33149 uint64_t ret_ref = tag_ptr(ret_copy, true);
33153 uint64_t __attribute__((export_name("TS_FailureCode_invalid_onion_payload"))) TS_FailureCode_invalid_onion_payload(uint64_t a) {
33154 void* a_ptr = untag_ptr(a);
33155 CHECK_ACCESS(a_ptr);
33156 LDKCOption_C2Tuple_u64u16ZZ a_conv = *(LDKCOption_C2Tuple_u64u16ZZ*)(a_ptr);
33157 a_conv = COption_C2Tuple_u64u16ZZ_clone((LDKCOption_C2Tuple_u64u16ZZ*)untag_ptr(a));
33158 LDKFailureCode *ret_copy = MALLOC(sizeof(LDKFailureCode), "LDKFailureCode");
33159 *ret_copy = FailureCode_invalid_onion_payload(a_conv);
33160 uint64_t ret_ref = tag_ptr(ret_copy, true);
33164 void __attribute__((export_name("TS_ChannelManager_free"))) TS_ChannelManager_free(uint64_t this_obj) {
33165 LDKChannelManager this_obj_conv;
33166 this_obj_conv.inner = untag_ptr(this_obj);
33167 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33169 ChannelManager_free(this_obj_conv);
33172 void __attribute__((export_name("TS_ChainParameters_free"))) TS_ChainParameters_free(uint64_t this_obj) {
33173 LDKChainParameters this_obj_conv;
33174 this_obj_conv.inner = untag_ptr(this_obj);
33175 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33177 ChainParameters_free(this_obj_conv);
33180 uint32_t __attribute__((export_name("TS_ChainParameters_get_network"))) TS_ChainParameters_get_network(uint64_t this_ptr) {
33181 LDKChainParameters this_ptr_conv;
33182 this_ptr_conv.inner = untag_ptr(this_ptr);
33183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33185 this_ptr_conv.is_owned = false;
33186 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
33190 void __attribute__((export_name("TS_ChainParameters_set_network"))) TS_ChainParameters_set_network(uint64_t this_ptr, uint32_t val) {
33191 LDKChainParameters this_ptr_conv;
33192 this_ptr_conv.inner = untag_ptr(this_ptr);
33193 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33195 this_ptr_conv.is_owned = false;
33196 LDKNetwork val_conv = LDKNetwork_from_js(val);
33197 ChainParameters_set_network(&this_ptr_conv, val_conv);
33200 uint64_t __attribute__((export_name("TS_ChainParameters_get_best_block"))) TS_ChainParameters_get_best_block(uint64_t this_ptr) {
33201 LDKChainParameters this_ptr_conv;
33202 this_ptr_conv.inner = untag_ptr(this_ptr);
33203 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33204 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33205 this_ptr_conv.is_owned = false;
33206 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
33207 uint64_t ret_ref = 0;
33208 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33209 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33213 void __attribute__((export_name("TS_ChainParameters_set_best_block"))) TS_ChainParameters_set_best_block(uint64_t this_ptr, uint64_t val) {
33214 LDKChainParameters this_ptr_conv;
33215 this_ptr_conv.inner = untag_ptr(this_ptr);
33216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33218 this_ptr_conv.is_owned = false;
33219 LDKBestBlock val_conv;
33220 val_conv.inner = untag_ptr(val);
33221 val_conv.is_owned = ptr_is_owned(val);
33222 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33223 val_conv = BestBlock_clone(&val_conv);
33224 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
33227 uint64_t __attribute__((export_name("TS_ChainParameters_new"))) TS_ChainParameters_new(uint32_t network_arg, uint64_t best_block_arg) {
33228 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
33229 LDKBestBlock best_block_arg_conv;
33230 best_block_arg_conv.inner = untag_ptr(best_block_arg);
33231 best_block_arg_conv.is_owned = ptr_is_owned(best_block_arg);
33232 CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
33233 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
33234 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
33235 uint64_t ret_ref = 0;
33236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33237 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33241 static inline uint64_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
33242 LDKChainParameters ret_var = ChainParameters_clone(arg);
33243 uint64_t ret_ref = 0;
33244 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33245 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33248 int64_t __attribute__((export_name("TS_ChainParameters_clone_ptr"))) TS_ChainParameters_clone_ptr(uint64_t arg) {
33249 LDKChainParameters arg_conv;
33250 arg_conv.inner = untag_ptr(arg);
33251 arg_conv.is_owned = ptr_is_owned(arg);
33252 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33253 arg_conv.is_owned = false;
33254 int64_t ret_conv = ChainParameters_clone_ptr(&arg_conv);
33258 uint64_t __attribute__((export_name("TS_ChainParameters_clone"))) TS_ChainParameters_clone(uint64_t orig) {
33259 LDKChainParameters orig_conv;
33260 orig_conv.inner = untag_ptr(orig);
33261 orig_conv.is_owned = ptr_is_owned(orig);
33262 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33263 orig_conv.is_owned = false;
33264 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
33265 uint64_t ret_ref = 0;
33266 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33267 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33271 void __attribute__((export_name("TS_CounterpartyForwardingInfo_free"))) TS_CounterpartyForwardingInfo_free(uint64_t this_obj) {
33272 LDKCounterpartyForwardingInfo this_obj_conv;
33273 this_obj_conv.inner = untag_ptr(this_obj);
33274 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33276 CounterpartyForwardingInfo_free(this_obj_conv);
33279 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_base_msat"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint64_t this_ptr) {
33280 LDKCounterpartyForwardingInfo this_ptr_conv;
33281 this_ptr_conv.inner = untag_ptr(this_ptr);
33282 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33283 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33284 this_ptr_conv.is_owned = false;
33285 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
33289 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_base_msat"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
33290 LDKCounterpartyForwardingInfo this_ptr_conv;
33291 this_ptr_conv.inner = untag_ptr(this_ptr);
33292 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33294 this_ptr_conv.is_owned = false;
33295 CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
33298 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
33299 LDKCounterpartyForwardingInfo this_ptr_conv;
33300 this_ptr_conv.inner = untag_ptr(this_ptr);
33301 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33303 this_ptr_conv.is_owned = false;
33304 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
33308 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
33309 LDKCounterpartyForwardingInfo this_ptr_conv;
33310 this_ptr_conv.inner = untag_ptr(this_ptr);
33311 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33313 this_ptr_conv.is_owned = false;
33314 CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
33317 int16_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
33318 LDKCounterpartyForwardingInfo this_ptr_conv;
33319 this_ptr_conv.inner = untag_ptr(this_ptr);
33320 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33322 this_ptr_conv.is_owned = false;
33323 int16_t ret_conv = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
33327 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
33328 LDKCounterpartyForwardingInfo this_ptr_conv;
33329 this_ptr_conv.inner = untag_ptr(this_ptr);
33330 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33332 this_ptr_conv.is_owned = false;
33333 CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
33336 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) {
33337 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
33338 uint64_t ret_ref = 0;
33339 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33340 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33344 static inline uint64_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
33345 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
33346 uint64_t ret_ref = 0;
33347 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33348 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33351 int64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone_ptr"))) TS_CounterpartyForwardingInfo_clone_ptr(uint64_t arg) {
33352 LDKCounterpartyForwardingInfo arg_conv;
33353 arg_conv.inner = untag_ptr(arg);
33354 arg_conv.is_owned = ptr_is_owned(arg);
33355 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33356 arg_conv.is_owned = false;
33357 int64_t ret_conv = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
33361 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone"))) TS_CounterpartyForwardingInfo_clone(uint64_t orig) {
33362 LDKCounterpartyForwardingInfo orig_conv;
33363 orig_conv.inner = untag_ptr(orig);
33364 orig_conv.is_owned = ptr_is_owned(orig);
33365 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33366 orig_conv.is_owned = false;
33367 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
33368 uint64_t ret_ref = 0;
33369 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33370 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33374 void __attribute__((export_name("TS_ChannelCounterparty_free"))) TS_ChannelCounterparty_free(uint64_t this_obj) {
33375 LDKChannelCounterparty this_obj_conv;
33376 this_obj_conv.inner = untag_ptr(this_obj);
33377 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33379 ChannelCounterparty_free(this_obj_conv);
33382 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_get_node_id"))) TS_ChannelCounterparty_get_node_id(uint64_t this_ptr) {
33383 LDKChannelCounterparty this_ptr_conv;
33384 this_ptr_conv.inner = untag_ptr(this_ptr);
33385 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33386 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33387 this_ptr_conv.is_owned = false;
33388 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
33389 memcpy(ret_arr->elems, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
33393 void __attribute__((export_name("TS_ChannelCounterparty_set_node_id"))) TS_ChannelCounterparty_set_node_id(uint64_t this_ptr, int8_tArray val) {
33394 LDKChannelCounterparty this_ptr_conv;
33395 this_ptr_conv.inner = untag_ptr(this_ptr);
33396 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33398 this_ptr_conv.is_owned = false;
33399 LDKPublicKey val_ref;
33400 CHECK(val->arr_len == 33);
33401 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
33402 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
33405 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_features"))) TS_ChannelCounterparty_get_features(uint64_t this_ptr) {
33406 LDKChannelCounterparty this_ptr_conv;
33407 this_ptr_conv.inner = untag_ptr(this_ptr);
33408 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33410 this_ptr_conv.is_owned = false;
33411 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
33412 uint64_t ret_ref = 0;
33413 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33414 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33418 void __attribute__((export_name("TS_ChannelCounterparty_set_features"))) TS_ChannelCounterparty_set_features(uint64_t this_ptr, uint64_t val) {
33419 LDKChannelCounterparty this_ptr_conv;
33420 this_ptr_conv.inner = untag_ptr(this_ptr);
33421 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33423 this_ptr_conv.is_owned = false;
33424 LDKInitFeatures val_conv;
33425 val_conv.inner = untag_ptr(val);
33426 val_conv.is_owned = ptr_is_owned(val);
33427 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33428 val_conv = InitFeatures_clone(&val_conv);
33429 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
33432 int64_t __attribute__((export_name("TS_ChannelCounterparty_get_unspendable_punishment_reserve"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint64_t this_ptr) {
33433 LDKChannelCounterparty this_ptr_conv;
33434 this_ptr_conv.inner = untag_ptr(this_ptr);
33435 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33436 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33437 this_ptr_conv.is_owned = false;
33438 int64_t ret_conv = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
33442 void __attribute__((export_name("TS_ChannelCounterparty_set_unspendable_punishment_reserve"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint64_t this_ptr, int64_t val) {
33443 LDKChannelCounterparty this_ptr_conv;
33444 this_ptr_conv.inner = untag_ptr(this_ptr);
33445 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33447 this_ptr_conv.is_owned = false;
33448 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
33451 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_forwarding_info"))) TS_ChannelCounterparty_get_forwarding_info(uint64_t this_ptr) {
33452 LDKChannelCounterparty this_ptr_conv;
33453 this_ptr_conv.inner = untag_ptr(this_ptr);
33454 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33456 this_ptr_conv.is_owned = false;
33457 LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
33458 uint64_t ret_ref = 0;
33459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33464 void __attribute__((export_name("TS_ChannelCounterparty_set_forwarding_info"))) TS_ChannelCounterparty_set_forwarding_info(uint64_t this_ptr, uint64_t val) {
33465 LDKChannelCounterparty this_ptr_conv;
33466 this_ptr_conv.inner = untag_ptr(this_ptr);
33467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33469 this_ptr_conv.is_owned = false;
33470 LDKCounterpartyForwardingInfo val_conv;
33471 val_conv.inner = untag_ptr(val);
33472 val_conv.is_owned = ptr_is_owned(val);
33473 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33474 val_conv = CounterpartyForwardingInfo_clone(&val_conv);
33475 ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
33478 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(uint64_t this_ptr) {
33479 LDKChannelCounterparty this_ptr_conv;
33480 this_ptr_conv.inner = untag_ptr(this_ptr);
33481 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33482 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33483 this_ptr_conv.is_owned = false;
33484 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33485 *ret_copy = ChannelCounterparty_get_outbound_htlc_minimum_msat(&this_ptr_conv);
33486 uint64_t ret_ref = tag_ptr(ret_copy, true);
33490 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) {
33491 LDKChannelCounterparty this_ptr_conv;
33492 this_ptr_conv.inner = untag_ptr(this_ptr);
33493 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33495 this_ptr_conv.is_owned = false;
33496 void* val_ptr = untag_ptr(val);
33497 CHECK_ACCESS(val_ptr);
33498 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33499 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33500 ChannelCounterparty_set_outbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
33503 uint64_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(uint64_t this_ptr) {
33504 LDKChannelCounterparty this_ptr_conv;
33505 this_ptr_conv.inner = untag_ptr(this_ptr);
33506 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33507 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33508 this_ptr_conv.is_owned = false;
33509 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33510 *ret_copy = ChannelCounterparty_get_outbound_htlc_maximum_msat(&this_ptr_conv);
33511 uint64_t ret_ref = tag_ptr(ret_copy, true);
33515 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) {
33516 LDKChannelCounterparty 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 void* val_ptr = untag_ptr(val);
33522 CHECK_ACCESS(val_ptr);
33523 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33524 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33525 ChannelCounterparty_set_outbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
33528 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) {
33529 LDKPublicKey node_id_arg_ref;
33530 CHECK(node_id_arg->arr_len == 33);
33531 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
33532 LDKInitFeatures features_arg_conv;
33533 features_arg_conv.inner = untag_ptr(features_arg);
33534 features_arg_conv.is_owned = ptr_is_owned(features_arg);
33535 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
33536 features_arg_conv = InitFeatures_clone(&features_arg_conv);
33537 LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
33538 forwarding_info_arg_conv.inner = untag_ptr(forwarding_info_arg);
33539 forwarding_info_arg_conv.is_owned = ptr_is_owned(forwarding_info_arg);
33540 CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
33541 forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
33542 void* outbound_htlc_minimum_msat_arg_ptr = untag_ptr(outbound_htlc_minimum_msat_arg);
33543 CHECK_ACCESS(outbound_htlc_minimum_msat_arg_ptr);
33544 LDKCOption_u64Z outbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_minimum_msat_arg_ptr);
33545 outbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_minimum_msat_arg));
33546 void* outbound_htlc_maximum_msat_arg_ptr = untag_ptr(outbound_htlc_maximum_msat_arg);
33547 CHECK_ACCESS(outbound_htlc_maximum_msat_arg_ptr);
33548 LDKCOption_u64Z outbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_maximum_msat_arg_ptr);
33549 outbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_htlc_maximum_msat_arg));
33550 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);
33551 uint64_t ret_ref = 0;
33552 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33553 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33557 static inline uint64_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
33558 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
33559 uint64_t ret_ref = 0;
33560 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33561 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33564 int64_t __attribute__((export_name("TS_ChannelCounterparty_clone_ptr"))) TS_ChannelCounterparty_clone_ptr(uint64_t arg) {
33565 LDKChannelCounterparty arg_conv;
33566 arg_conv.inner = untag_ptr(arg);
33567 arg_conv.is_owned = ptr_is_owned(arg);
33568 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33569 arg_conv.is_owned = false;
33570 int64_t ret_conv = ChannelCounterparty_clone_ptr(&arg_conv);
33574 uint64_t __attribute__((export_name("TS_ChannelCounterparty_clone"))) TS_ChannelCounterparty_clone(uint64_t orig) {
33575 LDKChannelCounterparty orig_conv;
33576 orig_conv.inner = untag_ptr(orig);
33577 orig_conv.is_owned = ptr_is_owned(orig);
33578 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33579 orig_conv.is_owned = false;
33580 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
33581 uint64_t ret_ref = 0;
33582 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33583 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33587 void __attribute__((export_name("TS_ChannelDetails_free"))) TS_ChannelDetails_free(uint64_t this_obj) {
33588 LDKChannelDetails this_obj_conv;
33589 this_obj_conv.inner = untag_ptr(this_obj);
33590 this_obj_conv.is_owned = ptr_is_owned(this_obj);
33591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33592 ChannelDetails_free(this_obj_conv);
33595 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_channel_id"))) TS_ChannelDetails_get_channel_id(uint64_t this_ptr) {
33596 LDKChannelDetails this_ptr_conv;
33597 this_ptr_conv.inner = untag_ptr(this_ptr);
33598 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33599 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33600 this_ptr_conv.is_owned = false;
33601 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33602 memcpy(ret_arr->elems, *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
33606 void __attribute__((export_name("TS_ChannelDetails_set_channel_id"))) TS_ChannelDetails_set_channel_id(uint64_t this_ptr, int8_tArray val) {
33607 LDKChannelDetails this_ptr_conv;
33608 this_ptr_conv.inner = untag_ptr(this_ptr);
33609 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33611 this_ptr_conv.is_owned = false;
33612 LDKThirtyTwoBytes val_ref;
33613 CHECK(val->arr_len == 32);
33614 memcpy(val_ref.data, val->elems, 32); FREE(val);
33615 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
33618 uint64_t __attribute__((export_name("TS_ChannelDetails_get_counterparty"))) TS_ChannelDetails_get_counterparty(uint64_t this_ptr) {
33619 LDKChannelDetails this_ptr_conv;
33620 this_ptr_conv.inner = untag_ptr(this_ptr);
33621 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33622 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33623 this_ptr_conv.is_owned = false;
33624 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
33625 uint64_t ret_ref = 0;
33626 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33627 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33631 void __attribute__((export_name("TS_ChannelDetails_set_counterparty"))) TS_ChannelDetails_set_counterparty(uint64_t this_ptr, uint64_t val) {
33632 LDKChannelDetails this_ptr_conv;
33633 this_ptr_conv.inner = untag_ptr(this_ptr);
33634 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33635 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33636 this_ptr_conv.is_owned = false;
33637 LDKChannelCounterparty val_conv;
33638 val_conv.inner = untag_ptr(val);
33639 val_conv.is_owned = ptr_is_owned(val);
33640 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33641 val_conv = ChannelCounterparty_clone(&val_conv);
33642 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
33645 uint64_t __attribute__((export_name("TS_ChannelDetails_get_funding_txo"))) TS_ChannelDetails_get_funding_txo(uint64_t this_ptr) {
33646 LDKChannelDetails this_ptr_conv;
33647 this_ptr_conv.inner = untag_ptr(this_ptr);
33648 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33650 this_ptr_conv.is_owned = false;
33651 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
33652 uint64_t ret_ref = 0;
33653 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33654 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33658 void __attribute__((export_name("TS_ChannelDetails_set_funding_txo"))) TS_ChannelDetails_set_funding_txo(uint64_t this_ptr, uint64_t val) {
33659 LDKChannelDetails this_ptr_conv;
33660 this_ptr_conv.inner = untag_ptr(this_ptr);
33661 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33663 this_ptr_conv.is_owned = false;
33664 LDKOutPoint val_conv;
33665 val_conv.inner = untag_ptr(val);
33666 val_conv.is_owned = ptr_is_owned(val);
33667 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33668 val_conv = OutPoint_clone(&val_conv);
33669 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
33672 uint64_t __attribute__((export_name("TS_ChannelDetails_get_channel_type"))) TS_ChannelDetails_get_channel_type(uint64_t this_ptr) {
33673 LDKChannelDetails this_ptr_conv;
33674 this_ptr_conv.inner = untag_ptr(this_ptr);
33675 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33677 this_ptr_conv.is_owned = false;
33678 LDKChannelTypeFeatures ret_var = ChannelDetails_get_channel_type(&this_ptr_conv);
33679 uint64_t ret_ref = 0;
33680 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33681 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
33685 void __attribute__((export_name("TS_ChannelDetails_set_channel_type"))) TS_ChannelDetails_set_channel_type(uint64_t this_ptr, uint64_t val) {
33686 LDKChannelDetails this_ptr_conv;
33687 this_ptr_conv.inner = untag_ptr(this_ptr);
33688 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33690 this_ptr_conv.is_owned = false;
33691 LDKChannelTypeFeatures val_conv;
33692 val_conv.inner = untag_ptr(val);
33693 val_conv.is_owned = ptr_is_owned(val);
33694 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33695 val_conv = ChannelTypeFeatures_clone(&val_conv);
33696 ChannelDetails_set_channel_type(&this_ptr_conv, val_conv);
33699 uint64_t __attribute__((export_name("TS_ChannelDetails_get_short_channel_id"))) TS_ChannelDetails_get_short_channel_id(uint64_t this_ptr) {
33700 LDKChannelDetails this_ptr_conv;
33701 this_ptr_conv.inner = untag_ptr(this_ptr);
33702 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33704 this_ptr_conv.is_owned = false;
33705 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33706 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
33707 uint64_t ret_ref = tag_ptr(ret_copy, true);
33711 void __attribute__((export_name("TS_ChannelDetails_set_short_channel_id"))) TS_ChannelDetails_set_short_channel_id(uint64_t this_ptr, uint64_t val) {
33712 LDKChannelDetails this_ptr_conv;
33713 this_ptr_conv.inner = untag_ptr(this_ptr);
33714 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33716 this_ptr_conv.is_owned = false;
33717 void* val_ptr = untag_ptr(val);
33718 CHECK_ACCESS(val_ptr);
33719 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33720 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33721 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
33724 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_scid_alias"))) TS_ChannelDetails_get_outbound_scid_alias(uint64_t this_ptr) {
33725 LDKChannelDetails this_ptr_conv;
33726 this_ptr_conv.inner = untag_ptr(this_ptr);
33727 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33729 this_ptr_conv.is_owned = false;
33730 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33731 *ret_copy = ChannelDetails_get_outbound_scid_alias(&this_ptr_conv);
33732 uint64_t ret_ref = tag_ptr(ret_copy, true);
33736 void __attribute__((export_name("TS_ChannelDetails_set_outbound_scid_alias"))) TS_ChannelDetails_set_outbound_scid_alias(uint64_t this_ptr, uint64_t val) {
33737 LDKChannelDetails this_ptr_conv;
33738 this_ptr_conv.inner = untag_ptr(this_ptr);
33739 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33741 this_ptr_conv.is_owned = false;
33742 void* val_ptr = untag_ptr(val);
33743 CHECK_ACCESS(val_ptr);
33744 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33745 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33746 ChannelDetails_set_outbound_scid_alias(&this_ptr_conv, val_conv);
33749 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_scid_alias"))) TS_ChannelDetails_get_inbound_scid_alias(uint64_t this_ptr) {
33750 LDKChannelDetails this_ptr_conv;
33751 this_ptr_conv.inner = untag_ptr(this_ptr);
33752 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33754 this_ptr_conv.is_owned = false;
33755 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33756 *ret_copy = ChannelDetails_get_inbound_scid_alias(&this_ptr_conv);
33757 uint64_t ret_ref = tag_ptr(ret_copy, true);
33761 void __attribute__((export_name("TS_ChannelDetails_set_inbound_scid_alias"))) TS_ChannelDetails_set_inbound_scid_alias(uint64_t this_ptr, uint64_t val) {
33762 LDKChannelDetails this_ptr_conv;
33763 this_ptr_conv.inner = untag_ptr(this_ptr);
33764 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33766 this_ptr_conv.is_owned = false;
33767 void* val_ptr = untag_ptr(val);
33768 CHECK_ACCESS(val_ptr);
33769 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33770 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33771 ChannelDetails_set_inbound_scid_alias(&this_ptr_conv, val_conv);
33774 int64_t __attribute__((export_name("TS_ChannelDetails_get_channel_value_satoshis"))) TS_ChannelDetails_get_channel_value_satoshis(uint64_t this_ptr) {
33775 LDKChannelDetails this_ptr_conv;
33776 this_ptr_conv.inner = untag_ptr(this_ptr);
33777 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33779 this_ptr_conv.is_owned = false;
33780 int64_t ret_conv = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
33784 void __attribute__((export_name("TS_ChannelDetails_set_channel_value_satoshis"))) TS_ChannelDetails_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
33785 LDKChannelDetails this_ptr_conv;
33786 this_ptr_conv.inner = untag_ptr(this_ptr);
33787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33789 this_ptr_conv.is_owned = false;
33790 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
33793 uint64_t __attribute__((export_name("TS_ChannelDetails_get_unspendable_punishment_reserve"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint64_t this_ptr) {
33794 LDKChannelDetails this_ptr_conv;
33795 this_ptr_conv.inner = untag_ptr(this_ptr);
33796 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33798 this_ptr_conv.is_owned = false;
33799 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
33800 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
33801 uint64_t ret_ref = tag_ptr(ret_copy, true);
33805 void __attribute__((export_name("TS_ChannelDetails_set_unspendable_punishment_reserve"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint64_t this_ptr, uint64_t val) {
33806 LDKChannelDetails this_ptr_conv;
33807 this_ptr_conv.inner = untag_ptr(this_ptr);
33808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33810 this_ptr_conv.is_owned = false;
33811 void* val_ptr = untag_ptr(val);
33812 CHECK_ACCESS(val_ptr);
33813 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
33814 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
33815 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
33818 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_user_channel_id"))) TS_ChannelDetails_get_user_channel_id(uint64_t this_ptr) {
33819 LDKChannelDetails this_ptr_conv;
33820 this_ptr_conv.inner = untag_ptr(this_ptr);
33821 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33823 this_ptr_conv.is_owned = false;
33824 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
33825 memcpy(ret_arr->elems, ChannelDetails_get_user_channel_id(&this_ptr_conv).le_bytes, 16);
33829 void __attribute__((export_name("TS_ChannelDetails_set_user_channel_id"))) TS_ChannelDetails_set_user_channel_id(uint64_t this_ptr, int8_tArray val) {
33830 LDKChannelDetails this_ptr_conv;
33831 this_ptr_conv.inner = untag_ptr(this_ptr);
33832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33834 this_ptr_conv.is_owned = false;
33836 CHECK(val->arr_len == 16);
33837 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
33838 ChannelDetails_set_user_channel_id(&this_ptr_conv, val_ref);
33841 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) {
33842 LDKChannelDetails this_ptr_conv;
33843 this_ptr_conv.inner = untag_ptr(this_ptr);
33844 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33846 this_ptr_conv.is_owned = false;
33847 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
33848 *ret_copy = ChannelDetails_get_feerate_sat_per_1000_weight(&this_ptr_conv);
33849 uint64_t ret_ref = tag_ptr(ret_copy, true);
33853 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) {
33854 LDKChannelDetails this_ptr_conv;
33855 this_ptr_conv.inner = untag_ptr(this_ptr);
33856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33858 this_ptr_conv.is_owned = false;
33859 void* val_ptr = untag_ptr(val);
33860 CHECK_ACCESS(val_ptr);
33861 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
33862 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
33863 ChannelDetails_set_feerate_sat_per_1000_weight(&this_ptr_conv, val_conv);
33866 int64_t __attribute__((export_name("TS_ChannelDetails_get_balance_msat"))) TS_ChannelDetails_get_balance_msat(uint64_t this_ptr) {
33867 LDKChannelDetails this_ptr_conv;
33868 this_ptr_conv.inner = untag_ptr(this_ptr);
33869 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33871 this_ptr_conv.is_owned = false;
33872 int64_t ret_conv = ChannelDetails_get_balance_msat(&this_ptr_conv);
33876 void __attribute__((export_name("TS_ChannelDetails_set_balance_msat"))) TS_ChannelDetails_set_balance_msat(uint64_t this_ptr, int64_t val) {
33877 LDKChannelDetails this_ptr_conv;
33878 this_ptr_conv.inner = untag_ptr(this_ptr);
33879 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33881 this_ptr_conv.is_owned = false;
33882 ChannelDetails_set_balance_msat(&this_ptr_conv, val);
33885 int64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_capacity_msat"))) TS_ChannelDetails_get_outbound_capacity_msat(uint64_t this_ptr) {
33886 LDKChannelDetails this_ptr_conv;
33887 this_ptr_conv.inner = untag_ptr(this_ptr);
33888 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33889 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33890 this_ptr_conv.is_owned = false;
33891 int64_t ret_conv = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
33895 void __attribute__((export_name("TS_ChannelDetails_set_outbound_capacity_msat"))) TS_ChannelDetails_set_outbound_capacity_msat(uint64_t this_ptr, int64_t val) {
33896 LDKChannelDetails this_ptr_conv;
33897 this_ptr_conv.inner = untag_ptr(this_ptr);
33898 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33900 this_ptr_conv.is_owned = false;
33901 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
33904 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) {
33905 LDKChannelDetails this_ptr_conv;
33906 this_ptr_conv.inner = untag_ptr(this_ptr);
33907 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33909 this_ptr_conv.is_owned = false;
33910 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_limit_msat(&this_ptr_conv);
33914 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) {
33915 LDKChannelDetails this_ptr_conv;
33916 this_ptr_conv.inner = untag_ptr(this_ptr);
33917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33919 this_ptr_conv.is_owned = false;
33920 ChannelDetails_set_next_outbound_htlc_limit_msat(&this_ptr_conv, val);
33923 int64_t __attribute__((export_name("TS_ChannelDetails_get_next_outbound_htlc_minimum_msat"))) TS_ChannelDetails_get_next_outbound_htlc_minimum_msat(uint64_t this_ptr) {
33924 LDKChannelDetails this_ptr_conv;
33925 this_ptr_conv.inner = untag_ptr(this_ptr);
33926 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33928 this_ptr_conv.is_owned = false;
33929 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_minimum_msat(&this_ptr_conv);
33933 void __attribute__((export_name("TS_ChannelDetails_set_next_outbound_htlc_minimum_msat"))) TS_ChannelDetails_set_next_outbound_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
33934 LDKChannelDetails this_ptr_conv;
33935 this_ptr_conv.inner = untag_ptr(this_ptr);
33936 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33938 this_ptr_conv.is_owned = false;
33939 ChannelDetails_set_next_outbound_htlc_minimum_msat(&this_ptr_conv, val);
33942 int64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_capacity_msat"))) TS_ChannelDetails_get_inbound_capacity_msat(uint64_t this_ptr) {
33943 LDKChannelDetails this_ptr_conv;
33944 this_ptr_conv.inner = untag_ptr(this_ptr);
33945 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33947 this_ptr_conv.is_owned = false;
33948 int64_t ret_conv = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
33952 void __attribute__((export_name("TS_ChannelDetails_set_inbound_capacity_msat"))) TS_ChannelDetails_set_inbound_capacity_msat(uint64_t this_ptr, int64_t val) {
33953 LDKChannelDetails this_ptr_conv;
33954 this_ptr_conv.inner = untag_ptr(this_ptr);
33955 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33957 this_ptr_conv.is_owned = false;
33958 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
33961 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations_required"))) TS_ChannelDetails_get_confirmations_required(uint64_t this_ptr) {
33962 LDKChannelDetails this_ptr_conv;
33963 this_ptr_conv.inner = untag_ptr(this_ptr);
33964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33966 this_ptr_conv.is_owned = false;
33967 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
33968 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
33969 uint64_t ret_ref = tag_ptr(ret_copy, true);
33973 void __attribute__((export_name("TS_ChannelDetails_set_confirmations_required"))) TS_ChannelDetails_set_confirmations_required(uint64_t this_ptr, uint64_t val) {
33974 LDKChannelDetails this_ptr_conv;
33975 this_ptr_conv.inner = untag_ptr(this_ptr);
33976 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33978 this_ptr_conv.is_owned = false;
33979 void* val_ptr = untag_ptr(val);
33980 CHECK_ACCESS(val_ptr);
33981 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
33982 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
33983 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
33986 uint64_t __attribute__((export_name("TS_ChannelDetails_get_confirmations"))) TS_ChannelDetails_get_confirmations(uint64_t this_ptr) {
33987 LDKChannelDetails this_ptr_conv;
33988 this_ptr_conv.inner = untag_ptr(this_ptr);
33989 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
33990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33991 this_ptr_conv.is_owned = false;
33992 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
33993 *ret_copy = ChannelDetails_get_confirmations(&this_ptr_conv);
33994 uint64_t ret_ref = tag_ptr(ret_copy, true);
33998 void __attribute__((export_name("TS_ChannelDetails_set_confirmations"))) TS_ChannelDetails_set_confirmations(uint64_t this_ptr, uint64_t val) {
33999 LDKChannelDetails this_ptr_conv;
34000 this_ptr_conv.inner = untag_ptr(this_ptr);
34001 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34003 this_ptr_conv.is_owned = false;
34004 void* val_ptr = untag_ptr(val);
34005 CHECK_ACCESS(val_ptr);
34006 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
34007 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
34008 ChannelDetails_set_confirmations(&this_ptr_conv, val_conv);
34011 uint64_t __attribute__((export_name("TS_ChannelDetails_get_force_close_spend_delay"))) TS_ChannelDetails_get_force_close_spend_delay(uint64_t this_ptr) {
34012 LDKChannelDetails this_ptr_conv;
34013 this_ptr_conv.inner = untag_ptr(this_ptr);
34014 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34016 this_ptr_conv.is_owned = false;
34017 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
34018 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
34019 uint64_t ret_ref = tag_ptr(ret_copy, true);
34023 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) {
34024 LDKChannelDetails this_ptr_conv;
34025 this_ptr_conv.inner = untag_ptr(this_ptr);
34026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34028 this_ptr_conv.is_owned = false;
34029 void* val_ptr = untag_ptr(val);
34030 CHECK_ACCESS(val_ptr);
34031 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
34032 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(val));
34033 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
34036 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_outbound"))) TS_ChannelDetails_get_is_outbound(uint64_t this_ptr) {
34037 LDKChannelDetails this_ptr_conv;
34038 this_ptr_conv.inner = untag_ptr(this_ptr);
34039 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34041 this_ptr_conv.is_owned = false;
34042 jboolean ret_conv = ChannelDetails_get_is_outbound(&this_ptr_conv);
34046 void __attribute__((export_name("TS_ChannelDetails_set_is_outbound"))) TS_ChannelDetails_set_is_outbound(uint64_t this_ptr, jboolean val) {
34047 LDKChannelDetails this_ptr_conv;
34048 this_ptr_conv.inner = untag_ptr(this_ptr);
34049 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34050 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34051 this_ptr_conv.is_owned = false;
34052 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
34055 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_channel_ready"))) TS_ChannelDetails_get_is_channel_ready(uint64_t this_ptr) {
34056 LDKChannelDetails this_ptr_conv;
34057 this_ptr_conv.inner = untag_ptr(this_ptr);
34058 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34060 this_ptr_conv.is_owned = false;
34061 jboolean ret_conv = ChannelDetails_get_is_channel_ready(&this_ptr_conv);
34065 void __attribute__((export_name("TS_ChannelDetails_set_is_channel_ready"))) TS_ChannelDetails_set_is_channel_ready(uint64_t this_ptr, jboolean val) {
34066 LDKChannelDetails this_ptr_conv;
34067 this_ptr_conv.inner = untag_ptr(this_ptr);
34068 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34070 this_ptr_conv.is_owned = false;
34071 ChannelDetails_set_is_channel_ready(&this_ptr_conv, val);
34074 uint64_t __attribute__((export_name("TS_ChannelDetails_get_channel_shutdown_state"))) TS_ChannelDetails_get_channel_shutdown_state(uint64_t this_ptr) {
34075 LDKChannelDetails this_ptr_conv;
34076 this_ptr_conv.inner = untag_ptr(this_ptr);
34077 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34078 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34079 this_ptr_conv.is_owned = false;
34080 LDKCOption_ChannelShutdownStateZ *ret_copy = MALLOC(sizeof(LDKCOption_ChannelShutdownStateZ), "LDKCOption_ChannelShutdownStateZ");
34081 *ret_copy = ChannelDetails_get_channel_shutdown_state(&this_ptr_conv);
34082 uint64_t ret_ref = tag_ptr(ret_copy, true);
34086 void __attribute__((export_name("TS_ChannelDetails_set_channel_shutdown_state"))) TS_ChannelDetails_set_channel_shutdown_state(uint64_t this_ptr, uint64_t val) {
34087 LDKChannelDetails this_ptr_conv;
34088 this_ptr_conv.inner = untag_ptr(this_ptr);
34089 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34091 this_ptr_conv.is_owned = false;
34092 void* val_ptr = untag_ptr(val);
34093 CHECK_ACCESS(val_ptr);
34094 LDKCOption_ChannelShutdownStateZ val_conv = *(LDKCOption_ChannelShutdownStateZ*)(val_ptr);
34095 val_conv = COption_ChannelShutdownStateZ_clone((LDKCOption_ChannelShutdownStateZ*)untag_ptr(val));
34096 ChannelDetails_set_channel_shutdown_state(&this_ptr_conv, val_conv);
34099 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_usable"))) TS_ChannelDetails_get_is_usable(uint64_t this_ptr) {
34100 LDKChannelDetails this_ptr_conv;
34101 this_ptr_conv.inner = untag_ptr(this_ptr);
34102 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34104 this_ptr_conv.is_owned = false;
34105 jboolean ret_conv = ChannelDetails_get_is_usable(&this_ptr_conv);
34109 void __attribute__((export_name("TS_ChannelDetails_set_is_usable"))) TS_ChannelDetails_set_is_usable(uint64_t this_ptr, jboolean val) {
34110 LDKChannelDetails this_ptr_conv;
34111 this_ptr_conv.inner = untag_ptr(this_ptr);
34112 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34113 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34114 this_ptr_conv.is_owned = false;
34115 ChannelDetails_set_is_usable(&this_ptr_conv, val);
34118 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_public"))) TS_ChannelDetails_get_is_public(uint64_t this_ptr) {
34119 LDKChannelDetails this_ptr_conv;
34120 this_ptr_conv.inner = untag_ptr(this_ptr);
34121 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34123 this_ptr_conv.is_owned = false;
34124 jboolean ret_conv = ChannelDetails_get_is_public(&this_ptr_conv);
34128 void __attribute__((export_name("TS_ChannelDetails_set_is_public"))) TS_ChannelDetails_set_is_public(uint64_t this_ptr, jboolean val) {
34129 LDKChannelDetails this_ptr_conv;
34130 this_ptr_conv.inner = untag_ptr(this_ptr);
34131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34133 this_ptr_conv.is_owned = false;
34134 ChannelDetails_set_is_public(&this_ptr_conv, val);
34137 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_minimum_msat"))) TS_ChannelDetails_get_inbound_htlc_minimum_msat(uint64_t this_ptr) {
34138 LDKChannelDetails this_ptr_conv;
34139 this_ptr_conv.inner = untag_ptr(this_ptr);
34140 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34142 this_ptr_conv.is_owned = false;
34143 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
34144 *ret_copy = ChannelDetails_get_inbound_htlc_minimum_msat(&this_ptr_conv);
34145 uint64_t ret_ref = tag_ptr(ret_copy, true);
34149 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) {
34150 LDKChannelDetails this_ptr_conv;
34151 this_ptr_conv.inner = untag_ptr(this_ptr);
34152 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34153 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34154 this_ptr_conv.is_owned = false;
34155 void* val_ptr = untag_ptr(val);
34156 CHECK_ACCESS(val_ptr);
34157 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
34158 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
34159 ChannelDetails_set_inbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
34162 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_maximum_msat"))) TS_ChannelDetails_get_inbound_htlc_maximum_msat(uint64_t this_ptr) {
34163 LDKChannelDetails this_ptr_conv;
34164 this_ptr_conv.inner = untag_ptr(this_ptr);
34165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34167 this_ptr_conv.is_owned = false;
34168 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
34169 *ret_copy = ChannelDetails_get_inbound_htlc_maximum_msat(&this_ptr_conv);
34170 uint64_t ret_ref = tag_ptr(ret_copy, true);
34174 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) {
34175 LDKChannelDetails this_ptr_conv;
34176 this_ptr_conv.inner = untag_ptr(this_ptr);
34177 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34179 this_ptr_conv.is_owned = false;
34180 void* val_ptr = untag_ptr(val);
34181 CHECK_ACCESS(val_ptr);
34182 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
34183 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
34184 ChannelDetails_set_inbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
34187 uint64_t __attribute__((export_name("TS_ChannelDetails_get_config"))) TS_ChannelDetails_get_config(uint64_t this_ptr) {
34188 LDKChannelDetails this_ptr_conv;
34189 this_ptr_conv.inner = untag_ptr(this_ptr);
34190 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34191 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34192 this_ptr_conv.is_owned = false;
34193 LDKChannelConfig ret_var = ChannelDetails_get_config(&this_ptr_conv);
34194 uint64_t ret_ref = 0;
34195 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34196 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34200 void __attribute__((export_name("TS_ChannelDetails_set_config"))) TS_ChannelDetails_set_config(uint64_t this_ptr, uint64_t val) {
34201 LDKChannelDetails this_ptr_conv;
34202 this_ptr_conv.inner = untag_ptr(this_ptr);
34203 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34204 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34205 this_ptr_conv.is_owned = false;
34206 LDKChannelConfig val_conv;
34207 val_conv.inner = untag_ptr(val);
34208 val_conv.is_owned = ptr_is_owned(val);
34209 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
34210 val_conv = ChannelConfig_clone(&val_conv);
34211 ChannelDetails_set_config(&this_ptr_conv, val_conv);
34214 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 next_outbound_htlc_minimum_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, uint64_t channel_shutdown_state_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) {
34215 LDKThirtyTwoBytes channel_id_arg_ref;
34216 CHECK(channel_id_arg->arr_len == 32);
34217 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
34218 LDKChannelCounterparty counterparty_arg_conv;
34219 counterparty_arg_conv.inner = untag_ptr(counterparty_arg);
34220 counterparty_arg_conv.is_owned = ptr_is_owned(counterparty_arg);
34221 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
34222 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
34223 LDKOutPoint funding_txo_arg_conv;
34224 funding_txo_arg_conv.inner = untag_ptr(funding_txo_arg);
34225 funding_txo_arg_conv.is_owned = ptr_is_owned(funding_txo_arg);
34226 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
34227 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
34228 LDKChannelTypeFeatures channel_type_arg_conv;
34229 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
34230 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
34231 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
34232 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
34233 void* short_channel_id_arg_ptr = untag_ptr(short_channel_id_arg);
34234 CHECK_ACCESS(short_channel_id_arg_ptr);
34235 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_arg_ptr);
34236 short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_arg));
34237 void* outbound_scid_alias_arg_ptr = untag_ptr(outbound_scid_alias_arg);
34238 CHECK_ACCESS(outbound_scid_alias_arg_ptr);
34239 LDKCOption_u64Z outbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(outbound_scid_alias_arg_ptr);
34240 outbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_scid_alias_arg));
34241 void* inbound_scid_alias_arg_ptr = untag_ptr(inbound_scid_alias_arg);
34242 CHECK_ACCESS(inbound_scid_alias_arg_ptr);
34243 LDKCOption_u64Z inbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(inbound_scid_alias_arg_ptr);
34244 inbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_scid_alias_arg));
34245 void* unspendable_punishment_reserve_arg_ptr = untag_ptr(unspendable_punishment_reserve_arg);
34246 CHECK_ACCESS(unspendable_punishment_reserve_arg_ptr);
34247 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(unspendable_punishment_reserve_arg_ptr);
34248 LDKU128 user_channel_id_arg_ref;
34249 CHECK(user_channel_id_arg->arr_len == 16);
34250 memcpy(user_channel_id_arg_ref.le_bytes, user_channel_id_arg->elems, 16); FREE(user_channel_id_arg);
34251 void* feerate_sat_per_1000_weight_arg_ptr = untag_ptr(feerate_sat_per_1000_weight_arg);
34252 CHECK_ACCESS(feerate_sat_per_1000_weight_arg_ptr);
34253 LDKCOption_u32Z feerate_sat_per_1000_weight_arg_conv = *(LDKCOption_u32Z*)(feerate_sat_per_1000_weight_arg_ptr);
34254 feerate_sat_per_1000_weight_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(feerate_sat_per_1000_weight_arg));
34255 void* confirmations_required_arg_ptr = untag_ptr(confirmations_required_arg);
34256 CHECK_ACCESS(confirmations_required_arg_ptr);
34257 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(confirmations_required_arg_ptr);
34258 confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_required_arg));
34259 void* confirmations_arg_ptr = untag_ptr(confirmations_arg);
34260 CHECK_ACCESS(confirmations_arg_ptr);
34261 LDKCOption_u32Z confirmations_arg_conv = *(LDKCOption_u32Z*)(confirmations_arg_ptr);
34262 confirmations_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(confirmations_arg));
34263 void* force_close_spend_delay_arg_ptr = untag_ptr(force_close_spend_delay_arg);
34264 CHECK_ACCESS(force_close_spend_delay_arg_ptr);
34265 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(force_close_spend_delay_arg_ptr);
34266 force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(force_close_spend_delay_arg));
34267 void* channel_shutdown_state_arg_ptr = untag_ptr(channel_shutdown_state_arg);
34268 CHECK_ACCESS(channel_shutdown_state_arg_ptr);
34269 LDKCOption_ChannelShutdownStateZ channel_shutdown_state_arg_conv = *(LDKCOption_ChannelShutdownStateZ*)(channel_shutdown_state_arg_ptr);
34270 channel_shutdown_state_arg_conv = COption_ChannelShutdownStateZ_clone((LDKCOption_ChannelShutdownStateZ*)untag_ptr(channel_shutdown_state_arg));
34271 void* inbound_htlc_minimum_msat_arg_ptr = untag_ptr(inbound_htlc_minimum_msat_arg);
34272 CHECK_ACCESS(inbound_htlc_minimum_msat_arg_ptr);
34273 LDKCOption_u64Z inbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_minimum_msat_arg_ptr);
34274 inbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_minimum_msat_arg));
34275 void* inbound_htlc_maximum_msat_arg_ptr = untag_ptr(inbound_htlc_maximum_msat_arg);
34276 CHECK_ACCESS(inbound_htlc_maximum_msat_arg_ptr);
34277 LDKCOption_u64Z inbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_maximum_msat_arg_ptr);
34278 inbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(inbound_htlc_maximum_msat_arg));
34279 LDKChannelConfig config_arg_conv;
34280 config_arg_conv.inner = untag_ptr(config_arg);
34281 config_arg_conv.is_owned = ptr_is_owned(config_arg);
34282 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_arg_conv);
34283 config_arg_conv = ChannelConfig_clone(&config_arg_conv);
34284 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, next_outbound_htlc_minimum_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, channel_shutdown_state_arg_conv, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg_conv, inbound_htlc_maximum_msat_arg_conv, config_arg_conv);
34285 uint64_t ret_ref = 0;
34286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34287 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34291 static inline uint64_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
34292 LDKChannelDetails ret_var = ChannelDetails_clone(arg);
34293 uint64_t ret_ref = 0;
34294 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34295 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34298 int64_t __attribute__((export_name("TS_ChannelDetails_clone_ptr"))) TS_ChannelDetails_clone_ptr(uint64_t arg) {
34299 LDKChannelDetails arg_conv;
34300 arg_conv.inner = untag_ptr(arg);
34301 arg_conv.is_owned = ptr_is_owned(arg);
34302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34303 arg_conv.is_owned = false;
34304 int64_t ret_conv = ChannelDetails_clone_ptr(&arg_conv);
34308 uint64_t __attribute__((export_name("TS_ChannelDetails_clone"))) TS_ChannelDetails_clone(uint64_t orig) {
34309 LDKChannelDetails orig_conv;
34310 orig_conv.inner = untag_ptr(orig);
34311 orig_conv.is_owned = ptr_is_owned(orig);
34312 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34313 orig_conv.is_owned = false;
34314 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
34315 uint64_t ret_ref = 0;
34316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34321 uint64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_payment_scid"))) TS_ChannelDetails_get_inbound_payment_scid(uint64_t this_arg) {
34322 LDKChannelDetails this_arg_conv;
34323 this_arg_conv.inner = untag_ptr(this_arg);
34324 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34326 this_arg_conv.is_owned = false;
34327 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
34328 *ret_copy = ChannelDetails_get_inbound_payment_scid(&this_arg_conv);
34329 uint64_t ret_ref = tag_ptr(ret_copy, true);
34333 uint64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_payment_scid"))) TS_ChannelDetails_get_outbound_payment_scid(uint64_t this_arg) {
34334 LDKChannelDetails this_arg_conv;
34335 this_arg_conv.inner = untag_ptr(this_arg);
34336 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34337 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34338 this_arg_conv.is_owned = false;
34339 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
34340 *ret_copy = ChannelDetails_get_outbound_payment_scid(&this_arg_conv);
34341 uint64_t ret_ref = tag_ptr(ret_copy, true);
34345 uint32_t __attribute__((export_name("TS_ChannelShutdownState_clone"))) TS_ChannelShutdownState_clone(uint64_t orig) {
34346 LDKChannelShutdownState* orig_conv = (LDKChannelShutdownState*)untag_ptr(orig);
34347 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_clone(orig_conv));
34351 uint32_t __attribute__((export_name("TS_ChannelShutdownState_not_shutting_down"))) TS_ChannelShutdownState_not_shutting_down() {
34352 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_not_shutting_down());
34356 uint32_t __attribute__((export_name("TS_ChannelShutdownState_shutdown_initiated"))) TS_ChannelShutdownState_shutdown_initiated() {
34357 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_shutdown_initiated());
34361 uint32_t __attribute__((export_name("TS_ChannelShutdownState_resolving_htlcs"))) TS_ChannelShutdownState_resolving_htlcs() {
34362 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_resolving_htlcs());
34366 uint32_t __attribute__((export_name("TS_ChannelShutdownState_negotiating_closing_fee"))) TS_ChannelShutdownState_negotiating_closing_fee() {
34367 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_negotiating_closing_fee());
34371 uint32_t __attribute__((export_name("TS_ChannelShutdownState_shutdown_complete"))) TS_ChannelShutdownState_shutdown_complete() {
34372 uint32_t ret_conv = LDKChannelShutdownState_to_js(ChannelShutdownState_shutdown_complete());
34376 jboolean __attribute__((export_name("TS_ChannelShutdownState_eq"))) TS_ChannelShutdownState_eq(uint64_t a, uint64_t b) {
34377 LDKChannelShutdownState* a_conv = (LDKChannelShutdownState*)untag_ptr(a);
34378 LDKChannelShutdownState* b_conv = (LDKChannelShutdownState*)untag_ptr(b);
34379 jboolean ret_conv = ChannelShutdownState_eq(a_conv, b_conv);
34383 void __attribute__((export_name("TS_RecentPaymentDetails_free"))) TS_RecentPaymentDetails_free(uint64_t this_ptr) {
34384 if (!ptr_is_owned(this_ptr)) return;
34385 void* this_ptr_ptr = untag_ptr(this_ptr);
34386 CHECK_ACCESS(this_ptr_ptr);
34387 LDKRecentPaymentDetails this_ptr_conv = *(LDKRecentPaymentDetails*)(this_ptr_ptr);
34388 FREE(untag_ptr(this_ptr));
34389 RecentPaymentDetails_free(this_ptr_conv);
34392 static inline uint64_t RecentPaymentDetails_clone_ptr(LDKRecentPaymentDetails *NONNULL_PTR arg) {
34393 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34394 *ret_copy = RecentPaymentDetails_clone(arg);
34395 uint64_t ret_ref = tag_ptr(ret_copy, true);
34398 int64_t __attribute__((export_name("TS_RecentPaymentDetails_clone_ptr"))) TS_RecentPaymentDetails_clone_ptr(uint64_t arg) {
34399 LDKRecentPaymentDetails* arg_conv = (LDKRecentPaymentDetails*)untag_ptr(arg);
34400 int64_t ret_conv = RecentPaymentDetails_clone_ptr(arg_conv);
34404 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_clone"))) TS_RecentPaymentDetails_clone(uint64_t orig) {
34405 LDKRecentPaymentDetails* orig_conv = (LDKRecentPaymentDetails*)untag_ptr(orig);
34406 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34407 *ret_copy = RecentPaymentDetails_clone(orig_conv);
34408 uint64_t ret_ref = tag_ptr(ret_copy, true);
34412 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_awaiting_invoice"))) TS_RecentPaymentDetails_awaiting_invoice(int8_tArray payment_id) {
34413 LDKThirtyTwoBytes payment_id_ref;
34414 CHECK(payment_id->arr_len == 32);
34415 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34416 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34417 *ret_copy = RecentPaymentDetails_awaiting_invoice(payment_id_ref);
34418 uint64_t ret_ref = tag_ptr(ret_copy, true);
34422 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_pending"))) TS_RecentPaymentDetails_pending(int8_tArray payment_id, int8_tArray payment_hash, int64_t total_msat) {
34423 LDKThirtyTwoBytes payment_id_ref;
34424 CHECK(payment_id->arr_len == 32);
34425 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34426 LDKThirtyTwoBytes payment_hash_ref;
34427 CHECK(payment_hash->arr_len == 32);
34428 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
34429 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34430 *ret_copy = RecentPaymentDetails_pending(payment_id_ref, payment_hash_ref, total_msat);
34431 uint64_t ret_ref = tag_ptr(ret_copy, true);
34435 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_fulfilled"))) TS_RecentPaymentDetails_fulfilled(int8_tArray payment_id, uint64_t payment_hash) {
34436 LDKThirtyTwoBytes payment_id_ref;
34437 CHECK(payment_id->arr_len == 32);
34438 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34439 void* payment_hash_ptr = untag_ptr(payment_hash);
34440 CHECK_ACCESS(payment_hash_ptr);
34441 LDKCOption_ThirtyTwoBytesZ payment_hash_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_hash_ptr);
34442 payment_hash_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_hash));
34443 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34444 *ret_copy = RecentPaymentDetails_fulfilled(payment_id_ref, payment_hash_conv);
34445 uint64_t ret_ref = tag_ptr(ret_copy, true);
34449 uint64_t __attribute__((export_name("TS_RecentPaymentDetails_abandoned"))) TS_RecentPaymentDetails_abandoned(int8_tArray payment_id, int8_tArray payment_hash) {
34450 LDKThirtyTwoBytes payment_id_ref;
34451 CHECK(payment_id->arr_len == 32);
34452 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34453 LDKThirtyTwoBytes payment_hash_ref;
34454 CHECK(payment_hash->arr_len == 32);
34455 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
34456 LDKRecentPaymentDetails *ret_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34457 *ret_copy = RecentPaymentDetails_abandoned(payment_id_ref, payment_hash_ref);
34458 uint64_t ret_ref = tag_ptr(ret_copy, true);
34462 void __attribute__((export_name("TS_PhantomRouteHints_free"))) TS_PhantomRouteHints_free(uint64_t this_obj) {
34463 LDKPhantomRouteHints this_obj_conv;
34464 this_obj_conv.inner = untag_ptr(this_obj);
34465 this_obj_conv.is_owned = ptr_is_owned(this_obj);
34466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34467 PhantomRouteHints_free(this_obj_conv);
34470 uint64_tArray __attribute__((export_name("TS_PhantomRouteHints_get_channels"))) TS_PhantomRouteHints_get_channels(uint64_t this_ptr) {
34471 LDKPhantomRouteHints this_ptr_conv;
34472 this_ptr_conv.inner = untag_ptr(this_ptr);
34473 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34475 this_ptr_conv.is_owned = false;
34476 LDKCVec_ChannelDetailsZ ret_var = PhantomRouteHints_get_channels(&this_ptr_conv);
34477 uint64_tArray ret_arr = NULL;
34478 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34479 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34480 for (size_t q = 0; q < ret_var.datalen; q++) {
34481 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
34482 uint64_t ret_conv_16_ref = 0;
34483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
34484 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
34485 ret_arr_ptr[q] = ret_conv_16_ref;
34488 FREE(ret_var.data);
34492 void __attribute__((export_name("TS_PhantomRouteHints_set_channels"))) TS_PhantomRouteHints_set_channels(uint64_t this_ptr, uint64_tArray val) {
34493 LDKPhantomRouteHints this_ptr_conv;
34494 this_ptr_conv.inner = untag_ptr(this_ptr);
34495 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34497 this_ptr_conv.is_owned = false;
34498 LDKCVec_ChannelDetailsZ val_constr;
34499 val_constr.datalen = val->arr_len;
34500 if (val_constr.datalen > 0)
34501 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
34503 val_constr.data = NULL;
34504 uint64_t* val_vals = val->elems;
34505 for (size_t q = 0; q < val_constr.datalen; q++) {
34506 uint64_t val_conv_16 = val_vals[q];
34507 LDKChannelDetails val_conv_16_conv;
34508 val_conv_16_conv.inner = untag_ptr(val_conv_16);
34509 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
34510 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
34511 val_conv_16_conv = ChannelDetails_clone(&val_conv_16_conv);
34512 val_constr.data[q] = val_conv_16_conv;
34515 PhantomRouteHints_set_channels(&this_ptr_conv, val_constr);
34518 int64_t __attribute__((export_name("TS_PhantomRouteHints_get_phantom_scid"))) TS_PhantomRouteHints_get_phantom_scid(uint64_t this_ptr) {
34519 LDKPhantomRouteHints this_ptr_conv;
34520 this_ptr_conv.inner = untag_ptr(this_ptr);
34521 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34523 this_ptr_conv.is_owned = false;
34524 int64_t ret_conv = PhantomRouteHints_get_phantom_scid(&this_ptr_conv);
34528 void __attribute__((export_name("TS_PhantomRouteHints_set_phantom_scid"))) TS_PhantomRouteHints_set_phantom_scid(uint64_t this_ptr, int64_t val) {
34529 LDKPhantomRouteHints this_ptr_conv;
34530 this_ptr_conv.inner = untag_ptr(this_ptr);
34531 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34533 this_ptr_conv.is_owned = false;
34534 PhantomRouteHints_set_phantom_scid(&this_ptr_conv, val);
34537 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_get_real_node_pubkey"))) TS_PhantomRouteHints_get_real_node_pubkey(uint64_t this_ptr) {
34538 LDKPhantomRouteHints this_ptr_conv;
34539 this_ptr_conv.inner = untag_ptr(this_ptr);
34540 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34542 this_ptr_conv.is_owned = false;
34543 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
34544 memcpy(ret_arr->elems, PhantomRouteHints_get_real_node_pubkey(&this_ptr_conv).compressed_form, 33);
34548 void __attribute__((export_name("TS_PhantomRouteHints_set_real_node_pubkey"))) TS_PhantomRouteHints_set_real_node_pubkey(uint64_t this_ptr, int8_tArray val) {
34549 LDKPhantomRouteHints this_ptr_conv;
34550 this_ptr_conv.inner = untag_ptr(this_ptr);
34551 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
34552 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34553 this_ptr_conv.is_owned = false;
34554 LDKPublicKey val_ref;
34555 CHECK(val->arr_len == 33);
34556 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
34557 PhantomRouteHints_set_real_node_pubkey(&this_ptr_conv, val_ref);
34560 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) {
34561 LDKCVec_ChannelDetailsZ channels_arg_constr;
34562 channels_arg_constr.datalen = channels_arg->arr_len;
34563 if (channels_arg_constr.datalen > 0)
34564 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
34566 channels_arg_constr.data = NULL;
34567 uint64_t* channels_arg_vals = channels_arg->elems;
34568 for (size_t q = 0; q < channels_arg_constr.datalen; q++) {
34569 uint64_t channels_arg_conv_16 = channels_arg_vals[q];
34570 LDKChannelDetails channels_arg_conv_16_conv;
34571 channels_arg_conv_16_conv.inner = untag_ptr(channels_arg_conv_16);
34572 channels_arg_conv_16_conv.is_owned = ptr_is_owned(channels_arg_conv_16);
34573 CHECK_INNER_FIELD_ACCESS_OR_NULL(channels_arg_conv_16_conv);
34574 channels_arg_conv_16_conv = ChannelDetails_clone(&channels_arg_conv_16_conv);
34575 channels_arg_constr.data[q] = channels_arg_conv_16_conv;
34577 FREE(channels_arg);
34578 LDKPublicKey real_node_pubkey_arg_ref;
34579 CHECK(real_node_pubkey_arg->arr_len == 33);
34580 memcpy(real_node_pubkey_arg_ref.compressed_form, real_node_pubkey_arg->elems, 33); FREE(real_node_pubkey_arg);
34581 LDKPhantomRouteHints ret_var = PhantomRouteHints_new(channels_arg_constr, phantom_scid_arg, real_node_pubkey_arg_ref);
34582 uint64_t ret_ref = 0;
34583 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34584 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34588 static inline uint64_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg) {
34589 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(arg);
34590 uint64_t ret_ref = 0;
34591 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34592 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34595 int64_t __attribute__((export_name("TS_PhantomRouteHints_clone_ptr"))) TS_PhantomRouteHints_clone_ptr(uint64_t arg) {
34596 LDKPhantomRouteHints arg_conv;
34597 arg_conv.inner = untag_ptr(arg);
34598 arg_conv.is_owned = ptr_is_owned(arg);
34599 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34600 arg_conv.is_owned = false;
34601 int64_t ret_conv = PhantomRouteHints_clone_ptr(&arg_conv);
34605 uint64_t __attribute__((export_name("TS_PhantomRouteHints_clone"))) TS_PhantomRouteHints_clone(uint64_t orig) {
34606 LDKPhantomRouteHints orig_conv;
34607 orig_conv.inner = untag_ptr(orig);
34608 orig_conv.is_owned = ptr_is_owned(orig);
34609 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34610 orig_conv.is_owned = false;
34611 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(&orig_conv);
34612 uint64_t ret_ref = 0;
34613 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34614 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34618 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, int32_t current_timestamp) {
34619 void* fee_est_ptr = untag_ptr(fee_est);
34620 CHECK_ACCESS(fee_est_ptr);
34621 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(fee_est_ptr);
34622 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
34623 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34624 LDKFeeEstimator_JCalls_cloned(&fee_est_conv);
34626 void* chain_monitor_ptr = untag_ptr(chain_monitor);
34627 CHECK_ACCESS(chain_monitor_ptr);
34628 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
34629 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
34630 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34631 LDKWatch_JCalls_cloned(&chain_monitor_conv);
34633 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
34634 CHECK_ACCESS(tx_broadcaster_ptr);
34635 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
34636 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
34637 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34638 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
34640 void* router_ptr = untag_ptr(router);
34641 CHECK_ACCESS(router_ptr);
34642 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
34643 if (router_conv.free == LDKRouter_JCalls_free) {
34644 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34645 LDKRouter_JCalls_cloned(&router_conv);
34647 void* logger_ptr = untag_ptr(logger);
34648 CHECK_ACCESS(logger_ptr);
34649 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
34650 if (logger_conv.free == LDKLogger_JCalls_free) {
34651 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34652 LDKLogger_JCalls_cloned(&logger_conv);
34654 void* entropy_source_ptr = untag_ptr(entropy_source);
34655 CHECK_ACCESS(entropy_source_ptr);
34656 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
34657 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
34658 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34659 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
34661 void* node_signer_ptr = untag_ptr(node_signer);
34662 CHECK_ACCESS(node_signer_ptr);
34663 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
34664 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
34665 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34666 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
34668 void* signer_provider_ptr = untag_ptr(signer_provider);
34669 CHECK_ACCESS(signer_provider_ptr);
34670 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
34671 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
34672 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34673 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
34675 LDKUserConfig config_conv;
34676 config_conv.inner = untag_ptr(config);
34677 config_conv.is_owned = ptr_is_owned(config);
34678 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
34679 config_conv = UserConfig_clone(&config_conv);
34680 LDKChainParameters params_conv;
34681 params_conv.inner = untag_ptr(params);
34682 params_conv.is_owned = ptr_is_owned(params);
34683 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
34684 params_conv = ChainParameters_clone(¶ms_conv);
34685 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, current_timestamp);
34686 uint64_t ret_ref = 0;
34687 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34688 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34692 uint64_t __attribute__((export_name("TS_ChannelManager_get_current_default_configuration"))) TS_ChannelManager_get_current_default_configuration(uint64_t this_arg) {
34693 LDKChannelManager this_arg_conv;
34694 this_arg_conv.inner = untag_ptr(this_arg);
34695 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34696 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34697 this_arg_conv.is_owned = false;
34698 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
34699 uint64_t ret_ref = 0;
34700 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34701 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
34705 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) {
34706 LDKChannelManager this_arg_conv;
34707 this_arg_conv.inner = untag_ptr(this_arg);
34708 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34710 this_arg_conv.is_owned = false;
34711 LDKPublicKey their_network_key_ref;
34712 CHECK(their_network_key->arr_len == 33);
34713 memcpy(their_network_key_ref.compressed_form, their_network_key->elems, 33); FREE(their_network_key);
34714 LDKU128 user_channel_id_ref;
34715 CHECK(user_channel_id->arr_len == 16);
34716 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
34717 LDKUserConfig override_config_conv;
34718 override_config_conv.inner = untag_ptr(override_config);
34719 override_config_conv.is_owned = ptr_is_owned(override_config);
34720 CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
34721 override_config_conv = UserConfig_clone(&override_config_conv);
34722 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
34723 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id_ref, override_config_conv);
34724 return tag_ptr(ret_conv, true);
34727 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_channels"))) TS_ChannelManager_list_channels(uint64_t this_arg) {
34728 LDKChannelManager this_arg_conv;
34729 this_arg_conv.inner = untag_ptr(this_arg);
34730 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34732 this_arg_conv.is_owned = false;
34733 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
34734 uint64_tArray ret_arr = NULL;
34735 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34736 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34737 for (size_t q = 0; q < ret_var.datalen; q++) {
34738 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
34739 uint64_t ret_conv_16_ref = 0;
34740 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
34741 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
34742 ret_arr_ptr[q] = ret_conv_16_ref;
34745 FREE(ret_var.data);
34749 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_usable_channels"))) TS_ChannelManager_list_usable_channels(uint64_t this_arg) {
34750 LDKChannelManager this_arg_conv;
34751 this_arg_conv.inner = untag_ptr(this_arg);
34752 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34754 this_arg_conv.is_owned = false;
34755 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
34756 uint64_tArray ret_arr = NULL;
34757 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34758 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34759 for (size_t q = 0; q < ret_var.datalen; q++) {
34760 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
34761 uint64_t ret_conv_16_ref = 0;
34762 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
34763 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
34764 ret_arr_ptr[q] = ret_conv_16_ref;
34767 FREE(ret_var.data);
34771 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) {
34772 LDKChannelManager this_arg_conv;
34773 this_arg_conv.inner = untag_ptr(this_arg);
34774 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34776 this_arg_conv.is_owned = false;
34777 LDKPublicKey counterparty_node_id_ref;
34778 CHECK(counterparty_node_id->arr_len == 33);
34779 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
34780 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels_with_counterparty(&this_arg_conv, counterparty_node_id_ref);
34781 uint64_tArray ret_arr = NULL;
34782 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34783 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34784 for (size_t q = 0; q < ret_var.datalen; q++) {
34785 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
34786 uint64_t ret_conv_16_ref = 0;
34787 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
34788 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
34789 ret_arr_ptr[q] = ret_conv_16_ref;
34792 FREE(ret_var.data);
34796 uint64_tArray __attribute__((export_name("TS_ChannelManager_list_recent_payments"))) TS_ChannelManager_list_recent_payments(uint64_t this_arg) {
34797 LDKChannelManager this_arg_conv;
34798 this_arg_conv.inner = untag_ptr(this_arg);
34799 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34801 this_arg_conv.is_owned = false;
34802 LDKCVec_RecentPaymentDetailsZ ret_var = ChannelManager_list_recent_payments(&this_arg_conv);
34803 uint64_tArray ret_arr = NULL;
34804 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
34805 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
34806 for (size_t w = 0; w < ret_var.datalen; w++) {
34807 LDKRecentPaymentDetails *ret_conv_22_copy = MALLOC(sizeof(LDKRecentPaymentDetails), "LDKRecentPaymentDetails");
34808 *ret_conv_22_copy = ret_var.data[w];
34809 uint64_t ret_conv_22_ref = tag_ptr(ret_conv_22_copy, true);
34810 ret_arr_ptr[w] = ret_conv_22_ref;
34813 FREE(ret_var.data);
34817 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) {
34818 LDKChannelManager this_arg_conv;
34819 this_arg_conv.inner = untag_ptr(this_arg);
34820 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34822 this_arg_conv.is_owned = false;
34823 uint8_t channel_id_arr[32];
34824 CHECK(channel_id->arr_len == 32);
34825 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
34826 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
34827 LDKPublicKey counterparty_node_id_ref;
34828 CHECK(counterparty_node_id->arr_len == 33);
34829 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
34830 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
34831 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
34832 return tag_ptr(ret_conv, true);
34835 uint64_t __attribute__((export_name("TS_ChannelManager_close_channel_with_feerate_and_script"))) TS_ChannelManager_close_channel_with_feerate_and_script(uint64_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id, uint64_t target_feerate_sats_per_1000_weight, uint64_t shutdown_script) {
34836 LDKChannelManager this_arg_conv;
34837 this_arg_conv.inner = untag_ptr(this_arg);
34838 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34840 this_arg_conv.is_owned = false;
34841 uint8_t channel_id_arr[32];
34842 CHECK(channel_id->arr_len == 32);
34843 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
34844 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
34845 LDKPublicKey counterparty_node_id_ref;
34846 CHECK(counterparty_node_id->arr_len == 33);
34847 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
34848 void* target_feerate_sats_per_1000_weight_ptr = untag_ptr(target_feerate_sats_per_1000_weight);
34849 CHECK_ACCESS(target_feerate_sats_per_1000_weight_ptr);
34850 LDKCOption_u32Z target_feerate_sats_per_1000_weight_conv = *(LDKCOption_u32Z*)(target_feerate_sats_per_1000_weight_ptr);
34851 target_feerate_sats_per_1000_weight_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(target_feerate_sats_per_1000_weight));
34852 LDKShutdownScript shutdown_script_conv;
34853 shutdown_script_conv.inner = untag_ptr(shutdown_script);
34854 shutdown_script_conv.is_owned = ptr_is_owned(shutdown_script);
34855 CHECK_INNER_FIELD_ACCESS_OR_NULL(shutdown_script_conv);
34856 shutdown_script_conv = ShutdownScript_clone(&shutdown_script_conv);
34857 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
34858 *ret_conv = ChannelManager_close_channel_with_feerate_and_script(&this_arg_conv, channel_id_ref, counterparty_node_id_ref, target_feerate_sats_per_1000_weight_conv, shutdown_script_conv);
34859 return tag_ptr(ret_conv, true);
34862 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) {
34863 LDKChannelManager this_arg_conv;
34864 this_arg_conv.inner = untag_ptr(this_arg);
34865 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34867 this_arg_conv.is_owned = false;
34868 uint8_t channel_id_arr[32];
34869 CHECK(channel_id->arr_len == 32);
34870 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
34871 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
34872 LDKPublicKey counterparty_node_id_ref;
34873 CHECK(counterparty_node_id->arr_len == 33);
34874 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
34875 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
34876 *ret_conv = ChannelManager_force_close_broadcasting_latest_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
34877 return tag_ptr(ret_conv, true);
34880 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) {
34881 LDKChannelManager this_arg_conv;
34882 this_arg_conv.inner = untag_ptr(this_arg);
34883 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34885 this_arg_conv.is_owned = false;
34886 uint8_t channel_id_arr[32];
34887 CHECK(channel_id->arr_len == 32);
34888 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
34889 uint8_t (*channel_id_ref)[32] = &channel_id_arr;
34890 LDKPublicKey counterparty_node_id_ref;
34891 CHECK(counterparty_node_id->arr_len == 33);
34892 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
34893 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
34894 *ret_conv = ChannelManager_force_close_without_broadcasting_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
34895 return tag_ptr(ret_conv, true);
34898 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) {
34899 LDKChannelManager this_arg_conv;
34900 this_arg_conv.inner = untag_ptr(this_arg);
34901 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34902 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34903 this_arg_conv.is_owned = false;
34904 ChannelManager_force_close_all_channels_broadcasting_latest_txn(&this_arg_conv);
34907 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) {
34908 LDKChannelManager this_arg_conv;
34909 this_arg_conv.inner = untag_ptr(this_arg);
34910 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34912 this_arg_conv.is_owned = false;
34913 ChannelManager_force_close_all_channels_without_broadcasting_txn(&this_arg_conv);
34916 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) {
34917 LDKChannelManager this_arg_conv;
34918 this_arg_conv.inner = untag_ptr(this_arg);
34919 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34921 this_arg_conv.is_owned = false;
34922 LDKRoute route_conv;
34923 route_conv.inner = untag_ptr(route);
34924 route_conv.is_owned = ptr_is_owned(route);
34925 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
34926 route_conv.is_owned = false;
34927 LDKThirtyTwoBytes payment_hash_ref;
34928 CHECK(payment_hash->arr_len == 32);
34929 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
34930 LDKRecipientOnionFields recipient_onion_conv;
34931 recipient_onion_conv.inner = untag_ptr(recipient_onion);
34932 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
34933 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
34934 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
34935 LDKThirtyTwoBytes payment_id_ref;
34936 CHECK(payment_id->arr_len == 32);
34937 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34938 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
34939 *ret_conv = ChannelManager_send_payment_with_route(&this_arg_conv, &route_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref);
34940 return tag_ptr(ret_conv, true);
34943 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) {
34944 LDKChannelManager this_arg_conv;
34945 this_arg_conv.inner = untag_ptr(this_arg);
34946 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34948 this_arg_conv.is_owned = false;
34949 LDKThirtyTwoBytes payment_hash_ref;
34950 CHECK(payment_hash->arr_len == 32);
34951 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
34952 LDKRecipientOnionFields recipient_onion_conv;
34953 recipient_onion_conv.inner = untag_ptr(recipient_onion);
34954 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
34955 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
34956 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
34957 LDKThirtyTwoBytes payment_id_ref;
34958 CHECK(payment_id->arr_len == 32);
34959 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34960 LDKRouteParameters route_params_conv;
34961 route_params_conv.inner = untag_ptr(route_params);
34962 route_params_conv.is_owned = ptr_is_owned(route_params);
34963 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
34964 route_params_conv = RouteParameters_clone(&route_params_conv);
34965 void* retry_strategy_ptr = untag_ptr(retry_strategy);
34966 CHECK_ACCESS(retry_strategy_ptr);
34967 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
34968 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
34969 LDKCResult_NoneRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneRetryableSendFailureZ), "LDKCResult_NoneRetryableSendFailureZ");
34970 *ret_conv = ChannelManager_send_payment(&this_arg_conv, payment_hash_ref, recipient_onion_conv, payment_id_ref, route_params_conv, retry_strategy_conv);
34971 return tag_ptr(ret_conv, true);
34974 void __attribute__((export_name("TS_ChannelManager_abandon_payment"))) TS_ChannelManager_abandon_payment(uint64_t this_arg, int8_tArray payment_id) {
34975 LDKChannelManager this_arg_conv;
34976 this_arg_conv.inner = untag_ptr(this_arg);
34977 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34979 this_arg_conv.is_owned = false;
34980 LDKThirtyTwoBytes payment_id_ref;
34981 CHECK(payment_id->arr_len == 32);
34982 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
34983 ChannelManager_abandon_payment(&this_arg_conv, payment_id_ref);
34986 uint64_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_payment"))) TS_ChannelManager_send_spontaneous_payment(uint64_t this_arg, uint64_t route, uint64_t payment_preimage, uint64_t recipient_onion, int8_tArray payment_id) {
34987 LDKChannelManager this_arg_conv;
34988 this_arg_conv.inner = untag_ptr(this_arg);
34989 this_arg_conv.is_owned = ptr_is_owned(this_arg);
34990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34991 this_arg_conv.is_owned = false;
34992 LDKRoute route_conv;
34993 route_conv.inner = untag_ptr(route);
34994 route_conv.is_owned = ptr_is_owned(route);
34995 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
34996 route_conv.is_owned = false;
34997 void* payment_preimage_ptr = untag_ptr(payment_preimage);
34998 CHECK_ACCESS(payment_preimage_ptr);
34999 LDKCOption_ThirtyTwoBytesZ payment_preimage_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_preimage_ptr);
35000 payment_preimage_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_preimage));
35001 LDKRecipientOnionFields recipient_onion_conv;
35002 recipient_onion_conv.inner = untag_ptr(recipient_onion);
35003 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
35004 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
35005 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
35006 LDKThirtyTwoBytes payment_id_ref;
35007 CHECK(payment_id->arr_len == 32);
35008 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
35009 LDKCResult_ThirtyTwoBytesPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentSendFailureZ), "LDKCResult_ThirtyTwoBytesPaymentSendFailureZ");
35010 *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_conv, recipient_onion_conv, payment_id_ref);
35011 return tag_ptr(ret_conv, true);
35014 uint64_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_payment_with_retry"))) TS_ChannelManager_send_spontaneous_payment_with_retry(uint64_t this_arg, uint64_t payment_preimage, uint64_t recipient_onion, int8_tArray payment_id, uint64_t route_params, uint64_t retry_strategy) {
35015 LDKChannelManager this_arg_conv;
35016 this_arg_conv.inner = untag_ptr(this_arg);
35017 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35018 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35019 this_arg_conv.is_owned = false;
35020 void* payment_preimage_ptr = untag_ptr(payment_preimage);
35021 CHECK_ACCESS(payment_preimage_ptr);
35022 LDKCOption_ThirtyTwoBytesZ payment_preimage_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_preimage_ptr);
35023 payment_preimage_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_preimage));
35024 LDKRecipientOnionFields recipient_onion_conv;
35025 recipient_onion_conv.inner = untag_ptr(recipient_onion);
35026 recipient_onion_conv.is_owned = ptr_is_owned(recipient_onion);
35027 CHECK_INNER_FIELD_ACCESS_OR_NULL(recipient_onion_conv);
35028 recipient_onion_conv = RecipientOnionFields_clone(&recipient_onion_conv);
35029 LDKThirtyTwoBytes payment_id_ref;
35030 CHECK(payment_id->arr_len == 32);
35031 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
35032 LDKRouteParameters route_params_conv;
35033 route_params_conv.inner = untag_ptr(route_params);
35034 route_params_conv.is_owned = ptr_is_owned(route_params);
35035 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
35036 route_params_conv = RouteParameters_clone(&route_params_conv);
35037 void* retry_strategy_ptr = untag_ptr(retry_strategy);
35038 CHECK_ACCESS(retry_strategy_ptr);
35039 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
35040 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
35041 LDKCResult_ThirtyTwoBytesRetryableSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesRetryableSendFailureZ), "LDKCResult_ThirtyTwoBytesRetryableSendFailureZ");
35042 *ret_conv = ChannelManager_send_spontaneous_payment_with_retry(&this_arg_conv, payment_preimage_conv, recipient_onion_conv, payment_id_ref, route_params_conv, retry_strategy_conv);
35043 return tag_ptr(ret_conv, true);
35046 uint64_t __attribute__((export_name("TS_ChannelManager_send_probe"))) TS_ChannelManager_send_probe(uint64_t this_arg, uint64_t path) {
35047 LDKChannelManager this_arg_conv;
35048 this_arg_conv.inner = untag_ptr(this_arg);
35049 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35050 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35051 this_arg_conv.is_owned = false;
35053 path_conv.inner = untag_ptr(path);
35054 path_conv.is_owned = ptr_is_owned(path);
35055 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
35056 path_conv = Path_clone(&path_conv);
35057 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZPaymentSendFailureZ");
35058 *ret_conv = ChannelManager_send_probe(&this_arg_conv, path_conv);
35059 return tag_ptr(ret_conv, true);
35062 uint64_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_preflight_probes"))) TS_ChannelManager_send_spontaneous_preflight_probes(uint64_t this_arg, int8_tArray node_id, int64_t amount_msat, int32_t final_cltv_expiry_delta, uint64_t liquidity_limit_multiplier) {
35063 LDKChannelManager this_arg_conv;
35064 this_arg_conv.inner = untag_ptr(this_arg);
35065 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35067 this_arg_conv.is_owned = false;
35068 LDKPublicKey node_id_ref;
35069 CHECK(node_id->arr_len == 33);
35070 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
35071 void* liquidity_limit_multiplier_ptr = untag_ptr(liquidity_limit_multiplier);
35072 CHECK_ACCESS(liquidity_limit_multiplier_ptr);
35073 LDKCOption_u64Z liquidity_limit_multiplier_conv = *(LDKCOption_u64Z*)(liquidity_limit_multiplier_ptr);
35074 liquidity_limit_multiplier_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(liquidity_limit_multiplier));
35075 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
35076 *ret_conv = ChannelManager_send_spontaneous_preflight_probes(&this_arg_conv, node_id_ref, amount_msat, final_cltv_expiry_delta, liquidity_limit_multiplier_conv);
35077 return tag_ptr(ret_conv, true);
35080 uint64_t __attribute__((export_name("TS_ChannelManager_send_preflight_probes"))) TS_ChannelManager_send_preflight_probes(uint64_t this_arg, uint64_t route_params, uint64_t liquidity_limit_multiplier) {
35081 LDKChannelManager this_arg_conv;
35082 this_arg_conv.inner = untag_ptr(this_arg);
35083 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35085 this_arg_conv.is_owned = false;
35086 LDKRouteParameters route_params_conv;
35087 route_params_conv.inner = untag_ptr(route_params);
35088 route_params_conv.is_owned = ptr_is_owned(route_params);
35089 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
35090 route_params_conv = RouteParameters_clone(&route_params_conv);
35091 void* liquidity_limit_multiplier_ptr = untag_ptr(liquidity_limit_multiplier);
35092 CHECK_ACCESS(liquidity_limit_multiplier_ptr);
35093 LDKCOption_u64Z liquidity_limit_multiplier_conv = *(LDKCOption_u64Z*)(liquidity_limit_multiplier_ptr);
35094 liquidity_limit_multiplier_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(liquidity_limit_multiplier));
35095 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbeSendFailureZ");
35096 *ret_conv = ChannelManager_send_preflight_probes(&this_arg_conv, route_params_conv, liquidity_limit_multiplier_conv);
35097 return tag_ptr(ret_conv, true);
35100 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) {
35101 LDKChannelManager this_arg_conv;
35102 this_arg_conv.inner = untag_ptr(this_arg);
35103 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35105 this_arg_conv.is_owned = false;
35106 uint8_t temporary_channel_id_arr[32];
35107 CHECK(temporary_channel_id->arr_len == 32);
35108 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
35109 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
35110 LDKPublicKey counterparty_node_id_ref;
35111 CHECK(counterparty_node_id->arr_len == 33);
35112 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
35113 LDKTransaction funding_transaction_ref;
35114 funding_transaction_ref.datalen = funding_transaction->arr_len;
35115 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
35116 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
35117 funding_transaction_ref.data_is_owned = true;
35118 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35119 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, funding_transaction_ref);
35120 return tag_ptr(ret_conv, true);
35123 uint64_t __attribute__((export_name("TS_ChannelManager_batch_funding_transaction_generated"))) TS_ChannelManager_batch_funding_transaction_generated(uint64_t this_arg, uint64_tArray temporary_channels, int8_tArray funding_transaction) {
35124 LDKChannelManager this_arg_conv;
35125 this_arg_conv.inner = untag_ptr(this_arg);
35126 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35128 this_arg_conv.is_owned = false;
35129 LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ temporary_channels_constr;
35130 temporary_channels_constr.datalen = temporary_channels->arr_len;
35131 if (temporary_channels_constr.datalen > 0)
35132 temporary_channels_constr.data = MALLOC(temporary_channels_constr.datalen * sizeof(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ), "LDKCVec_C2Tuple_ThirtyTwoBytesPublicKeyZZ Elements");
35134 temporary_channels_constr.data = NULL;
35135 uint64_t* temporary_channels_vals = temporary_channels->elems;
35136 for (size_t j = 0; j < temporary_channels_constr.datalen; j++) {
35137 uint64_t temporary_channels_conv_35 = temporary_channels_vals[j];
35138 void* temporary_channels_conv_35_ptr = untag_ptr(temporary_channels_conv_35);
35139 CHECK_ACCESS(temporary_channels_conv_35_ptr);
35140 LDKC2Tuple_ThirtyTwoBytesPublicKeyZ temporary_channels_conv_35_conv = *(LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)(temporary_channels_conv_35_ptr);
35141 temporary_channels_conv_35_conv = C2Tuple_ThirtyTwoBytesPublicKeyZ_clone((LDKC2Tuple_ThirtyTwoBytesPublicKeyZ*)untag_ptr(temporary_channels_conv_35));
35142 temporary_channels_constr.data[j] = temporary_channels_conv_35_conv;
35144 FREE(temporary_channels);
35145 LDKTransaction funding_transaction_ref;
35146 funding_transaction_ref.datalen = funding_transaction->arr_len;
35147 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
35148 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
35149 funding_transaction_ref.data_is_owned = true;
35150 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35151 *ret_conv = ChannelManager_batch_funding_transaction_generated(&this_arg_conv, temporary_channels_constr, funding_transaction_ref);
35152 return tag_ptr(ret_conv, true);
35155 uint64_t __attribute__((export_name("TS_ChannelManager_update_partial_channel_config"))) TS_ChannelManager_update_partial_channel_config(uint64_t this_arg, int8_tArray counterparty_node_id, ptrArray channel_ids, uint64_t config_update) {
35156 LDKChannelManager this_arg_conv;
35157 this_arg_conv.inner = untag_ptr(this_arg);
35158 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35160 this_arg_conv.is_owned = false;
35161 LDKPublicKey counterparty_node_id_ref;
35162 CHECK(counterparty_node_id->arr_len == 33);
35163 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
35164 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
35165 channel_ids_constr.datalen = channel_ids->arr_len;
35166 if (channel_ids_constr.datalen > 0)
35167 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
35169 channel_ids_constr.data = NULL;
35170 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
35171 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
35172 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
35173 LDKThirtyTwoBytes channel_ids_conv_12_ref;
35174 CHECK(channel_ids_conv_12->arr_len == 32);
35175 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
35176 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
35179 LDKChannelConfigUpdate config_update_conv;
35180 config_update_conv.inner = untag_ptr(config_update);
35181 config_update_conv.is_owned = ptr_is_owned(config_update);
35182 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_update_conv);
35183 config_update_conv.is_owned = false;
35184 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35185 *ret_conv = ChannelManager_update_partial_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_update_conv);
35186 return tag_ptr(ret_conv, true);
35189 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) {
35190 LDKChannelManager this_arg_conv;
35191 this_arg_conv.inner = untag_ptr(this_arg);
35192 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35194 this_arg_conv.is_owned = false;
35195 LDKPublicKey counterparty_node_id_ref;
35196 CHECK(counterparty_node_id->arr_len == 33);
35197 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
35198 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
35199 channel_ids_constr.datalen = channel_ids->arr_len;
35200 if (channel_ids_constr.datalen > 0)
35201 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
35203 channel_ids_constr.data = NULL;
35204 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
35205 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
35206 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
35207 LDKThirtyTwoBytes channel_ids_conv_12_ref;
35208 CHECK(channel_ids_conv_12->arr_len == 32);
35209 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
35210 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
35213 LDKChannelConfig config_conv;
35214 config_conv.inner = untag_ptr(config);
35215 config_conv.is_owned = ptr_is_owned(config);
35216 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
35217 config_conv.is_owned = false;
35218 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35219 *ret_conv = ChannelManager_update_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_conv);
35220 return tag_ptr(ret_conv, true);
35223 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) {
35224 LDKChannelManager this_arg_conv;
35225 this_arg_conv.inner = untag_ptr(this_arg);
35226 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35228 this_arg_conv.is_owned = false;
35229 LDKThirtyTwoBytes intercept_id_ref;
35230 CHECK(intercept_id->arr_len == 32);
35231 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
35232 uint8_t next_hop_channel_id_arr[32];
35233 CHECK(next_hop_channel_id->arr_len == 32);
35234 memcpy(next_hop_channel_id_arr, next_hop_channel_id->elems, 32); FREE(next_hop_channel_id);
35235 uint8_t (*next_hop_channel_id_ref)[32] = &next_hop_channel_id_arr;
35236 LDKPublicKey next_node_id_ref;
35237 CHECK(next_node_id->arr_len == 33);
35238 memcpy(next_node_id_ref.compressed_form, next_node_id->elems, 33); FREE(next_node_id);
35239 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35240 *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);
35241 return tag_ptr(ret_conv, true);
35244 uint64_t __attribute__((export_name("TS_ChannelManager_fail_intercepted_htlc"))) TS_ChannelManager_fail_intercepted_htlc(uint64_t this_arg, int8_tArray intercept_id) {
35245 LDKChannelManager this_arg_conv;
35246 this_arg_conv.inner = untag_ptr(this_arg);
35247 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35249 this_arg_conv.is_owned = false;
35250 LDKThirtyTwoBytes intercept_id_ref;
35251 CHECK(intercept_id->arr_len == 32);
35252 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
35253 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35254 *ret_conv = ChannelManager_fail_intercepted_htlc(&this_arg_conv, intercept_id_ref);
35255 return tag_ptr(ret_conv, true);
35258 void __attribute__((export_name("TS_ChannelManager_process_pending_htlc_forwards"))) TS_ChannelManager_process_pending_htlc_forwards(uint64_t this_arg) {
35259 LDKChannelManager this_arg_conv;
35260 this_arg_conv.inner = untag_ptr(this_arg);
35261 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35263 this_arg_conv.is_owned = false;
35264 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
35267 void __attribute__((export_name("TS_ChannelManager_timer_tick_occurred"))) TS_ChannelManager_timer_tick_occurred(uint64_t this_arg) {
35268 LDKChannelManager this_arg_conv;
35269 this_arg_conv.inner = untag_ptr(this_arg);
35270 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35272 this_arg_conv.is_owned = false;
35273 ChannelManager_timer_tick_occurred(&this_arg_conv);
35276 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards"))) TS_ChannelManager_fail_htlc_backwards(uint64_t this_arg, int8_tArray payment_hash) {
35277 LDKChannelManager this_arg_conv;
35278 this_arg_conv.inner = untag_ptr(this_arg);
35279 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35281 this_arg_conv.is_owned = false;
35282 uint8_t payment_hash_arr[32];
35283 CHECK(payment_hash->arr_len == 32);
35284 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
35285 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
35286 ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
35289 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, uint64_t failure_code) {
35290 LDKChannelManager this_arg_conv;
35291 this_arg_conv.inner = untag_ptr(this_arg);
35292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35294 this_arg_conv.is_owned = false;
35295 uint8_t payment_hash_arr[32];
35296 CHECK(payment_hash->arr_len == 32);
35297 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
35298 uint8_t (*payment_hash_ref)[32] = &payment_hash_arr;
35299 void* failure_code_ptr = untag_ptr(failure_code);
35300 CHECK_ACCESS(failure_code_ptr);
35301 LDKFailureCode failure_code_conv = *(LDKFailureCode*)(failure_code_ptr);
35302 failure_code_conv = FailureCode_clone((LDKFailureCode*)untag_ptr(failure_code));
35303 ChannelManager_fail_htlc_backwards_with_reason(&this_arg_conv, payment_hash_ref, failure_code_conv);
35306 void __attribute__((export_name("TS_ChannelManager_claim_funds"))) TS_ChannelManager_claim_funds(uint64_t this_arg, int8_tArray payment_preimage) {
35307 LDKChannelManager this_arg_conv;
35308 this_arg_conv.inner = untag_ptr(this_arg);
35309 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35310 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35311 this_arg_conv.is_owned = false;
35312 LDKThirtyTwoBytes payment_preimage_ref;
35313 CHECK(payment_preimage->arr_len == 32);
35314 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
35315 ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
35318 void __attribute__((export_name("TS_ChannelManager_claim_funds_with_known_custom_tlvs"))) TS_ChannelManager_claim_funds_with_known_custom_tlvs(uint64_t this_arg, int8_tArray payment_preimage) {
35319 LDKChannelManager this_arg_conv;
35320 this_arg_conv.inner = untag_ptr(this_arg);
35321 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35323 this_arg_conv.is_owned = false;
35324 LDKThirtyTwoBytes payment_preimage_ref;
35325 CHECK(payment_preimage->arr_len == 32);
35326 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
35327 ChannelManager_claim_funds_with_known_custom_tlvs(&this_arg_conv, payment_preimage_ref);
35330 int8_tArray __attribute__((export_name("TS_ChannelManager_get_our_node_id"))) TS_ChannelManager_get_our_node_id(uint64_t this_arg) {
35331 LDKChannelManager this_arg_conv;
35332 this_arg_conv.inner = untag_ptr(this_arg);
35333 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35335 this_arg_conv.is_owned = false;
35336 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35337 memcpy(ret_arr->elems, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
35341 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) {
35342 LDKChannelManager this_arg_conv;
35343 this_arg_conv.inner = untag_ptr(this_arg);
35344 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35345 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35346 this_arg_conv.is_owned = false;
35347 uint8_t temporary_channel_id_arr[32];
35348 CHECK(temporary_channel_id->arr_len == 32);
35349 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
35350 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
35351 LDKPublicKey counterparty_node_id_ref;
35352 CHECK(counterparty_node_id->arr_len == 33);
35353 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
35354 LDKU128 user_channel_id_ref;
35355 CHECK(user_channel_id->arr_len == 16);
35356 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
35357 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35358 *ret_conv = ChannelManager_accept_inbound_channel(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id_ref);
35359 return tag_ptr(ret_conv, true);
35362 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) {
35363 LDKChannelManager this_arg_conv;
35364 this_arg_conv.inner = untag_ptr(this_arg);
35365 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35367 this_arg_conv.is_owned = false;
35368 uint8_t temporary_channel_id_arr[32];
35369 CHECK(temporary_channel_id->arr_len == 32);
35370 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
35371 uint8_t (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
35372 LDKPublicKey counterparty_node_id_ref;
35373 CHECK(counterparty_node_id->arr_len == 33);
35374 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
35375 LDKU128 user_channel_id_ref;
35376 CHECK(user_channel_id->arr_len == 16);
35377 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
35378 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
35379 *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);
35380 return tag_ptr(ret_conv, true);
35383 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) {
35384 LDKChannelManager this_arg_conv;
35385 this_arg_conv.inner = untag_ptr(this_arg);
35386 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35388 this_arg_conv.is_owned = false;
35389 void* min_value_msat_ptr = untag_ptr(min_value_msat);
35390 CHECK_ACCESS(min_value_msat_ptr);
35391 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
35392 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
35393 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
35394 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
35395 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
35396 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
35397 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
35398 *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, min_final_cltv_expiry_delta_conv);
35399 return tag_ptr(ret_conv, true);
35402 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) {
35403 LDKChannelManager this_arg_conv;
35404 this_arg_conv.inner = untag_ptr(this_arg);
35405 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35406 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35407 this_arg_conv.is_owned = false;
35408 LDKThirtyTwoBytes payment_hash_ref;
35409 CHECK(payment_hash->arr_len == 32);
35410 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
35411 void* min_value_msat_ptr = untag_ptr(min_value_msat);
35412 CHECK_ACCESS(min_value_msat_ptr);
35413 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
35414 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
35415 void* min_final_cltv_expiry_ptr = untag_ptr(min_final_cltv_expiry);
35416 CHECK_ACCESS(min_final_cltv_expiry_ptr);
35417 LDKCOption_u16Z min_final_cltv_expiry_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_ptr);
35418 min_final_cltv_expiry_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry));
35419 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
35420 *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);
35421 return tag_ptr(ret_conv, true);
35424 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) {
35425 LDKChannelManager this_arg_conv;
35426 this_arg_conv.inner = untag_ptr(this_arg);
35427 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35429 this_arg_conv.is_owned = false;
35430 LDKThirtyTwoBytes payment_hash_ref;
35431 CHECK(payment_hash->arr_len == 32);
35432 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
35433 LDKThirtyTwoBytes payment_secret_ref;
35434 CHECK(payment_secret->arr_len == 32);
35435 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
35436 LDKCResult_ThirtyTwoBytesAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesAPIErrorZ), "LDKCResult_ThirtyTwoBytesAPIErrorZ");
35437 *ret_conv = ChannelManager_get_payment_preimage(&this_arg_conv, payment_hash_ref, payment_secret_ref);
35438 return tag_ptr(ret_conv, true);
35441 int64_t __attribute__((export_name("TS_ChannelManager_get_phantom_scid"))) TS_ChannelManager_get_phantom_scid(uint64_t this_arg) {
35442 LDKChannelManager this_arg_conv;
35443 this_arg_conv.inner = untag_ptr(this_arg);
35444 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35446 this_arg_conv.is_owned = false;
35447 int64_t ret_conv = ChannelManager_get_phantom_scid(&this_arg_conv);
35451 uint64_t __attribute__((export_name("TS_ChannelManager_get_phantom_route_hints"))) TS_ChannelManager_get_phantom_route_hints(uint64_t this_arg) {
35452 LDKChannelManager this_arg_conv;
35453 this_arg_conv.inner = untag_ptr(this_arg);
35454 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35456 this_arg_conv.is_owned = false;
35457 LDKPhantomRouteHints ret_var = ChannelManager_get_phantom_route_hints(&this_arg_conv);
35458 uint64_t ret_ref = 0;
35459 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35460 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35464 int64_t __attribute__((export_name("TS_ChannelManager_get_intercept_scid"))) TS_ChannelManager_get_intercept_scid(uint64_t this_arg) {
35465 LDKChannelManager this_arg_conv;
35466 this_arg_conv.inner = untag_ptr(this_arg);
35467 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35469 this_arg_conv.is_owned = false;
35470 int64_t ret_conv = ChannelManager_get_intercept_scid(&this_arg_conv);
35474 uint64_t __attribute__((export_name("TS_ChannelManager_compute_inflight_htlcs"))) TS_ChannelManager_compute_inflight_htlcs(uint64_t this_arg) {
35475 LDKChannelManager this_arg_conv;
35476 this_arg_conv.inner = untag_ptr(this_arg);
35477 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35478 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35479 this_arg_conv.is_owned = false;
35480 LDKInFlightHtlcs ret_var = ChannelManager_compute_inflight_htlcs(&this_arg_conv);
35481 uint64_t ret_ref = 0;
35482 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35483 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35487 uint64_t __attribute__((export_name("TS_ChannelManager_as_MessageSendEventsProvider"))) TS_ChannelManager_as_MessageSendEventsProvider(uint64_t this_arg) {
35488 LDKChannelManager this_arg_conv;
35489 this_arg_conv.inner = untag_ptr(this_arg);
35490 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35492 this_arg_conv.is_owned = false;
35493 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
35494 *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
35495 return tag_ptr(ret_ret, true);
35498 uint64_t __attribute__((export_name("TS_ChannelManager_as_EventsProvider"))) TS_ChannelManager_as_EventsProvider(uint64_t this_arg) {
35499 LDKChannelManager this_arg_conv;
35500 this_arg_conv.inner = untag_ptr(this_arg);
35501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35503 this_arg_conv.is_owned = false;
35504 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
35505 *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
35506 return tag_ptr(ret_ret, true);
35509 uint64_t __attribute__((export_name("TS_ChannelManager_as_Listen"))) TS_ChannelManager_as_Listen(uint64_t this_arg) {
35510 LDKChannelManager this_arg_conv;
35511 this_arg_conv.inner = untag_ptr(this_arg);
35512 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35514 this_arg_conv.is_owned = false;
35515 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
35516 *ret_ret = ChannelManager_as_Listen(&this_arg_conv);
35517 return tag_ptr(ret_ret, true);
35520 uint64_t __attribute__((export_name("TS_ChannelManager_as_Confirm"))) TS_ChannelManager_as_Confirm(uint64_t this_arg) {
35521 LDKChannelManager this_arg_conv;
35522 this_arg_conv.inner = untag_ptr(this_arg);
35523 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35525 this_arg_conv.is_owned = false;
35526 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
35527 *ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
35528 return tag_ptr(ret_ret, true);
35531 uint64_t __attribute__((export_name("TS_ChannelManager_get_event_or_persistence_needed_future"))) TS_ChannelManager_get_event_or_persistence_needed_future(uint64_t this_arg) {
35532 LDKChannelManager this_arg_conv;
35533 this_arg_conv.inner = untag_ptr(this_arg);
35534 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35535 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35536 this_arg_conv.is_owned = false;
35537 LDKFuture ret_var = ChannelManager_get_event_or_persistence_needed_future(&this_arg_conv);
35538 uint64_t ret_ref = 0;
35539 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35540 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35544 jboolean __attribute__((export_name("TS_ChannelManager_get_and_clear_needs_persistence"))) TS_ChannelManager_get_and_clear_needs_persistence(uint64_t this_arg) {
35545 LDKChannelManager this_arg_conv;
35546 this_arg_conv.inner = untag_ptr(this_arg);
35547 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35549 this_arg_conv.is_owned = false;
35550 jboolean ret_conv = ChannelManager_get_and_clear_needs_persistence(&this_arg_conv);
35554 uint64_t __attribute__((export_name("TS_ChannelManager_current_best_block"))) TS_ChannelManager_current_best_block(uint64_t this_arg) {
35555 LDKChannelManager this_arg_conv;
35556 this_arg_conv.inner = untag_ptr(this_arg);
35557 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35559 this_arg_conv.is_owned = false;
35560 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
35561 uint64_t ret_ref = 0;
35562 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35563 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35567 uint64_t __attribute__((export_name("TS_ChannelManager_node_features"))) TS_ChannelManager_node_features(uint64_t this_arg) {
35568 LDKChannelManager this_arg_conv;
35569 this_arg_conv.inner = untag_ptr(this_arg);
35570 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35572 this_arg_conv.is_owned = false;
35573 LDKNodeFeatures ret_var = ChannelManager_node_features(&this_arg_conv);
35574 uint64_t ret_ref = 0;
35575 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35576 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35580 uint64_t __attribute__((export_name("TS_ChannelManager_channel_features"))) TS_ChannelManager_channel_features(uint64_t this_arg) {
35581 LDKChannelManager this_arg_conv;
35582 this_arg_conv.inner = untag_ptr(this_arg);
35583 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35585 this_arg_conv.is_owned = false;
35586 LDKChannelFeatures ret_var = ChannelManager_channel_features(&this_arg_conv);
35587 uint64_t ret_ref = 0;
35588 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35589 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35593 uint64_t __attribute__((export_name("TS_ChannelManager_channel_type_features"))) TS_ChannelManager_channel_type_features(uint64_t this_arg) {
35594 LDKChannelManager this_arg_conv;
35595 this_arg_conv.inner = untag_ptr(this_arg);
35596 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35597 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35598 this_arg_conv.is_owned = false;
35599 LDKChannelTypeFeatures ret_var = ChannelManager_channel_type_features(&this_arg_conv);
35600 uint64_t ret_ref = 0;
35601 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35602 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35606 uint64_t __attribute__((export_name("TS_ChannelManager_init_features"))) TS_ChannelManager_init_features(uint64_t this_arg) {
35607 LDKChannelManager this_arg_conv;
35608 this_arg_conv.inner = untag_ptr(this_arg);
35609 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35611 this_arg_conv.is_owned = false;
35612 LDKInitFeatures ret_var = ChannelManager_init_features(&this_arg_conv);
35613 uint64_t ret_ref = 0;
35614 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35615 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35619 uint64_t __attribute__((export_name("TS_ChannelManager_as_ChannelMessageHandler"))) TS_ChannelManager_as_ChannelMessageHandler(uint64_t this_arg) {
35620 LDKChannelManager this_arg_conv;
35621 this_arg_conv.inner = untag_ptr(this_arg);
35622 this_arg_conv.is_owned = ptr_is_owned(this_arg);
35623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35624 this_arg_conv.is_owned = false;
35625 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
35626 *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
35627 return tag_ptr(ret_ret, true);
35630 uint64_t __attribute__((export_name("TS_provided_init_features"))) TS_provided_init_features(uint64_t config) {
35631 LDKUserConfig config_conv;
35632 config_conv.inner = untag_ptr(config);
35633 config_conv.is_owned = ptr_is_owned(config);
35634 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
35635 config_conv.is_owned = false;
35636 LDKInitFeatures ret_var = provided_init_features(&config_conv);
35637 uint64_t ret_ref = 0;
35638 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35639 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
35643 int8_tArray __attribute__((export_name("TS_CounterpartyForwardingInfo_write"))) TS_CounterpartyForwardingInfo_write(uint64_t obj) {
35644 LDKCounterpartyForwardingInfo obj_conv;
35645 obj_conv.inner = untag_ptr(obj);
35646 obj_conv.is_owned = ptr_is_owned(obj);
35647 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35648 obj_conv.is_owned = false;
35649 LDKCVec_u8Z ret_var = CounterpartyForwardingInfo_write(&obj_conv);
35650 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35651 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35652 CVec_u8Z_free(ret_var);
35656 uint64_t __attribute__((export_name("TS_CounterpartyForwardingInfo_read"))) TS_CounterpartyForwardingInfo_read(int8_tArray ser) {
35657 LDKu8slice ser_ref;
35658 ser_ref.datalen = ser->arr_len;
35659 ser_ref.data = ser->elems;
35660 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
35661 *ret_conv = CounterpartyForwardingInfo_read(ser_ref);
35663 return tag_ptr(ret_conv, true);
35666 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_write"))) TS_ChannelCounterparty_write(uint64_t obj) {
35667 LDKChannelCounterparty obj_conv;
35668 obj_conv.inner = untag_ptr(obj);
35669 obj_conv.is_owned = ptr_is_owned(obj);
35670 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35671 obj_conv.is_owned = false;
35672 LDKCVec_u8Z ret_var = ChannelCounterparty_write(&obj_conv);
35673 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35674 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35675 CVec_u8Z_free(ret_var);
35679 uint64_t __attribute__((export_name("TS_ChannelCounterparty_read"))) TS_ChannelCounterparty_read(int8_tArray ser) {
35680 LDKu8slice ser_ref;
35681 ser_ref.datalen = ser->arr_len;
35682 ser_ref.data = ser->elems;
35683 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
35684 *ret_conv = ChannelCounterparty_read(ser_ref);
35686 return tag_ptr(ret_conv, true);
35689 int8_tArray __attribute__((export_name("TS_ChannelDetails_write"))) TS_ChannelDetails_write(uint64_t obj) {
35690 LDKChannelDetails obj_conv;
35691 obj_conv.inner = untag_ptr(obj);
35692 obj_conv.is_owned = ptr_is_owned(obj);
35693 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35694 obj_conv.is_owned = false;
35695 LDKCVec_u8Z ret_var = ChannelDetails_write(&obj_conv);
35696 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35697 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35698 CVec_u8Z_free(ret_var);
35702 uint64_t __attribute__((export_name("TS_ChannelDetails_read"))) TS_ChannelDetails_read(int8_tArray ser) {
35703 LDKu8slice ser_ref;
35704 ser_ref.datalen = ser->arr_len;
35705 ser_ref.data = ser->elems;
35706 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
35707 *ret_conv = ChannelDetails_read(ser_ref);
35709 return tag_ptr(ret_conv, true);
35712 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_write"))) TS_PhantomRouteHints_write(uint64_t obj) {
35713 LDKPhantomRouteHints obj_conv;
35714 obj_conv.inner = untag_ptr(obj);
35715 obj_conv.is_owned = ptr_is_owned(obj);
35716 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35717 obj_conv.is_owned = false;
35718 LDKCVec_u8Z ret_var = PhantomRouteHints_write(&obj_conv);
35719 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35720 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35721 CVec_u8Z_free(ret_var);
35725 uint64_t __attribute__((export_name("TS_PhantomRouteHints_read"))) TS_PhantomRouteHints_read(int8_tArray ser) {
35726 LDKu8slice ser_ref;
35727 ser_ref.datalen = ser->arr_len;
35728 ser_ref.data = ser->elems;
35729 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
35730 *ret_conv = PhantomRouteHints_read(ser_ref);
35732 return tag_ptr(ret_conv, true);
35735 int8_tArray __attribute__((export_name("TS_ChannelManager_write"))) TS_ChannelManager_write(uint64_t obj) {
35736 LDKChannelManager obj_conv;
35737 obj_conv.inner = untag_ptr(obj);
35738 obj_conv.is_owned = ptr_is_owned(obj);
35739 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35740 obj_conv.is_owned = false;
35741 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
35742 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35743 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35744 CVec_u8Z_free(ret_var);
35748 int8_tArray __attribute__((export_name("TS_ChannelShutdownState_write"))) TS_ChannelShutdownState_write(uint64_t obj) {
35749 LDKChannelShutdownState* obj_conv = (LDKChannelShutdownState*)untag_ptr(obj);
35750 LDKCVec_u8Z ret_var = ChannelShutdownState_write(obj_conv);
35751 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35752 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35753 CVec_u8Z_free(ret_var);
35757 uint64_t __attribute__((export_name("TS_ChannelShutdownState_read"))) TS_ChannelShutdownState_read(int8_tArray ser) {
35758 LDKu8slice ser_ref;
35759 ser_ref.datalen = ser->arr_len;
35760 ser_ref.data = ser->elems;
35761 LDKCResult_ChannelShutdownStateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelShutdownStateDecodeErrorZ), "LDKCResult_ChannelShutdownStateDecodeErrorZ");
35762 *ret_conv = ChannelShutdownState_read(ser_ref);
35764 return tag_ptr(ret_conv, true);
35767 void __attribute__((export_name("TS_ChannelManagerReadArgs_free"))) TS_ChannelManagerReadArgs_free(uint64_t this_obj) {
35768 LDKChannelManagerReadArgs this_obj_conv;
35769 this_obj_conv.inner = untag_ptr(this_obj);
35770 this_obj_conv.is_owned = ptr_is_owned(this_obj);
35771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35772 ChannelManagerReadArgs_free(this_obj_conv);
35775 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_entropy_source"))) TS_ChannelManagerReadArgs_get_entropy_source(uint64_t this_ptr) {
35776 LDKChannelManagerReadArgs this_ptr_conv;
35777 this_ptr_conv.inner = untag_ptr(this_ptr);
35778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35780 this_ptr_conv.is_owned = false;
35781 // WARNING: This object doesn't live past this scope, needs clone!
35782 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_entropy_source(&this_ptr_conv), false);
35786 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_entropy_source"))) TS_ChannelManagerReadArgs_set_entropy_source(uint64_t this_ptr, uint64_t val) {
35787 LDKChannelManagerReadArgs this_ptr_conv;
35788 this_ptr_conv.inner = untag_ptr(this_ptr);
35789 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35790 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35791 this_ptr_conv.is_owned = false;
35792 void* val_ptr = untag_ptr(val);
35793 CHECK_ACCESS(val_ptr);
35794 LDKEntropySource val_conv = *(LDKEntropySource*)(val_ptr);
35795 if (val_conv.free == LDKEntropySource_JCalls_free) {
35796 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35797 LDKEntropySource_JCalls_cloned(&val_conv);
35799 ChannelManagerReadArgs_set_entropy_source(&this_ptr_conv, val_conv);
35802 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_node_signer"))) TS_ChannelManagerReadArgs_get_node_signer(uint64_t this_ptr) {
35803 LDKChannelManagerReadArgs this_ptr_conv;
35804 this_ptr_conv.inner = untag_ptr(this_ptr);
35805 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35807 this_ptr_conv.is_owned = false;
35808 // WARNING: This object doesn't live past this scope, needs clone!
35809 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_node_signer(&this_ptr_conv), false);
35813 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_node_signer"))) TS_ChannelManagerReadArgs_set_node_signer(uint64_t this_ptr, uint64_t val) {
35814 LDKChannelManagerReadArgs this_ptr_conv;
35815 this_ptr_conv.inner = untag_ptr(this_ptr);
35816 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35818 this_ptr_conv.is_owned = false;
35819 void* val_ptr = untag_ptr(val);
35820 CHECK_ACCESS(val_ptr);
35821 LDKNodeSigner val_conv = *(LDKNodeSigner*)(val_ptr);
35822 if (val_conv.free == LDKNodeSigner_JCalls_free) {
35823 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35824 LDKNodeSigner_JCalls_cloned(&val_conv);
35826 ChannelManagerReadArgs_set_node_signer(&this_ptr_conv, val_conv);
35829 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_signer_provider"))) TS_ChannelManagerReadArgs_get_signer_provider(uint64_t this_ptr) {
35830 LDKChannelManagerReadArgs this_ptr_conv;
35831 this_ptr_conv.inner = untag_ptr(this_ptr);
35832 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35834 this_ptr_conv.is_owned = false;
35835 // WARNING: This object doesn't live past this scope, needs clone!
35836 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_signer_provider(&this_ptr_conv), false);
35840 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_signer_provider"))) TS_ChannelManagerReadArgs_set_signer_provider(uint64_t this_ptr, uint64_t val) {
35841 LDKChannelManagerReadArgs this_ptr_conv;
35842 this_ptr_conv.inner = untag_ptr(this_ptr);
35843 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35844 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35845 this_ptr_conv.is_owned = false;
35846 void* val_ptr = untag_ptr(val);
35847 CHECK_ACCESS(val_ptr);
35848 LDKSignerProvider val_conv = *(LDKSignerProvider*)(val_ptr);
35849 if (val_conv.free == LDKSignerProvider_JCalls_free) {
35850 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35851 LDKSignerProvider_JCalls_cloned(&val_conv);
35853 ChannelManagerReadArgs_set_signer_provider(&this_ptr_conv, val_conv);
35856 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_fee_estimator"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint64_t this_ptr) {
35857 LDKChannelManagerReadArgs this_ptr_conv;
35858 this_ptr_conv.inner = untag_ptr(this_ptr);
35859 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35861 this_ptr_conv.is_owned = false;
35862 // WARNING: This object doesn't live past this scope, needs clone!
35863 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv), false);
35867 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_fee_estimator"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint64_t this_ptr, uint64_t val) {
35868 LDKChannelManagerReadArgs this_ptr_conv;
35869 this_ptr_conv.inner = untag_ptr(this_ptr);
35870 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35872 this_ptr_conv.is_owned = false;
35873 void* val_ptr = untag_ptr(val);
35874 CHECK_ACCESS(val_ptr);
35875 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
35876 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
35877 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35878 LDKFeeEstimator_JCalls_cloned(&val_conv);
35880 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
35883 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_chain_monitor"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint64_t this_ptr) {
35884 LDKChannelManagerReadArgs 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 // WARNING: This object doesn't live past this scope, needs clone!
35890 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv), false);
35894 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_chain_monitor"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint64_t this_ptr, uint64_t val) {
35895 LDKChannelManagerReadArgs this_ptr_conv;
35896 this_ptr_conv.inner = untag_ptr(this_ptr);
35897 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35899 this_ptr_conv.is_owned = false;
35900 void* val_ptr = untag_ptr(val);
35901 CHECK_ACCESS(val_ptr);
35902 LDKWatch val_conv = *(LDKWatch*)(val_ptr);
35903 if (val_conv.free == LDKWatch_JCalls_free) {
35904 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35905 LDKWatch_JCalls_cloned(&val_conv);
35907 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
35910 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_tx_broadcaster"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint64_t this_ptr) {
35911 LDKChannelManagerReadArgs this_ptr_conv;
35912 this_ptr_conv.inner = untag_ptr(this_ptr);
35913 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35915 this_ptr_conv.is_owned = false;
35916 // WARNING: This object doesn't live past this scope, needs clone!
35917 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv), false);
35921 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_tx_broadcaster"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint64_t this_ptr, uint64_t val) {
35922 LDKChannelManagerReadArgs this_ptr_conv;
35923 this_ptr_conv.inner = untag_ptr(this_ptr);
35924 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35926 this_ptr_conv.is_owned = false;
35927 void* val_ptr = untag_ptr(val);
35928 CHECK_ACCESS(val_ptr);
35929 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
35930 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
35931 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35932 LDKBroadcasterInterface_JCalls_cloned(&val_conv);
35934 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
35937 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_router"))) TS_ChannelManagerReadArgs_get_router(uint64_t this_ptr) {
35938 LDKChannelManagerReadArgs this_ptr_conv;
35939 this_ptr_conv.inner = untag_ptr(this_ptr);
35940 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35942 this_ptr_conv.is_owned = false;
35943 // WARNING: This object doesn't live past this scope, needs clone!
35944 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_router(&this_ptr_conv), false);
35948 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_router"))) TS_ChannelManagerReadArgs_set_router(uint64_t this_ptr, uint64_t val) {
35949 LDKChannelManagerReadArgs this_ptr_conv;
35950 this_ptr_conv.inner = untag_ptr(this_ptr);
35951 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35953 this_ptr_conv.is_owned = false;
35954 void* val_ptr = untag_ptr(val);
35955 CHECK_ACCESS(val_ptr);
35956 LDKRouter val_conv = *(LDKRouter*)(val_ptr);
35957 if (val_conv.free == LDKRouter_JCalls_free) {
35958 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35959 LDKRouter_JCalls_cloned(&val_conv);
35961 ChannelManagerReadArgs_set_router(&this_ptr_conv, val_conv);
35964 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_logger"))) TS_ChannelManagerReadArgs_get_logger(uint64_t this_ptr) {
35965 LDKChannelManagerReadArgs this_ptr_conv;
35966 this_ptr_conv.inner = untag_ptr(this_ptr);
35967 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35969 this_ptr_conv.is_owned = false;
35970 // WARNING: This object doesn't live past this scope, needs clone!
35971 uint64_t ret_ret = tag_ptr(ChannelManagerReadArgs_get_logger(&this_ptr_conv), false);
35975 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_logger"))) TS_ChannelManagerReadArgs_set_logger(uint64_t this_ptr, uint64_t val) {
35976 LDKChannelManagerReadArgs this_ptr_conv;
35977 this_ptr_conv.inner = untag_ptr(this_ptr);
35978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35980 this_ptr_conv.is_owned = false;
35981 void* val_ptr = untag_ptr(val);
35982 CHECK_ACCESS(val_ptr);
35983 LDKLogger val_conv = *(LDKLogger*)(val_ptr);
35984 if (val_conv.free == LDKLogger_JCalls_free) {
35985 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
35986 LDKLogger_JCalls_cloned(&val_conv);
35988 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
35991 uint64_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_default_config"))) TS_ChannelManagerReadArgs_get_default_config(uint64_t this_ptr) {
35992 LDKChannelManagerReadArgs this_ptr_conv;
35993 this_ptr_conv.inner = untag_ptr(this_ptr);
35994 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
35995 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35996 this_ptr_conv.is_owned = false;
35997 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
35998 uint64_t ret_ref = 0;
35999 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36000 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36004 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_default_config"))) TS_ChannelManagerReadArgs_set_default_config(uint64_t this_ptr, uint64_t val) {
36005 LDKChannelManagerReadArgs this_ptr_conv;
36006 this_ptr_conv.inner = untag_ptr(this_ptr);
36007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36009 this_ptr_conv.is_owned = false;
36010 LDKUserConfig val_conv;
36011 val_conv.inner = untag_ptr(val);
36012 val_conv.is_owned = ptr_is_owned(val);
36013 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36014 val_conv = UserConfig_clone(&val_conv);
36015 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
36018 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) {
36019 void* entropy_source_ptr = untag_ptr(entropy_source);
36020 CHECK_ACCESS(entropy_source_ptr);
36021 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
36022 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
36023 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36024 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
36026 void* node_signer_ptr = untag_ptr(node_signer);
36027 CHECK_ACCESS(node_signer_ptr);
36028 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
36029 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
36030 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36031 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
36033 void* signer_provider_ptr = untag_ptr(signer_provider);
36034 CHECK_ACCESS(signer_provider_ptr);
36035 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
36036 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
36037 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36038 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
36040 void* fee_estimator_ptr = untag_ptr(fee_estimator);
36041 CHECK_ACCESS(fee_estimator_ptr);
36042 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
36043 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
36044 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36045 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
36047 void* chain_monitor_ptr = untag_ptr(chain_monitor);
36048 CHECK_ACCESS(chain_monitor_ptr);
36049 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
36050 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
36051 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36052 LDKWatch_JCalls_cloned(&chain_monitor_conv);
36054 void* tx_broadcaster_ptr = untag_ptr(tx_broadcaster);
36055 CHECK_ACCESS(tx_broadcaster_ptr);
36056 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
36057 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
36058 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36059 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
36061 void* router_ptr = untag_ptr(router);
36062 CHECK_ACCESS(router_ptr);
36063 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
36064 if (router_conv.free == LDKRouter_JCalls_free) {
36065 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36066 LDKRouter_JCalls_cloned(&router_conv);
36068 void* logger_ptr = untag_ptr(logger);
36069 CHECK_ACCESS(logger_ptr);
36070 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
36071 if (logger_conv.free == LDKLogger_JCalls_free) {
36072 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
36073 LDKLogger_JCalls_cloned(&logger_conv);
36075 LDKUserConfig default_config_conv;
36076 default_config_conv.inner = untag_ptr(default_config);
36077 default_config_conv.is_owned = ptr_is_owned(default_config);
36078 CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
36079 default_config_conv = UserConfig_clone(&default_config_conv);
36080 LDKCVec_ChannelMonitorZ channel_monitors_constr;
36081 channel_monitors_constr.datalen = channel_monitors->arr_len;
36082 if (channel_monitors_constr.datalen > 0)
36083 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
36085 channel_monitors_constr.data = NULL;
36086 uint64_t* channel_monitors_vals = channel_monitors->elems;
36087 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
36088 uint64_t channel_monitors_conv_16 = channel_monitors_vals[q];
36089 LDKChannelMonitor channel_monitors_conv_16_conv;
36090 channel_monitors_conv_16_conv.inner = untag_ptr(channel_monitors_conv_16);
36091 channel_monitors_conv_16_conv.is_owned = ptr_is_owned(channel_monitors_conv_16);
36092 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
36093 channel_monitors_conv_16_conv.is_owned = false;
36094 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
36096 FREE(channel_monitors);
36097 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);
36098 uint64_t ret_ref = 0;
36099 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36100 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36104 uint64_t __attribute__((export_name("TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read"))) TS_C2Tuple_ThirtyTwoBytesChannelManagerZ_read(int8_tArray ser, uint64_t arg) {
36105 LDKu8slice ser_ref;
36106 ser_ref.datalen = ser->arr_len;
36107 ser_ref.data = ser->elems;
36108 LDKChannelManagerReadArgs arg_conv;
36109 arg_conv.inner = untag_ptr(arg);
36110 arg_conv.is_owned = ptr_is_owned(arg);
36111 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36112 // WARNING: we need a move here but no clone is available for LDKChannelManagerReadArgs
36114 LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_ThirtyTwoBytesChannelManagerZDecodeErrorZ");
36115 *ret_conv = C2Tuple_ThirtyTwoBytesChannelManagerZ_read(ser_ref, arg_conv);
36117 return tag_ptr(ret_conv, true);
36120 void __attribute__((export_name("TS_ExpandedKey_free"))) TS_ExpandedKey_free(uint64_t this_obj) {
36121 LDKExpandedKey this_obj_conv;
36122 this_obj_conv.inner = untag_ptr(this_obj);
36123 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36125 ExpandedKey_free(this_obj_conv);
36128 uint64_t __attribute__((export_name("TS_ExpandedKey_new"))) TS_ExpandedKey_new(int8_tArray key_material) {
36129 uint8_t key_material_arr[32];
36130 CHECK(key_material->arr_len == 32);
36131 memcpy(key_material_arr, key_material->elems, 32); FREE(key_material);
36132 uint8_t (*key_material_ref)[32] = &key_material_arr;
36133 LDKExpandedKey ret_var = ExpandedKey_new(key_material_ref);
36134 uint64_t ret_ref = 0;
36135 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36136 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36140 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) {
36141 LDKExpandedKey keys_conv;
36142 keys_conv.inner = untag_ptr(keys);
36143 keys_conv.is_owned = ptr_is_owned(keys);
36144 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
36145 keys_conv.is_owned = false;
36146 void* min_value_msat_ptr = untag_ptr(min_value_msat);
36147 CHECK_ACCESS(min_value_msat_ptr);
36148 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
36149 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
36150 void* entropy_source_ptr = untag_ptr(entropy_source);
36151 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
36152 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
36153 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
36154 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
36155 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
36156 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
36157 LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ), "LDKCResult_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZNoneZ");
36158 *ret_conv = create(&keys_conv, min_value_msat_conv, invoice_expiry_delta_secs, entropy_source_conv, current_time, min_final_cltv_expiry_delta_conv);
36159 return tag_ptr(ret_conv, true);
36162 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) {
36163 LDKExpandedKey keys_conv;
36164 keys_conv.inner = untag_ptr(keys);
36165 keys_conv.is_owned = ptr_is_owned(keys);
36166 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
36167 keys_conv.is_owned = false;
36168 void* min_value_msat_ptr = untag_ptr(min_value_msat);
36169 CHECK_ACCESS(min_value_msat_ptr);
36170 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
36171 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(min_value_msat));
36172 LDKThirtyTwoBytes payment_hash_ref;
36173 CHECK(payment_hash->arr_len == 32);
36174 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
36175 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
36176 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
36177 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
36178 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
36179 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
36180 *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);
36181 return tag_ptr(ret_conv, true);
36184 void __attribute__((export_name("TS_DecodeError_free"))) TS_DecodeError_free(uint64_t this_ptr) {
36185 if (!ptr_is_owned(this_ptr)) return;
36186 void* this_ptr_ptr = untag_ptr(this_ptr);
36187 CHECK_ACCESS(this_ptr_ptr);
36188 LDKDecodeError this_ptr_conv = *(LDKDecodeError*)(this_ptr_ptr);
36189 FREE(untag_ptr(this_ptr));
36190 DecodeError_free(this_ptr_conv);
36193 static inline uint64_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
36194 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36195 *ret_copy = DecodeError_clone(arg);
36196 uint64_t ret_ref = tag_ptr(ret_copy, true);
36199 int64_t __attribute__((export_name("TS_DecodeError_clone_ptr"))) TS_DecodeError_clone_ptr(uint64_t arg) {
36200 LDKDecodeError* arg_conv = (LDKDecodeError*)untag_ptr(arg);
36201 int64_t ret_conv = DecodeError_clone_ptr(arg_conv);
36205 uint64_t __attribute__((export_name("TS_DecodeError_clone"))) TS_DecodeError_clone(uint64_t orig) {
36206 LDKDecodeError* orig_conv = (LDKDecodeError*)untag_ptr(orig);
36207 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36208 *ret_copy = DecodeError_clone(orig_conv);
36209 uint64_t ret_ref = tag_ptr(ret_copy, true);
36213 uint64_t __attribute__((export_name("TS_DecodeError_unknown_version"))) TS_DecodeError_unknown_version() {
36214 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36215 *ret_copy = DecodeError_unknown_version();
36216 uint64_t ret_ref = tag_ptr(ret_copy, true);
36220 uint64_t __attribute__((export_name("TS_DecodeError_unknown_required_feature"))) TS_DecodeError_unknown_required_feature() {
36221 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36222 *ret_copy = DecodeError_unknown_required_feature();
36223 uint64_t ret_ref = tag_ptr(ret_copy, true);
36227 uint64_t __attribute__((export_name("TS_DecodeError_invalid_value"))) TS_DecodeError_invalid_value() {
36228 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36229 *ret_copy = DecodeError_invalid_value();
36230 uint64_t ret_ref = tag_ptr(ret_copy, true);
36234 uint64_t __attribute__((export_name("TS_DecodeError_short_read"))) TS_DecodeError_short_read() {
36235 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36236 *ret_copy = DecodeError_short_read();
36237 uint64_t ret_ref = tag_ptr(ret_copy, true);
36241 uint64_t __attribute__((export_name("TS_DecodeError_bad_length_descriptor"))) TS_DecodeError_bad_length_descriptor() {
36242 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36243 *ret_copy = DecodeError_bad_length_descriptor();
36244 uint64_t ret_ref = tag_ptr(ret_copy, true);
36248 uint64_t __attribute__((export_name("TS_DecodeError_io"))) TS_DecodeError_io(uint32_t a) {
36249 LDKIOError a_conv = LDKIOError_from_js(a);
36250 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36251 *ret_copy = DecodeError_io(a_conv);
36252 uint64_t ret_ref = tag_ptr(ret_copy, true);
36256 uint64_t __attribute__((export_name("TS_DecodeError_unsupported_compression"))) TS_DecodeError_unsupported_compression() {
36257 LDKDecodeError *ret_copy = MALLOC(sizeof(LDKDecodeError), "LDKDecodeError");
36258 *ret_copy = DecodeError_unsupported_compression();
36259 uint64_t ret_ref = tag_ptr(ret_copy, true);
36263 jboolean __attribute__((export_name("TS_DecodeError_eq"))) TS_DecodeError_eq(uint64_t a, uint64_t b) {
36264 LDKDecodeError* a_conv = (LDKDecodeError*)untag_ptr(a);
36265 LDKDecodeError* b_conv = (LDKDecodeError*)untag_ptr(b);
36266 jboolean ret_conv = DecodeError_eq(a_conv, b_conv);
36270 void __attribute__((export_name("TS_Init_free"))) TS_Init_free(uint64_t this_obj) {
36271 LDKInit this_obj_conv;
36272 this_obj_conv.inner = untag_ptr(this_obj);
36273 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36274 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36275 Init_free(this_obj_conv);
36278 uint64_t __attribute__((export_name("TS_Init_get_features"))) TS_Init_get_features(uint64_t this_ptr) {
36279 LDKInit this_ptr_conv;
36280 this_ptr_conv.inner = untag_ptr(this_ptr);
36281 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36283 this_ptr_conv.is_owned = false;
36284 LDKInitFeatures ret_var = Init_get_features(&this_ptr_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 void __attribute__((export_name("TS_Init_set_features"))) TS_Init_set_features(uint64_t this_ptr, uint64_t val) {
36292 LDKInit this_ptr_conv;
36293 this_ptr_conv.inner = untag_ptr(this_ptr);
36294 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36295 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36296 this_ptr_conv.is_owned = false;
36297 LDKInitFeatures val_conv;
36298 val_conv.inner = untag_ptr(val);
36299 val_conv.is_owned = ptr_is_owned(val);
36300 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36301 val_conv = InitFeatures_clone(&val_conv);
36302 Init_set_features(&this_ptr_conv, val_conv);
36305 uint64_t __attribute__((export_name("TS_Init_get_networks"))) TS_Init_get_networks(uint64_t this_ptr) {
36306 LDKInit this_ptr_conv;
36307 this_ptr_conv.inner = untag_ptr(this_ptr);
36308 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36310 this_ptr_conv.is_owned = false;
36311 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
36312 *ret_copy = Init_get_networks(&this_ptr_conv);
36313 uint64_t ret_ref = tag_ptr(ret_copy, true);
36317 void __attribute__((export_name("TS_Init_set_networks"))) TS_Init_set_networks(uint64_t this_ptr, uint64_t val) {
36318 LDKInit this_ptr_conv;
36319 this_ptr_conv.inner = untag_ptr(this_ptr);
36320 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36322 this_ptr_conv.is_owned = false;
36323 void* val_ptr = untag_ptr(val);
36324 CHECK_ACCESS(val_ptr);
36325 LDKCOption_CVec_ThirtyTwoBytesZZ val_conv = *(LDKCOption_CVec_ThirtyTwoBytesZZ*)(val_ptr);
36326 val_conv = COption_CVec_ThirtyTwoBytesZZ_clone((LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(val));
36327 Init_set_networks(&this_ptr_conv, val_conv);
36330 uint64_t __attribute__((export_name("TS_Init_get_remote_network_address"))) TS_Init_get_remote_network_address(uint64_t this_ptr) {
36331 LDKInit this_ptr_conv;
36332 this_ptr_conv.inner = untag_ptr(this_ptr);
36333 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36335 this_ptr_conv.is_owned = false;
36336 LDKCOption_SocketAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_SocketAddressZ), "LDKCOption_SocketAddressZ");
36337 *ret_copy = Init_get_remote_network_address(&this_ptr_conv);
36338 uint64_t ret_ref = tag_ptr(ret_copy, true);
36342 void __attribute__((export_name("TS_Init_set_remote_network_address"))) TS_Init_set_remote_network_address(uint64_t this_ptr, uint64_t val) {
36343 LDKInit this_ptr_conv;
36344 this_ptr_conv.inner = untag_ptr(this_ptr);
36345 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36346 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36347 this_ptr_conv.is_owned = false;
36348 void* val_ptr = untag_ptr(val);
36349 CHECK_ACCESS(val_ptr);
36350 LDKCOption_SocketAddressZ val_conv = *(LDKCOption_SocketAddressZ*)(val_ptr);
36351 val_conv = COption_SocketAddressZ_clone((LDKCOption_SocketAddressZ*)untag_ptr(val));
36352 Init_set_remote_network_address(&this_ptr_conv, val_conv);
36355 uint64_t __attribute__((export_name("TS_Init_new"))) TS_Init_new(uint64_t features_arg, uint64_t networks_arg, uint64_t remote_network_address_arg) {
36356 LDKInitFeatures features_arg_conv;
36357 features_arg_conv.inner = untag_ptr(features_arg);
36358 features_arg_conv.is_owned = ptr_is_owned(features_arg);
36359 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
36360 features_arg_conv = InitFeatures_clone(&features_arg_conv);
36361 void* networks_arg_ptr = untag_ptr(networks_arg);
36362 CHECK_ACCESS(networks_arg_ptr);
36363 LDKCOption_CVec_ThirtyTwoBytesZZ networks_arg_conv = *(LDKCOption_CVec_ThirtyTwoBytesZZ*)(networks_arg_ptr);
36364 networks_arg_conv = COption_CVec_ThirtyTwoBytesZZ_clone((LDKCOption_CVec_ThirtyTwoBytesZZ*)untag_ptr(networks_arg));
36365 void* remote_network_address_arg_ptr = untag_ptr(remote_network_address_arg);
36366 CHECK_ACCESS(remote_network_address_arg_ptr);
36367 LDKCOption_SocketAddressZ remote_network_address_arg_conv = *(LDKCOption_SocketAddressZ*)(remote_network_address_arg_ptr);
36368 LDKInit ret_var = Init_new(features_arg_conv, networks_arg_conv, remote_network_address_arg_conv);
36369 uint64_t ret_ref = 0;
36370 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36371 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36375 static inline uint64_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
36376 LDKInit ret_var = Init_clone(arg);
36377 uint64_t ret_ref = 0;
36378 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36379 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36382 int64_t __attribute__((export_name("TS_Init_clone_ptr"))) TS_Init_clone_ptr(uint64_t arg) {
36384 arg_conv.inner = untag_ptr(arg);
36385 arg_conv.is_owned = ptr_is_owned(arg);
36386 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36387 arg_conv.is_owned = false;
36388 int64_t ret_conv = Init_clone_ptr(&arg_conv);
36392 uint64_t __attribute__((export_name("TS_Init_clone"))) TS_Init_clone(uint64_t orig) {
36394 orig_conv.inner = untag_ptr(orig);
36395 orig_conv.is_owned = ptr_is_owned(orig);
36396 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36397 orig_conv.is_owned = false;
36398 LDKInit ret_var = Init_clone(&orig_conv);
36399 uint64_t ret_ref = 0;
36400 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36401 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36405 jboolean __attribute__((export_name("TS_Init_eq"))) TS_Init_eq(uint64_t a, uint64_t b) {
36407 a_conv.inner = untag_ptr(a);
36408 a_conv.is_owned = ptr_is_owned(a);
36409 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36410 a_conv.is_owned = false;
36412 b_conv.inner = untag_ptr(b);
36413 b_conv.is_owned = ptr_is_owned(b);
36414 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36415 b_conv.is_owned = false;
36416 jboolean ret_conv = Init_eq(&a_conv, &b_conv);
36420 void __attribute__((export_name("TS_ErrorMessage_free"))) TS_ErrorMessage_free(uint64_t this_obj) {
36421 LDKErrorMessage this_obj_conv;
36422 this_obj_conv.inner = untag_ptr(this_obj);
36423 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36425 ErrorMessage_free(this_obj_conv);
36428 int8_tArray __attribute__((export_name("TS_ErrorMessage_get_channel_id"))) TS_ErrorMessage_get_channel_id(uint64_t this_ptr) {
36429 LDKErrorMessage this_ptr_conv;
36430 this_ptr_conv.inner = untag_ptr(this_ptr);
36431 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36433 this_ptr_conv.is_owned = false;
36434 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36435 memcpy(ret_arr->elems, *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
36439 void __attribute__((export_name("TS_ErrorMessage_set_channel_id"))) TS_ErrorMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
36440 LDKErrorMessage this_ptr_conv;
36441 this_ptr_conv.inner = untag_ptr(this_ptr);
36442 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36444 this_ptr_conv.is_owned = false;
36445 LDKThirtyTwoBytes val_ref;
36446 CHECK(val->arr_len == 32);
36447 memcpy(val_ref.data, val->elems, 32); FREE(val);
36448 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
36451 jstring __attribute__((export_name("TS_ErrorMessage_get_data"))) TS_ErrorMessage_get_data(uint64_t this_ptr) {
36452 LDKErrorMessage this_ptr_conv;
36453 this_ptr_conv.inner = untag_ptr(this_ptr);
36454 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36456 this_ptr_conv.is_owned = false;
36457 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
36458 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
36463 void __attribute__((export_name("TS_ErrorMessage_set_data"))) TS_ErrorMessage_set_data(uint64_t this_ptr, jstring val) {
36464 LDKErrorMessage this_ptr_conv;
36465 this_ptr_conv.inner = untag_ptr(this_ptr);
36466 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36468 this_ptr_conv.is_owned = false;
36469 LDKStr val_conv = str_ref_to_owned_c(val);
36470 ErrorMessage_set_data(&this_ptr_conv, val_conv);
36473 uint64_t __attribute__((export_name("TS_ErrorMessage_new"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
36474 LDKThirtyTwoBytes channel_id_arg_ref;
36475 CHECK(channel_id_arg->arr_len == 32);
36476 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
36477 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
36478 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
36479 uint64_t ret_ref = 0;
36480 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36481 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36485 static inline uint64_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
36486 LDKErrorMessage ret_var = ErrorMessage_clone(arg);
36487 uint64_t ret_ref = 0;
36488 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36489 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36492 int64_t __attribute__((export_name("TS_ErrorMessage_clone_ptr"))) TS_ErrorMessage_clone_ptr(uint64_t arg) {
36493 LDKErrorMessage arg_conv;
36494 arg_conv.inner = untag_ptr(arg);
36495 arg_conv.is_owned = ptr_is_owned(arg);
36496 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36497 arg_conv.is_owned = false;
36498 int64_t ret_conv = ErrorMessage_clone_ptr(&arg_conv);
36502 uint64_t __attribute__((export_name("TS_ErrorMessage_clone"))) TS_ErrorMessage_clone(uint64_t orig) {
36503 LDKErrorMessage orig_conv;
36504 orig_conv.inner = untag_ptr(orig);
36505 orig_conv.is_owned = ptr_is_owned(orig);
36506 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36507 orig_conv.is_owned = false;
36508 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
36509 uint64_t ret_ref = 0;
36510 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36511 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36515 jboolean __attribute__((export_name("TS_ErrorMessage_eq"))) TS_ErrorMessage_eq(uint64_t a, uint64_t b) {
36516 LDKErrorMessage a_conv;
36517 a_conv.inner = untag_ptr(a);
36518 a_conv.is_owned = ptr_is_owned(a);
36519 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36520 a_conv.is_owned = false;
36521 LDKErrorMessage b_conv;
36522 b_conv.inner = untag_ptr(b);
36523 b_conv.is_owned = ptr_is_owned(b);
36524 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36525 b_conv.is_owned = false;
36526 jboolean ret_conv = ErrorMessage_eq(&a_conv, &b_conv);
36530 void __attribute__((export_name("TS_WarningMessage_free"))) TS_WarningMessage_free(uint64_t this_obj) {
36531 LDKWarningMessage this_obj_conv;
36532 this_obj_conv.inner = untag_ptr(this_obj);
36533 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36535 WarningMessage_free(this_obj_conv);
36538 int8_tArray __attribute__((export_name("TS_WarningMessage_get_channel_id"))) TS_WarningMessage_get_channel_id(uint64_t this_ptr) {
36539 LDKWarningMessage this_ptr_conv;
36540 this_ptr_conv.inner = untag_ptr(this_ptr);
36541 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36542 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36543 this_ptr_conv.is_owned = false;
36544 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36545 memcpy(ret_arr->elems, *WarningMessage_get_channel_id(&this_ptr_conv), 32);
36549 void __attribute__((export_name("TS_WarningMessage_set_channel_id"))) TS_WarningMessage_set_channel_id(uint64_t this_ptr, int8_tArray val) {
36550 LDKWarningMessage this_ptr_conv;
36551 this_ptr_conv.inner = untag_ptr(this_ptr);
36552 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36554 this_ptr_conv.is_owned = false;
36555 LDKThirtyTwoBytes val_ref;
36556 CHECK(val->arr_len == 32);
36557 memcpy(val_ref.data, val->elems, 32); FREE(val);
36558 WarningMessage_set_channel_id(&this_ptr_conv, val_ref);
36561 jstring __attribute__((export_name("TS_WarningMessage_get_data"))) TS_WarningMessage_get_data(uint64_t this_ptr) {
36562 LDKWarningMessage this_ptr_conv;
36563 this_ptr_conv.inner = untag_ptr(this_ptr);
36564 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36566 this_ptr_conv.is_owned = false;
36567 LDKStr ret_str = WarningMessage_get_data(&this_ptr_conv);
36568 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
36573 void __attribute__((export_name("TS_WarningMessage_set_data"))) TS_WarningMessage_set_data(uint64_t this_ptr, jstring val) {
36574 LDKWarningMessage this_ptr_conv;
36575 this_ptr_conv.inner = untag_ptr(this_ptr);
36576 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36578 this_ptr_conv.is_owned = false;
36579 LDKStr val_conv = str_ref_to_owned_c(val);
36580 WarningMessage_set_data(&this_ptr_conv, val_conv);
36583 uint64_t __attribute__((export_name("TS_WarningMessage_new"))) TS_WarningMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
36584 LDKThirtyTwoBytes channel_id_arg_ref;
36585 CHECK(channel_id_arg->arr_len == 32);
36586 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
36587 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
36588 LDKWarningMessage ret_var = WarningMessage_new(channel_id_arg_ref, data_arg_conv);
36589 uint64_t ret_ref = 0;
36590 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36591 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36595 static inline uint64_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg) {
36596 LDKWarningMessage ret_var = WarningMessage_clone(arg);
36597 uint64_t ret_ref = 0;
36598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36599 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36602 int64_t __attribute__((export_name("TS_WarningMessage_clone_ptr"))) TS_WarningMessage_clone_ptr(uint64_t arg) {
36603 LDKWarningMessage arg_conv;
36604 arg_conv.inner = untag_ptr(arg);
36605 arg_conv.is_owned = ptr_is_owned(arg);
36606 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36607 arg_conv.is_owned = false;
36608 int64_t ret_conv = WarningMessage_clone_ptr(&arg_conv);
36612 uint64_t __attribute__((export_name("TS_WarningMessage_clone"))) TS_WarningMessage_clone(uint64_t orig) {
36613 LDKWarningMessage orig_conv;
36614 orig_conv.inner = untag_ptr(orig);
36615 orig_conv.is_owned = ptr_is_owned(orig);
36616 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36617 orig_conv.is_owned = false;
36618 LDKWarningMessage ret_var = WarningMessage_clone(&orig_conv);
36619 uint64_t ret_ref = 0;
36620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36621 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36625 jboolean __attribute__((export_name("TS_WarningMessage_eq"))) TS_WarningMessage_eq(uint64_t a, uint64_t b) {
36626 LDKWarningMessage a_conv;
36627 a_conv.inner = untag_ptr(a);
36628 a_conv.is_owned = ptr_is_owned(a);
36629 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36630 a_conv.is_owned = false;
36631 LDKWarningMessage b_conv;
36632 b_conv.inner = untag_ptr(b);
36633 b_conv.is_owned = ptr_is_owned(b);
36634 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36635 b_conv.is_owned = false;
36636 jboolean ret_conv = WarningMessage_eq(&a_conv, &b_conv);
36640 void __attribute__((export_name("TS_Ping_free"))) TS_Ping_free(uint64_t this_obj) {
36641 LDKPing this_obj_conv;
36642 this_obj_conv.inner = untag_ptr(this_obj);
36643 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36645 Ping_free(this_obj_conv);
36648 int16_t __attribute__((export_name("TS_Ping_get_ponglen"))) TS_Ping_get_ponglen(uint64_t this_ptr) {
36649 LDKPing this_ptr_conv;
36650 this_ptr_conv.inner = untag_ptr(this_ptr);
36651 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36653 this_ptr_conv.is_owned = false;
36654 int16_t ret_conv = Ping_get_ponglen(&this_ptr_conv);
36658 void __attribute__((export_name("TS_Ping_set_ponglen"))) TS_Ping_set_ponglen(uint64_t this_ptr, int16_t val) {
36659 LDKPing this_ptr_conv;
36660 this_ptr_conv.inner = untag_ptr(this_ptr);
36661 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36663 this_ptr_conv.is_owned = false;
36664 Ping_set_ponglen(&this_ptr_conv, val);
36667 int16_t __attribute__((export_name("TS_Ping_get_byteslen"))) TS_Ping_get_byteslen(uint64_t this_ptr) {
36668 LDKPing this_ptr_conv;
36669 this_ptr_conv.inner = untag_ptr(this_ptr);
36670 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36672 this_ptr_conv.is_owned = false;
36673 int16_t ret_conv = Ping_get_byteslen(&this_ptr_conv);
36677 void __attribute__((export_name("TS_Ping_set_byteslen"))) TS_Ping_set_byteslen(uint64_t this_ptr, int16_t val) {
36678 LDKPing this_ptr_conv;
36679 this_ptr_conv.inner = untag_ptr(this_ptr);
36680 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36681 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36682 this_ptr_conv.is_owned = false;
36683 Ping_set_byteslen(&this_ptr_conv, val);
36686 uint64_t __attribute__((export_name("TS_Ping_new"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
36687 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
36688 uint64_t ret_ref = 0;
36689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36694 static inline uint64_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
36695 LDKPing ret_var = Ping_clone(arg);
36696 uint64_t ret_ref = 0;
36697 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36698 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36701 int64_t __attribute__((export_name("TS_Ping_clone_ptr"))) TS_Ping_clone_ptr(uint64_t arg) {
36703 arg_conv.inner = untag_ptr(arg);
36704 arg_conv.is_owned = ptr_is_owned(arg);
36705 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36706 arg_conv.is_owned = false;
36707 int64_t ret_conv = Ping_clone_ptr(&arg_conv);
36711 uint64_t __attribute__((export_name("TS_Ping_clone"))) TS_Ping_clone(uint64_t orig) {
36713 orig_conv.inner = untag_ptr(orig);
36714 orig_conv.is_owned = ptr_is_owned(orig);
36715 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36716 orig_conv.is_owned = false;
36717 LDKPing ret_var = Ping_clone(&orig_conv);
36718 uint64_t ret_ref = 0;
36719 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36720 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36724 jboolean __attribute__((export_name("TS_Ping_eq"))) TS_Ping_eq(uint64_t a, uint64_t b) {
36726 a_conv.inner = untag_ptr(a);
36727 a_conv.is_owned = ptr_is_owned(a);
36728 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36729 a_conv.is_owned = false;
36731 b_conv.inner = untag_ptr(b);
36732 b_conv.is_owned = ptr_is_owned(b);
36733 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36734 b_conv.is_owned = false;
36735 jboolean ret_conv = Ping_eq(&a_conv, &b_conv);
36739 void __attribute__((export_name("TS_Pong_free"))) TS_Pong_free(uint64_t this_obj) {
36740 LDKPong this_obj_conv;
36741 this_obj_conv.inner = untag_ptr(this_obj);
36742 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36744 Pong_free(this_obj_conv);
36747 int16_t __attribute__((export_name("TS_Pong_get_byteslen"))) TS_Pong_get_byteslen(uint64_t this_ptr) {
36748 LDKPong this_ptr_conv;
36749 this_ptr_conv.inner = untag_ptr(this_ptr);
36750 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36752 this_ptr_conv.is_owned = false;
36753 int16_t ret_conv = Pong_get_byteslen(&this_ptr_conv);
36757 void __attribute__((export_name("TS_Pong_set_byteslen"))) TS_Pong_set_byteslen(uint64_t this_ptr, int16_t val) {
36758 LDKPong this_ptr_conv;
36759 this_ptr_conv.inner = untag_ptr(this_ptr);
36760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36762 this_ptr_conv.is_owned = false;
36763 Pong_set_byteslen(&this_ptr_conv, val);
36766 uint64_t __attribute__((export_name("TS_Pong_new"))) TS_Pong_new(int16_t byteslen_arg) {
36767 LDKPong ret_var = Pong_new(byteslen_arg);
36768 uint64_t ret_ref = 0;
36769 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36770 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36774 static inline uint64_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
36775 LDKPong ret_var = Pong_clone(arg);
36776 uint64_t ret_ref = 0;
36777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36781 int64_t __attribute__((export_name("TS_Pong_clone_ptr"))) TS_Pong_clone_ptr(uint64_t arg) {
36783 arg_conv.inner = untag_ptr(arg);
36784 arg_conv.is_owned = ptr_is_owned(arg);
36785 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36786 arg_conv.is_owned = false;
36787 int64_t ret_conv = Pong_clone_ptr(&arg_conv);
36791 uint64_t __attribute__((export_name("TS_Pong_clone"))) TS_Pong_clone(uint64_t orig) {
36793 orig_conv.inner = untag_ptr(orig);
36794 orig_conv.is_owned = ptr_is_owned(orig);
36795 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36796 orig_conv.is_owned = false;
36797 LDKPong ret_var = Pong_clone(&orig_conv);
36798 uint64_t ret_ref = 0;
36799 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36800 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
36804 jboolean __attribute__((export_name("TS_Pong_eq"))) TS_Pong_eq(uint64_t a, uint64_t b) {
36806 a_conv.inner = untag_ptr(a);
36807 a_conv.is_owned = ptr_is_owned(a);
36808 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
36809 a_conv.is_owned = false;
36811 b_conv.inner = untag_ptr(b);
36812 b_conv.is_owned = ptr_is_owned(b);
36813 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
36814 b_conv.is_owned = false;
36815 jboolean ret_conv = Pong_eq(&a_conv, &b_conv);
36819 void __attribute__((export_name("TS_OpenChannel_free"))) TS_OpenChannel_free(uint64_t this_obj) {
36820 LDKOpenChannel this_obj_conv;
36821 this_obj_conv.inner = untag_ptr(this_obj);
36822 this_obj_conv.is_owned = ptr_is_owned(this_obj);
36823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36824 OpenChannel_free(this_obj_conv);
36827 int8_tArray __attribute__((export_name("TS_OpenChannel_get_chain_hash"))) TS_OpenChannel_get_chain_hash(uint64_t this_ptr) {
36828 LDKOpenChannel this_ptr_conv;
36829 this_ptr_conv.inner = untag_ptr(this_ptr);
36830 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36832 this_ptr_conv.is_owned = false;
36833 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36834 memcpy(ret_arr->elems, *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
36838 void __attribute__((export_name("TS_OpenChannel_set_chain_hash"))) TS_OpenChannel_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
36839 LDKOpenChannel this_ptr_conv;
36840 this_ptr_conv.inner = untag_ptr(this_ptr);
36841 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36843 this_ptr_conv.is_owned = false;
36844 LDKThirtyTwoBytes val_ref;
36845 CHECK(val->arr_len == 32);
36846 memcpy(val_ref.data, val->elems, 32); FREE(val);
36847 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
36850 int8_tArray __attribute__((export_name("TS_OpenChannel_get_temporary_channel_id"))) TS_OpenChannel_get_temporary_channel_id(uint64_t this_ptr) {
36851 LDKOpenChannel this_ptr_conv;
36852 this_ptr_conv.inner = untag_ptr(this_ptr);
36853 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36855 this_ptr_conv.is_owned = false;
36856 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36857 memcpy(ret_arr->elems, *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
36861 void __attribute__((export_name("TS_OpenChannel_set_temporary_channel_id"))) TS_OpenChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
36862 LDKOpenChannel this_ptr_conv;
36863 this_ptr_conv.inner = untag_ptr(this_ptr);
36864 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36866 this_ptr_conv.is_owned = false;
36867 LDKThirtyTwoBytes val_ref;
36868 CHECK(val->arr_len == 32);
36869 memcpy(val_ref.data, val->elems, 32); FREE(val);
36870 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
36873 int64_t __attribute__((export_name("TS_OpenChannel_get_funding_satoshis"))) TS_OpenChannel_get_funding_satoshis(uint64_t this_ptr) {
36874 LDKOpenChannel this_ptr_conv;
36875 this_ptr_conv.inner = untag_ptr(this_ptr);
36876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36878 this_ptr_conv.is_owned = false;
36879 int64_t ret_conv = OpenChannel_get_funding_satoshis(&this_ptr_conv);
36883 void __attribute__((export_name("TS_OpenChannel_set_funding_satoshis"))) TS_OpenChannel_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
36884 LDKOpenChannel this_ptr_conv;
36885 this_ptr_conv.inner = untag_ptr(this_ptr);
36886 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36888 this_ptr_conv.is_owned = false;
36889 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
36892 int64_t __attribute__((export_name("TS_OpenChannel_get_push_msat"))) TS_OpenChannel_get_push_msat(uint64_t this_ptr) {
36893 LDKOpenChannel this_ptr_conv;
36894 this_ptr_conv.inner = untag_ptr(this_ptr);
36895 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36897 this_ptr_conv.is_owned = false;
36898 int64_t ret_conv = OpenChannel_get_push_msat(&this_ptr_conv);
36902 void __attribute__((export_name("TS_OpenChannel_set_push_msat"))) TS_OpenChannel_set_push_msat(uint64_t this_ptr, int64_t val) {
36903 LDKOpenChannel this_ptr_conv;
36904 this_ptr_conv.inner = untag_ptr(this_ptr);
36905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36907 this_ptr_conv.is_owned = false;
36908 OpenChannel_set_push_msat(&this_ptr_conv, val);
36911 int64_t __attribute__((export_name("TS_OpenChannel_get_dust_limit_satoshis"))) TS_OpenChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
36912 LDKOpenChannel this_ptr_conv;
36913 this_ptr_conv.inner = untag_ptr(this_ptr);
36914 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36916 this_ptr_conv.is_owned = false;
36917 int64_t ret_conv = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
36921 void __attribute__((export_name("TS_OpenChannel_set_dust_limit_satoshis"))) TS_OpenChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
36922 LDKOpenChannel this_ptr_conv;
36923 this_ptr_conv.inner = untag_ptr(this_ptr);
36924 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36926 this_ptr_conv.is_owned = false;
36927 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
36930 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) {
36931 LDKOpenChannel this_ptr_conv;
36932 this_ptr_conv.inner = untag_ptr(this_ptr);
36933 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36935 this_ptr_conv.is_owned = false;
36936 int64_t ret_conv = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
36940 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) {
36941 LDKOpenChannel this_ptr_conv;
36942 this_ptr_conv.inner = untag_ptr(this_ptr);
36943 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36945 this_ptr_conv.is_owned = false;
36946 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
36949 int64_t __attribute__((export_name("TS_OpenChannel_get_channel_reserve_satoshis"))) TS_OpenChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
36950 LDKOpenChannel this_ptr_conv;
36951 this_ptr_conv.inner = untag_ptr(this_ptr);
36952 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36954 this_ptr_conv.is_owned = false;
36955 int64_t ret_conv = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
36959 void __attribute__((export_name("TS_OpenChannel_set_channel_reserve_satoshis"))) TS_OpenChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
36960 LDKOpenChannel this_ptr_conv;
36961 this_ptr_conv.inner = untag_ptr(this_ptr);
36962 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36964 this_ptr_conv.is_owned = false;
36965 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
36968 int64_t __attribute__((export_name("TS_OpenChannel_get_htlc_minimum_msat"))) TS_OpenChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
36969 LDKOpenChannel this_ptr_conv;
36970 this_ptr_conv.inner = untag_ptr(this_ptr);
36971 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36973 this_ptr_conv.is_owned = false;
36974 int64_t ret_conv = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
36978 void __attribute__((export_name("TS_OpenChannel_set_htlc_minimum_msat"))) TS_OpenChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
36979 LDKOpenChannel this_ptr_conv;
36980 this_ptr_conv.inner = untag_ptr(this_ptr);
36981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36983 this_ptr_conv.is_owned = false;
36984 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
36987 int32_t __attribute__((export_name("TS_OpenChannel_get_feerate_per_kw"))) TS_OpenChannel_get_feerate_per_kw(uint64_t this_ptr) {
36988 LDKOpenChannel this_ptr_conv;
36989 this_ptr_conv.inner = untag_ptr(this_ptr);
36990 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
36991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36992 this_ptr_conv.is_owned = false;
36993 int32_t ret_conv = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
36997 void __attribute__((export_name("TS_OpenChannel_set_feerate_per_kw"))) TS_OpenChannel_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
36998 LDKOpenChannel this_ptr_conv;
36999 this_ptr_conv.inner = untag_ptr(this_ptr);
37000 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37002 this_ptr_conv.is_owned = false;
37003 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
37006 int16_t __attribute__((export_name("TS_OpenChannel_get_to_self_delay"))) TS_OpenChannel_get_to_self_delay(uint64_t this_ptr) {
37007 LDKOpenChannel this_ptr_conv;
37008 this_ptr_conv.inner = untag_ptr(this_ptr);
37009 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37011 this_ptr_conv.is_owned = false;
37012 int16_t ret_conv = OpenChannel_get_to_self_delay(&this_ptr_conv);
37016 void __attribute__((export_name("TS_OpenChannel_set_to_self_delay"))) TS_OpenChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
37017 LDKOpenChannel this_ptr_conv;
37018 this_ptr_conv.inner = untag_ptr(this_ptr);
37019 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37021 this_ptr_conv.is_owned = false;
37022 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
37025 int16_t __attribute__((export_name("TS_OpenChannel_get_max_accepted_htlcs"))) TS_OpenChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
37026 LDKOpenChannel this_ptr_conv;
37027 this_ptr_conv.inner = untag_ptr(this_ptr);
37028 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37030 this_ptr_conv.is_owned = false;
37031 int16_t ret_conv = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
37035 void __attribute__((export_name("TS_OpenChannel_set_max_accepted_htlcs"))) TS_OpenChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
37036 LDKOpenChannel this_ptr_conv;
37037 this_ptr_conv.inner = untag_ptr(this_ptr);
37038 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37039 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37040 this_ptr_conv.is_owned = false;
37041 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
37044 int8_tArray __attribute__((export_name("TS_OpenChannel_get_funding_pubkey"))) TS_OpenChannel_get_funding_pubkey(uint64_t this_ptr) {
37045 LDKOpenChannel this_ptr_conv;
37046 this_ptr_conv.inner = untag_ptr(this_ptr);
37047 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37048 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37049 this_ptr_conv.is_owned = false;
37050 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37051 memcpy(ret_arr->elems, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
37055 void __attribute__((export_name("TS_OpenChannel_set_funding_pubkey"))) TS_OpenChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
37056 LDKOpenChannel this_ptr_conv;
37057 this_ptr_conv.inner = untag_ptr(this_ptr);
37058 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37060 this_ptr_conv.is_owned = false;
37061 LDKPublicKey val_ref;
37062 CHECK(val->arr_len == 33);
37063 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37064 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
37067 int8_tArray __attribute__((export_name("TS_OpenChannel_get_revocation_basepoint"))) TS_OpenChannel_get_revocation_basepoint(uint64_t this_ptr) {
37068 LDKOpenChannel this_ptr_conv;
37069 this_ptr_conv.inner = untag_ptr(this_ptr);
37070 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37071 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37072 this_ptr_conv.is_owned = false;
37073 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37074 memcpy(ret_arr->elems, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
37078 void __attribute__((export_name("TS_OpenChannel_set_revocation_basepoint"))) TS_OpenChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
37079 LDKOpenChannel this_ptr_conv;
37080 this_ptr_conv.inner = untag_ptr(this_ptr);
37081 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37083 this_ptr_conv.is_owned = false;
37084 LDKPublicKey val_ref;
37085 CHECK(val->arr_len == 33);
37086 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37087 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
37090 int8_tArray __attribute__((export_name("TS_OpenChannel_get_payment_point"))) TS_OpenChannel_get_payment_point(uint64_t this_ptr) {
37091 LDKOpenChannel this_ptr_conv;
37092 this_ptr_conv.inner = untag_ptr(this_ptr);
37093 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37095 this_ptr_conv.is_owned = false;
37096 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37097 memcpy(ret_arr->elems, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
37101 void __attribute__((export_name("TS_OpenChannel_set_payment_point"))) TS_OpenChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
37102 LDKOpenChannel this_ptr_conv;
37103 this_ptr_conv.inner = untag_ptr(this_ptr);
37104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37106 this_ptr_conv.is_owned = false;
37107 LDKPublicKey val_ref;
37108 CHECK(val->arr_len == 33);
37109 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37110 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
37113 int8_tArray __attribute__((export_name("TS_OpenChannel_get_delayed_payment_basepoint"))) TS_OpenChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
37114 LDKOpenChannel this_ptr_conv;
37115 this_ptr_conv.inner = untag_ptr(this_ptr);
37116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37118 this_ptr_conv.is_owned = false;
37119 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37120 memcpy(ret_arr->elems, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
37124 void __attribute__((export_name("TS_OpenChannel_set_delayed_payment_basepoint"))) TS_OpenChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
37125 LDKOpenChannel this_ptr_conv;
37126 this_ptr_conv.inner = untag_ptr(this_ptr);
37127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37129 this_ptr_conv.is_owned = false;
37130 LDKPublicKey val_ref;
37131 CHECK(val->arr_len == 33);
37132 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37133 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
37136 int8_tArray __attribute__((export_name("TS_OpenChannel_get_htlc_basepoint"))) TS_OpenChannel_get_htlc_basepoint(uint64_t this_ptr) {
37137 LDKOpenChannel this_ptr_conv;
37138 this_ptr_conv.inner = untag_ptr(this_ptr);
37139 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37141 this_ptr_conv.is_owned = false;
37142 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37143 memcpy(ret_arr->elems, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
37147 void __attribute__((export_name("TS_OpenChannel_set_htlc_basepoint"))) TS_OpenChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
37148 LDKOpenChannel this_ptr_conv;
37149 this_ptr_conv.inner = untag_ptr(this_ptr);
37150 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37152 this_ptr_conv.is_owned = false;
37153 LDKPublicKey val_ref;
37154 CHECK(val->arr_len == 33);
37155 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37156 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
37159 int8_tArray __attribute__((export_name("TS_OpenChannel_get_first_per_commitment_point"))) TS_OpenChannel_get_first_per_commitment_point(uint64_t this_ptr) {
37160 LDKOpenChannel this_ptr_conv;
37161 this_ptr_conv.inner = untag_ptr(this_ptr);
37162 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37163 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37164 this_ptr_conv.is_owned = false;
37165 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37166 memcpy(ret_arr->elems, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37170 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) {
37171 LDKOpenChannel this_ptr_conv;
37172 this_ptr_conv.inner = untag_ptr(this_ptr);
37173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37175 this_ptr_conv.is_owned = false;
37176 LDKPublicKey val_ref;
37177 CHECK(val->arr_len == 33);
37178 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37179 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
37182 int8_t __attribute__((export_name("TS_OpenChannel_get_channel_flags"))) TS_OpenChannel_get_channel_flags(uint64_t this_ptr) {
37183 LDKOpenChannel this_ptr_conv;
37184 this_ptr_conv.inner = untag_ptr(this_ptr);
37185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37187 this_ptr_conv.is_owned = false;
37188 int8_t ret_conv = OpenChannel_get_channel_flags(&this_ptr_conv);
37192 void __attribute__((export_name("TS_OpenChannel_set_channel_flags"))) TS_OpenChannel_set_channel_flags(uint64_t this_ptr, int8_t val) {
37193 LDKOpenChannel this_ptr_conv;
37194 this_ptr_conv.inner = untag_ptr(this_ptr);
37195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37197 this_ptr_conv.is_owned = false;
37198 OpenChannel_set_channel_flags(&this_ptr_conv, val);
37201 uint64_t __attribute__((export_name("TS_OpenChannel_get_shutdown_scriptpubkey"))) TS_OpenChannel_get_shutdown_scriptpubkey(uint64_t this_ptr) {
37202 LDKOpenChannel this_ptr_conv;
37203 this_ptr_conv.inner = untag_ptr(this_ptr);
37204 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37206 this_ptr_conv.is_owned = false;
37207 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
37208 *ret_copy = OpenChannel_get_shutdown_scriptpubkey(&this_ptr_conv);
37209 uint64_t ret_ref = tag_ptr(ret_copy, true);
37213 void __attribute__((export_name("TS_OpenChannel_set_shutdown_scriptpubkey"))) TS_OpenChannel_set_shutdown_scriptpubkey(uint64_t this_ptr, uint64_t val) {
37214 LDKOpenChannel this_ptr_conv;
37215 this_ptr_conv.inner = untag_ptr(this_ptr);
37216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37218 this_ptr_conv.is_owned = false;
37219 void* val_ptr = untag_ptr(val);
37220 CHECK_ACCESS(val_ptr);
37221 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
37222 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
37223 OpenChannel_set_shutdown_scriptpubkey(&this_ptr_conv, val_conv);
37226 uint64_t __attribute__((export_name("TS_OpenChannel_get_channel_type"))) TS_OpenChannel_get_channel_type(uint64_t this_ptr) {
37227 LDKOpenChannel this_ptr_conv;
37228 this_ptr_conv.inner = untag_ptr(this_ptr);
37229 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37231 this_ptr_conv.is_owned = false;
37232 LDKChannelTypeFeatures ret_var = OpenChannel_get_channel_type(&this_ptr_conv);
37233 uint64_t ret_ref = 0;
37234 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37235 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37239 void __attribute__((export_name("TS_OpenChannel_set_channel_type"))) TS_OpenChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
37240 LDKOpenChannel this_ptr_conv;
37241 this_ptr_conv.inner = untag_ptr(this_ptr);
37242 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37244 this_ptr_conv.is_owned = false;
37245 LDKChannelTypeFeatures val_conv;
37246 val_conv.inner = untag_ptr(val);
37247 val_conv.is_owned = ptr_is_owned(val);
37248 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
37249 val_conv = ChannelTypeFeatures_clone(&val_conv);
37250 OpenChannel_set_channel_type(&this_ptr_conv, val_conv);
37253 uint64_t __attribute__((export_name("TS_OpenChannel_new"))) TS_OpenChannel_new(int8_tArray chain_hash_arg, int8_tArray temporary_channel_id_arg, int64_t funding_satoshis_arg, int64_t push_msat_arg, int64_t dust_limit_satoshis_arg, int64_t max_htlc_value_in_flight_msat_arg, int64_t channel_reserve_satoshis_arg, int64_t htlc_minimum_msat_arg, int32_t feerate_per_kw_arg, int16_t to_self_delay_arg, int16_t max_accepted_htlcs_arg, 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, int8_tArray first_per_commitment_point_arg, int8_t channel_flags_arg, uint64_t shutdown_scriptpubkey_arg, uint64_t channel_type_arg) {
37254 LDKThirtyTwoBytes chain_hash_arg_ref;
37255 CHECK(chain_hash_arg->arr_len == 32);
37256 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
37257 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
37258 CHECK(temporary_channel_id_arg->arr_len == 32);
37259 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
37260 LDKPublicKey funding_pubkey_arg_ref;
37261 CHECK(funding_pubkey_arg->arr_len == 33);
37262 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
37263 LDKPublicKey revocation_basepoint_arg_ref;
37264 CHECK(revocation_basepoint_arg->arr_len == 33);
37265 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
37266 LDKPublicKey payment_point_arg_ref;
37267 CHECK(payment_point_arg->arr_len == 33);
37268 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
37269 LDKPublicKey delayed_payment_basepoint_arg_ref;
37270 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
37271 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
37272 LDKPublicKey htlc_basepoint_arg_ref;
37273 CHECK(htlc_basepoint_arg->arr_len == 33);
37274 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
37275 LDKPublicKey first_per_commitment_point_arg_ref;
37276 CHECK(first_per_commitment_point_arg->arr_len == 33);
37277 memcpy(first_per_commitment_point_arg_ref.compressed_form, first_per_commitment_point_arg->elems, 33); FREE(first_per_commitment_point_arg);
37278 void* shutdown_scriptpubkey_arg_ptr = untag_ptr(shutdown_scriptpubkey_arg);
37279 CHECK_ACCESS(shutdown_scriptpubkey_arg_ptr);
37280 LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg_conv = *(LDKCOption_CVec_u8ZZ*)(shutdown_scriptpubkey_arg_ptr);
37281 shutdown_scriptpubkey_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(shutdown_scriptpubkey_arg));
37282 LDKChannelTypeFeatures channel_type_arg_conv;
37283 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
37284 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
37285 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
37286 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
37287 LDKOpenChannel ret_var = OpenChannel_new(chain_hash_arg_ref, temporary_channel_id_arg_ref, funding_satoshis_arg, push_msat_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, feerate_per_kw_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg_ref, revocation_basepoint_arg_ref, payment_point_arg_ref, delayed_payment_basepoint_arg_ref, htlc_basepoint_arg_ref, first_per_commitment_point_arg_ref, channel_flags_arg, shutdown_scriptpubkey_arg_conv, channel_type_arg_conv);
37288 uint64_t ret_ref = 0;
37289 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37290 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37294 static inline uint64_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
37295 LDKOpenChannel ret_var = OpenChannel_clone(arg);
37296 uint64_t ret_ref = 0;
37297 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37298 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37301 int64_t __attribute__((export_name("TS_OpenChannel_clone_ptr"))) TS_OpenChannel_clone_ptr(uint64_t arg) {
37302 LDKOpenChannel arg_conv;
37303 arg_conv.inner = untag_ptr(arg);
37304 arg_conv.is_owned = ptr_is_owned(arg);
37305 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37306 arg_conv.is_owned = false;
37307 int64_t ret_conv = OpenChannel_clone_ptr(&arg_conv);
37311 uint64_t __attribute__((export_name("TS_OpenChannel_clone"))) TS_OpenChannel_clone(uint64_t orig) {
37312 LDKOpenChannel orig_conv;
37313 orig_conv.inner = untag_ptr(orig);
37314 orig_conv.is_owned = ptr_is_owned(orig);
37315 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37316 orig_conv.is_owned = false;
37317 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
37318 uint64_t ret_ref = 0;
37319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37320 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37324 jboolean __attribute__((export_name("TS_OpenChannel_eq"))) TS_OpenChannel_eq(uint64_t a, uint64_t b) {
37325 LDKOpenChannel a_conv;
37326 a_conv.inner = untag_ptr(a);
37327 a_conv.is_owned = ptr_is_owned(a);
37328 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37329 a_conv.is_owned = false;
37330 LDKOpenChannel b_conv;
37331 b_conv.inner = untag_ptr(b);
37332 b_conv.is_owned = ptr_is_owned(b);
37333 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37334 b_conv.is_owned = false;
37335 jboolean ret_conv = OpenChannel_eq(&a_conv, &b_conv);
37339 void __attribute__((export_name("TS_OpenChannelV2_free"))) TS_OpenChannelV2_free(uint64_t this_obj) {
37340 LDKOpenChannelV2 this_obj_conv;
37341 this_obj_conv.inner = untag_ptr(this_obj);
37342 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37344 OpenChannelV2_free(this_obj_conv);
37347 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_chain_hash"))) TS_OpenChannelV2_get_chain_hash(uint64_t this_ptr) {
37348 LDKOpenChannelV2 this_ptr_conv;
37349 this_ptr_conv.inner = untag_ptr(this_ptr);
37350 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37352 this_ptr_conv.is_owned = false;
37353 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37354 memcpy(ret_arr->elems, *OpenChannelV2_get_chain_hash(&this_ptr_conv), 32);
37358 void __attribute__((export_name("TS_OpenChannelV2_set_chain_hash"))) TS_OpenChannelV2_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
37359 LDKOpenChannelV2 this_ptr_conv;
37360 this_ptr_conv.inner = untag_ptr(this_ptr);
37361 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37363 this_ptr_conv.is_owned = false;
37364 LDKThirtyTwoBytes val_ref;
37365 CHECK(val->arr_len == 32);
37366 memcpy(val_ref.data, val->elems, 32); FREE(val);
37367 OpenChannelV2_set_chain_hash(&this_ptr_conv, val_ref);
37370 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_temporary_channel_id"))) TS_OpenChannelV2_get_temporary_channel_id(uint64_t this_ptr) {
37371 LDKOpenChannelV2 this_ptr_conv;
37372 this_ptr_conv.inner = untag_ptr(this_ptr);
37373 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37375 this_ptr_conv.is_owned = false;
37376 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37377 memcpy(ret_arr->elems, *OpenChannelV2_get_temporary_channel_id(&this_ptr_conv), 32);
37381 void __attribute__((export_name("TS_OpenChannelV2_set_temporary_channel_id"))) TS_OpenChannelV2_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
37382 LDKOpenChannelV2 this_ptr_conv;
37383 this_ptr_conv.inner = untag_ptr(this_ptr);
37384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37386 this_ptr_conv.is_owned = false;
37387 LDKThirtyTwoBytes val_ref;
37388 CHECK(val->arr_len == 32);
37389 memcpy(val_ref.data, val->elems, 32); FREE(val);
37390 OpenChannelV2_set_temporary_channel_id(&this_ptr_conv, val_ref);
37393 int32_t __attribute__((export_name("TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight"))) TS_OpenChannelV2_get_funding_feerate_sat_per_1000_weight(uint64_t this_ptr) {
37394 LDKOpenChannelV2 this_ptr_conv;
37395 this_ptr_conv.inner = untag_ptr(this_ptr);
37396 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37398 this_ptr_conv.is_owned = false;
37399 int32_t ret_conv = OpenChannelV2_get_funding_feerate_sat_per_1000_weight(&this_ptr_conv);
37403 void __attribute__((export_name("TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight"))) TS_OpenChannelV2_set_funding_feerate_sat_per_1000_weight(uint64_t this_ptr, int32_t val) {
37404 LDKOpenChannelV2 this_ptr_conv;
37405 this_ptr_conv.inner = untag_ptr(this_ptr);
37406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37408 this_ptr_conv.is_owned = false;
37409 OpenChannelV2_set_funding_feerate_sat_per_1000_weight(&this_ptr_conv, val);
37412 int32_t __attribute__((export_name("TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight"))) TS_OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(uint64_t this_ptr) {
37413 LDKOpenChannelV2 this_ptr_conv;
37414 this_ptr_conv.inner = untag_ptr(this_ptr);
37415 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37417 this_ptr_conv.is_owned = false;
37418 int32_t ret_conv = OpenChannelV2_get_commitment_feerate_sat_per_1000_weight(&this_ptr_conv);
37422 void __attribute__((export_name("TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight"))) TS_OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(uint64_t this_ptr, int32_t val) {
37423 LDKOpenChannelV2 this_ptr_conv;
37424 this_ptr_conv.inner = untag_ptr(this_ptr);
37425 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37427 this_ptr_conv.is_owned = false;
37428 OpenChannelV2_set_commitment_feerate_sat_per_1000_weight(&this_ptr_conv, val);
37431 int64_t __attribute__((export_name("TS_OpenChannelV2_get_funding_satoshis"))) TS_OpenChannelV2_get_funding_satoshis(uint64_t this_ptr) {
37432 LDKOpenChannelV2 this_ptr_conv;
37433 this_ptr_conv.inner = untag_ptr(this_ptr);
37434 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37436 this_ptr_conv.is_owned = false;
37437 int64_t ret_conv = OpenChannelV2_get_funding_satoshis(&this_ptr_conv);
37441 void __attribute__((export_name("TS_OpenChannelV2_set_funding_satoshis"))) TS_OpenChannelV2_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
37442 LDKOpenChannelV2 this_ptr_conv;
37443 this_ptr_conv.inner = untag_ptr(this_ptr);
37444 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37446 this_ptr_conv.is_owned = false;
37447 OpenChannelV2_set_funding_satoshis(&this_ptr_conv, val);
37450 int64_t __attribute__((export_name("TS_OpenChannelV2_get_dust_limit_satoshis"))) TS_OpenChannelV2_get_dust_limit_satoshis(uint64_t this_ptr) {
37451 LDKOpenChannelV2 this_ptr_conv;
37452 this_ptr_conv.inner = untag_ptr(this_ptr);
37453 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37454 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37455 this_ptr_conv.is_owned = false;
37456 int64_t ret_conv = OpenChannelV2_get_dust_limit_satoshis(&this_ptr_conv);
37460 void __attribute__((export_name("TS_OpenChannelV2_set_dust_limit_satoshis"))) TS_OpenChannelV2_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
37461 LDKOpenChannelV2 this_ptr_conv;
37462 this_ptr_conv.inner = untag_ptr(this_ptr);
37463 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37464 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37465 this_ptr_conv.is_owned = false;
37466 OpenChannelV2_set_dust_limit_satoshis(&this_ptr_conv, val);
37469 int64_t __attribute__((export_name("TS_OpenChannelV2_get_max_htlc_value_in_flight_msat"))) TS_OpenChannelV2_get_max_htlc_value_in_flight_msat(uint64_t this_ptr) {
37470 LDKOpenChannelV2 this_ptr_conv;
37471 this_ptr_conv.inner = untag_ptr(this_ptr);
37472 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37474 this_ptr_conv.is_owned = false;
37475 int64_t ret_conv = OpenChannelV2_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
37479 void __attribute__((export_name("TS_OpenChannelV2_set_max_htlc_value_in_flight_msat"))) TS_OpenChannelV2_set_max_htlc_value_in_flight_msat(uint64_t this_ptr, int64_t val) {
37480 LDKOpenChannelV2 this_ptr_conv;
37481 this_ptr_conv.inner = untag_ptr(this_ptr);
37482 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37484 this_ptr_conv.is_owned = false;
37485 OpenChannelV2_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
37488 int64_t __attribute__((export_name("TS_OpenChannelV2_get_htlc_minimum_msat"))) TS_OpenChannelV2_get_htlc_minimum_msat(uint64_t this_ptr) {
37489 LDKOpenChannelV2 this_ptr_conv;
37490 this_ptr_conv.inner = untag_ptr(this_ptr);
37491 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37493 this_ptr_conv.is_owned = false;
37494 int64_t ret_conv = OpenChannelV2_get_htlc_minimum_msat(&this_ptr_conv);
37498 void __attribute__((export_name("TS_OpenChannelV2_set_htlc_minimum_msat"))) TS_OpenChannelV2_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
37499 LDKOpenChannelV2 this_ptr_conv;
37500 this_ptr_conv.inner = untag_ptr(this_ptr);
37501 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37503 this_ptr_conv.is_owned = false;
37504 OpenChannelV2_set_htlc_minimum_msat(&this_ptr_conv, val);
37507 int16_t __attribute__((export_name("TS_OpenChannelV2_get_to_self_delay"))) TS_OpenChannelV2_get_to_self_delay(uint64_t this_ptr) {
37508 LDKOpenChannelV2 this_ptr_conv;
37509 this_ptr_conv.inner = untag_ptr(this_ptr);
37510 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37512 this_ptr_conv.is_owned = false;
37513 int16_t ret_conv = OpenChannelV2_get_to_self_delay(&this_ptr_conv);
37517 void __attribute__((export_name("TS_OpenChannelV2_set_to_self_delay"))) TS_OpenChannelV2_set_to_self_delay(uint64_t this_ptr, int16_t val) {
37518 LDKOpenChannelV2 this_ptr_conv;
37519 this_ptr_conv.inner = untag_ptr(this_ptr);
37520 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37522 this_ptr_conv.is_owned = false;
37523 OpenChannelV2_set_to_self_delay(&this_ptr_conv, val);
37526 int16_t __attribute__((export_name("TS_OpenChannelV2_get_max_accepted_htlcs"))) TS_OpenChannelV2_get_max_accepted_htlcs(uint64_t this_ptr) {
37527 LDKOpenChannelV2 this_ptr_conv;
37528 this_ptr_conv.inner = untag_ptr(this_ptr);
37529 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37531 this_ptr_conv.is_owned = false;
37532 int16_t ret_conv = OpenChannelV2_get_max_accepted_htlcs(&this_ptr_conv);
37536 void __attribute__((export_name("TS_OpenChannelV2_set_max_accepted_htlcs"))) TS_OpenChannelV2_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
37537 LDKOpenChannelV2 this_ptr_conv;
37538 this_ptr_conv.inner = untag_ptr(this_ptr);
37539 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37541 this_ptr_conv.is_owned = false;
37542 OpenChannelV2_set_max_accepted_htlcs(&this_ptr_conv, val);
37545 int32_t __attribute__((export_name("TS_OpenChannelV2_get_locktime"))) TS_OpenChannelV2_get_locktime(uint64_t this_ptr) {
37546 LDKOpenChannelV2 this_ptr_conv;
37547 this_ptr_conv.inner = untag_ptr(this_ptr);
37548 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37550 this_ptr_conv.is_owned = false;
37551 int32_t ret_conv = OpenChannelV2_get_locktime(&this_ptr_conv);
37555 void __attribute__((export_name("TS_OpenChannelV2_set_locktime"))) TS_OpenChannelV2_set_locktime(uint64_t this_ptr, int32_t val) {
37556 LDKOpenChannelV2 this_ptr_conv;
37557 this_ptr_conv.inner = untag_ptr(this_ptr);
37558 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37560 this_ptr_conv.is_owned = false;
37561 OpenChannelV2_set_locktime(&this_ptr_conv, val);
37564 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_funding_pubkey"))) TS_OpenChannelV2_get_funding_pubkey(uint64_t this_ptr) {
37565 LDKOpenChannelV2 this_ptr_conv;
37566 this_ptr_conv.inner = untag_ptr(this_ptr);
37567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37569 this_ptr_conv.is_owned = false;
37570 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37571 memcpy(ret_arr->elems, OpenChannelV2_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
37575 void __attribute__((export_name("TS_OpenChannelV2_set_funding_pubkey"))) TS_OpenChannelV2_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
37576 LDKOpenChannelV2 this_ptr_conv;
37577 this_ptr_conv.inner = untag_ptr(this_ptr);
37578 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37580 this_ptr_conv.is_owned = false;
37581 LDKPublicKey val_ref;
37582 CHECK(val->arr_len == 33);
37583 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37584 OpenChannelV2_set_funding_pubkey(&this_ptr_conv, val_ref);
37587 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_revocation_basepoint"))) TS_OpenChannelV2_get_revocation_basepoint(uint64_t this_ptr) {
37588 LDKOpenChannelV2 this_ptr_conv;
37589 this_ptr_conv.inner = untag_ptr(this_ptr);
37590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37592 this_ptr_conv.is_owned = false;
37593 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37594 memcpy(ret_arr->elems, OpenChannelV2_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
37598 void __attribute__((export_name("TS_OpenChannelV2_set_revocation_basepoint"))) TS_OpenChannelV2_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
37599 LDKOpenChannelV2 this_ptr_conv;
37600 this_ptr_conv.inner = untag_ptr(this_ptr);
37601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37603 this_ptr_conv.is_owned = false;
37604 LDKPublicKey val_ref;
37605 CHECK(val->arr_len == 33);
37606 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37607 OpenChannelV2_set_revocation_basepoint(&this_ptr_conv, val_ref);
37610 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_payment_basepoint"))) TS_OpenChannelV2_get_payment_basepoint(uint64_t this_ptr) {
37611 LDKOpenChannelV2 this_ptr_conv;
37612 this_ptr_conv.inner = untag_ptr(this_ptr);
37613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37615 this_ptr_conv.is_owned = false;
37616 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37617 memcpy(ret_arr->elems, OpenChannelV2_get_payment_basepoint(&this_ptr_conv).compressed_form, 33);
37621 void __attribute__((export_name("TS_OpenChannelV2_set_payment_basepoint"))) TS_OpenChannelV2_set_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
37622 LDKOpenChannelV2 this_ptr_conv;
37623 this_ptr_conv.inner = untag_ptr(this_ptr);
37624 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37625 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37626 this_ptr_conv.is_owned = false;
37627 LDKPublicKey val_ref;
37628 CHECK(val->arr_len == 33);
37629 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37630 OpenChannelV2_set_payment_basepoint(&this_ptr_conv, val_ref);
37633 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_delayed_payment_basepoint"))) TS_OpenChannelV2_get_delayed_payment_basepoint(uint64_t this_ptr) {
37634 LDKOpenChannelV2 this_ptr_conv;
37635 this_ptr_conv.inner = untag_ptr(this_ptr);
37636 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37638 this_ptr_conv.is_owned = false;
37639 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37640 memcpy(ret_arr->elems, OpenChannelV2_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
37644 void __attribute__((export_name("TS_OpenChannelV2_set_delayed_payment_basepoint"))) TS_OpenChannelV2_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
37645 LDKOpenChannelV2 this_ptr_conv;
37646 this_ptr_conv.inner = untag_ptr(this_ptr);
37647 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37649 this_ptr_conv.is_owned = false;
37650 LDKPublicKey val_ref;
37651 CHECK(val->arr_len == 33);
37652 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37653 OpenChannelV2_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
37656 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_htlc_basepoint"))) TS_OpenChannelV2_get_htlc_basepoint(uint64_t this_ptr) {
37657 LDKOpenChannelV2 this_ptr_conv;
37658 this_ptr_conv.inner = untag_ptr(this_ptr);
37659 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37660 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37661 this_ptr_conv.is_owned = false;
37662 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37663 memcpy(ret_arr->elems, OpenChannelV2_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
37667 void __attribute__((export_name("TS_OpenChannelV2_set_htlc_basepoint"))) TS_OpenChannelV2_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
37668 LDKOpenChannelV2 this_ptr_conv;
37669 this_ptr_conv.inner = untag_ptr(this_ptr);
37670 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37672 this_ptr_conv.is_owned = false;
37673 LDKPublicKey val_ref;
37674 CHECK(val->arr_len == 33);
37675 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37676 OpenChannelV2_set_htlc_basepoint(&this_ptr_conv, val_ref);
37679 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_first_per_commitment_point"))) TS_OpenChannelV2_get_first_per_commitment_point(uint64_t this_ptr) {
37680 LDKOpenChannelV2 this_ptr_conv;
37681 this_ptr_conv.inner = untag_ptr(this_ptr);
37682 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37683 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37684 this_ptr_conv.is_owned = false;
37685 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37686 memcpy(ret_arr->elems, OpenChannelV2_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37690 void __attribute__((export_name("TS_OpenChannelV2_set_first_per_commitment_point"))) TS_OpenChannelV2_set_first_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
37691 LDKOpenChannelV2 this_ptr_conv;
37692 this_ptr_conv.inner = untag_ptr(this_ptr);
37693 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37695 this_ptr_conv.is_owned = false;
37696 LDKPublicKey val_ref;
37697 CHECK(val->arr_len == 33);
37698 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37699 OpenChannelV2_set_first_per_commitment_point(&this_ptr_conv, val_ref);
37702 int8_tArray __attribute__((export_name("TS_OpenChannelV2_get_second_per_commitment_point"))) TS_OpenChannelV2_get_second_per_commitment_point(uint64_t this_ptr) {
37703 LDKOpenChannelV2 this_ptr_conv;
37704 this_ptr_conv.inner = untag_ptr(this_ptr);
37705 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37706 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37707 this_ptr_conv.is_owned = false;
37708 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
37709 memcpy(ret_arr->elems, OpenChannelV2_get_second_per_commitment_point(&this_ptr_conv).compressed_form, 33);
37713 void __attribute__((export_name("TS_OpenChannelV2_set_second_per_commitment_point"))) TS_OpenChannelV2_set_second_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
37714 LDKOpenChannelV2 this_ptr_conv;
37715 this_ptr_conv.inner = untag_ptr(this_ptr);
37716 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37717 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37718 this_ptr_conv.is_owned = false;
37719 LDKPublicKey val_ref;
37720 CHECK(val->arr_len == 33);
37721 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
37722 OpenChannelV2_set_second_per_commitment_point(&this_ptr_conv, val_ref);
37725 int8_t __attribute__((export_name("TS_OpenChannelV2_get_channel_flags"))) TS_OpenChannelV2_get_channel_flags(uint64_t this_ptr) {
37726 LDKOpenChannelV2 this_ptr_conv;
37727 this_ptr_conv.inner = untag_ptr(this_ptr);
37728 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37730 this_ptr_conv.is_owned = false;
37731 int8_t ret_conv = OpenChannelV2_get_channel_flags(&this_ptr_conv);
37735 void __attribute__((export_name("TS_OpenChannelV2_set_channel_flags"))) TS_OpenChannelV2_set_channel_flags(uint64_t this_ptr, int8_t val) {
37736 LDKOpenChannelV2 this_ptr_conv;
37737 this_ptr_conv.inner = untag_ptr(this_ptr);
37738 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37740 this_ptr_conv.is_owned = false;
37741 OpenChannelV2_set_channel_flags(&this_ptr_conv, val);
37744 uint64_t __attribute__((export_name("TS_OpenChannelV2_get_shutdown_scriptpubkey"))) TS_OpenChannelV2_get_shutdown_scriptpubkey(uint64_t this_ptr) {
37745 LDKOpenChannelV2 this_ptr_conv;
37746 this_ptr_conv.inner = untag_ptr(this_ptr);
37747 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37749 this_ptr_conv.is_owned = false;
37750 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
37751 *ret_copy = OpenChannelV2_get_shutdown_scriptpubkey(&this_ptr_conv);
37752 uint64_t ret_ref = tag_ptr(ret_copy, true);
37756 void __attribute__((export_name("TS_OpenChannelV2_set_shutdown_scriptpubkey"))) TS_OpenChannelV2_set_shutdown_scriptpubkey(uint64_t this_ptr, uint64_t val) {
37757 LDKOpenChannelV2 this_ptr_conv;
37758 this_ptr_conv.inner = untag_ptr(this_ptr);
37759 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37760 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37761 this_ptr_conv.is_owned = false;
37762 void* val_ptr = untag_ptr(val);
37763 CHECK_ACCESS(val_ptr);
37764 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
37765 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
37766 OpenChannelV2_set_shutdown_scriptpubkey(&this_ptr_conv, val_conv);
37769 uint64_t __attribute__((export_name("TS_OpenChannelV2_get_channel_type"))) TS_OpenChannelV2_get_channel_type(uint64_t this_ptr) {
37770 LDKOpenChannelV2 this_ptr_conv;
37771 this_ptr_conv.inner = untag_ptr(this_ptr);
37772 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37774 this_ptr_conv.is_owned = false;
37775 LDKChannelTypeFeatures ret_var = OpenChannelV2_get_channel_type(&this_ptr_conv);
37776 uint64_t ret_ref = 0;
37777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37782 void __attribute__((export_name("TS_OpenChannelV2_set_channel_type"))) TS_OpenChannelV2_set_channel_type(uint64_t this_ptr, uint64_t val) {
37783 LDKOpenChannelV2 this_ptr_conv;
37784 this_ptr_conv.inner = untag_ptr(this_ptr);
37785 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37787 this_ptr_conv.is_owned = false;
37788 LDKChannelTypeFeatures val_conv;
37789 val_conv.inner = untag_ptr(val);
37790 val_conv.is_owned = ptr_is_owned(val);
37791 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
37792 val_conv = ChannelTypeFeatures_clone(&val_conv);
37793 OpenChannelV2_set_channel_type(&this_ptr_conv, val_conv);
37796 uint32_t __attribute__((export_name("TS_OpenChannelV2_get_require_confirmed_inputs"))) TS_OpenChannelV2_get_require_confirmed_inputs(uint64_t this_ptr) {
37797 LDKOpenChannelV2 this_ptr_conv;
37798 this_ptr_conv.inner = untag_ptr(this_ptr);
37799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37801 this_ptr_conv.is_owned = false;
37802 uint32_t ret_conv = LDKCOption_NoneZ_to_js(OpenChannelV2_get_require_confirmed_inputs(&this_ptr_conv));
37806 void __attribute__((export_name("TS_OpenChannelV2_set_require_confirmed_inputs"))) TS_OpenChannelV2_set_require_confirmed_inputs(uint64_t this_ptr, uint32_t val) {
37807 LDKOpenChannelV2 this_ptr_conv;
37808 this_ptr_conv.inner = untag_ptr(this_ptr);
37809 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37811 this_ptr_conv.is_owned = false;
37812 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
37813 OpenChannelV2_set_require_confirmed_inputs(&this_ptr_conv, val_conv);
37816 uint64_t __attribute__((export_name("TS_OpenChannelV2_new"))) TS_OpenChannelV2_new(int8_tArray chain_hash_arg, int8_tArray temporary_channel_id_arg, int32_t funding_feerate_sat_per_1000_weight_arg, int32_t commitment_feerate_sat_per_1000_weight_arg, int64_t funding_satoshis_arg, int64_t dust_limit_satoshis_arg, int64_t max_htlc_value_in_flight_msat_arg, int64_t htlc_minimum_msat_arg, int16_t to_self_delay_arg, int16_t max_accepted_htlcs_arg, int32_t locktime_arg, int8_tArray funding_pubkey_arg, int8_tArray revocation_basepoint_arg, int8_tArray payment_basepoint_arg, int8_tArray delayed_payment_basepoint_arg, int8_tArray htlc_basepoint_arg, int8_tArray first_per_commitment_point_arg, int8_tArray second_per_commitment_point_arg, int8_t channel_flags_arg, uint64_t shutdown_scriptpubkey_arg, uint64_t channel_type_arg, uint32_t require_confirmed_inputs_arg) {
37817 LDKThirtyTwoBytes chain_hash_arg_ref;
37818 CHECK(chain_hash_arg->arr_len == 32);
37819 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
37820 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
37821 CHECK(temporary_channel_id_arg->arr_len == 32);
37822 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
37823 LDKPublicKey funding_pubkey_arg_ref;
37824 CHECK(funding_pubkey_arg->arr_len == 33);
37825 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
37826 LDKPublicKey revocation_basepoint_arg_ref;
37827 CHECK(revocation_basepoint_arg->arr_len == 33);
37828 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
37829 LDKPublicKey payment_basepoint_arg_ref;
37830 CHECK(payment_basepoint_arg->arr_len == 33);
37831 memcpy(payment_basepoint_arg_ref.compressed_form, payment_basepoint_arg->elems, 33); FREE(payment_basepoint_arg);
37832 LDKPublicKey delayed_payment_basepoint_arg_ref;
37833 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
37834 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
37835 LDKPublicKey htlc_basepoint_arg_ref;
37836 CHECK(htlc_basepoint_arg->arr_len == 33);
37837 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
37838 LDKPublicKey first_per_commitment_point_arg_ref;
37839 CHECK(first_per_commitment_point_arg->arr_len == 33);
37840 memcpy(first_per_commitment_point_arg_ref.compressed_form, first_per_commitment_point_arg->elems, 33); FREE(first_per_commitment_point_arg);
37841 LDKPublicKey second_per_commitment_point_arg_ref;
37842 CHECK(second_per_commitment_point_arg->arr_len == 33);
37843 memcpy(second_per_commitment_point_arg_ref.compressed_form, second_per_commitment_point_arg->elems, 33); FREE(second_per_commitment_point_arg);
37844 void* shutdown_scriptpubkey_arg_ptr = untag_ptr(shutdown_scriptpubkey_arg);
37845 CHECK_ACCESS(shutdown_scriptpubkey_arg_ptr);
37846 LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg_conv = *(LDKCOption_CVec_u8ZZ*)(shutdown_scriptpubkey_arg_ptr);
37847 shutdown_scriptpubkey_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(shutdown_scriptpubkey_arg));
37848 LDKChannelTypeFeatures channel_type_arg_conv;
37849 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
37850 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
37851 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
37852 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
37853 LDKCOption_NoneZ require_confirmed_inputs_arg_conv = LDKCOption_NoneZ_from_js(require_confirmed_inputs_arg);
37854 LDKOpenChannelV2 ret_var = OpenChannelV2_new(chain_hash_arg_ref, temporary_channel_id_arg_ref, funding_feerate_sat_per_1000_weight_arg, commitment_feerate_sat_per_1000_weight_arg, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, to_self_delay_arg, max_accepted_htlcs_arg, locktime_arg, funding_pubkey_arg_ref, revocation_basepoint_arg_ref, payment_basepoint_arg_ref, delayed_payment_basepoint_arg_ref, htlc_basepoint_arg_ref, first_per_commitment_point_arg_ref, second_per_commitment_point_arg_ref, channel_flags_arg, shutdown_scriptpubkey_arg_conv, channel_type_arg_conv, require_confirmed_inputs_arg_conv);
37855 uint64_t ret_ref = 0;
37856 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37857 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37861 static inline uint64_t OpenChannelV2_clone_ptr(LDKOpenChannelV2 *NONNULL_PTR arg) {
37862 LDKOpenChannelV2 ret_var = OpenChannelV2_clone(arg);
37863 uint64_t ret_ref = 0;
37864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37865 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37868 int64_t __attribute__((export_name("TS_OpenChannelV2_clone_ptr"))) TS_OpenChannelV2_clone_ptr(uint64_t arg) {
37869 LDKOpenChannelV2 arg_conv;
37870 arg_conv.inner = untag_ptr(arg);
37871 arg_conv.is_owned = ptr_is_owned(arg);
37872 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37873 arg_conv.is_owned = false;
37874 int64_t ret_conv = OpenChannelV2_clone_ptr(&arg_conv);
37878 uint64_t __attribute__((export_name("TS_OpenChannelV2_clone"))) TS_OpenChannelV2_clone(uint64_t orig) {
37879 LDKOpenChannelV2 orig_conv;
37880 orig_conv.inner = untag_ptr(orig);
37881 orig_conv.is_owned = ptr_is_owned(orig);
37882 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37883 orig_conv.is_owned = false;
37884 LDKOpenChannelV2 ret_var = OpenChannelV2_clone(&orig_conv);
37885 uint64_t ret_ref = 0;
37886 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37887 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
37891 jboolean __attribute__((export_name("TS_OpenChannelV2_eq"))) TS_OpenChannelV2_eq(uint64_t a, uint64_t b) {
37892 LDKOpenChannelV2 a_conv;
37893 a_conv.inner = untag_ptr(a);
37894 a_conv.is_owned = ptr_is_owned(a);
37895 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37896 a_conv.is_owned = false;
37897 LDKOpenChannelV2 b_conv;
37898 b_conv.inner = untag_ptr(b);
37899 b_conv.is_owned = ptr_is_owned(b);
37900 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37901 b_conv.is_owned = false;
37902 jboolean ret_conv = OpenChannelV2_eq(&a_conv, &b_conv);
37906 void __attribute__((export_name("TS_AcceptChannel_free"))) TS_AcceptChannel_free(uint64_t this_obj) {
37907 LDKAcceptChannel this_obj_conv;
37908 this_obj_conv.inner = untag_ptr(this_obj);
37909 this_obj_conv.is_owned = ptr_is_owned(this_obj);
37910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37911 AcceptChannel_free(this_obj_conv);
37914 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_temporary_channel_id"))) TS_AcceptChannel_get_temporary_channel_id(uint64_t this_ptr) {
37915 LDKAcceptChannel this_ptr_conv;
37916 this_ptr_conv.inner = untag_ptr(this_ptr);
37917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37919 this_ptr_conv.is_owned = false;
37920 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37921 memcpy(ret_arr->elems, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
37925 void __attribute__((export_name("TS_AcceptChannel_set_temporary_channel_id"))) TS_AcceptChannel_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
37926 LDKAcceptChannel this_ptr_conv;
37927 this_ptr_conv.inner = untag_ptr(this_ptr);
37928 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37930 this_ptr_conv.is_owned = false;
37931 LDKThirtyTwoBytes val_ref;
37932 CHECK(val->arr_len == 32);
37933 memcpy(val_ref.data, val->elems, 32); FREE(val);
37934 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
37937 int64_t __attribute__((export_name("TS_AcceptChannel_get_dust_limit_satoshis"))) TS_AcceptChannel_get_dust_limit_satoshis(uint64_t this_ptr) {
37938 LDKAcceptChannel this_ptr_conv;
37939 this_ptr_conv.inner = untag_ptr(this_ptr);
37940 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37942 this_ptr_conv.is_owned = false;
37943 int64_t ret_conv = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
37947 void __attribute__((export_name("TS_AcceptChannel_set_dust_limit_satoshis"))) TS_AcceptChannel_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
37948 LDKAcceptChannel this_ptr_conv;
37949 this_ptr_conv.inner = untag_ptr(this_ptr);
37950 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37952 this_ptr_conv.is_owned = false;
37953 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
37956 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) {
37957 LDKAcceptChannel this_ptr_conv;
37958 this_ptr_conv.inner = untag_ptr(this_ptr);
37959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37961 this_ptr_conv.is_owned = false;
37962 int64_t ret_conv = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
37966 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) {
37967 LDKAcceptChannel this_ptr_conv;
37968 this_ptr_conv.inner = untag_ptr(this_ptr);
37969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37971 this_ptr_conv.is_owned = false;
37972 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
37975 int64_t __attribute__((export_name("TS_AcceptChannel_get_channel_reserve_satoshis"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint64_t this_ptr) {
37976 LDKAcceptChannel this_ptr_conv;
37977 this_ptr_conv.inner = untag_ptr(this_ptr);
37978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37980 this_ptr_conv.is_owned = false;
37981 int64_t ret_conv = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
37985 void __attribute__((export_name("TS_AcceptChannel_set_channel_reserve_satoshis"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint64_t this_ptr, int64_t val) {
37986 LDKAcceptChannel this_ptr_conv;
37987 this_ptr_conv.inner = untag_ptr(this_ptr);
37988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37990 this_ptr_conv.is_owned = false;
37991 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
37994 int64_t __attribute__((export_name("TS_AcceptChannel_get_htlc_minimum_msat"))) TS_AcceptChannel_get_htlc_minimum_msat(uint64_t this_ptr) {
37995 LDKAcceptChannel this_ptr_conv;
37996 this_ptr_conv.inner = untag_ptr(this_ptr);
37997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
37998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
37999 this_ptr_conv.is_owned = false;
38000 int64_t ret_conv = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
38004 void __attribute__((export_name("TS_AcceptChannel_set_htlc_minimum_msat"))) TS_AcceptChannel_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
38005 LDKAcceptChannel this_ptr_conv;
38006 this_ptr_conv.inner = untag_ptr(this_ptr);
38007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38009 this_ptr_conv.is_owned = false;
38010 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
38013 int32_t __attribute__((export_name("TS_AcceptChannel_get_minimum_depth"))) TS_AcceptChannel_get_minimum_depth(uint64_t this_ptr) {
38014 LDKAcceptChannel this_ptr_conv;
38015 this_ptr_conv.inner = untag_ptr(this_ptr);
38016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38018 this_ptr_conv.is_owned = false;
38019 int32_t ret_conv = AcceptChannel_get_minimum_depth(&this_ptr_conv);
38023 void __attribute__((export_name("TS_AcceptChannel_set_minimum_depth"))) TS_AcceptChannel_set_minimum_depth(uint64_t this_ptr, int32_t val) {
38024 LDKAcceptChannel this_ptr_conv;
38025 this_ptr_conv.inner = untag_ptr(this_ptr);
38026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38028 this_ptr_conv.is_owned = false;
38029 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
38032 int16_t __attribute__((export_name("TS_AcceptChannel_get_to_self_delay"))) TS_AcceptChannel_get_to_self_delay(uint64_t this_ptr) {
38033 LDKAcceptChannel this_ptr_conv;
38034 this_ptr_conv.inner = untag_ptr(this_ptr);
38035 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38037 this_ptr_conv.is_owned = false;
38038 int16_t ret_conv = AcceptChannel_get_to_self_delay(&this_ptr_conv);
38042 void __attribute__((export_name("TS_AcceptChannel_set_to_self_delay"))) TS_AcceptChannel_set_to_self_delay(uint64_t this_ptr, int16_t val) {
38043 LDKAcceptChannel this_ptr_conv;
38044 this_ptr_conv.inner = untag_ptr(this_ptr);
38045 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38047 this_ptr_conv.is_owned = false;
38048 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
38051 int16_t __attribute__((export_name("TS_AcceptChannel_get_max_accepted_htlcs"))) TS_AcceptChannel_get_max_accepted_htlcs(uint64_t this_ptr) {
38052 LDKAcceptChannel this_ptr_conv;
38053 this_ptr_conv.inner = untag_ptr(this_ptr);
38054 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38056 this_ptr_conv.is_owned = false;
38057 int16_t ret_conv = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
38061 void __attribute__((export_name("TS_AcceptChannel_set_max_accepted_htlcs"))) TS_AcceptChannel_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
38062 LDKAcceptChannel 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 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
38070 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_funding_pubkey"))) TS_AcceptChannel_get_funding_pubkey(uint64_t this_ptr) {
38071 LDKAcceptChannel this_ptr_conv;
38072 this_ptr_conv.inner = untag_ptr(this_ptr);
38073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38075 this_ptr_conv.is_owned = false;
38076 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38077 memcpy(ret_arr->elems, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
38081 void __attribute__((export_name("TS_AcceptChannel_set_funding_pubkey"))) TS_AcceptChannel_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
38082 LDKAcceptChannel this_ptr_conv;
38083 this_ptr_conv.inner = untag_ptr(this_ptr);
38084 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38086 this_ptr_conv.is_owned = false;
38087 LDKPublicKey val_ref;
38088 CHECK(val->arr_len == 33);
38089 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38090 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
38093 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_revocation_basepoint"))) TS_AcceptChannel_get_revocation_basepoint(uint64_t this_ptr) {
38094 LDKAcceptChannel this_ptr_conv;
38095 this_ptr_conv.inner = untag_ptr(this_ptr);
38096 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38098 this_ptr_conv.is_owned = false;
38099 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38100 memcpy(ret_arr->elems, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
38104 void __attribute__((export_name("TS_AcceptChannel_set_revocation_basepoint"))) TS_AcceptChannel_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
38105 LDKAcceptChannel this_ptr_conv;
38106 this_ptr_conv.inner = untag_ptr(this_ptr);
38107 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38109 this_ptr_conv.is_owned = false;
38110 LDKPublicKey val_ref;
38111 CHECK(val->arr_len == 33);
38112 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38113 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
38116 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_payment_point"))) TS_AcceptChannel_get_payment_point(uint64_t this_ptr) {
38117 LDKAcceptChannel this_ptr_conv;
38118 this_ptr_conv.inner = untag_ptr(this_ptr);
38119 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38121 this_ptr_conv.is_owned = false;
38122 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38123 memcpy(ret_arr->elems, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
38127 void __attribute__((export_name("TS_AcceptChannel_set_payment_point"))) TS_AcceptChannel_set_payment_point(uint64_t this_ptr, int8_tArray val) {
38128 LDKAcceptChannel this_ptr_conv;
38129 this_ptr_conv.inner = untag_ptr(this_ptr);
38130 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38132 this_ptr_conv.is_owned = false;
38133 LDKPublicKey val_ref;
38134 CHECK(val->arr_len == 33);
38135 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38136 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
38139 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_delayed_payment_basepoint"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint64_t this_ptr) {
38140 LDKAcceptChannel this_ptr_conv;
38141 this_ptr_conv.inner = untag_ptr(this_ptr);
38142 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38144 this_ptr_conv.is_owned = false;
38145 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38146 memcpy(ret_arr->elems, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
38150 void __attribute__((export_name("TS_AcceptChannel_set_delayed_payment_basepoint"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
38151 LDKAcceptChannel this_ptr_conv;
38152 this_ptr_conv.inner = untag_ptr(this_ptr);
38153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38155 this_ptr_conv.is_owned = false;
38156 LDKPublicKey val_ref;
38157 CHECK(val->arr_len == 33);
38158 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38159 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
38162 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_htlc_basepoint"))) TS_AcceptChannel_get_htlc_basepoint(uint64_t this_ptr) {
38163 LDKAcceptChannel this_ptr_conv;
38164 this_ptr_conv.inner = untag_ptr(this_ptr);
38165 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38167 this_ptr_conv.is_owned = false;
38168 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38169 memcpy(ret_arr->elems, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
38173 void __attribute__((export_name("TS_AcceptChannel_set_htlc_basepoint"))) TS_AcceptChannel_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
38174 LDKAcceptChannel this_ptr_conv;
38175 this_ptr_conv.inner = untag_ptr(this_ptr);
38176 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38178 this_ptr_conv.is_owned = false;
38179 LDKPublicKey val_ref;
38180 CHECK(val->arr_len == 33);
38181 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38182 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
38185 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_first_per_commitment_point"))) TS_AcceptChannel_get_first_per_commitment_point(uint64_t this_ptr) {
38186 LDKAcceptChannel this_ptr_conv;
38187 this_ptr_conv.inner = untag_ptr(this_ptr);
38188 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38189 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38190 this_ptr_conv.is_owned = false;
38191 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38192 memcpy(ret_arr->elems, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
38196 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) {
38197 LDKAcceptChannel this_ptr_conv;
38198 this_ptr_conv.inner = untag_ptr(this_ptr);
38199 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38200 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38201 this_ptr_conv.is_owned = false;
38202 LDKPublicKey val_ref;
38203 CHECK(val->arr_len == 33);
38204 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38205 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
38208 uint64_t __attribute__((export_name("TS_AcceptChannel_get_shutdown_scriptpubkey"))) TS_AcceptChannel_get_shutdown_scriptpubkey(uint64_t this_ptr) {
38209 LDKAcceptChannel this_ptr_conv;
38210 this_ptr_conv.inner = untag_ptr(this_ptr);
38211 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38212 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38213 this_ptr_conv.is_owned = false;
38214 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
38215 *ret_copy = AcceptChannel_get_shutdown_scriptpubkey(&this_ptr_conv);
38216 uint64_t ret_ref = tag_ptr(ret_copy, true);
38220 void __attribute__((export_name("TS_AcceptChannel_set_shutdown_scriptpubkey"))) TS_AcceptChannel_set_shutdown_scriptpubkey(uint64_t this_ptr, uint64_t val) {
38221 LDKAcceptChannel this_ptr_conv;
38222 this_ptr_conv.inner = untag_ptr(this_ptr);
38223 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38225 this_ptr_conv.is_owned = false;
38226 void* val_ptr = untag_ptr(val);
38227 CHECK_ACCESS(val_ptr);
38228 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
38229 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
38230 AcceptChannel_set_shutdown_scriptpubkey(&this_ptr_conv, val_conv);
38233 uint64_t __attribute__((export_name("TS_AcceptChannel_get_channel_type"))) TS_AcceptChannel_get_channel_type(uint64_t this_ptr) {
38234 LDKAcceptChannel this_ptr_conv;
38235 this_ptr_conv.inner = untag_ptr(this_ptr);
38236 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38238 this_ptr_conv.is_owned = false;
38239 LDKChannelTypeFeatures ret_var = AcceptChannel_get_channel_type(&this_ptr_conv);
38240 uint64_t ret_ref = 0;
38241 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38242 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38246 void __attribute__((export_name("TS_AcceptChannel_set_channel_type"))) TS_AcceptChannel_set_channel_type(uint64_t this_ptr, uint64_t val) {
38247 LDKAcceptChannel this_ptr_conv;
38248 this_ptr_conv.inner = untag_ptr(this_ptr);
38249 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38251 this_ptr_conv.is_owned = false;
38252 LDKChannelTypeFeatures val_conv;
38253 val_conv.inner = untag_ptr(val);
38254 val_conv.is_owned = ptr_is_owned(val);
38255 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38256 val_conv = ChannelTypeFeatures_clone(&val_conv);
38257 AcceptChannel_set_channel_type(&this_ptr_conv, val_conv);
38260 uint64_t __attribute__((export_name("TS_AcceptChannel_new"))) TS_AcceptChannel_new(int8_tArray temporary_channel_id_arg, int64_t dust_limit_satoshis_arg, int64_t max_htlc_value_in_flight_msat_arg, int64_t channel_reserve_satoshis_arg, int64_t htlc_minimum_msat_arg, int32_t minimum_depth_arg, int16_t to_self_delay_arg, int16_t max_accepted_htlcs_arg, 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, int8_tArray first_per_commitment_point_arg, uint64_t shutdown_scriptpubkey_arg, uint64_t channel_type_arg) {
38261 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
38262 CHECK(temporary_channel_id_arg->arr_len == 32);
38263 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
38264 LDKPublicKey funding_pubkey_arg_ref;
38265 CHECK(funding_pubkey_arg->arr_len == 33);
38266 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
38267 LDKPublicKey revocation_basepoint_arg_ref;
38268 CHECK(revocation_basepoint_arg->arr_len == 33);
38269 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
38270 LDKPublicKey payment_point_arg_ref;
38271 CHECK(payment_point_arg->arr_len == 33);
38272 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
38273 LDKPublicKey delayed_payment_basepoint_arg_ref;
38274 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
38275 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
38276 LDKPublicKey htlc_basepoint_arg_ref;
38277 CHECK(htlc_basepoint_arg->arr_len == 33);
38278 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
38279 LDKPublicKey first_per_commitment_point_arg_ref;
38280 CHECK(first_per_commitment_point_arg->arr_len == 33);
38281 memcpy(first_per_commitment_point_arg_ref.compressed_form, first_per_commitment_point_arg->elems, 33); FREE(first_per_commitment_point_arg);
38282 void* shutdown_scriptpubkey_arg_ptr = untag_ptr(shutdown_scriptpubkey_arg);
38283 CHECK_ACCESS(shutdown_scriptpubkey_arg_ptr);
38284 LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg_conv = *(LDKCOption_CVec_u8ZZ*)(shutdown_scriptpubkey_arg_ptr);
38285 shutdown_scriptpubkey_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(shutdown_scriptpubkey_arg));
38286 LDKChannelTypeFeatures channel_type_arg_conv;
38287 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
38288 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
38289 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
38290 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
38291 LDKAcceptChannel ret_var = AcceptChannel_new(temporary_channel_id_arg_ref, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, channel_reserve_satoshis_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg_ref, revocation_basepoint_arg_ref, payment_point_arg_ref, delayed_payment_basepoint_arg_ref, htlc_basepoint_arg_ref, first_per_commitment_point_arg_ref, shutdown_scriptpubkey_arg_conv, channel_type_arg_conv);
38292 uint64_t ret_ref = 0;
38293 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38294 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38298 static inline uint64_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
38299 LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
38300 uint64_t ret_ref = 0;
38301 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38302 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38305 int64_t __attribute__((export_name("TS_AcceptChannel_clone_ptr"))) TS_AcceptChannel_clone_ptr(uint64_t arg) {
38306 LDKAcceptChannel arg_conv;
38307 arg_conv.inner = untag_ptr(arg);
38308 arg_conv.is_owned = ptr_is_owned(arg);
38309 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38310 arg_conv.is_owned = false;
38311 int64_t ret_conv = AcceptChannel_clone_ptr(&arg_conv);
38315 uint64_t __attribute__((export_name("TS_AcceptChannel_clone"))) TS_AcceptChannel_clone(uint64_t orig) {
38316 LDKAcceptChannel orig_conv;
38317 orig_conv.inner = untag_ptr(orig);
38318 orig_conv.is_owned = ptr_is_owned(orig);
38319 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38320 orig_conv.is_owned = false;
38321 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
38322 uint64_t ret_ref = 0;
38323 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38324 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38328 jboolean __attribute__((export_name("TS_AcceptChannel_eq"))) TS_AcceptChannel_eq(uint64_t a, uint64_t b) {
38329 LDKAcceptChannel a_conv;
38330 a_conv.inner = untag_ptr(a);
38331 a_conv.is_owned = ptr_is_owned(a);
38332 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38333 a_conv.is_owned = false;
38334 LDKAcceptChannel b_conv;
38335 b_conv.inner = untag_ptr(b);
38336 b_conv.is_owned = ptr_is_owned(b);
38337 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38338 b_conv.is_owned = false;
38339 jboolean ret_conv = AcceptChannel_eq(&a_conv, &b_conv);
38343 void __attribute__((export_name("TS_AcceptChannelV2_free"))) TS_AcceptChannelV2_free(uint64_t this_obj) {
38344 LDKAcceptChannelV2 this_obj_conv;
38345 this_obj_conv.inner = untag_ptr(this_obj);
38346 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38348 AcceptChannelV2_free(this_obj_conv);
38351 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_temporary_channel_id"))) TS_AcceptChannelV2_get_temporary_channel_id(uint64_t this_ptr) {
38352 LDKAcceptChannelV2 this_ptr_conv;
38353 this_ptr_conv.inner = untag_ptr(this_ptr);
38354 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38356 this_ptr_conv.is_owned = false;
38357 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38358 memcpy(ret_arr->elems, *AcceptChannelV2_get_temporary_channel_id(&this_ptr_conv), 32);
38362 void __attribute__((export_name("TS_AcceptChannelV2_set_temporary_channel_id"))) TS_AcceptChannelV2_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
38363 LDKAcceptChannelV2 this_ptr_conv;
38364 this_ptr_conv.inner = untag_ptr(this_ptr);
38365 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38367 this_ptr_conv.is_owned = false;
38368 LDKThirtyTwoBytes val_ref;
38369 CHECK(val->arr_len == 32);
38370 memcpy(val_ref.data, val->elems, 32); FREE(val);
38371 AcceptChannelV2_set_temporary_channel_id(&this_ptr_conv, val_ref);
38374 int64_t __attribute__((export_name("TS_AcceptChannelV2_get_funding_satoshis"))) TS_AcceptChannelV2_get_funding_satoshis(uint64_t this_ptr) {
38375 LDKAcceptChannelV2 this_ptr_conv;
38376 this_ptr_conv.inner = untag_ptr(this_ptr);
38377 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38379 this_ptr_conv.is_owned = false;
38380 int64_t ret_conv = AcceptChannelV2_get_funding_satoshis(&this_ptr_conv);
38384 void __attribute__((export_name("TS_AcceptChannelV2_set_funding_satoshis"))) TS_AcceptChannelV2_set_funding_satoshis(uint64_t this_ptr, int64_t val) {
38385 LDKAcceptChannelV2 this_ptr_conv;
38386 this_ptr_conv.inner = untag_ptr(this_ptr);
38387 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38388 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38389 this_ptr_conv.is_owned = false;
38390 AcceptChannelV2_set_funding_satoshis(&this_ptr_conv, val);
38393 int64_t __attribute__((export_name("TS_AcceptChannelV2_get_dust_limit_satoshis"))) TS_AcceptChannelV2_get_dust_limit_satoshis(uint64_t this_ptr) {
38394 LDKAcceptChannelV2 this_ptr_conv;
38395 this_ptr_conv.inner = untag_ptr(this_ptr);
38396 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38398 this_ptr_conv.is_owned = false;
38399 int64_t ret_conv = AcceptChannelV2_get_dust_limit_satoshis(&this_ptr_conv);
38403 void __attribute__((export_name("TS_AcceptChannelV2_set_dust_limit_satoshis"))) TS_AcceptChannelV2_set_dust_limit_satoshis(uint64_t this_ptr, int64_t val) {
38404 LDKAcceptChannelV2 this_ptr_conv;
38405 this_ptr_conv.inner = untag_ptr(this_ptr);
38406 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38408 this_ptr_conv.is_owned = false;
38409 AcceptChannelV2_set_dust_limit_satoshis(&this_ptr_conv, val);
38412 int64_t __attribute__((export_name("TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat"))) TS_AcceptChannelV2_get_max_htlc_value_in_flight_msat(uint64_t this_ptr) {
38413 LDKAcceptChannelV2 this_ptr_conv;
38414 this_ptr_conv.inner = untag_ptr(this_ptr);
38415 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38417 this_ptr_conv.is_owned = false;
38418 int64_t ret_conv = AcceptChannelV2_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
38422 void __attribute__((export_name("TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat"))) TS_AcceptChannelV2_set_max_htlc_value_in_flight_msat(uint64_t this_ptr, int64_t val) {
38423 LDKAcceptChannelV2 this_ptr_conv;
38424 this_ptr_conv.inner = untag_ptr(this_ptr);
38425 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38427 this_ptr_conv.is_owned = false;
38428 AcceptChannelV2_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
38431 int64_t __attribute__((export_name("TS_AcceptChannelV2_get_htlc_minimum_msat"))) TS_AcceptChannelV2_get_htlc_minimum_msat(uint64_t this_ptr) {
38432 LDKAcceptChannelV2 this_ptr_conv;
38433 this_ptr_conv.inner = untag_ptr(this_ptr);
38434 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38436 this_ptr_conv.is_owned = false;
38437 int64_t ret_conv = AcceptChannelV2_get_htlc_minimum_msat(&this_ptr_conv);
38441 void __attribute__((export_name("TS_AcceptChannelV2_set_htlc_minimum_msat"))) TS_AcceptChannelV2_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
38442 LDKAcceptChannelV2 this_ptr_conv;
38443 this_ptr_conv.inner = untag_ptr(this_ptr);
38444 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38446 this_ptr_conv.is_owned = false;
38447 AcceptChannelV2_set_htlc_minimum_msat(&this_ptr_conv, val);
38450 int32_t __attribute__((export_name("TS_AcceptChannelV2_get_minimum_depth"))) TS_AcceptChannelV2_get_minimum_depth(uint64_t this_ptr) {
38451 LDKAcceptChannelV2 this_ptr_conv;
38452 this_ptr_conv.inner = untag_ptr(this_ptr);
38453 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38454 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38455 this_ptr_conv.is_owned = false;
38456 int32_t ret_conv = AcceptChannelV2_get_minimum_depth(&this_ptr_conv);
38460 void __attribute__((export_name("TS_AcceptChannelV2_set_minimum_depth"))) TS_AcceptChannelV2_set_minimum_depth(uint64_t this_ptr, int32_t val) {
38461 LDKAcceptChannelV2 this_ptr_conv;
38462 this_ptr_conv.inner = untag_ptr(this_ptr);
38463 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38464 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38465 this_ptr_conv.is_owned = false;
38466 AcceptChannelV2_set_minimum_depth(&this_ptr_conv, val);
38469 int16_t __attribute__((export_name("TS_AcceptChannelV2_get_to_self_delay"))) TS_AcceptChannelV2_get_to_self_delay(uint64_t this_ptr) {
38470 LDKAcceptChannelV2 this_ptr_conv;
38471 this_ptr_conv.inner = untag_ptr(this_ptr);
38472 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38474 this_ptr_conv.is_owned = false;
38475 int16_t ret_conv = AcceptChannelV2_get_to_self_delay(&this_ptr_conv);
38479 void __attribute__((export_name("TS_AcceptChannelV2_set_to_self_delay"))) TS_AcceptChannelV2_set_to_self_delay(uint64_t this_ptr, int16_t val) {
38480 LDKAcceptChannelV2 this_ptr_conv;
38481 this_ptr_conv.inner = untag_ptr(this_ptr);
38482 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38484 this_ptr_conv.is_owned = false;
38485 AcceptChannelV2_set_to_self_delay(&this_ptr_conv, val);
38488 int16_t __attribute__((export_name("TS_AcceptChannelV2_get_max_accepted_htlcs"))) TS_AcceptChannelV2_get_max_accepted_htlcs(uint64_t this_ptr) {
38489 LDKAcceptChannelV2 this_ptr_conv;
38490 this_ptr_conv.inner = untag_ptr(this_ptr);
38491 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38493 this_ptr_conv.is_owned = false;
38494 int16_t ret_conv = AcceptChannelV2_get_max_accepted_htlcs(&this_ptr_conv);
38498 void __attribute__((export_name("TS_AcceptChannelV2_set_max_accepted_htlcs"))) TS_AcceptChannelV2_set_max_accepted_htlcs(uint64_t this_ptr, int16_t val) {
38499 LDKAcceptChannelV2 this_ptr_conv;
38500 this_ptr_conv.inner = untag_ptr(this_ptr);
38501 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38503 this_ptr_conv.is_owned = false;
38504 AcceptChannelV2_set_max_accepted_htlcs(&this_ptr_conv, val);
38507 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_funding_pubkey"))) TS_AcceptChannelV2_get_funding_pubkey(uint64_t this_ptr) {
38508 LDKAcceptChannelV2 this_ptr_conv;
38509 this_ptr_conv.inner = untag_ptr(this_ptr);
38510 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38512 this_ptr_conv.is_owned = false;
38513 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38514 memcpy(ret_arr->elems, AcceptChannelV2_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
38518 void __attribute__((export_name("TS_AcceptChannelV2_set_funding_pubkey"))) TS_AcceptChannelV2_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
38519 LDKAcceptChannelV2 this_ptr_conv;
38520 this_ptr_conv.inner = untag_ptr(this_ptr);
38521 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38523 this_ptr_conv.is_owned = false;
38524 LDKPublicKey val_ref;
38525 CHECK(val->arr_len == 33);
38526 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38527 AcceptChannelV2_set_funding_pubkey(&this_ptr_conv, val_ref);
38530 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_revocation_basepoint"))) TS_AcceptChannelV2_get_revocation_basepoint(uint64_t this_ptr) {
38531 LDKAcceptChannelV2 this_ptr_conv;
38532 this_ptr_conv.inner = untag_ptr(this_ptr);
38533 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38535 this_ptr_conv.is_owned = false;
38536 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38537 memcpy(ret_arr->elems, AcceptChannelV2_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
38541 void __attribute__((export_name("TS_AcceptChannelV2_set_revocation_basepoint"))) TS_AcceptChannelV2_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
38542 LDKAcceptChannelV2 this_ptr_conv;
38543 this_ptr_conv.inner = untag_ptr(this_ptr);
38544 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38546 this_ptr_conv.is_owned = false;
38547 LDKPublicKey val_ref;
38548 CHECK(val->arr_len == 33);
38549 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38550 AcceptChannelV2_set_revocation_basepoint(&this_ptr_conv, val_ref);
38553 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_payment_basepoint"))) TS_AcceptChannelV2_get_payment_basepoint(uint64_t this_ptr) {
38554 LDKAcceptChannelV2 this_ptr_conv;
38555 this_ptr_conv.inner = untag_ptr(this_ptr);
38556 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38558 this_ptr_conv.is_owned = false;
38559 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38560 memcpy(ret_arr->elems, AcceptChannelV2_get_payment_basepoint(&this_ptr_conv).compressed_form, 33);
38564 void __attribute__((export_name("TS_AcceptChannelV2_set_payment_basepoint"))) TS_AcceptChannelV2_set_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
38565 LDKAcceptChannelV2 this_ptr_conv;
38566 this_ptr_conv.inner = untag_ptr(this_ptr);
38567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38569 this_ptr_conv.is_owned = false;
38570 LDKPublicKey val_ref;
38571 CHECK(val->arr_len == 33);
38572 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38573 AcceptChannelV2_set_payment_basepoint(&this_ptr_conv, val_ref);
38576 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_delayed_payment_basepoint"))) TS_AcceptChannelV2_get_delayed_payment_basepoint(uint64_t this_ptr) {
38577 LDKAcceptChannelV2 this_ptr_conv;
38578 this_ptr_conv.inner = untag_ptr(this_ptr);
38579 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38580 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38581 this_ptr_conv.is_owned = false;
38582 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38583 memcpy(ret_arr->elems, AcceptChannelV2_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
38587 void __attribute__((export_name("TS_AcceptChannelV2_set_delayed_payment_basepoint"))) TS_AcceptChannelV2_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
38588 LDKAcceptChannelV2 this_ptr_conv;
38589 this_ptr_conv.inner = untag_ptr(this_ptr);
38590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38592 this_ptr_conv.is_owned = false;
38593 LDKPublicKey val_ref;
38594 CHECK(val->arr_len == 33);
38595 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38596 AcceptChannelV2_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
38599 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_htlc_basepoint"))) TS_AcceptChannelV2_get_htlc_basepoint(uint64_t this_ptr) {
38600 LDKAcceptChannelV2 this_ptr_conv;
38601 this_ptr_conv.inner = untag_ptr(this_ptr);
38602 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38604 this_ptr_conv.is_owned = false;
38605 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38606 memcpy(ret_arr->elems, AcceptChannelV2_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
38610 void __attribute__((export_name("TS_AcceptChannelV2_set_htlc_basepoint"))) TS_AcceptChannelV2_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
38611 LDKAcceptChannelV2 this_ptr_conv;
38612 this_ptr_conv.inner = untag_ptr(this_ptr);
38613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38615 this_ptr_conv.is_owned = false;
38616 LDKPublicKey val_ref;
38617 CHECK(val->arr_len == 33);
38618 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38619 AcceptChannelV2_set_htlc_basepoint(&this_ptr_conv, val_ref);
38622 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_first_per_commitment_point"))) TS_AcceptChannelV2_get_first_per_commitment_point(uint64_t this_ptr) {
38623 LDKAcceptChannelV2 this_ptr_conv;
38624 this_ptr_conv.inner = untag_ptr(this_ptr);
38625 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38626 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38627 this_ptr_conv.is_owned = false;
38628 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38629 memcpy(ret_arr->elems, AcceptChannelV2_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
38633 void __attribute__((export_name("TS_AcceptChannelV2_set_first_per_commitment_point"))) TS_AcceptChannelV2_set_first_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
38634 LDKAcceptChannelV2 this_ptr_conv;
38635 this_ptr_conv.inner = untag_ptr(this_ptr);
38636 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38638 this_ptr_conv.is_owned = false;
38639 LDKPublicKey val_ref;
38640 CHECK(val->arr_len == 33);
38641 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38642 AcceptChannelV2_set_first_per_commitment_point(&this_ptr_conv, val_ref);
38645 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_get_second_per_commitment_point"))) TS_AcceptChannelV2_get_second_per_commitment_point(uint64_t this_ptr) {
38646 LDKAcceptChannelV2 this_ptr_conv;
38647 this_ptr_conv.inner = untag_ptr(this_ptr);
38648 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38650 this_ptr_conv.is_owned = false;
38651 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
38652 memcpy(ret_arr->elems, AcceptChannelV2_get_second_per_commitment_point(&this_ptr_conv).compressed_form, 33);
38656 void __attribute__((export_name("TS_AcceptChannelV2_set_second_per_commitment_point"))) TS_AcceptChannelV2_set_second_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
38657 LDKAcceptChannelV2 this_ptr_conv;
38658 this_ptr_conv.inner = untag_ptr(this_ptr);
38659 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38660 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38661 this_ptr_conv.is_owned = false;
38662 LDKPublicKey val_ref;
38663 CHECK(val->arr_len == 33);
38664 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
38665 AcceptChannelV2_set_second_per_commitment_point(&this_ptr_conv, val_ref);
38668 uint64_t __attribute__((export_name("TS_AcceptChannelV2_get_shutdown_scriptpubkey"))) TS_AcceptChannelV2_get_shutdown_scriptpubkey(uint64_t this_ptr) {
38669 LDKAcceptChannelV2 this_ptr_conv;
38670 this_ptr_conv.inner = untag_ptr(this_ptr);
38671 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38673 this_ptr_conv.is_owned = false;
38674 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
38675 *ret_copy = AcceptChannelV2_get_shutdown_scriptpubkey(&this_ptr_conv);
38676 uint64_t ret_ref = tag_ptr(ret_copy, true);
38680 void __attribute__((export_name("TS_AcceptChannelV2_set_shutdown_scriptpubkey"))) TS_AcceptChannelV2_set_shutdown_scriptpubkey(uint64_t this_ptr, uint64_t val) {
38681 LDKAcceptChannelV2 this_ptr_conv;
38682 this_ptr_conv.inner = untag_ptr(this_ptr);
38683 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38685 this_ptr_conv.is_owned = false;
38686 void* val_ptr = untag_ptr(val);
38687 CHECK_ACCESS(val_ptr);
38688 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
38689 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
38690 AcceptChannelV2_set_shutdown_scriptpubkey(&this_ptr_conv, val_conv);
38693 uint64_t __attribute__((export_name("TS_AcceptChannelV2_get_channel_type"))) TS_AcceptChannelV2_get_channel_type(uint64_t this_ptr) {
38694 LDKAcceptChannelV2 this_ptr_conv;
38695 this_ptr_conv.inner = untag_ptr(this_ptr);
38696 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38698 this_ptr_conv.is_owned = false;
38699 LDKChannelTypeFeatures ret_var = AcceptChannelV2_get_channel_type(&this_ptr_conv);
38700 uint64_t ret_ref = 0;
38701 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38702 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38706 void __attribute__((export_name("TS_AcceptChannelV2_set_channel_type"))) TS_AcceptChannelV2_set_channel_type(uint64_t this_ptr, uint64_t val) {
38707 LDKAcceptChannelV2 this_ptr_conv;
38708 this_ptr_conv.inner = untag_ptr(this_ptr);
38709 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38711 this_ptr_conv.is_owned = false;
38712 LDKChannelTypeFeatures val_conv;
38713 val_conv.inner = untag_ptr(val);
38714 val_conv.is_owned = ptr_is_owned(val);
38715 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
38716 val_conv = ChannelTypeFeatures_clone(&val_conv);
38717 AcceptChannelV2_set_channel_type(&this_ptr_conv, val_conv);
38720 uint32_t __attribute__((export_name("TS_AcceptChannelV2_get_require_confirmed_inputs"))) TS_AcceptChannelV2_get_require_confirmed_inputs(uint64_t this_ptr) {
38721 LDKAcceptChannelV2 this_ptr_conv;
38722 this_ptr_conv.inner = untag_ptr(this_ptr);
38723 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38725 this_ptr_conv.is_owned = false;
38726 uint32_t ret_conv = LDKCOption_NoneZ_to_js(AcceptChannelV2_get_require_confirmed_inputs(&this_ptr_conv));
38730 void __attribute__((export_name("TS_AcceptChannelV2_set_require_confirmed_inputs"))) TS_AcceptChannelV2_set_require_confirmed_inputs(uint64_t this_ptr, uint32_t val) {
38731 LDKAcceptChannelV2 this_ptr_conv;
38732 this_ptr_conv.inner = untag_ptr(this_ptr);
38733 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38735 this_ptr_conv.is_owned = false;
38736 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
38737 AcceptChannelV2_set_require_confirmed_inputs(&this_ptr_conv, val_conv);
38740 uint64_t __attribute__((export_name("TS_AcceptChannelV2_new"))) TS_AcceptChannelV2_new(int8_tArray temporary_channel_id_arg, int64_t funding_satoshis_arg, int64_t dust_limit_satoshis_arg, int64_t max_htlc_value_in_flight_msat_arg, int64_t htlc_minimum_msat_arg, int32_t minimum_depth_arg, int16_t to_self_delay_arg, int16_t max_accepted_htlcs_arg, int8_tArray funding_pubkey_arg, int8_tArray revocation_basepoint_arg, int8_tArray payment_basepoint_arg, int8_tArray delayed_payment_basepoint_arg, int8_tArray htlc_basepoint_arg, int8_tArray first_per_commitment_point_arg, int8_tArray second_per_commitment_point_arg, uint64_t shutdown_scriptpubkey_arg, uint64_t channel_type_arg, uint32_t require_confirmed_inputs_arg) {
38741 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
38742 CHECK(temporary_channel_id_arg->arr_len == 32);
38743 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
38744 LDKPublicKey funding_pubkey_arg_ref;
38745 CHECK(funding_pubkey_arg->arr_len == 33);
38746 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
38747 LDKPublicKey revocation_basepoint_arg_ref;
38748 CHECK(revocation_basepoint_arg->arr_len == 33);
38749 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
38750 LDKPublicKey payment_basepoint_arg_ref;
38751 CHECK(payment_basepoint_arg->arr_len == 33);
38752 memcpy(payment_basepoint_arg_ref.compressed_form, payment_basepoint_arg->elems, 33); FREE(payment_basepoint_arg);
38753 LDKPublicKey delayed_payment_basepoint_arg_ref;
38754 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
38755 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
38756 LDKPublicKey htlc_basepoint_arg_ref;
38757 CHECK(htlc_basepoint_arg->arr_len == 33);
38758 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
38759 LDKPublicKey first_per_commitment_point_arg_ref;
38760 CHECK(first_per_commitment_point_arg->arr_len == 33);
38761 memcpy(first_per_commitment_point_arg_ref.compressed_form, first_per_commitment_point_arg->elems, 33); FREE(first_per_commitment_point_arg);
38762 LDKPublicKey second_per_commitment_point_arg_ref;
38763 CHECK(second_per_commitment_point_arg->arr_len == 33);
38764 memcpy(second_per_commitment_point_arg_ref.compressed_form, second_per_commitment_point_arg->elems, 33); FREE(second_per_commitment_point_arg);
38765 void* shutdown_scriptpubkey_arg_ptr = untag_ptr(shutdown_scriptpubkey_arg);
38766 CHECK_ACCESS(shutdown_scriptpubkey_arg_ptr);
38767 LDKCOption_CVec_u8ZZ shutdown_scriptpubkey_arg_conv = *(LDKCOption_CVec_u8ZZ*)(shutdown_scriptpubkey_arg_ptr);
38768 shutdown_scriptpubkey_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(shutdown_scriptpubkey_arg));
38769 LDKChannelTypeFeatures channel_type_arg_conv;
38770 channel_type_arg_conv.inner = untag_ptr(channel_type_arg);
38771 channel_type_arg_conv.is_owned = ptr_is_owned(channel_type_arg);
38772 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
38773 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
38774 LDKCOption_NoneZ require_confirmed_inputs_arg_conv = LDKCOption_NoneZ_from_js(require_confirmed_inputs_arg);
38775 LDKAcceptChannelV2 ret_var = AcceptChannelV2_new(temporary_channel_id_arg_ref, funding_satoshis_arg, dust_limit_satoshis_arg, max_htlc_value_in_flight_msat_arg, htlc_minimum_msat_arg, minimum_depth_arg, to_self_delay_arg, max_accepted_htlcs_arg, funding_pubkey_arg_ref, revocation_basepoint_arg_ref, payment_basepoint_arg_ref, delayed_payment_basepoint_arg_ref, htlc_basepoint_arg_ref, first_per_commitment_point_arg_ref, second_per_commitment_point_arg_ref, shutdown_scriptpubkey_arg_conv, channel_type_arg_conv, require_confirmed_inputs_arg_conv);
38776 uint64_t ret_ref = 0;
38777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38782 static inline uint64_t AcceptChannelV2_clone_ptr(LDKAcceptChannelV2 *NONNULL_PTR arg) {
38783 LDKAcceptChannelV2 ret_var = AcceptChannelV2_clone(arg);
38784 uint64_t ret_ref = 0;
38785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38786 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38789 int64_t __attribute__((export_name("TS_AcceptChannelV2_clone_ptr"))) TS_AcceptChannelV2_clone_ptr(uint64_t arg) {
38790 LDKAcceptChannelV2 arg_conv;
38791 arg_conv.inner = untag_ptr(arg);
38792 arg_conv.is_owned = ptr_is_owned(arg);
38793 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38794 arg_conv.is_owned = false;
38795 int64_t ret_conv = AcceptChannelV2_clone_ptr(&arg_conv);
38799 uint64_t __attribute__((export_name("TS_AcceptChannelV2_clone"))) TS_AcceptChannelV2_clone(uint64_t orig) {
38800 LDKAcceptChannelV2 orig_conv;
38801 orig_conv.inner = untag_ptr(orig);
38802 orig_conv.is_owned = ptr_is_owned(orig);
38803 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38804 orig_conv.is_owned = false;
38805 LDKAcceptChannelV2 ret_var = AcceptChannelV2_clone(&orig_conv);
38806 uint64_t ret_ref = 0;
38807 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38808 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38812 jboolean __attribute__((export_name("TS_AcceptChannelV2_eq"))) TS_AcceptChannelV2_eq(uint64_t a, uint64_t b) {
38813 LDKAcceptChannelV2 a_conv;
38814 a_conv.inner = untag_ptr(a);
38815 a_conv.is_owned = ptr_is_owned(a);
38816 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38817 a_conv.is_owned = false;
38818 LDKAcceptChannelV2 b_conv;
38819 b_conv.inner = untag_ptr(b);
38820 b_conv.is_owned = ptr_is_owned(b);
38821 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38822 b_conv.is_owned = false;
38823 jboolean ret_conv = AcceptChannelV2_eq(&a_conv, &b_conv);
38827 void __attribute__((export_name("TS_FundingCreated_free"))) TS_FundingCreated_free(uint64_t this_obj) {
38828 LDKFundingCreated this_obj_conv;
38829 this_obj_conv.inner = untag_ptr(this_obj);
38830 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38832 FundingCreated_free(this_obj_conv);
38835 int8_tArray __attribute__((export_name("TS_FundingCreated_get_temporary_channel_id"))) TS_FundingCreated_get_temporary_channel_id(uint64_t this_ptr) {
38836 LDKFundingCreated this_ptr_conv;
38837 this_ptr_conv.inner = untag_ptr(this_ptr);
38838 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38840 this_ptr_conv.is_owned = false;
38841 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38842 memcpy(ret_arr->elems, *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
38846 void __attribute__((export_name("TS_FundingCreated_set_temporary_channel_id"))) TS_FundingCreated_set_temporary_channel_id(uint64_t this_ptr, int8_tArray val) {
38847 LDKFundingCreated this_ptr_conv;
38848 this_ptr_conv.inner = untag_ptr(this_ptr);
38849 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38851 this_ptr_conv.is_owned = false;
38852 LDKThirtyTwoBytes val_ref;
38853 CHECK(val->arr_len == 32);
38854 memcpy(val_ref.data, val->elems, 32); FREE(val);
38855 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
38858 int8_tArray __attribute__((export_name("TS_FundingCreated_get_funding_txid"))) TS_FundingCreated_get_funding_txid(uint64_t this_ptr) {
38859 LDKFundingCreated this_ptr_conv;
38860 this_ptr_conv.inner = untag_ptr(this_ptr);
38861 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38862 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38863 this_ptr_conv.is_owned = false;
38864 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
38865 memcpy(ret_arr->elems, *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
38869 void __attribute__((export_name("TS_FundingCreated_set_funding_txid"))) TS_FundingCreated_set_funding_txid(uint64_t this_ptr, int8_tArray val) {
38870 LDKFundingCreated this_ptr_conv;
38871 this_ptr_conv.inner = untag_ptr(this_ptr);
38872 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38874 this_ptr_conv.is_owned = false;
38875 LDKThirtyTwoBytes val_ref;
38876 CHECK(val->arr_len == 32);
38877 memcpy(val_ref.data, val->elems, 32); FREE(val);
38878 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
38881 int16_t __attribute__((export_name("TS_FundingCreated_get_funding_output_index"))) TS_FundingCreated_get_funding_output_index(uint64_t this_ptr) {
38882 LDKFundingCreated this_ptr_conv;
38883 this_ptr_conv.inner = untag_ptr(this_ptr);
38884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38886 this_ptr_conv.is_owned = false;
38887 int16_t ret_conv = FundingCreated_get_funding_output_index(&this_ptr_conv);
38891 void __attribute__((export_name("TS_FundingCreated_set_funding_output_index"))) TS_FundingCreated_set_funding_output_index(uint64_t this_ptr, int16_t val) {
38892 LDKFundingCreated this_ptr_conv;
38893 this_ptr_conv.inner = untag_ptr(this_ptr);
38894 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38896 this_ptr_conv.is_owned = false;
38897 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
38900 int8_tArray __attribute__((export_name("TS_FundingCreated_get_signature"))) TS_FundingCreated_get_signature(uint64_t this_ptr) {
38901 LDKFundingCreated this_ptr_conv;
38902 this_ptr_conv.inner = untag_ptr(this_ptr);
38903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38905 this_ptr_conv.is_owned = false;
38906 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
38907 memcpy(ret_arr->elems, FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
38911 void __attribute__((export_name("TS_FundingCreated_set_signature"))) TS_FundingCreated_set_signature(uint64_t this_ptr, int8_tArray val) {
38912 LDKFundingCreated this_ptr_conv;
38913 this_ptr_conv.inner = untag_ptr(this_ptr);
38914 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38916 this_ptr_conv.is_owned = false;
38917 LDKECDSASignature val_ref;
38918 CHECK(val->arr_len == 64);
38919 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
38920 FundingCreated_set_signature(&this_ptr_conv, val_ref);
38923 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) {
38924 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
38925 CHECK(temporary_channel_id_arg->arr_len == 32);
38926 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
38927 LDKThirtyTwoBytes funding_txid_arg_ref;
38928 CHECK(funding_txid_arg->arr_len == 32);
38929 memcpy(funding_txid_arg_ref.data, funding_txid_arg->elems, 32); FREE(funding_txid_arg);
38930 LDKECDSASignature signature_arg_ref;
38931 CHECK(signature_arg->arr_len == 64);
38932 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
38933 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
38934 uint64_t ret_ref = 0;
38935 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38936 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38940 static inline uint64_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
38941 LDKFundingCreated ret_var = FundingCreated_clone(arg);
38942 uint64_t ret_ref = 0;
38943 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38944 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38947 int64_t __attribute__((export_name("TS_FundingCreated_clone_ptr"))) TS_FundingCreated_clone_ptr(uint64_t arg) {
38948 LDKFundingCreated arg_conv;
38949 arg_conv.inner = untag_ptr(arg);
38950 arg_conv.is_owned = ptr_is_owned(arg);
38951 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38952 arg_conv.is_owned = false;
38953 int64_t ret_conv = FundingCreated_clone_ptr(&arg_conv);
38957 uint64_t __attribute__((export_name("TS_FundingCreated_clone"))) TS_FundingCreated_clone(uint64_t orig) {
38958 LDKFundingCreated orig_conv;
38959 orig_conv.inner = untag_ptr(orig);
38960 orig_conv.is_owned = ptr_is_owned(orig);
38961 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38962 orig_conv.is_owned = false;
38963 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
38964 uint64_t ret_ref = 0;
38965 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38966 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
38970 jboolean __attribute__((export_name("TS_FundingCreated_eq"))) TS_FundingCreated_eq(uint64_t a, uint64_t b) {
38971 LDKFundingCreated a_conv;
38972 a_conv.inner = untag_ptr(a);
38973 a_conv.is_owned = ptr_is_owned(a);
38974 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
38975 a_conv.is_owned = false;
38976 LDKFundingCreated b_conv;
38977 b_conv.inner = untag_ptr(b);
38978 b_conv.is_owned = ptr_is_owned(b);
38979 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
38980 b_conv.is_owned = false;
38981 jboolean ret_conv = FundingCreated_eq(&a_conv, &b_conv);
38985 void __attribute__((export_name("TS_FundingSigned_free"))) TS_FundingSigned_free(uint64_t this_obj) {
38986 LDKFundingSigned this_obj_conv;
38987 this_obj_conv.inner = untag_ptr(this_obj);
38988 this_obj_conv.is_owned = ptr_is_owned(this_obj);
38989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38990 FundingSigned_free(this_obj_conv);
38993 int8_tArray __attribute__((export_name("TS_FundingSigned_get_channel_id"))) TS_FundingSigned_get_channel_id(uint64_t this_ptr) {
38994 LDKFundingSigned this_ptr_conv;
38995 this_ptr_conv.inner = untag_ptr(this_ptr);
38996 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
38997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38998 this_ptr_conv.is_owned = false;
38999 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39000 memcpy(ret_arr->elems, *FundingSigned_get_channel_id(&this_ptr_conv), 32);
39004 void __attribute__((export_name("TS_FundingSigned_set_channel_id"))) TS_FundingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39005 LDKFundingSigned this_ptr_conv;
39006 this_ptr_conv.inner = untag_ptr(this_ptr);
39007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39009 this_ptr_conv.is_owned = false;
39010 LDKThirtyTwoBytes val_ref;
39011 CHECK(val->arr_len == 32);
39012 memcpy(val_ref.data, val->elems, 32); FREE(val);
39013 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
39016 int8_tArray __attribute__((export_name("TS_FundingSigned_get_signature"))) TS_FundingSigned_get_signature(uint64_t this_ptr) {
39017 LDKFundingSigned this_ptr_conv;
39018 this_ptr_conv.inner = untag_ptr(this_ptr);
39019 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39021 this_ptr_conv.is_owned = false;
39022 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
39023 memcpy(ret_arr->elems, FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
39027 void __attribute__((export_name("TS_FundingSigned_set_signature"))) TS_FundingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
39028 LDKFundingSigned 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 LDKECDSASignature val_ref;
39034 CHECK(val->arr_len == 64);
39035 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
39036 FundingSigned_set_signature(&this_ptr_conv, val_ref);
39039 uint64_t __attribute__((export_name("TS_FundingSigned_new"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
39040 LDKThirtyTwoBytes channel_id_arg_ref;
39041 CHECK(channel_id_arg->arr_len == 32);
39042 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39043 LDKECDSASignature signature_arg_ref;
39044 CHECK(signature_arg->arr_len == 64);
39045 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
39046 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
39047 uint64_t ret_ref = 0;
39048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39049 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39053 static inline uint64_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
39054 LDKFundingSigned ret_var = FundingSigned_clone(arg);
39055 uint64_t ret_ref = 0;
39056 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39057 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39060 int64_t __attribute__((export_name("TS_FundingSigned_clone_ptr"))) TS_FundingSigned_clone_ptr(uint64_t arg) {
39061 LDKFundingSigned arg_conv;
39062 arg_conv.inner = untag_ptr(arg);
39063 arg_conv.is_owned = ptr_is_owned(arg);
39064 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39065 arg_conv.is_owned = false;
39066 int64_t ret_conv = FundingSigned_clone_ptr(&arg_conv);
39070 uint64_t __attribute__((export_name("TS_FundingSigned_clone"))) TS_FundingSigned_clone(uint64_t orig) {
39071 LDKFundingSigned orig_conv;
39072 orig_conv.inner = untag_ptr(orig);
39073 orig_conv.is_owned = ptr_is_owned(orig);
39074 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39075 orig_conv.is_owned = false;
39076 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
39077 uint64_t ret_ref = 0;
39078 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39079 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39083 jboolean __attribute__((export_name("TS_FundingSigned_eq"))) TS_FundingSigned_eq(uint64_t a, uint64_t b) {
39084 LDKFundingSigned a_conv;
39085 a_conv.inner = untag_ptr(a);
39086 a_conv.is_owned = ptr_is_owned(a);
39087 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39088 a_conv.is_owned = false;
39089 LDKFundingSigned b_conv;
39090 b_conv.inner = untag_ptr(b);
39091 b_conv.is_owned = ptr_is_owned(b);
39092 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39093 b_conv.is_owned = false;
39094 jboolean ret_conv = FundingSigned_eq(&a_conv, &b_conv);
39098 void __attribute__((export_name("TS_ChannelReady_free"))) TS_ChannelReady_free(uint64_t this_obj) {
39099 LDKChannelReady this_obj_conv;
39100 this_obj_conv.inner = untag_ptr(this_obj);
39101 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39103 ChannelReady_free(this_obj_conv);
39106 int8_tArray __attribute__((export_name("TS_ChannelReady_get_channel_id"))) TS_ChannelReady_get_channel_id(uint64_t this_ptr) {
39107 LDKChannelReady this_ptr_conv;
39108 this_ptr_conv.inner = untag_ptr(this_ptr);
39109 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39110 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39111 this_ptr_conv.is_owned = false;
39112 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39113 memcpy(ret_arr->elems, *ChannelReady_get_channel_id(&this_ptr_conv), 32);
39117 void __attribute__((export_name("TS_ChannelReady_set_channel_id"))) TS_ChannelReady_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39118 LDKChannelReady this_ptr_conv;
39119 this_ptr_conv.inner = untag_ptr(this_ptr);
39120 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39121 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39122 this_ptr_conv.is_owned = false;
39123 LDKThirtyTwoBytes val_ref;
39124 CHECK(val->arr_len == 32);
39125 memcpy(val_ref.data, val->elems, 32); FREE(val);
39126 ChannelReady_set_channel_id(&this_ptr_conv, val_ref);
39129 int8_tArray __attribute__((export_name("TS_ChannelReady_get_next_per_commitment_point"))) TS_ChannelReady_get_next_per_commitment_point(uint64_t this_ptr) {
39130 LDKChannelReady this_ptr_conv;
39131 this_ptr_conv.inner = untag_ptr(this_ptr);
39132 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39134 this_ptr_conv.is_owned = false;
39135 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
39136 memcpy(ret_arr->elems, ChannelReady_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
39140 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) {
39141 LDKChannelReady this_ptr_conv;
39142 this_ptr_conv.inner = untag_ptr(this_ptr);
39143 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39144 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39145 this_ptr_conv.is_owned = false;
39146 LDKPublicKey val_ref;
39147 CHECK(val->arr_len == 33);
39148 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
39149 ChannelReady_set_next_per_commitment_point(&this_ptr_conv, val_ref);
39152 uint64_t __attribute__((export_name("TS_ChannelReady_get_short_channel_id_alias"))) TS_ChannelReady_get_short_channel_id_alias(uint64_t this_ptr) {
39153 LDKChannelReady this_ptr_conv;
39154 this_ptr_conv.inner = untag_ptr(this_ptr);
39155 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39157 this_ptr_conv.is_owned = false;
39158 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
39159 *ret_copy = ChannelReady_get_short_channel_id_alias(&this_ptr_conv);
39160 uint64_t ret_ref = tag_ptr(ret_copy, true);
39164 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) {
39165 LDKChannelReady this_ptr_conv;
39166 this_ptr_conv.inner = untag_ptr(this_ptr);
39167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39169 this_ptr_conv.is_owned = false;
39170 void* val_ptr = untag_ptr(val);
39171 CHECK_ACCESS(val_ptr);
39172 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
39173 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
39174 ChannelReady_set_short_channel_id_alias(&this_ptr_conv, val_conv);
39177 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) {
39178 LDKThirtyTwoBytes channel_id_arg_ref;
39179 CHECK(channel_id_arg->arr_len == 32);
39180 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39181 LDKPublicKey next_per_commitment_point_arg_ref;
39182 CHECK(next_per_commitment_point_arg->arr_len == 33);
39183 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
39184 void* short_channel_id_alias_arg_ptr = untag_ptr(short_channel_id_alias_arg);
39185 CHECK_ACCESS(short_channel_id_alias_arg_ptr);
39186 LDKCOption_u64Z short_channel_id_alias_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_alias_arg_ptr);
39187 short_channel_id_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id_alias_arg));
39188 LDKChannelReady ret_var = ChannelReady_new(channel_id_arg_ref, next_per_commitment_point_arg_ref, short_channel_id_alias_arg_conv);
39189 uint64_t ret_ref = 0;
39190 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39191 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39195 static inline uint64_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg) {
39196 LDKChannelReady ret_var = ChannelReady_clone(arg);
39197 uint64_t ret_ref = 0;
39198 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39199 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39202 int64_t __attribute__((export_name("TS_ChannelReady_clone_ptr"))) TS_ChannelReady_clone_ptr(uint64_t arg) {
39203 LDKChannelReady arg_conv;
39204 arg_conv.inner = untag_ptr(arg);
39205 arg_conv.is_owned = ptr_is_owned(arg);
39206 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39207 arg_conv.is_owned = false;
39208 int64_t ret_conv = ChannelReady_clone_ptr(&arg_conv);
39212 uint64_t __attribute__((export_name("TS_ChannelReady_clone"))) TS_ChannelReady_clone(uint64_t orig) {
39213 LDKChannelReady orig_conv;
39214 orig_conv.inner = untag_ptr(orig);
39215 orig_conv.is_owned = ptr_is_owned(orig);
39216 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39217 orig_conv.is_owned = false;
39218 LDKChannelReady ret_var = ChannelReady_clone(&orig_conv);
39219 uint64_t ret_ref = 0;
39220 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39221 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39225 jboolean __attribute__((export_name("TS_ChannelReady_eq"))) TS_ChannelReady_eq(uint64_t a, uint64_t b) {
39226 LDKChannelReady a_conv;
39227 a_conv.inner = untag_ptr(a);
39228 a_conv.is_owned = ptr_is_owned(a);
39229 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39230 a_conv.is_owned = false;
39231 LDKChannelReady b_conv;
39232 b_conv.inner = untag_ptr(b);
39233 b_conv.is_owned = ptr_is_owned(b);
39234 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39235 b_conv.is_owned = false;
39236 jboolean ret_conv = ChannelReady_eq(&a_conv, &b_conv);
39240 void __attribute__((export_name("TS_TxAddInput_free"))) TS_TxAddInput_free(uint64_t this_obj) {
39241 LDKTxAddInput this_obj_conv;
39242 this_obj_conv.inner = untag_ptr(this_obj);
39243 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39244 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39245 TxAddInput_free(this_obj_conv);
39248 int8_tArray __attribute__((export_name("TS_TxAddInput_get_channel_id"))) TS_TxAddInput_get_channel_id(uint64_t this_ptr) {
39249 LDKTxAddInput this_ptr_conv;
39250 this_ptr_conv.inner = untag_ptr(this_ptr);
39251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39253 this_ptr_conv.is_owned = false;
39254 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39255 memcpy(ret_arr->elems, *TxAddInput_get_channel_id(&this_ptr_conv), 32);
39259 void __attribute__((export_name("TS_TxAddInput_set_channel_id"))) TS_TxAddInput_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39260 LDKTxAddInput this_ptr_conv;
39261 this_ptr_conv.inner = untag_ptr(this_ptr);
39262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39264 this_ptr_conv.is_owned = false;
39265 LDKThirtyTwoBytes val_ref;
39266 CHECK(val->arr_len == 32);
39267 memcpy(val_ref.data, val->elems, 32); FREE(val);
39268 TxAddInput_set_channel_id(&this_ptr_conv, val_ref);
39271 int64_t __attribute__((export_name("TS_TxAddInput_get_serial_id"))) TS_TxAddInput_get_serial_id(uint64_t this_ptr) {
39272 LDKTxAddInput 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 int64_t ret_conv = TxAddInput_get_serial_id(&this_ptr_conv);
39281 void __attribute__((export_name("TS_TxAddInput_set_serial_id"))) TS_TxAddInput_set_serial_id(uint64_t this_ptr, int64_t val) {
39282 LDKTxAddInput this_ptr_conv;
39283 this_ptr_conv.inner = untag_ptr(this_ptr);
39284 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39286 this_ptr_conv.is_owned = false;
39287 TxAddInput_set_serial_id(&this_ptr_conv, val);
39290 uint64_t __attribute__((export_name("TS_TxAddInput_get_prevtx"))) TS_TxAddInput_get_prevtx(uint64_t this_ptr) {
39291 LDKTxAddInput this_ptr_conv;
39292 this_ptr_conv.inner = untag_ptr(this_ptr);
39293 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39295 this_ptr_conv.is_owned = false;
39296 LDKTransactionU16LenLimited ret_var = TxAddInput_get_prevtx(&this_ptr_conv);
39297 uint64_t ret_ref = 0;
39298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39303 void __attribute__((export_name("TS_TxAddInput_set_prevtx"))) TS_TxAddInput_set_prevtx(uint64_t this_ptr, uint64_t val) {
39304 LDKTxAddInput this_ptr_conv;
39305 this_ptr_conv.inner = untag_ptr(this_ptr);
39306 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39308 this_ptr_conv.is_owned = false;
39309 LDKTransactionU16LenLimited val_conv;
39310 val_conv.inner = untag_ptr(val);
39311 val_conv.is_owned = ptr_is_owned(val);
39312 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39313 val_conv = TransactionU16LenLimited_clone(&val_conv);
39314 TxAddInput_set_prevtx(&this_ptr_conv, val_conv);
39317 int32_t __attribute__((export_name("TS_TxAddInput_get_prevtx_out"))) TS_TxAddInput_get_prevtx_out(uint64_t this_ptr) {
39318 LDKTxAddInput this_ptr_conv;
39319 this_ptr_conv.inner = untag_ptr(this_ptr);
39320 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39322 this_ptr_conv.is_owned = false;
39323 int32_t ret_conv = TxAddInput_get_prevtx_out(&this_ptr_conv);
39327 void __attribute__((export_name("TS_TxAddInput_set_prevtx_out"))) TS_TxAddInput_set_prevtx_out(uint64_t this_ptr, int32_t val) {
39328 LDKTxAddInput this_ptr_conv;
39329 this_ptr_conv.inner = untag_ptr(this_ptr);
39330 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39332 this_ptr_conv.is_owned = false;
39333 TxAddInput_set_prevtx_out(&this_ptr_conv, val);
39336 int32_t __attribute__((export_name("TS_TxAddInput_get_sequence"))) TS_TxAddInput_get_sequence(uint64_t this_ptr) {
39337 LDKTxAddInput this_ptr_conv;
39338 this_ptr_conv.inner = untag_ptr(this_ptr);
39339 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39341 this_ptr_conv.is_owned = false;
39342 int32_t ret_conv = TxAddInput_get_sequence(&this_ptr_conv);
39346 void __attribute__((export_name("TS_TxAddInput_set_sequence"))) TS_TxAddInput_set_sequence(uint64_t this_ptr, int32_t val) {
39347 LDKTxAddInput this_ptr_conv;
39348 this_ptr_conv.inner = untag_ptr(this_ptr);
39349 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39350 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39351 this_ptr_conv.is_owned = false;
39352 TxAddInput_set_sequence(&this_ptr_conv, val);
39355 uint64_t __attribute__((export_name("TS_TxAddInput_new"))) TS_TxAddInput_new(int8_tArray channel_id_arg, int64_t serial_id_arg, uint64_t prevtx_arg, int32_t prevtx_out_arg, int32_t sequence_arg) {
39356 LDKThirtyTwoBytes channel_id_arg_ref;
39357 CHECK(channel_id_arg->arr_len == 32);
39358 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39359 LDKTransactionU16LenLimited prevtx_arg_conv;
39360 prevtx_arg_conv.inner = untag_ptr(prevtx_arg);
39361 prevtx_arg_conv.is_owned = ptr_is_owned(prevtx_arg);
39362 CHECK_INNER_FIELD_ACCESS_OR_NULL(prevtx_arg_conv);
39363 prevtx_arg_conv = TransactionU16LenLimited_clone(&prevtx_arg_conv);
39364 LDKTxAddInput ret_var = TxAddInput_new(channel_id_arg_ref, serial_id_arg, prevtx_arg_conv, prevtx_out_arg, sequence_arg);
39365 uint64_t ret_ref = 0;
39366 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39367 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39371 static inline uint64_t TxAddInput_clone_ptr(LDKTxAddInput *NONNULL_PTR arg) {
39372 LDKTxAddInput ret_var = TxAddInput_clone(arg);
39373 uint64_t ret_ref = 0;
39374 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39375 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39378 int64_t __attribute__((export_name("TS_TxAddInput_clone_ptr"))) TS_TxAddInput_clone_ptr(uint64_t arg) {
39379 LDKTxAddInput arg_conv;
39380 arg_conv.inner = untag_ptr(arg);
39381 arg_conv.is_owned = ptr_is_owned(arg);
39382 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39383 arg_conv.is_owned = false;
39384 int64_t ret_conv = TxAddInput_clone_ptr(&arg_conv);
39388 uint64_t __attribute__((export_name("TS_TxAddInput_clone"))) TS_TxAddInput_clone(uint64_t orig) {
39389 LDKTxAddInput orig_conv;
39390 orig_conv.inner = untag_ptr(orig);
39391 orig_conv.is_owned = ptr_is_owned(orig);
39392 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39393 orig_conv.is_owned = false;
39394 LDKTxAddInput ret_var = TxAddInput_clone(&orig_conv);
39395 uint64_t ret_ref = 0;
39396 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39397 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39401 jboolean __attribute__((export_name("TS_TxAddInput_eq"))) TS_TxAddInput_eq(uint64_t a, uint64_t b) {
39402 LDKTxAddInput a_conv;
39403 a_conv.inner = untag_ptr(a);
39404 a_conv.is_owned = ptr_is_owned(a);
39405 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39406 a_conv.is_owned = false;
39407 LDKTxAddInput b_conv;
39408 b_conv.inner = untag_ptr(b);
39409 b_conv.is_owned = ptr_is_owned(b);
39410 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39411 b_conv.is_owned = false;
39412 jboolean ret_conv = TxAddInput_eq(&a_conv, &b_conv);
39416 void __attribute__((export_name("TS_TxAddOutput_free"))) TS_TxAddOutput_free(uint64_t this_obj) {
39417 LDKTxAddOutput this_obj_conv;
39418 this_obj_conv.inner = untag_ptr(this_obj);
39419 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39420 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39421 TxAddOutput_free(this_obj_conv);
39424 int8_tArray __attribute__((export_name("TS_TxAddOutput_get_channel_id"))) TS_TxAddOutput_get_channel_id(uint64_t this_ptr) {
39425 LDKTxAddOutput this_ptr_conv;
39426 this_ptr_conv.inner = untag_ptr(this_ptr);
39427 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39429 this_ptr_conv.is_owned = false;
39430 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39431 memcpy(ret_arr->elems, *TxAddOutput_get_channel_id(&this_ptr_conv), 32);
39435 void __attribute__((export_name("TS_TxAddOutput_set_channel_id"))) TS_TxAddOutput_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39436 LDKTxAddOutput this_ptr_conv;
39437 this_ptr_conv.inner = untag_ptr(this_ptr);
39438 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39440 this_ptr_conv.is_owned = false;
39441 LDKThirtyTwoBytes val_ref;
39442 CHECK(val->arr_len == 32);
39443 memcpy(val_ref.data, val->elems, 32); FREE(val);
39444 TxAddOutput_set_channel_id(&this_ptr_conv, val_ref);
39447 int64_t __attribute__((export_name("TS_TxAddOutput_get_serial_id"))) TS_TxAddOutput_get_serial_id(uint64_t this_ptr) {
39448 LDKTxAddOutput this_ptr_conv;
39449 this_ptr_conv.inner = untag_ptr(this_ptr);
39450 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39452 this_ptr_conv.is_owned = false;
39453 int64_t ret_conv = TxAddOutput_get_serial_id(&this_ptr_conv);
39457 void __attribute__((export_name("TS_TxAddOutput_set_serial_id"))) TS_TxAddOutput_set_serial_id(uint64_t this_ptr, int64_t val) {
39458 LDKTxAddOutput this_ptr_conv;
39459 this_ptr_conv.inner = untag_ptr(this_ptr);
39460 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39462 this_ptr_conv.is_owned = false;
39463 TxAddOutput_set_serial_id(&this_ptr_conv, val);
39466 int64_t __attribute__((export_name("TS_TxAddOutput_get_sats"))) TS_TxAddOutput_get_sats(uint64_t this_ptr) {
39467 LDKTxAddOutput this_ptr_conv;
39468 this_ptr_conv.inner = untag_ptr(this_ptr);
39469 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39471 this_ptr_conv.is_owned = false;
39472 int64_t ret_conv = TxAddOutput_get_sats(&this_ptr_conv);
39476 void __attribute__((export_name("TS_TxAddOutput_set_sats"))) TS_TxAddOutput_set_sats(uint64_t this_ptr, int64_t val) {
39477 LDKTxAddOutput this_ptr_conv;
39478 this_ptr_conv.inner = untag_ptr(this_ptr);
39479 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39481 this_ptr_conv.is_owned = false;
39482 TxAddOutput_set_sats(&this_ptr_conv, val);
39485 int8_tArray __attribute__((export_name("TS_TxAddOutput_get_script"))) TS_TxAddOutput_get_script(uint64_t this_ptr) {
39486 LDKTxAddOutput this_ptr_conv;
39487 this_ptr_conv.inner = untag_ptr(this_ptr);
39488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39490 this_ptr_conv.is_owned = false;
39491 LDKu8slice ret_var = TxAddOutput_get_script(&this_ptr_conv);
39492 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39493 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39497 void __attribute__((export_name("TS_TxAddOutput_set_script"))) TS_TxAddOutput_set_script(uint64_t this_ptr, int8_tArray val) {
39498 LDKTxAddOutput this_ptr_conv;
39499 this_ptr_conv.inner = untag_ptr(this_ptr);
39500 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39501 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39502 this_ptr_conv.is_owned = false;
39503 LDKCVec_u8Z val_ref;
39504 val_ref.datalen = val->arr_len;
39505 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
39506 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
39507 TxAddOutput_set_script(&this_ptr_conv, val_ref);
39510 uint64_t __attribute__((export_name("TS_TxAddOutput_new"))) TS_TxAddOutput_new(int8_tArray channel_id_arg, int64_t serial_id_arg, int64_t sats_arg, int8_tArray script_arg) {
39511 LDKThirtyTwoBytes channel_id_arg_ref;
39512 CHECK(channel_id_arg->arr_len == 32);
39513 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39514 LDKCVec_u8Z script_arg_ref;
39515 script_arg_ref.datalen = script_arg->arr_len;
39516 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
39517 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
39518 LDKTxAddOutput ret_var = TxAddOutput_new(channel_id_arg_ref, serial_id_arg, sats_arg, script_arg_ref);
39519 uint64_t ret_ref = 0;
39520 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39521 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39525 static inline uint64_t TxAddOutput_clone_ptr(LDKTxAddOutput *NONNULL_PTR arg) {
39526 LDKTxAddOutput ret_var = TxAddOutput_clone(arg);
39527 uint64_t ret_ref = 0;
39528 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39529 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39532 int64_t __attribute__((export_name("TS_TxAddOutput_clone_ptr"))) TS_TxAddOutput_clone_ptr(uint64_t arg) {
39533 LDKTxAddOutput arg_conv;
39534 arg_conv.inner = untag_ptr(arg);
39535 arg_conv.is_owned = ptr_is_owned(arg);
39536 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39537 arg_conv.is_owned = false;
39538 int64_t ret_conv = TxAddOutput_clone_ptr(&arg_conv);
39542 uint64_t __attribute__((export_name("TS_TxAddOutput_clone"))) TS_TxAddOutput_clone(uint64_t orig) {
39543 LDKTxAddOutput orig_conv;
39544 orig_conv.inner = untag_ptr(orig);
39545 orig_conv.is_owned = ptr_is_owned(orig);
39546 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39547 orig_conv.is_owned = false;
39548 LDKTxAddOutput ret_var = TxAddOutput_clone(&orig_conv);
39549 uint64_t ret_ref = 0;
39550 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39551 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39555 jboolean __attribute__((export_name("TS_TxAddOutput_eq"))) TS_TxAddOutput_eq(uint64_t a, uint64_t b) {
39556 LDKTxAddOutput a_conv;
39557 a_conv.inner = untag_ptr(a);
39558 a_conv.is_owned = ptr_is_owned(a);
39559 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39560 a_conv.is_owned = false;
39561 LDKTxAddOutput b_conv;
39562 b_conv.inner = untag_ptr(b);
39563 b_conv.is_owned = ptr_is_owned(b);
39564 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39565 b_conv.is_owned = false;
39566 jboolean ret_conv = TxAddOutput_eq(&a_conv, &b_conv);
39570 void __attribute__((export_name("TS_TxRemoveInput_free"))) TS_TxRemoveInput_free(uint64_t this_obj) {
39571 LDKTxRemoveInput this_obj_conv;
39572 this_obj_conv.inner = untag_ptr(this_obj);
39573 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39575 TxRemoveInput_free(this_obj_conv);
39578 int8_tArray __attribute__((export_name("TS_TxRemoveInput_get_channel_id"))) TS_TxRemoveInput_get_channel_id(uint64_t this_ptr) {
39579 LDKTxRemoveInput this_ptr_conv;
39580 this_ptr_conv.inner = untag_ptr(this_ptr);
39581 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39583 this_ptr_conv.is_owned = false;
39584 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39585 memcpy(ret_arr->elems, *TxRemoveInput_get_channel_id(&this_ptr_conv), 32);
39589 void __attribute__((export_name("TS_TxRemoveInput_set_channel_id"))) TS_TxRemoveInput_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39590 LDKTxRemoveInput this_ptr_conv;
39591 this_ptr_conv.inner = untag_ptr(this_ptr);
39592 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39594 this_ptr_conv.is_owned = false;
39595 LDKThirtyTwoBytes val_ref;
39596 CHECK(val->arr_len == 32);
39597 memcpy(val_ref.data, val->elems, 32); FREE(val);
39598 TxRemoveInput_set_channel_id(&this_ptr_conv, val_ref);
39601 int64_t __attribute__((export_name("TS_TxRemoveInput_get_serial_id"))) TS_TxRemoveInput_get_serial_id(uint64_t this_ptr) {
39602 LDKTxRemoveInput this_ptr_conv;
39603 this_ptr_conv.inner = untag_ptr(this_ptr);
39604 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39605 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39606 this_ptr_conv.is_owned = false;
39607 int64_t ret_conv = TxRemoveInput_get_serial_id(&this_ptr_conv);
39611 void __attribute__((export_name("TS_TxRemoveInput_set_serial_id"))) TS_TxRemoveInput_set_serial_id(uint64_t this_ptr, int64_t val) {
39612 LDKTxRemoveInput this_ptr_conv;
39613 this_ptr_conv.inner = untag_ptr(this_ptr);
39614 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39616 this_ptr_conv.is_owned = false;
39617 TxRemoveInput_set_serial_id(&this_ptr_conv, val);
39620 uint64_t __attribute__((export_name("TS_TxRemoveInput_new"))) TS_TxRemoveInput_new(int8_tArray channel_id_arg, int64_t serial_id_arg) {
39621 LDKThirtyTwoBytes channel_id_arg_ref;
39622 CHECK(channel_id_arg->arr_len == 32);
39623 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39624 LDKTxRemoveInput ret_var = TxRemoveInput_new(channel_id_arg_ref, serial_id_arg);
39625 uint64_t ret_ref = 0;
39626 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39627 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39631 static inline uint64_t TxRemoveInput_clone_ptr(LDKTxRemoveInput *NONNULL_PTR arg) {
39632 LDKTxRemoveInput ret_var = TxRemoveInput_clone(arg);
39633 uint64_t ret_ref = 0;
39634 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39635 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39638 int64_t __attribute__((export_name("TS_TxRemoveInput_clone_ptr"))) TS_TxRemoveInput_clone_ptr(uint64_t arg) {
39639 LDKTxRemoveInput arg_conv;
39640 arg_conv.inner = untag_ptr(arg);
39641 arg_conv.is_owned = ptr_is_owned(arg);
39642 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39643 arg_conv.is_owned = false;
39644 int64_t ret_conv = TxRemoveInput_clone_ptr(&arg_conv);
39648 uint64_t __attribute__((export_name("TS_TxRemoveInput_clone"))) TS_TxRemoveInput_clone(uint64_t orig) {
39649 LDKTxRemoveInput orig_conv;
39650 orig_conv.inner = untag_ptr(orig);
39651 orig_conv.is_owned = ptr_is_owned(orig);
39652 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39653 orig_conv.is_owned = false;
39654 LDKTxRemoveInput ret_var = TxRemoveInput_clone(&orig_conv);
39655 uint64_t ret_ref = 0;
39656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39657 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39661 jboolean __attribute__((export_name("TS_TxRemoveInput_eq"))) TS_TxRemoveInput_eq(uint64_t a, uint64_t b) {
39662 LDKTxRemoveInput a_conv;
39663 a_conv.inner = untag_ptr(a);
39664 a_conv.is_owned = ptr_is_owned(a);
39665 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39666 a_conv.is_owned = false;
39667 LDKTxRemoveInput b_conv;
39668 b_conv.inner = untag_ptr(b);
39669 b_conv.is_owned = ptr_is_owned(b);
39670 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39671 b_conv.is_owned = false;
39672 jboolean ret_conv = TxRemoveInput_eq(&a_conv, &b_conv);
39676 void __attribute__((export_name("TS_TxRemoveOutput_free"))) TS_TxRemoveOutput_free(uint64_t this_obj) {
39677 LDKTxRemoveOutput this_obj_conv;
39678 this_obj_conv.inner = untag_ptr(this_obj);
39679 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39681 TxRemoveOutput_free(this_obj_conv);
39684 int8_tArray __attribute__((export_name("TS_TxRemoveOutput_get_channel_id"))) TS_TxRemoveOutput_get_channel_id(uint64_t this_ptr) {
39685 LDKTxRemoveOutput this_ptr_conv;
39686 this_ptr_conv.inner = untag_ptr(this_ptr);
39687 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39689 this_ptr_conv.is_owned = false;
39690 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39691 memcpy(ret_arr->elems, *TxRemoveOutput_get_channel_id(&this_ptr_conv), 32);
39695 void __attribute__((export_name("TS_TxRemoveOutput_set_channel_id"))) TS_TxRemoveOutput_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39696 LDKTxRemoveOutput this_ptr_conv;
39697 this_ptr_conv.inner = untag_ptr(this_ptr);
39698 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39700 this_ptr_conv.is_owned = false;
39701 LDKThirtyTwoBytes val_ref;
39702 CHECK(val->arr_len == 32);
39703 memcpy(val_ref.data, val->elems, 32); FREE(val);
39704 TxRemoveOutput_set_channel_id(&this_ptr_conv, val_ref);
39707 int64_t __attribute__((export_name("TS_TxRemoveOutput_get_serial_id"))) TS_TxRemoveOutput_get_serial_id(uint64_t this_ptr) {
39708 LDKTxRemoveOutput this_ptr_conv;
39709 this_ptr_conv.inner = untag_ptr(this_ptr);
39710 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39712 this_ptr_conv.is_owned = false;
39713 int64_t ret_conv = TxRemoveOutput_get_serial_id(&this_ptr_conv);
39717 void __attribute__((export_name("TS_TxRemoveOutput_set_serial_id"))) TS_TxRemoveOutput_set_serial_id(uint64_t this_ptr, int64_t val) {
39718 LDKTxRemoveOutput this_ptr_conv;
39719 this_ptr_conv.inner = untag_ptr(this_ptr);
39720 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39722 this_ptr_conv.is_owned = false;
39723 TxRemoveOutput_set_serial_id(&this_ptr_conv, val);
39726 uint64_t __attribute__((export_name("TS_TxRemoveOutput_new"))) TS_TxRemoveOutput_new(int8_tArray channel_id_arg, int64_t serial_id_arg) {
39727 LDKThirtyTwoBytes channel_id_arg_ref;
39728 CHECK(channel_id_arg->arr_len == 32);
39729 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39730 LDKTxRemoveOutput ret_var = TxRemoveOutput_new(channel_id_arg_ref, serial_id_arg);
39731 uint64_t ret_ref = 0;
39732 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39733 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39737 static inline uint64_t TxRemoveOutput_clone_ptr(LDKTxRemoveOutput *NONNULL_PTR arg) {
39738 LDKTxRemoveOutput ret_var = TxRemoveOutput_clone(arg);
39739 uint64_t ret_ref = 0;
39740 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39741 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39744 int64_t __attribute__((export_name("TS_TxRemoveOutput_clone_ptr"))) TS_TxRemoveOutput_clone_ptr(uint64_t arg) {
39745 LDKTxRemoveOutput arg_conv;
39746 arg_conv.inner = untag_ptr(arg);
39747 arg_conv.is_owned = ptr_is_owned(arg);
39748 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39749 arg_conv.is_owned = false;
39750 int64_t ret_conv = TxRemoveOutput_clone_ptr(&arg_conv);
39754 uint64_t __attribute__((export_name("TS_TxRemoveOutput_clone"))) TS_TxRemoveOutput_clone(uint64_t orig) {
39755 LDKTxRemoveOutput orig_conv;
39756 orig_conv.inner = untag_ptr(orig);
39757 orig_conv.is_owned = ptr_is_owned(orig);
39758 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39759 orig_conv.is_owned = false;
39760 LDKTxRemoveOutput ret_var = TxRemoveOutput_clone(&orig_conv);
39761 uint64_t ret_ref = 0;
39762 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39763 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39767 jboolean __attribute__((export_name("TS_TxRemoveOutput_eq"))) TS_TxRemoveOutput_eq(uint64_t a, uint64_t b) {
39768 LDKTxRemoveOutput a_conv;
39769 a_conv.inner = untag_ptr(a);
39770 a_conv.is_owned = ptr_is_owned(a);
39771 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39772 a_conv.is_owned = false;
39773 LDKTxRemoveOutput b_conv;
39774 b_conv.inner = untag_ptr(b);
39775 b_conv.is_owned = ptr_is_owned(b);
39776 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39777 b_conv.is_owned = false;
39778 jboolean ret_conv = TxRemoveOutput_eq(&a_conv, &b_conv);
39782 void __attribute__((export_name("TS_TxComplete_free"))) TS_TxComplete_free(uint64_t this_obj) {
39783 LDKTxComplete this_obj_conv;
39784 this_obj_conv.inner = untag_ptr(this_obj);
39785 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39787 TxComplete_free(this_obj_conv);
39790 int8_tArray __attribute__((export_name("TS_TxComplete_get_channel_id"))) TS_TxComplete_get_channel_id(uint64_t this_ptr) {
39791 LDKTxComplete this_ptr_conv;
39792 this_ptr_conv.inner = untag_ptr(this_ptr);
39793 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39795 this_ptr_conv.is_owned = false;
39796 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39797 memcpy(ret_arr->elems, *TxComplete_get_channel_id(&this_ptr_conv), 32);
39801 void __attribute__((export_name("TS_TxComplete_set_channel_id"))) TS_TxComplete_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39802 LDKTxComplete this_ptr_conv;
39803 this_ptr_conv.inner = untag_ptr(this_ptr);
39804 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39806 this_ptr_conv.is_owned = false;
39807 LDKThirtyTwoBytes val_ref;
39808 CHECK(val->arr_len == 32);
39809 memcpy(val_ref.data, val->elems, 32); FREE(val);
39810 TxComplete_set_channel_id(&this_ptr_conv, val_ref);
39813 uint64_t __attribute__((export_name("TS_TxComplete_new"))) TS_TxComplete_new(int8_tArray channel_id_arg) {
39814 LDKThirtyTwoBytes channel_id_arg_ref;
39815 CHECK(channel_id_arg->arr_len == 32);
39816 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39817 LDKTxComplete ret_var = TxComplete_new(channel_id_arg_ref);
39818 uint64_t ret_ref = 0;
39819 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39820 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39824 static inline uint64_t TxComplete_clone_ptr(LDKTxComplete *NONNULL_PTR arg) {
39825 LDKTxComplete ret_var = TxComplete_clone(arg);
39826 uint64_t ret_ref = 0;
39827 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39828 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39831 int64_t __attribute__((export_name("TS_TxComplete_clone_ptr"))) TS_TxComplete_clone_ptr(uint64_t arg) {
39832 LDKTxComplete arg_conv;
39833 arg_conv.inner = untag_ptr(arg);
39834 arg_conv.is_owned = ptr_is_owned(arg);
39835 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39836 arg_conv.is_owned = false;
39837 int64_t ret_conv = TxComplete_clone_ptr(&arg_conv);
39841 uint64_t __attribute__((export_name("TS_TxComplete_clone"))) TS_TxComplete_clone(uint64_t orig) {
39842 LDKTxComplete orig_conv;
39843 orig_conv.inner = untag_ptr(orig);
39844 orig_conv.is_owned = ptr_is_owned(orig);
39845 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39846 orig_conv.is_owned = false;
39847 LDKTxComplete ret_var = TxComplete_clone(&orig_conv);
39848 uint64_t ret_ref = 0;
39849 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39850 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
39854 jboolean __attribute__((export_name("TS_TxComplete_eq"))) TS_TxComplete_eq(uint64_t a, uint64_t b) {
39855 LDKTxComplete a_conv;
39856 a_conv.inner = untag_ptr(a);
39857 a_conv.is_owned = ptr_is_owned(a);
39858 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
39859 a_conv.is_owned = false;
39860 LDKTxComplete b_conv;
39861 b_conv.inner = untag_ptr(b);
39862 b_conv.is_owned = ptr_is_owned(b);
39863 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
39864 b_conv.is_owned = false;
39865 jboolean ret_conv = TxComplete_eq(&a_conv, &b_conv);
39869 void __attribute__((export_name("TS_TxSignatures_free"))) TS_TxSignatures_free(uint64_t this_obj) {
39870 LDKTxSignatures this_obj_conv;
39871 this_obj_conv.inner = untag_ptr(this_obj);
39872 this_obj_conv.is_owned = ptr_is_owned(this_obj);
39873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39874 TxSignatures_free(this_obj_conv);
39877 int8_tArray __attribute__((export_name("TS_TxSignatures_get_channel_id"))) TS_TxSignatures_get_channel_id(uint64_t this_ptr) {
39878 LDKTxSignatures this_ptr_conv;
39879 this_ptr_conv.inner = untag_ptr(this_ptr);
39880 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39881 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39882 this_ptr_conv.is_owned = false;
39883 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39884 memcpy(ret_arr->elems, *TxSignatures_get_channel_id(&this_ptr_conv), 32);
39888 void __attribute__((export_name("TS_TxSignatures_set_channel_id"))) TS_TxSignatures_set_channel_id(uint64_t this_ptr, int8_tArray val) {
39889 LDKTxSignatures this_ptr_conv;
39890 this_ptr_conv.inner = untag_ptr(this_ptr);
39891 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39892 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39893 this_ptr_conv.is_owned = false;
39894 LDKThirtyTwoBytes val_ref;
39895 CHECK(val->arr_len == 32);
39896 memcpy(val_ref.data, val->elems, 32); FREE(val);
39897 TxSignatures_set_channel_id(&this_ptr_conv, val_ref);
39900 int8_tArray __attribute__((export_name("TS_TxSignatures_get_tx_hash"))) TS_TxSignatures_get_tx_hash(uint64_t this_ptr) {
39901 LDKTxSignatures this_ptr_conv;
39902 this_ptr_conv.inner = untag_ptr(this_ptr);
39903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39905 this_ptr_conv.is_owned = false;
39906 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
39907 memcpy(ret_arr->elems, *TxSignatures_get_tx_hash(&this_ptr_conv), 32);
39911 void __attribute__((export_name("TS_TxSignatures_set_tx_hash"))) TS_TxSignatures_set_tx_hash(uint64_t this_ptr, int8_tArray val) {
39912 LDKTxSignatures this_ptr_conv;
39913 this_ptr_conv.inner = untag_ptr(this_ptr);
39914 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39916 this_ptr_conv.is_owned = false;
39917 LDKThirtyTwoBytes val_ref;
39918 CHECK(val->arr_len == 32);
39919 memcpy(val_ref.data, val->elems, 32); FREE(val);
39920 TxSignatures_set_tx_hash(&this_ptr_conv, val_ref);
39923 ptrArray __attribute__((export_name("TS_TxSignatures_get_witnesses"))) TS_TxSignatures_get_witnesses(uint64_t this_ptr) {
39924 LDKTxSignatures this_ptr_conv;
39925 this_ptr_conv.inner = untag_ptr(this_ptr);
39926 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39928 this_ptr_conv.is_owned = false;
39929 LDKCVec_WitnessZ ret_var = TxSignatures_get_witnesses(&this_ptr_conv);
39930 ptrArray ret_arr = NULL;
39931 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
39932 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
39933 for (size_t m = 0; m < ret_var.datalen; m++) {
39934 LDKWitness ret_conv_12_var = ret_var.data[m];
39935 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
39936 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
39937 Witness_free(ret_conv_12_var);
39938 ret_arr_ptr[m] = ret_conv_12_arr;
39941 FREE(ret_var.data);
39945 void __attribute__((export_name("TS_TxSignatures_set_witnesses"))) TS_TxSignatures_set_witnesses(uint64_t this_ptr, ptrArray val) {
39946 LDKTxSignatures this_ptr_conv;
39947 this_ptr_conv.inner = untag_ptr(this_ptr);
39948 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
39949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39950 this_ptr_conv.is_owned = false;
39951 LDKCVec_WitnessZ val_constr;
39952 val_constr.datalen = val->arr_len;
39953 if (val_constr.datalen > 0)
39954 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKWitness), "LDKCVec_WitnessZ Elements");
39956 val_constr.data = NULL;
39957 int8_tArray* val_vals = (void*) val->elems;
39958 for (size_t m = 0; m < val_constr.datalen; m++) {
39959 int8_tArray val_conv_12 = val_vals[m];
39960 LDKWitness val_conv_12_ref;
39961 val_conv_12_ref.datalen = val_conv_12->arr_len;
39962 val_conv_12_ref.data = MALLOC(val_conv_12_ref.datalen, "LDKWitness Bytes");
39963 memcpy(val_conv_12_ref.data, val_conv_12->elems, val_conv_12_ref.datalen); FREE(val_conv_12);
39964 val_conv_12_ref.data_is_owned = true;
39965 val_constr.data[m] = val_conv_12_ref;
39968 TxSignatures_set_witnesses(&this_ptr_conv, val_constr);
39971 uint64_t __attribute__((export_name("TS_TxSignatures_new"))) TS_TxSignatures_new(int8_tArray channel_id_arg, int8_tArray tx_hash_arg, ptrArray witnesses_arg) {
39972 LDKThirtyTwoBytes channel_id_arg_ref;
39973 CHECK(channel_id_arg->arr_len == 32);
39974 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
39975 LDKThirtyTwoBytes tx_hash_arg_ref;
39976 CHECK(tx_hash_arg->arr_len == 32);
39977 memcpy(tx_hash_arg_ref.data, tx_hash_arg->elems, 32); FREE(tx_hash_arg);
39978 LDKCVec_WitnessZ witnesses_arg_constr;
39979 witnesses_arg_constr.datalen = witnesses_arg->arr_len;
39980 if (witnesses_arg_constr.datalen > 0)
39981 witnesses_arg_constr.data = MALLOC(witnesses_arg_constr.datalen * sizeof(LDKWitness), "LDKCVec_WitnessZ Elements");
39983 witnesses_arg_constr.data = NULL;
39984 int8_tArray* witnesses_arg_vals = (void*) witnesses_arg->elems;
39985 for (size_t m = 0; m < witnesses_arg_constr.datalen; m++) {
39986 int8_tArray witnesses_arg_conv_12 = witnesses_arg_vals[m];
39987 LDKWitness witnesses_arg_conv_12_ref;
39988 witnesses_arg_conv_12_ref.datalen = witnesses_arg_conv_12->arr_len;
39989 witnesses_arg_conv_12_ref.data = MALLOC(witnesses_arg_conv_12_ref.datalen, "LDKWitness Bytes");
39990 memcpy(witnesses_arg_conv_12_ref.data, witnesses_arg_conv_12->elems, witnesses_arg_conv_12_ref.datalen); FREE(witnesses_arg_conv_12);
39991 witnesses_arg_conv_12_ref.data_is_owned = true;
39992 witnesses_arg_constr.data[m] = witnesses_arg_conv_12_ref;
39994 FREE(witnesses_arg);
39995 LDKTxSignatures ret_var = TxSignatures_new(channel_id_arg_ref, tx_hash_arg_ref, witnesses_arg_constr);
39996 uint64_t ret_ref = 0;
39997 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39998 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40002 static inline uint64_t TxSignatures_clone_ptr(LDKTxSignatures *NONNULL_PTR arg) {
40003 LDKTxSignatures ret_var = TxSignatures_clone(arg);
40004 uint64_t ret_ref = 0;
40005 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40006 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40009 int64_t __attribute__((export_name("TS_TxSignatures_clone_ptr"))) TS_TxSignatures_clone_ptr(uint64_t arg) {
40010 LDKTxSignatures arg_conv;
40011 arg_conv.inner = untag_ptr(arg);
40012 arg_conv.is_owned = ptr_is_owned(arg);
40013 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40014 arg_conv.is_owned = false;
40015 int64_t ret_conv = TxSignatures_clone_ptr(&arg_conv);
40019 uint64_t __attribute__((export_name("TS_TxSignatures_clone"))) TS_TxSignatures_clone(uint64_t orig) {
40020 LDKTxSignatures orig_conv;
40021 orig_conv.inner = untag_ptr(orig);
40022 orig_conv.is_owned = ptr_is_owned(orig);
40023 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40024 orig_conv.is_owned = false;
40025 LDKTxSignatures ret_var = TxSignatures_clone(&orig_conv);
40026 uint64_t ret_ref = 0;
40027 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40028 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40032 jboolean __attribute__((export_name("TS_TxSignatures_eq"))) TS_TxSignatures_eq(uint64_t a, uint64_t b) {
40033 LDKTxSignatures a_conv;
40034 a_conv.inner = untag_ptr(a);
40035 a_conv.is_owned = ptr_is_owned(a);
40036 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40037 a_conv.is_owned = false;
40038 LDKTxSignatures b_conv;
40039 b_conv.inner = untag_ptr(b);
40040 b_conv.is_owned = ptr_is_owned(b);
40041 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40042 b_conv.is_owned = false;
40043 jboolean ret_conv = TxSignatures_eq(&a_conv, &b_conv);
40047 void __attribute__((export_name("TS_TxInitRbf_free"))) TS_TxInitRbf_free(uint64_t this_obj) {
40048 LDKTxInitRbf this_obj_conv;
40049 this_obj_conv.inner = untag_ptr(this_obj);
40050 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40052 TxInitRbf_free(this_obj_conv);
40055 int8_tArray __attribute__((export_name("TS_TxInitRbf_get_channel_id"))) TS_TxInitRbf_get_channel_id(uint64_t this_ptr) {
40056 LDKTxInitRbf this_ptr_conv;
40057 this_ptr_conv.inner = untag_ptr(this_ptr);
40058 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40060 this_ptr_conv.is_owned = false;
40061 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40062 memcpy(ret_arr->elems, *TxInitRbf_get_channel_id(&this_ptr_conv), 32);
40066 void __attribute__((export_name("TS_TxInitRbf_set_channel_id"))) TS_TxInitRbf_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40067 LDKTxInitRbf this_ptr_conv;
40068 this_ptr_conv.inner = untag_ptr(this_ptr);
40069 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40070 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40071 this_ptr_conv.is_owned = false;
40072 LDKThirtyTwoBytes val_ref;
40073 CHECK(val->arr_len == 32);
40074 memcpy(val_ref.data, val->elems, 32); FREE(val);
40075 TxInitRbf_set_channel_id(&this_ptr_conv, val_ref);
40078 int32_t __attribute__((export_name("TS_TxInitRbf_get_locktime"))) TS_TxInitRbf_get_locktime(uint64_t this_ptr) {
40079 LDKTxInitRbf this_ptr_conv;
40080 this_ptr_conv.inner = untag_ptr(this_ptr);
40081 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40083 this_ptr_conv.is_owned = false;
40084 int32_t ret_conv = TxInitRbf_get_locktime(&this_ptr_conv);
40088 void __attribute__((export_name("TS_TxInitRbf_set_locktime"))) TS_TxInitRbf_set_locktime(uint64_t this_ptr, int32_t val) {
40089 LDKTxInitRbf this_ptr_conv;
40090 this_ptr_conv.inner = untag_ptr(this_ptr);
40091 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40093 this_ptr_conv.is_owned = false;
40094 TxInitRbf_set_locktime(&this_ptr_conv, val);
40097 int32_t __attribute__((export_name("TS_TxInitRbf_get_feerate_sat_per_1000_weight"))) TS_TxInitRbf_get_feerate_sat_per_1000_weight(uint64_t this_ptr) {
40098 LDKTxInitRbf this_ptr_conv;
40099 this_ptr_conv.inner = untag_ptr(this_ptr);
40100 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40101 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40102 this_ptr_conv.is_owned = false;
40103 int32_t ret_conv = TxInitRbf_get_feerate_sat_per_1000_weight(&this_ptr_conv);
40107 void __attribute__((export_name("TS_TxInitRbf_set_feerate_sat_per_1000_weight"))) TS_TxInitRbf_set_feerate_sat_per_1000_weight(uint64_t this_ptr, int32_t val) {
40108 LDKTxInitRbf this_ptr_conv;
40109 this_ptr_conv.inner = untag_ptr(this_ptr);
40110 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40111 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40112 this_ptr_conv.is_owned = false;
40113 TxInitRbf_set_feerate_sat_per_1000_weight(&this_ptr_conv, val);
40116 uint64_t __attribute__((export_name("TS_TxInitRbf_get_funding_output_contribution"))) TS_TxInitRbf_get_funding_output_contribution(uint64_t this_ptr) {
40117 LDKTxInitRbf this_ptr_conv;
40118 this_ptr_conv.inner = untag_ptr(this_ptr);
40119 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40121 this_ptr_conv.is_owned = false;
40122 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
40123 *ret_copy = TxInitRbf_get_funding_output_contribution(&this_ptr_conv);
40124 uint64_t ret_ref = tag_ptr(ret_copy, true);
40128 void __attribute__((export_name("TS_TxInitRbf_set_funding_output_contribution"))) TS_TxInitRbf_set_funding_output_contribution(uint64_t this_ptr, uint64_t val) {
40129 LDKTxInitRbf this_ptr_conv;
40130 this_ptr_conv.inner = untag_ptr(this_ptr);
40131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40133 this_ptr_conv.is_owned = false;
40134 void* val_ptr = untag_ptr(val);
40135 CHECK_ACCESS(val_ptr);
40136 LDKCOption_i64Z val_conv = *(LDKCOption_i64Z*)(val_ptr);
40137 val_conv = COption_i64Z_clone((LDKCOption_i64Z*)untag_ptr(val));
40138 TxInitRbf_set_funding_output_contribution(&this_ptr_conv, val_conv);
40141 uint64_t __attribute__((export_name("TS_TxInitRbf_new"))) TS_TxInitRbf_new(int8_tArray channel_id_arg, int32_t locktime_arg, int32_t feerate_sat_per_1000_weight_arg, uint64_t funding_output_contribution_arg) {
40142 LDKThirtyTwoBytes channel_id_arg_ref;
40143 CHECK(channel_id_arg->arr_len == 32);
40144 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
40145 void* funding_output_contribution_arg_ptr = untag_ptr(funding_output_contribution_arg);
40146 CHECK_ACCESS(funding_output_contribution_arg_ptr);
40147 LDKCOption_i64Z funding_output_contribution_arg_conv = *(LDKCOption_i64Z*)(funding_output_contribution_arg_ptr);
40148 funding_output_contribution_arg_conv = COption_i64Z_clone((LDKCOption_i64Z*)untag_ptr(funding_output_contribution_arg));
40149 LDKTxInitRbf ret_var = TxInitRbf_new(channel_id_arg_ref, locktime_arg, feerate_sat_per_1000_weight_arg, funding_output_contribution_arg_conv);
40150 uint64_t ret_ref = 0;
40151 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40152 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40156 static inline uint64_t TxInitRbf_clone_ptr(LDKTxInitRbf *NONNULL_PTR arg) {
40157 LDKTxInitRbf ret_var = TxInitRbf_clone(arg);
40158 uint64_t ret_ref = 0;
40159 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40160 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40163 int64_t __attribute__((export_name("TS_TxInitRbf_clone_ptr"))) TS_TxInitRbf_clone_ptr(uint64_t arg) {
40164 LDKTxInitRbf arg_conv;
40165 arg_conv.inner = untag_ptr(arg);
40166 arg_conv.is_owned = ptr_is_owned(arg);
40167 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40168 arg_conv.is_owned = false;
40169 int64_t ret_conv = TxInitRbf_clone_ptr(&arg_conv);
40173 uint64_t __attribute__((export_name("TS_TxInitRbf_clone"))) TS_TxInitRbf_clone(uint64_t orig) {
40174 LDKTxInitRbf orig_conv;
40175 orig_conv.inner = untag_ptr(orig);
40176 orig_conv.is_owned = ptr_is_owned(orig);
40177 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40178 orig_conv.is_owned = false;
40179 LDKTxInitRbf ret_var = TxInitRbf_clone(&orig_conv);
40180 uint64_t ret_ref = 0;
40181 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40182 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40186 jboolean __attribute__((export_name("TS_TxInitRbf_eq"))) TS_TxInitRbf_eq(uint64_t a, uint64_t b) {
40187 LDKTxInitRbf a_conv;
40188 a_conv.inner = untag_ptr(a);
40189 a_conv.is_owned = ptr_is_owned(a);
40190 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40191 a_conv.is_owned = false;
40192 LDKTxInitRbf b_conv;
40193 b_conv.inner = untag_ptr(b);
40194 b_conv.is_owned = ptr_is_owned(b);
40195 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40196 b_conv.is_owned = false;
40197 jboolean ret_conv = TxInitRbf_eq(&a_conv, &b_conv);
40201 void __attribute__((export_name("TS_TxAckRbf_free"))) TS_TxAckRbf_free(uint64_t this_obj) {
40202 LDKTxAckRbf this_obj_conv;
40203 this_obj_conv.inner = untag_ptr(this_obj);
40204 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40206 TxAckRbf_free(this_obj_conv);
40209 int8_tArray __attribute__((export_name("TS_TxAckRbf_get_channel_id"))) TS_TxAckRbf_get_channel_id(uint64_t this_ptr) {
40210 LDKTxAckRbf this_ptr_conv;
40211 this_ptr_conv.inner = untag_ptr(this_ptr);
40212 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40214 this_ptr_conv.is_owned = false;
40215 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40216 memcpy(ret_arr->elems, *TxAckRbf_get_channel_id(&this_ptr_conv), 32);
40220 void __attribute__((export_name("TS_TxAckRbf_set_channel_id"))) TS_TxAckRbf_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40221 LDKTxAckRbf this_ptr_conv;
40222 this_ptr_conv.inner = untag_ptr(this_ptr);
40223 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40225 this_ptr_conv.is_owned = false;
40226 LDKThirtyTwoBytes val_ref;
40227 CHECK(val->arr_len == 32);
40228 memcpy(val_ref.data, val->elems, 32); FREE(val);
40229 TxAckRbf_set_channel_id(&this_ptr_conv, val_ref);
40232 uint64_t __attribute__((export_name("TS_TxAckRbf_get_funding_output_contribution"))) TS_TxAckRbf_get_funding_output_contribution(uint64_t this_ptr) {
40233 LDKTxAckRbf this_ptr_conv;
40234 this_ptr_conv.inner = untag_ptr(this_ptr);
40235 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40236 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40237 this_ptr_conv.is_owned = false;
40238 LDKCOption_i64Z *ret_copy = MALLOC(sizeof(LDKCOption_i64Z), "LDKCOption_i64Z");
40239 *ret_copy = TxAckRbf_get_funding_output_contribution(&this_ptr_conv);
40240 uint64_t ret_ref = tag_ptr(ret_copy, true);
40244 void __attribute__((export_name("TS_TxAckRbf_set_funding_output_contribution"))) TS_TxAckRbf_set_funding_output_contribution(uint64_t this_ptr, uint64_t val) {
40245 LDKTxAckRbf this_ptr_conv;
40246 this_ptr_conv.inner = untag_ptr(this_ptr);
40247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40249 this_ptr_conv.is_owned = false;
40250 void* val_ptr = untag_ptr(val);
40251 CHECK_ACCESS(val_ptr);
40252 LDKCOption_i64Z val_conv = *(LDKCOption_i64Z*)(val_ptr);
40253 val_conv = COption_i64Z_clone((LDKCOption_i64Z*)untag_ptr(val));
40254 TxAckRbf_set_funding_output_contribution(&this_ptr_conv, val_conv);
40257 uint64_t __attribute__((export_name("TS_TxAckRbf_new"))) TS_TxAckRbf_new(int8_tArray channel_id_arg, uint64_t funding_output_contribution_arg) {
40258 LDKThirtyTwoBytes channel_id_arg_ref;
40259 CHECK(channel_id_arg->arr_len == 32);
40260 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
40261 void* funding_output_contribution_arg_ptr = untag_ptr(funding_output_contribution_arg);
40262 CHECK_ACCESS(funding_output_contribution_arg_ptr);
40263 LDKCOption_i64Z funding_output_contribution_arg_conv = *(LDKCOption_i64Z*)(funding_output_contribution_arg_ptr);
40264 funding_output_contribution_arg_conv = COption_i64Z_clone((LDKCOption_i64Z*)untag_ptr(funding_output_contribution_arg));
40265 LDKTxAckRbf ret_var = TxAckRbf_new(channel_id_arg_ref, funding_output_contribution_arg_conv);
40266 uint64_t ret_ref = 0;
40267 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40268 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40272 static inline uint64_t TxAckRbf_clone_ptr(LDKTxAckRbf *NONNULL_PTR arg) {
40273 LDKTxAckRbf ret_var = TxAckRbf_clone(arg);
40274 uint64_t ret_ref = 0;
40275 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40276 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40279 int64_t __attribute__((export_name("TS_TxAckRbf_clone_ptr"))) TS_TxAckRbf_clone_ptr(uint64_t arg) {
40280 LDKTxAckRbf arg_conv;
40281 arg_conv.inner = untag_ptr(arg);
40282 arg_conv.is_owned = ptr_is_owned(arg);
40283 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40284 arg_conv.is_owned = false;
40285 int64_t ret_conv = TxAckRbf_clone_ptr(&arg_conv);
40289 uint64_t __attribute__((export_name("TS_TxAckRbf_clone"))) TS_TxAckRbf_clone(uint64_t orig) {
40290 LDKTxAckRbf orig_conv;
40291 orig_conv.inner = untag_ptr(orig);
40292 orig_conv.is_owned = ptr_is_owned(orig);
40293 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40294 orig_conv.is_owned = false;
40295 LDKTxAckRbf ret_var = TxAckRbf_clone(&orig_conv);
40296 uint64_t ret_ref = 0;
40297 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40298 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40302 jboolean __attribute__((export_name("TS_TxAckRbf_eq"))) TS_TxAckRbf_eq(uint64_t a, uint64_t b) {
40303 LDKTxAckRbf a_conv;
40304 a_conv.inner = untag_ptr(a);
40305 a_conv.is_owned = ptr_is_owned(a);
40306 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40307 a_conv.is_owned = false;
40308 LDKTxAckRbf b_conv;
40309 b_conv.inner = untag_ptr(b);
40310 b_conv.is_owned = ptr_is_owned(b);
40311 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40312 b_conv.is_owned = false;
40313 jboolean ret_conv = TxAckRbf_eq(&a_conv, &b_conv);
40317 void __attribute__((export_name("TS_TxAbort_free"))) TS_TxAbort_free(uint64_t this_obj) {
40318 LDKTxAbort this_obj_conv;
40319 this_obj_conv.inner = untag_ptr(this_obj);
40320 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40322 TxAbort_free(this_obj_conv);
40325 int8_tArray __attribute__((export_name("TS_TxAbort_get_channel_id"))) TS_TxAbort_get_channel_id(uint64_t this_ptr) {
40326 LDKTxAbort this_ptr_conv;
40327 this_ptr_conv.inner = untag_ptr(this_ptr);
40328 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40330 this_ptr_conv.is_owned = false;
40331 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40332 memcpy(ret_arr->elems, *TxAbort_get_channel_id(&this_ptr_conv), 32);
40336 void __attribute__((export_name("TS_TxAbort_set_channel_id"))) TS_TxAbort_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40337 LDKTxAbort this_ptr_conv;
40338 this_ptr_conv.inner = untag_ptr(this_ptr);
40339 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40341 this_ptr_conv.is_owned = false;
40342 LDKThirtyTwoBytes val_ref;
40343 CHECK(val->arr_len == 32);
40344 memcpy(val_ref.data, val->elems, 32); FREE(val);
40345 TxAbort_set_channel_id(&this_ptr_conv, val_ref);
40348 int8_tArray __attribute__((export_name("TS_TxAbort_get_data"))) TS_TxAbort_get_data(uint64_t this_ptr) {
40349 LDKTxAbort this_ptr_conv;
40350 this_ptr_conv.inner = untag_ptr(this_ptr);
40351 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40353 this_ptr_conv.is_owned = false;
40354 LDKCVec_u8Z ret_var = TxAbort_get_data(&this_ptr_conv);
40355 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40356 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40357 CVec_u8Z_free(ret_var);
40361 void __attribute__((export_name("TS_TxAbort_set_data"))) TS_TxAbort_set_data(uint64_t this_ptr, int8_tArray val) {
40362 LDKTxAbort this_ptr_conv;
40363 this_ptr_conv.inner = untag_ptr(this_ptr);
40364 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40366 this_ptr_conv.is_owned = false;
40367 LDKCVec_u8Z val_ref;
40368 val_ref.datalen = val->arr_len;
40369 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
40370 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
40371 TxAbort_set_data(&this_ptr_conv, val_ref);
40374 uint64_t __attribute__((export_name("TS_TxAbort_new"))) TS_TxAbort_new(int8_tArray channel_id_arg, int8_tArray data_arg) {
40375 LDKThirtyTwoBytes channel_id_arg_ref;
40376 CHECK(channel_id_arg->arr_len == 32);
40377 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
40378 LDKCVec_u8Z data_arg_ref;
40379 data_arg_ref.datalen = data_arg->arr_len;
40380 data_arg_ref.data = MALLOC(data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
40381 memcpy(data_arg_ref.data, data_arg->elems, data_arg_ref.datalen); FREE(data_arg);
40382 LDKTxAbort ret_var = TxAbort_new(channel_id_arg_ref, data_arg_ref);
40383 uint64_t ret_ref = 0;
40384 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40385 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40389 static inline uint64_t TxAbort_clone_ptr(LDKTxAbort *NONNULL_PTR arg) {
40390 LDKTxAbort ret_var = TxAbort_clone(arg);
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);
40396 int64_t __attribute__((export_name("TS_TxAbort_clone_ptr"))) TS_TxAbort_clone_ptr(uint64_t arg) {
40397 LDKTxAbort arg_conv;
40398 arg_conv.inner = untag_ptr(arg);
40399 arg_conv.is_owned = ptr_is_owned(arg);
40400 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40401 arg_conv.is_owned = false;
40402 int64_t ret_conv = TxAbort_clone_ptr(&arg_conv);
40406 uint64_t __attribute__((export_name("TS_TxAbort_clone"))) TS_TxAbort_clone(uint64_t orig) {
40407 LDKTxAbort orig_conv;
40408 orig_conv.inner = untag_ptr(orig);
40409 orig_conv.is_owned = ptr_is_owned(orig);
40410 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40411 orig_conv.is_owned = false;
40412 LDKTxAbort ret_var = TxAbort_clone(&orig_conv);
40413 uint64_t ret_ref = 0;
40414 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40415 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40419 jboolean __attribute__((export_name("TS_TxAbort_eq"))) TS_TxAbort_eq(uint64_t a, uint64_t b) {
40421 a_conv.inner = untag_ptr(a);
40422 a_conv.is_owned = ptr_is_owned(a);
40423 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40424 a_conv.is_owned = false;
40426 b_conv.inner = untag_ptr(b);
40427 b_conv.is_owned = ptr_is_owned(b);
40428 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40429 b_conv.is_owned = false;
40430 jboolean ret_conv = TxAbort_eq(&a_conv, &b_conv);
40434 void __attribute__((export_name("TS_Shutdown_free"))) TS_Shutdown_free(uint64_t this_obj) {
40435 LDKShutdown this_obj_conv;
40436 this_obj_conv.inner = untag_ptr(this_obj);
40437 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40439 Shutdown_free(this_obj_conv);
40442 int8_tArray __attribute__((export_name("TS_Shutdown_get_channel_id"))) TS_Shutdown_get_channel_id(uint64_t this_ptr) {
40443 LDKShutdown this_ptr_conv;
40444 this_ptr_conv.inner = untag_ptr(this_ptr);
40445 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40447 this_ptr_conv.is_owned = false;
40448 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40449 memcpy(ret_arr->elems, *Shutdown_get_channel_id(&this_ptr_conv), 32);
40453 void __attribute__((export_name("TS_Shutdown_set_channel_id"))) TS_Shutdown_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40454 LDKShutdown this_ptr_conv;
40455 this_ptr_conv.inner = untag_ptr(this_ptr);
40456 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40458 this_ptr_conv.is_owned = false;
40459 LDKThirtyTwoBytes val_ref;
40460 CHECK(val->arr_len == 32);
40461 memcpy(val_ref.data, val->elems, 32); FREE(val);
40462 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
40465 int8_tArray __attribute__((export_name("TS_Shutdown_get_scriptpubkey"))) TS_Shutdown_get_scriptpubkey(uint64_t this_ptr) {
40466 LDKShutdown this_ptr_conv;
40467 this_ptr_conv.inner = untag_ptr(this_ptr);
40468 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40469 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40470 this_ptr_conv.is_owned = false;
40471 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
40472 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40473 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40477 void __attribute__((export_name("TS_Shutdown_set_scriptpubkey"))) TS_Shutdown_set_scriptpubkey(uint64_t this_ptr, int8_tArray val) {
40478 LDKShutdown this_ptr_conv;
40479 this_ptr_conv.inner = untag_ptr(this_ptr);
40480 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40482 this_ptr_conv.is_owned = false;
40483 LDKCVec_u8Z val_ref;
40484 val_ref.datalen = val->arr_len;
40485 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
40486 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
40487 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
40490 uint64_t __attribute__((export_name("TS_Shutdown_new"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
40491 LDKThirtyTwoBytes channel_id_arg_ref;
40492 CHECK(channel_id_arg->arr_len == 32);
40493 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
40494 LDKCVec_u8Z scriptpubkey_arg_ref;
40495 scriptpubkey_arg_ref.datalen = scriptpubkey_arg->arr_len;
40496 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
40497 memcpy(scriptpubkey_arg_ref.data, scriptpubkey_arg->elems, scriptpubkey_arg_ref.datalen); FREE(scriptpubkey_arg);
40498 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
40499 uint64_t ret_ref = 0;
40500 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40501 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40505 static inline uint64_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
40506 LDKShutdown ret_var = Shutdown_clone(arg);
40507 uint64_t ret_ref = 0;
40508 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40509 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40512 int64_t __attribute__((export_name("TS_Shutdown_clone_ptr"))) TS_Shutdown_clone_ptr(uint64_t arg) {
40513 LDKShutdown arg_conv;
40514 arg_conv.inner = untag_ptr(arg);
40515 arg_conv.is_owned = ptr_is_owned(arg);
40516 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40517 arg_conv.is_owned = false;
40518 int64_t ret_conv = Shutdown_clone_ptr(&arg_conv);
40522 uint64_t __attribute__((export_name("TS_Shutdown_clone"))) TS_Shutdown_clone(uint64_t orig) {
40523 LDKShutdown orig_conv;
40524 orig_conv.inner = untag_ptr(orig);
40525 orig_conv.is_owned = ptr_is_owned(orig);
40526 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40527 orig_conv.is_owned = false;
40528 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
40529 uint64_t ret_ref = 0;
40530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40531 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40535 jboolean __attribute__((export_name("TS_Shutdown_eq"))) TS_Shutdown_eq(uint64_t a, uint64_t b) {
40536 LDKShutdown a_conv;
40537 a_conv.inner = untag_ptr(a);
40538 a_conv.is_owned = ptr_is_owned(a);
40539 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40540 a_conv.is_owned = false;
40541 LDKShutdown b_conv;
40542 b_conv.inner = untag_ptr(b);
40543 b_conv.is_owned = ptr_is_owned(b);
40544 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40545 b_conv.is_owned = false;
40546 jboolean ret_conv = Shutdown_eq(&a_conv, &b_conv);
40550 void __attribute__((export_name("TS_ClosingSignedFeeRange_free"))) TS_ClosingSignedFeeRange_free(uint64_t this_obj) {
40551 LDKClosingSignedFeeRange this_obj_conv;
40552 this_obj_conv.inner = untag_ptr(this_obj);
40553 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40555 ClosingSignedFeeRange_free(this_obj_conv);
40558 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_min_fee_satoshis"))) TS_ClosingSignedFeeRange_get_min_fee_satoshis(uint64_t this_ptr) {
40559 LDKClosingSignedFeeRange this_ptr_conv;
40560 this_ptr_conv.inner = untag_ptr(this_ptr);
40561 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40562 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40563 this_ptr_conv.is_owned = false;
40564 int64_t ret_conv = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
40568 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_min_fee_satoshis"))) TS_ClosingSignedFeeRange_set_min_fee_satoshis(uint64_t this_ptr, int64_t val) {
40569 LDKClosingSignedFeeRange this_ptr_conv;
40570 this_ptr_conv.inner = untag_ptr(this_ptr);
40571 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40573 this_ptr_conv.is_owned = false;
40574 ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
40577 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_max_fee_satoshis"))) TS_ClosingSignedFeeRange_get_max_fee_satoshis(uint64_t this_ptr) {
40578 LDKClosingSignedFeeRange this_ptr_conv;
40579 this_ptr_conv.inner = untag_ptr(this_ptr);
40580 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40582 this_ptr_conv.is_owned = false;
40583 int64_t ret_conv = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
40587 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_max_fee_satoshis"))) TS_ClosingSignedFeeRange_set_max_fee_satoshis(uint64_t this_ptr, int64_t val) {
40588 LDKClosingSignedFeeRange this_ptr_conv;
40589 this_ptr_conv.inner = untag_ptr(this_ptr);
40590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40592 this_ptr_conv.is_owned = false;
40593 ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
40596 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_new"))) TS_ClosingSignedFeeRange_new(int64_t min_fee_satoshis_arg, int64_t max_fee_satoshis_arg) {
40597 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
40598 uint64_t ret_ref = 0;
40599 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40600 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40604 static inline uint64_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
40605 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
40606 uint64_t ret_ref = 0;
40607 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40608 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40611 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone_ptr"))) TS_ClosingSignedFeeRange_clone_ptr(uint64_t arg) {
40612 LDKClosingSignedFeeRange arg_conv;
40613 arg_conv.inner = untag_ptr(arg);
40614 arg_conv.is_owned = ptr_is_owned(arg);
40615 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40616 arg_conv.is_owned = false;
40617 int64_t ret_conv = ClosingSignedFeeRange_clone_ptr(&arg_conv);
40621 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone"))) TS_ClosingSignedFeeRange_clone(uint64_t orig) {
40622 LDKClosingSignedFeeRange orig_conv;
40623 orig_conv.inner = untag_ptr(orig);
40624 orig_conv.is_owned = ptr_is_owned(orig);
40625 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40626 orig_conv.is_owned = false;
40627 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
40628 uint64_t ret_ref = 0;
40629 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40630 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40634 jboolean __attribute__((export_name("TS_ClosingSignedFeeRange_eq"))) TS_ClosingSignedFeeRange_eq(uint64_t a, uint64_t b) {
40635 LDKClosingSignedFeeRange a_conv;
40636 a_conv.inner = untag_ptr(a);
40637 a_conv.is_owned = ptr_is_owned(a);
40638 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40639 a_conv.is_owned = false;
40640 LDKClosingSignedFeeRange b_conv;
40641 b_conv.inner = untag_ptr(b);
40642 b_conv.is_owned = ptr_is_owned(b);
40643 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40644 b_conv.is_owned = false;
40645 jboolean ret_conv = ClosingSignedFeeRange_eq(&a_conv, &b_conv);
40649 void __attribute__((export_name("TS_ClosingSigned_free"))) TS_ClosingSigned_free(uint64_t this_obj) {
40650 LDKClosingSigned this_obj_conv;
40651 this_obj_conv.inner = untag_ptr(this_obj);
40652 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40654 ClosingSigned_free(this_obj_conv);
40657 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_channel_id"))) TS_ClosingSigned_get_channel_id(uint64_t this_ptr) {
40658 LDKClosingSigned this_ptr_conv;
40659 this_ptr_conv.inner = untag_ptr(this_ptr);
40660 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40662 this_ptr_conv.is_owned = false;
40663 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40664 memcpy(ret_arr->elems, *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
40668 void __attribute__((export_name("TS_ClosingSigned_set_channel_id"))) TS_ClosingSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40669 LDKClosingSigned this_ptr_conv;
40670 this_ptr_conv.inner = untag_ptr(this_ptr);
40671 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40673 this_ptr_conv.is_owned = false;
40674 LDKThirtyTwoBytes val_ref;
40675 CHECK(val->arr_len == 32);
40676 memcpy(val_ref.data, val->elems, 32); FREE(val);
40677 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
40680 int64_t __attribute__((export_name("TS_ClosingSigned_get_fee_satoshis"))) TS_ClosingSigned_get_fee_satoshis(uint64_t this_ptr) {
40681 LDKClosingSigned this_ptr_conv;
40682 this_ptr_conv.inner = untag_ptr(this_ptr);
40683 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40685 this_ptr_conv.is_owned = false;
40686 int64_t ret_conv = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
40690 void __attribute__((export_name("TS_ClosingSigned_set_fee_satoshis"))) TS_ClosingSigned_set_fee_satoshis(uint64_t this_ptr, int64_t val) {
40691 LDKClosingSigned this_ptr_conv;
40692 this_ptr_conv.inner = untag_ptr(this_ptr);
40693 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40695 this_ptr_conv.is_owned = false;
40696 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
40699 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_signature"))) TS_ClosingSigned_get_signature(uint64_t this_ptr) {
40700 LDKClosingSigned this_ptr_conv;
40701 this_ptr_conv.inner = untag_ptr(this_ptr);
40702 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40704 this_ptr_conv.is_owned = false;
40705 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
40706 memcpy(ret_arr->elems, ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
40710 void __attribute__((export_name("TS_ClosingSigned_set_signature"))) TS_ClosingSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
40711 LDKClosingSigned this_ptr_conv;
40712 this_ptr_conv.inner = untag_ptr(this_ptr);
40713 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40715 this_ptr_conv.is_owned = false;
40716 LDKECDSASignature val_ref;
40717 CHECK(val->arr_len == 64);
40718 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
40719 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
40722 uint64_t __attribute__((export_name("TS_ClosingSigned_get_fee_range"))) TS_ClosingSigned_get_fee_range(uint64_t this_ptr) {
40723 LDKClosingSigned this_ptr_conv;
40724 this_ptr_conv.inner = untag_ptr(this_ptr);
40725 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40727 this_ptr_conv.is_owned = false;
40728 LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
40729 uint64_t ret_ref = 0;
40730 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40731 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40735 void __attribute__((export_name("TS_ClosingSigned_set_fee_range"))) TS_ClosingSigned_set_fee_range(uint64_t this_ptr, uint64_t val) {
40736 LDKClosingSigned this_ptr_conv;
40737 this_ptr_conv.inner = untag_ptr(this_ptr);
40738 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40740 this_ptr_conv.is_owned = false;
40741 LDKClosingSignedFeeRange val_conv;
40742 val_conv.inner = untag_ptr(val);
40743 val_conv.is_owned = ptr_is_owned(val);
40744 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40745 val_conv = ClosingSignedFeeRange_clone(&val_conv);
40746 ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
40749 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) {
40750 LDKThirtyTwoBytes channel_id_arg_ref;
40751 CHECK(channel_id_arg->arr_len == 32);
40752 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
40753 LDKECDSASignature signature_arg_ref;
40754 CHECK(signature_arg->arr_len == 64);
40755 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
40756 LDKClosingSignedFeeRange fee_range_arg_conv;
40757 fee_range_arg_conv.inner = untag_ptr(fee_range_arg);
40758 fee_range_arg_conv.is_owned = ptr_is_owned(fee_range_arg);
40759 CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
40760 fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
40761 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
40762 uint64_t ret_ref = 0;
40763 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40764 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40768 static inline uint64_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
40769 LDKClosingSigned ret_var = ClosingSigned_clone(arg);
40770 uint64_t ret_ref = 0;
40771 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40772 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40775 int64_t __attribute__((export_name("TS_ClosingSigned_clone_ptr"))) TS_ClosingSigned_clone_ptr(uint64_t arg) {
40776 LDKClosingSigned arg_conv;
40777 arg_conv.inner = untag_ptr(arg);
40778 arg_conv.is_owned = ptr_is_owned(arg);
40779 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40780 arg_conv.is_owned = false;
40781 int64_t ret_conv = ClosingSigned_clone_ptr(&arg_conv);
40785 uint64_t __attribute__((export_name("TS_ClosingSigned_clone"))) TS_ClosingSigned_clone(uint64_t orig) {
40786 LDKClosingSigned orig_conv;
40787 orig_conv.inner = untag_ptr(orig);
40788 orig_conv.is_owned = ptr_is_owned(orig);
40789 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40790 orig_conv.is_owned = false;
40791 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
40792 uint64_t ret_ref = 0;
40793 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40794 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40798 jboolean __attribute__((export_name("TS_ClosingSigned_eq"))) TS_ClosingSigned_eq(uint64_t a, uint64_t b) {
40799 LDKClosingSigned a_conv;
40800 a_conv.inner = untag_ptr(a);
40801 a_conv.is_owned = ptr_is_owned(a);
40802 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40803 a_conv.is_owned = false;
40804 LDKClosingSigned b_conv;
40805 b_conv.inner = untag_ptr(b);
40806 b_conv.is_owned = ptr_is_owned(b);
40807 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40808 b_conv.is_owned = false;
40809 jboolean ret_conv = ClosingSigned_eq(&a_conv, &b_conv);
40813 void __attribute__((export_name("TS_UpdateAddHTLC_free"))) TS_UpdateAddHTLC_free(uint64_t this_obj) {
40814 LDKUpdateAddHTLC this_obj_conv;
40815 this_obj_conv.inner = untag_ptr(this_obj);
40816 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40817 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40818 UpdateAddHTLC_free(this_obj_conv);
40821 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_channel_id"))) TS_UpdateAddHTLC_get_channel_id(uint64_t this_ptr) {
40822 LDKUpdateAddHTLC this_ptr_conv;
40823 this_ptr_conv.inner = untag_ptr(this_ptr);
40824 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40826 this_ptr_conv.is_owned = false;
40827 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40828 memcpy(ret_arr->elems, *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
40832 void __attribute__((export_name("TS_UpdateAddHTLC_set_channel_id"))) TS_UpdateAddHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
40833 LDKUpdateAddHTLC this_ptr_conv;
40834 this_ptr_conv.inner = untag_ptr(this_ptr);
40835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40837 this_ptr_conv.is_owned = false;
40838 LDKThirtyTwoBytes val_ref;
40839 CHECK(val->arr_len == 32);
40840 memcpy(val_ref.data, val->elems, 32); FREE(val);
40841 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
40844 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_htlc_id"))) TS_UpdateAddHTLC_get_htlc_id(uint64_t this_ptr) {
40845 LDKUpdateAddHTLC this_ptr_conv;
40846 this_ptr_conv.inner = untag_ptr(this_ptr);
40847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40849 this_ptr_conv.is_owned = false;
40850 int64_t ret_conv = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
40854 void __attribute__((export_name("TS_UpdateAddHTLC_set_htlc_id"))) TS_UpdateAddHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
40855 LDKUpdateAddHTLC this_ptr_conv;
40856 this_ptr_conv.inner = untag_ptr(this_ptr);
40857 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40858 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40859 this_ptr_conv.is_owned = false;
40860 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
40863 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_amount_msat"))) TS_UpdateAddHTLC_get_amount_msat(uint64_t this_ptr) {
40864 LDKUpdateAddHTLC this_ptr_conv;
40865 this_ptr_conv.inner = untag_ptr(this_ptr);
40866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40868 this_ptr_conv.is_owned = false;
40869 int64_t ret_conv = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
40873 void __attribute__((export_name("TS_UpdateAddHTLC_set_amount_msat"))) TS_UpdateAddHTLC_set_amount_msat(uint64_t this_ptr, int64_t val) {
40874 LDKUpdateAddHTLC this_ptr_conv;
40875 this_ptr_conv.inner = untag_ptr(this_ptr);
40876 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40878 this_ptr_conv.is_owned = false;
40879 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
40882 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_payment_hash"))) TS_UpdateAddHTLC_get_payment_hash(uint64_t this_ptr) {
40883 LDKUpdateAddHTLC this_ptr_conv;
40884 this_ptr_conv.inner = untag_ptr(this_ptr);
40885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40887 this_ptr_conv.is_owned = false;
40888 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40889 memcpy(ret_arr->elems, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
40893 void __attribute__((export_name("TS_UpdateAddHTLC_set_payment_hash"))) TS_UpdateAddHTLC_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
40894 LDKUpdateAddHTLC this_ptr_conv;
40895 this_ptr_conv.inner = untag_ptr(this_ptr);
40896 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40898 this_ptr_conv.is_owned = false;
40899 LDKThirtyTwoBytes val_ref;
40900 CHECK(val->arr_len == 32);
40901 memcpy(val_ref.data, val->elems, 32); FREE(val);
40902 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
40905 int32_t __attribute__((export_name("TS_UpdateAddHTLC_get_cltv_expiry"))) TS_UpdateAddHTLC_get_cltv_expiry(uint64_t this_ptr) {
40906 LDKUpdateAddHTLC this_ptr_conv;
40907 this_ptr_conv.inner = untag_ptr(this_ptr);
40908 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40910 this_ptr_conv.is_owned = false;
40911 int32_t ret_conv = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
40915 void __attribute__((export_name("TS_UpdateAddHTLC_set_cltv_expiry"))) TS_UpdateAddHTLC_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
40916 LDKUpdateAddHTLC this_ptr_conv;
40917 this_ptr_conv.inner = untag_ptr(this_ptr);
40918 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40920 this_ptr_conv.is_owned = false;
40921 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
40924 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_get_skimmed_fee_msat"))) TS_UpdateAddHTLC_get_skimmed_fee_msat(uint64_t this_ptr) {
40925 LDKUpdateAddHTLC this_ptr_conv;
40926 this_ptr_conv.inner = untag_ptr(this_ptr);
40927 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40929 this_ptr_conv.is_owned = false;
40930 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
40931 *ret_copy = UpdateAddHTLC_get_skimmed_fee_msat(&this_ptr_conv);
40932 uint64_t ret_ref = tag_ptr(ret_copy, true);
40936 void __attribute__((export_name("TS_UpdateAddHTLC_set_skimmed_fee_msat"))) TS_UpdateAddHTLC_set_skimmed_fee_msat(uint64_t this_ptr, uint64_t val) {
40937 LDKUpdateAddHTLC this_ptr_conv;
40938 this_ptr_conv.inner = untag_ptr(this_ptr);
40939 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
40940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40941 this_ptr_conv.is_owned = false;
40942 void* val_ptr = untag_ptr(val);
40943 CHECK_ACCESS(val_ptr);
40944 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
40945 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
40946 UpdateAddHTLC_set_skimmed_fee_msat(&this_ptr_conv, val_conv);
40949 static inline uint64_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
40950 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
40951 uint64_t ret_ref = 0;
40952 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40953 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40956 int64_t __attribute__((export_name("TS_UpdateAddHTLC_clone_ptr"))) TS_UpdateAddHTLC_clone_ptr(uint64_t arg) {
40957 LDKUpdateAddHTLC arg_conv;
40958 arg_conv.inner = untag_ptr(arg);
40959 arg_conv.is_owned = ptr_is_owned(arg);
40960 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40961 arg_conv.is_owned = false;
40962 int64_t ret_conv = UpdateAddHTLC_clone_ptr(&arg_conv);
40966 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_clone"))) TS_UpdateAddHTLC_clone(uint64_t orig) {
40967 LDKUpdateAddHTLC orig_conv;
40968 orig_conv.inner = untag_ptr(orig);
40969 orig_conv.is_owned = ptr_is_owned(orig);
40970 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40971 orig_conv.is_owned = false;
40972 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
40973 uint64_t ret_ref = 0;
40974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40975 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
40979 jboolean __attribute__((export_name("TS_UpdateAddHTLC_eq"))) TS_UpdateAddHTLC_eq(uint64_t a, uint64_t b) {
40980 LDKUpdateAddHTLC a_conv;
40981 a_conv.inner = untag_ptr(a);
40982 a_conv.is_owned = ptr_is_owned(a);
40983 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40984 a_conv.is_owned = false;
40985 LDKUpdateAddHTLC b_conv;
40986 b_conv.inner = untag_ptr(b);
40987 b_conv.is_owned = ptr_is_owned(b);
40988 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40989 b_conv.is_owned = false;
40990 jboolean ret_conv = UpdateAddHTLC_eq(&a_conv, &b_conv);
40994 void __attribute__((export_name("TS_OnionMessage_free"))) TS_OnionMessage_free(uint64_t this_obj) {
40995 LDKOnionMessage this_obj_conv;
40996 this_obj_conv.inner = untag_ptr(this_obj);
40997 this_obj_conv.is_owned = ptr_is_owned(this_obj);
40998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40999 OnionMessage_free(this_obj_conv);
41002 int8_tArray __attribute__((export_name("TS_OnionMessage_get_blinding_point"))) TS_OnionMessage_get_blinding_point(uint64_t this_ptr) {
41003 LDKOnionMessage this_ptr_conv;
41004 this_ptr_conv.inner = untag_ptr(this_ptr);
41005 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41006 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41007 this_ptr_conv.is_owned = false;
41008 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41009 memcpy(ret_arr->elems, OnionMessage_get_blinding_point(&this_ptr_conv).compressed_form, 33);
41013 void __attribute__((export_name("TS_OnionMessage_set_blinding_point"))) TS_OnionMessage_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
41014 LDKOnionMessage this_ptr_conv;
41015 this_ptr_conv.inner = untag_ptr(this_ptr);
41016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41018 this_ptr_conv.is_owned = false;
41019 LDKPublicKey val_ref;
41020 CHECK(val->arr_len == 33);
41021 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
41022 OnionMessage_set_blinding_point(&this_ptr_conv, val_ref);
41025 uint64_t __attribute__((export_name("TS_OnionMessage_get_onion_routing_packet"))) TS_OnionMessage_get_onion_routing_packet(uint64_t this_ptr) {
41026 LDKOnionMessage this_ptr_conv;
41027 this_ptr_conv.inner = untag_ptr(this_ptr);
41028 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41030 this_ptr_conv.is_owned = false;
41031 LDKPacket ret_var = OnionMessage_get_onion_routing_packet(&this_ptr_conv);
41032 uint64_t ret_ref = 0;
41033 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41034 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41038 void __attribute__((export_name("TS_OnionMessage_set_onion_routing_packet"))) TS_OnionMessage_set_onion_routing_packet(uint64_t this_ptr, uint64_t val) {
41039 LDKOnionMessage this_ptr_conv;
41040 this_ptr_conv.inner = untag_ptr(this_ptr);
41041 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41042 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41043 this_ptr_conv.is_owned = false;
41044 LDKPacket val_conv;
41045 val_conv.inner = untag_ptr(val);
41046 val_conv.is_owned = ptr_is_owned(val);
41047 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41048 val_conv = Packet_clone(&val_conv);
41049 OnionMessage_set_onion_routing_packet(&this_ptr_conv, val_conv);
41052 uint64_t __attribute__((export_name("TS_OnionMessage_new"))) TS_OnionMessage_new(int8_tArray blinding_point_arg, uint64_t onion_routing_packet_arg) {
41053 LDKPublicKey blinding_point_arg_ref;
41054 CHECK(blinding_point_arg->arr_len == 33);
41055 memcpy(blinding_point_arg_ref.compressed_form, blinding_point_arg->elems, 33); FREE(blinding_point_arg);
41056 LDKPacket onion_routing_packet_arg_conv;
41057 onion_routing_packet_arg_conv.inner = untag_ptr(onion_routing_packet_arg);
41058 onion_routing_packet_arg_conv.is_owned = ptr_is_owned(onion_routing_packet_arg);
41059 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_routing_packet_arg_conv);
41060 onion_routing_packet_arg_conv = Packet_clone(&onion_routing_packet_arg_conv);
41061 LDKOnionMessage ret_var = OnionMessage_new(blinding_point_arg_ref, onion_routing_packet_arg_conv);
41062 uint64_t ret_ref = 0;
41063 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41064 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41068 static inline uint64_t OnionMessage_clone_ptr(LDKOnionMessage *NONNULL_PTR arg) {
41069 LDKOnionMessage ret_var = OnionMessage_clone(arg);
41070 uint64_t ret_ref = 0;
41071 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41072 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41075 int64_t __attribute__((export_name("TS_OnionMessage_clone_ptr"))) TS_OnionMessage_clone_ptr(uint64_t arg) {
41076 LDKOnionMessage arg_conv;
41077 arg_conv.inner = untag_ptr(arg);
41078 arg_conv.is_owned = ptr_is_owned(arg);
41079 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41080 arg_conv.is_owned = false;
41081 int64_t ret_conv = OnionMessage_clone_ptr(&arg_conv);
41085 uint64_t __attribute__((export_name("TS_OnionMessage_clone"))) TS_OnionMessage_clone(uint64_t orig) {
41086 LDKOnionMessage orig_conv;
41087 orig_conv.inner = untag_ptr(orig);
41088 orig_conv.is_owned = ptr_is_owned(orig);
41089 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41090 orig_conv.is_owned = false;
41091 LDKOnionMessage ret_var = OnionMessage_clone(&orig_conv);
41092 uint64_t ret_ref = 0;
41093 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41094 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41098 jboolean __attribute__((export_name("TS_OnionMessage_eq"))) TS_OnionMessage_eq(uint64_t a, uint64_t b) {
41099 LDKOnionMessage a_conv;
41100 a_conv.inner = untag_ptr(a);
41101 a_conv.is_owned = ptr_is_owned(a);
41102 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41103 a_conv.is_owned = false;
41104 LDKOnionMessage b_conv;
41105 b_conv.inner = untag_ptr(b);
41106 b_conv.is_owned = ptr_is_owned(b);
41107 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41108 b_conv.is_owned = false;
41109 jboolean ret_conv = OnionMessage_eq(&a_conv, &b_conv);
41113 void __attribute__((export_name("TS_UpdateFulfillHTLC_free"))) TS_UpdateFulfillHTLC_free(uint64_t this_obj) {
41114 LDKUpdateFulfillHTLC this_obj_conv;
41115 this_obj_conv.inner = untag_ptr(this_obj);
41116 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41118 UpdateFulfillHTLC_free(this_obj_conv);
41121 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_channel_id"))) TS_UpdateFulfillHTLC_get_channel_id(uint64_t this_ptr) {
41122 LDKUpdateFulfillHTLC this_ptr_conv;
41123 this_ptr_conv.inner = untag_ptr(this_ptr);
41124 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41125 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41126 this_ptr_conv.is_owned = false;
41127 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41128 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
41132 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_channel_id"))) TS_UpdateFulfillHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41133 LDKUpdateFulfillHTLC this_ptr_conv;
41134 this_ptr_conv.inner = untag_ptr(this_ptr);
41135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41137 this_ptr_conv.is_owned = false;
41138 LDKThirtyTwoBytes val_ref;
41139 CHECK(val->arr_len == 32);
41140 memcpy(val_ref.data, val->elems, 32); FREE(val);
41141 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
41144 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_get_htlc_id"))) TS_UpdateFulfillHTLC_get_htlc_id(uint64_t this_ptr) {
41145 LDKUpdateFulfillHTLC this_ptr_conv;
41146 this_ptr_conv.inner = untag_ptr(this_ptr);
41147 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41149 this_ptr_conv.is_owned = false;
41150 int64_t ret_conv = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
41154 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_htlc_id"))) TS_UpdateFulfillHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
41155 LDKUpdateFulfillHTLC this_ptr_conv;
41156 this_ptr_conv.inner = untag_ptr(this_ptr);
41157 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41158 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41159 this_ptr_conv.is_owned = false;
41160 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
41163 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_payment_preimage"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint64_t this_ptr) {
41164 LDKUpdateFulfillHTLC this_ptr_conv;
41165 this_ptr_conv.inner = untag_ptr(this_ptr);
41166 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41168 this_ptr_conv.is_owned = false;
41169 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41170 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
41174 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_payment_preimage"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint64_t this_ptr, int8_tArray val) {
41175 LDKUpdateFulfillHTLC this_ptr_conv;
41176 this_ptr_conv.inner = untag_ptr(this_ptr);
41177 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41179 this_ptr_conv.is_owned = false;
41180 LDKThirtyTwoBytes val_ref;
41181 CHECK(val->arr_len == 32);
41182 memcpy(val_ref.data, val->elems, 32); FREE(val);
41183 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
41186 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) {
41187 LDKThirtyTwoBytes channel_id_arg_ref;
41188 CHECK(channel_id_arg->arr_len == 32);
41189 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
41190 LDKThirtyTwoBytes payment_preimage_arg_ref;
41191 CHECK(payment_preimage_arg->arr_len == 32);
41192 memcpy(payment_preimage_arg_ref.data, payment_preimage_arg->elems, 32); FREE(payment_preimage_arg);
41193 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
41194 uint64_t ret_ref = 0;
41195 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41196 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41200 static inline uint64_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
41201 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
41202 uint64_t ret_ref = 0;
41203 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41204 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41207 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone_ptr"))) TS_UpdateFulfillHTLC_clone_ptr(uint64_t arg) {
41208 LDKUpdateFulfillHTLC arg_conv;
41209 arg_conv.inner = untag_ptr(arg);
41210 arg_conv.is_owned = ptr_is_owned(arg);
41211 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41212 arg_conv.is_owned = false;
41213 int64_t ret_conv = UpdateFulfillHTLC_clone_ptr(&arg_conv);
41217 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone"))) TS_UpdateFulfillHTLC_clone(uint64_t orig) {
41218 LDKUpdateFulfillHTLC orig_conv;
41219 orig_conv.inner = untag_ptr(orig);
41220 orig_conv.is_owned = ptr_is_owned(orig);
41221 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41222 orig_conv.is_owned = false;
41223 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
41224 uint64_t ret_ref = 0;
41225 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41226 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41230 jboolean __attribute__((export_name("TS_UpdateFulfillHTLC_eq"))) TS_UpdateFulfillHTLC_eq(uint64_t a, uint64_t b) {
41231 LDKUpdateFulfillHTLC a_conv;
41232 a_conv.inner = untag_ptr(a);
41233 a_conv.is_owned = ptr_is_owned(a);
41234 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41235 a_conv.is_owned = false;
41236 LDKUpdateFulfillHTLC b_conv;
41237 b_conv.inner = untag_ptr(b);
41238 b_conv.is_owned = ptr_is_owned(b);
41239 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41240 b_conv.is_owned = false;
41241 jboolean ret_conv = UpdateFulfillHTLC_eq(&a_conv, &b_conv);
41245 void __attribute__((export_name("TS_UpdateFailHTLC_free"))) TS_UpdateFailHTLC_free(uint64_t this_obj) {
41246 LDKUpdateFailHTLC this_obj_conv;
41247 this_obj_conv.inner = untag_ptr(this_obj);
41248 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41250 UpdateFailHTLC_free(this_obj_conv);
41253 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_get_channel_id"))) TS_UpdateFailHTLC_get_channel_id(uint64_t this_ptr) {
41254 LDKUpdateFailHTLC this_ptr_conv;
41255 this_ptr_conv.inner = untag_ptr(this_ptr);
41256 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41258 this_ptr_conv.is_owned = false;
41259 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41260 memcpy(ret_arr->elems, *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
41264 void __attribute__((export_name("TS_UpdateFailHTLC_set_channel_id"))) TS_UpdateFailHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41265 LDKUpdateFailHTLC this_ptr_conv;
41266 this_ptr_conv.inner = untag_ptr(this_ptr);
41267 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41269 this_ptr_conv.is_owned = false;
41270 LDKThirtyTwoBytes val_ref;
41271 CHECK(val->arr_len == 32);
41272 memcpy(val_ref.data, val->elems, 32); FREE(val);
41273 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
41276 int64_t __attribute__((export_name("TS_UpdateFailHTLC_get_htlc_id"))) TS_UpdateFailHTLC_get_htlc_id(uint64_t this_ptr) {
41277 LDKUpdateFailHTLC this_ptr_conv;
41278 this_ptr_conv.inner = untag_ptr(this_ptr);
41279 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41281 this_ptr_conv.is_owned = false;
41282 int64_t ret_conv = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
41286 void __attribute__((export_name("TS_UpdateFailHTLC_set_htlc_id"))) TS_UpdateFailHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
41287 LDKUpdateFailHTLC this_ptr_conv;
41288 this_ptr_conv.inner = untag_ptr(this_ptr);
41289 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41291 this_ptr_conv.is_owned = false;
41292 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
41295 static inline uint64_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
41296 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
41297 uint64_t ret_ref = 0;
41298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41302 int64_t __attribute__((export_name("TS_UpdateFailHTLC_clone_ptr"))) TS_UpdateFailHTLC_clone_ptr(uint64_t arg) {
41303 LDKUpdateFailHTLC arg_conv;
41304 arg_conv.inner = untag_ptr(arg);
41305 arg_conv.is_owned = ptr_is_owned(arg);
41306 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41307 arg_conv.is_owned = false;
41308 int64_t ret_conv = UpdateFailHTLC_clone_ptr(&arg_conv);
41312 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_clone"))) TS_UpdateFailHTLC_clone(uint64_t orig) {
41313 LDKUpdateFailHTLC orig_conv;
41314 orig_conv.inner = untag_ptr(orig);
41315 orig_conv.is_owned = ptr_is_owned(orig);
41316 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41317 orig_conv.is_owned = false;
41318 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
41319 uint64_t ret_ref = 0;
41320 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41321 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41325 jboolean __attribute__((export_name("TS_UpdateFailHTLC_eq"))) TS_UpdateFailHTLC_eq(uint64_t a, uint64_t b) {
41326 LDKUpdateFailHTLC a_conv;
41327 a_conv.inner = untag_ptr(a);
41328 a_conv.is_owned = ptr_is_owned(a);
41329 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41330 a_conv.is_owned = false;
41331 LDKUpdateFailHTLC b_conv;
41332 b_conv.inner = untag_ptr(b);
41333 b_conv.is_owned = ptr_is_owned(b);
41334 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41335 b_conv.is_owned = false;
41336 jboolean ret_conv = UpdateFailHTLC_eq(&a_conv, &b_conv);
41340 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_free"))) TS_UpdateFailMalformedHTLC_free(uint64_t this_obj) {
41341 LDKUpdateFailMalformedHTLC this_obj_conv;
41342 this_obj_conv.inner = untag_ptr(this_obj);
41343 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41345 UpdateFailMalformedHTLC_free(this_obj_conv);
41348 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_channel_id"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint64_t this_ptr) {
41349 LDKUpdateFailMalformedHTLC this_ptr_conv;
41350 this_ptr_conv.inner = untag_ptr(this_ptr);
41351 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41353 this_ptr_conv.is_owned = false;
41354 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41355 memcpy(ret_arr->elems, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
41359 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_channel_id"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41360 LDKUpdateFailMalformedHTLC this_ptr_conv;
41361 this_ptr_conv.inner = untag_ptr(this_ptr);
41362 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41364 this_ptr_conv.is_owned = false;
41365 LDKThirtyTwoBytes val_ref;
41366 CHECK(val->arr_len == 32);
41367 memcpy(val_ref.data, val->elems, 32); FREE(val);
41368 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
41371 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_htlc_id"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint64_t this_ptr) {
41372 LDKUpdateFailMalformedHTLC this_ptr_conv;
41373 this_ptr_conv.inner = untag_ptr(this_ptr);
41374 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41376 this_ptr_conv.is_owned = false;
41377 int64_t ret_conv = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
41381 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_htlc_id"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint64_t this_ptr, int64_t val) {
41382 LDKUpdateFailMalformedHTLC this_ptr_conv;
41383 this_ptr_conv.inner = untag_ptr(this_ptr);
41384 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41386 this_ptr_conv.is_owned = false;
41387 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
41390 int16_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_failure_code"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint64_t this_ptr) {
41391 LDKUpdateFailMalformedHTLC this_ptr_conv;
41392 this_ptr_conv.inner = untag_ptr(this_ptr);
41393 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41395 this_ptr_conv.is_owned = false;
41396 int16_t ret_conv = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
41400 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_failure_code"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint64_t this_ptr, int16_t val) {
41401 LDKUpdateFailMalformedHTLC this_ptr_conv;
41402 this_ptr_conv.inner = untag_ptr(this_ptr);
41403 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41404 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41405 this_ptr_conv.is_owned = false;
41406 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
41409 static inline uint64_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
41410 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
41411 uint64_t ret_ref = 0;
41412 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41413 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41416 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone_ptr"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint64_t arg) {
41417 LDKUpdateFailMalformedHTLC arg_conv;
41418 arg_conv.inner = untag_ptr(arg);
41419 arg_conv.is_owned = ptr_is_owned(arg);
41420 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41421 arg_conv.is_owned = false;
41422 int64_t ret_conv = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
41426 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone"))) TS_UpdateFailMalformedHTLC_clone(uint64_t orig) {
41427 LDKUpdateFailMalformedHTLC orig_conv;
41428 orig_conv.inner = untag_ptr(orig);
41429 orig_conv.is_owned = ptr_is_owned(orig);
41430 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41431 orig_conv.is_owned = false;
41432 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
41433 uint64_t ret_ref = 0;
41434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41435 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41439 jboolean __attribute__((export_name("TS_UpdateFailMalformedHTLC_eq"))) TS_UpdateFailMalformedHTLC_eq(uint64_t a, uint64_t b) {
41440 LDKUpdateFailMalformedHTLC a_conv;
41441 a_conv.inner = untag_ptr(a);
41442 a_conv.is_owned = ptr_is_owned(a);
41443 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41444 a_conv.is_owned = false;
41445 LDKUpdateFailMalformedHTLC b_conv;
41446 b_conv.inner = untag_ptr(b);
41447 b_conv.is_owned = ptr_is_owned(b);
41448 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41449 b_conv.is_owned = false;
41450 jboolean ret_conv = UpdateFailMalformedHTLC_eq(&a_conv, &b_conv);
41454 void __attribute__((export_name("TS_CommitmentSigned_free"))) TS_CommitmentSigned_free(uint64_t this_obj) {
41455 LDKCommitmentSigned this_obj_conv;
41456 this_obj_conv.inner = untag_ptr(this_obj);
41457 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41459 CommitmentSigned_free(this_obj_conv);
41462 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_channel_id"))) TS_CommitmentSigned_get_channel_id(uint64_t this_ptr) {
41463 LDKCommitmentSigned this_ptr_conv;
41464 this_ptr_conv.inner = untag_ptr(this_ptr);
41465 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41467 this_ptr_conv.is_owned = false;
41468 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41469 memcpy(ret_arr->elems, *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
41473 void __attribute__((export_name("TS_CommitmentSigned_set_channel_id"))) TS_CommitmentSigned_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41474 LDKCommitmentSigned this_ptr_conv;
41475 this_ptr_conv.inner = untag_ptr(this_ptr);
41476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41478 this_ptr_conv.is_owned = false;
41479 LDKThirtyTwoBytes val_ref;
41480 CHECK(val->arr_len == 32);
41481 memcpy(val_ref.data, val->elems, 32); FREE(val);
41482 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
41485 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_signature"))) TS_CommitmentSigned_get_signature(uint64_t this_ptr) {
41486 LDKCommitmentSigned this_ptr_conv;
41487 this_ptr_conv.inner = untag_ptr(this_ptr);
41488 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41490 this_ptr_conv.is_owned = false;
41491 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
41492 memcpy(ret_arr->elems, CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
41496 void __attribute__((export_name("TS_CommitmentSigned_set_signature"))) TS_CommitmentSigned_set_signature(uint64_t this_ptr, int8_tArray val) {
41497 LDKCommitmentSigned this_ptr_conv;
41498 this_ptr_conv.inner = untag_ptr(this_ptr);
41499 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41501 this_ptr_conv.is_owned = false;
41502 LDKECDSASignature val_ref;
41503 CHECK(val->arr_len == 64);
41504 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
41505 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
41508 ptrArray __attribute__((export_name("TS_CommitmentSigned_get_htlc_signatures"))) TS_CommitmentSigned_get_htlc_signatures(uint64_t this_ptr) {
41509 LDKCommitmentSigned this_ptr_conv;
41510 this_ptr_conv.inner = untag_ptr(this_ptr);
41511 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41512 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41513 this_ptr_conv.is_owned = false;
41514 LDKCVec_ECDSASignatureZ ret_var = CommitmentSigned_get_htlc_signatures(&this_ptr_conv);
41515 ptrArray ret_arr = NULL;
41516 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
41517 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
41518 for (size_t m = 0; m < ret_var.datalen; m++) {
41519 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
41520 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
41521 ret_arr_ptr[m] = ret_conv_12_arr;
41524 FREE(ret_var.data);
41528 void __attribute__((export_name("TS_CommitmentSigned_set_htlc_signatures"))) TS_CommitmentSigned_set_htlc_signatures(uint64_t this_ptr, ptrArray val) {
41529 LDKCommitmentSigned this_ptr_conv;
41530 this_ptr_conv.inner = untag_ptr(this_ptr);
41531 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41533 this_ptr_conv.is_owned = false;
41534 LDKCVec_ECDSASignatureZ val_constr;
41535 val_constr.datalen = val->arr_len;
41536 if (val_constr.datalen > 0)
41537 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
41539 val_constr.data = NULL;
41540 int8_tArray* val_vals = (void*) val->elems;
41541 for (size_t m = 0; m < val_constr.datalen; m++) {
41542 int8_tArray val_conv_12 = val_vals[m];
41543 LDKECDSASignature val_conv_12_ref;
41544 CHECK(val_conv_12->arr_len == 64);
41545 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
41546 val_constr.data[m] = val_conv_12_ref;
41549 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
41552 uint64_t __attribute__((export_name("TS_CommitmentSigned_new"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
41553 LDKThirtyTwoBytes channel_id_arg_ref;
41554 CHECK(channel_id_arg->arr_len == 32);
41555 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
41556 LDKECDSASignature signature_arg_ref;
41557 CHECK(signature_arg->arr_len == 64);
41558 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
41559 LDKCVec_ECDSASignatureZ htlc_signatures_arg_constr;
41560 htlc_signatures_arg_constr.datalen = htlc_signatures_arg->arr_len;
41561 if (htlc_signatures_arg_constr.datalen > 0)
41562 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
41564 htlc_signatures_arg_constr.data = NULL;
41565 int8_tArray* htlc_signatures_arg_vals = (void*) htlc_signatures_arg->elems;
41566 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
41567 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
41568 LDKECDSASignature htlc_signatures_arg_conv_12_ref;
41569 CHECK(htlc_signatures_arg_conv_12->arr_len == 64);
41570 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, htlc_signatures_arg_conv_12->elems, 64); FREE(htlc_signatures_arg_conv_12);
41571 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
41573 FREE(htlc_signatures_arg);
41574 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
41575 uint64_t ret_ref = 0;
41576 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41577 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41581 static inline uint64_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
41582 LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
41583 uint64_t ret_ref = 0;
41584 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41585 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41588 int64_t __attribute__((export_name("TS_CommitmentSigned_clone_ptr"))) TS_CommitmentSigned_clone_ptr(uint64_t arg) {
41589 LDKCommitmentSigned arg_conv;
41590 arg_conv.inner = untag_ptr(arg);
41591 arg_conv.is_owned = ptr_is_owned(arg);
41592 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41593 arg_conv.is_owned = false;
41594 int64_t ret_conv = CommitmentSigned_clone_ptr(&arg_conv);
41598 uint64_t __attribute__((export_name("TS_CommitmentSigned_clone"))) TS_CommitmentSigned_clone(uint64_t orig) {
41599 LDKCommitmentSigned orig_conv;
41600 orig_conv.inner = untag_ptr(orig);
41601 orig_conv.is_owned = ptr_is_owned(orig);
41602 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41603 orig_conv.is_owned = false;
41604 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
41605 uint64_t ret_ref = 0;
41606 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41607 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41611 jboolean __attribute__((export_name("TS_CommitmentSigned_eq"))) TS_CommitmentSigned_eq(uint64_t a, uint64_t b) {
41612 LDKCommitmentSigned a_conv;
41613 a_conv.inner = untag_ptr(a);
41614 a_conv.is_owned = ptr_is_owned(a);
41615 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41616 a_conv.is_owned = false;
41617 LDKCommitmentSigned b_conv;
41618 b_conv.inner = untag_ptr(b);
41619 b_conv.is_owned = ptr_is_owned(b);
41620 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41621 b_conv.is_owned = false;
41622 jboolean ret_conv = CommitmentSigned_eq(&a_conv, &b_conv);
41626 void __attribute__((export_name("TS_RevokeAndACK_free"))) TS_RevokeAndACK_free(uint64_t this_obj) {
41627 LDKRevokeAndACK this_obj_conv;
41628 this_obj_conv.inner = untag_ptr(this_obj);
41629 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41631 RevokeAndACK_free(this_obj_conv);
41634 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_channel_id"))) TS_RevokeAndACK_get_channel_id(uint64_t this_ptr) {
41635 LDKRevokeAndACK this_ptr_conv;
41636 this_ptr_conv.inner = untag_ptr(this_ptr);
41637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41639 this_ptr_conv.is_owned = false;
41640 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41641 memcpy(ret_arr->elems, *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
41645 void __attribute__((export_name("TS_RevokeAndACK_set_channel_id"))) TS_RevokeAndACK_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41646 LDKRevokeAndACK this_ptr_conv;
41647 this_ptr_conv.inner = untag_ptr(this_ptr);
41648 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41650 this_ptr_conv.is_owned = false;
41651 LDKThirtyTwoBytes val_ref;
41652 CHECK(val->arr_len == 32);
41653 memcpy(val_ref.data, val->elems, 32); FREE(val);
41654 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
41657 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_per_commitment_secret"))) TS_RevokeAndACK_get_per_commitment_secret(uint64_t this_ptr) {
41658 LDKRevokeAndACK this_ptr_conv;
41659 this_ptr_conv.inner = untag_ptr(this_ptr);
41660 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41662 this_ptr_conv.is_owned = false;
41663 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41664 memcpy(ret_arr->elems, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
41668 void __attribute__((export_name("TS_RevokeAndACK_set_per_commitment_secret"))) TS_RevokeAndACK_set_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
41669 LDKRevokeAndACK this_ptr_conv;
41670 this_ptr_conv.inner = untag_ptr(this_ptr);
41671 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41673 this_ptr_conv.is_owned = false;
41674 LDKThirtyTwoBytes val_ref;
41675 CHECK(val->arr_len == 32);
41676 memcpy(val_ref.data, val->elems, 32); FREE(val);
41677 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
41680 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_next_per_commitment_point"))) TS_RevokeAndACK_get_next_per_commitment_point(uint64_t this_ptr) {
41681 LDKRevokeAndACK this_ptr_conv;
41682 this_ptr_conv.inner = untag_ptr(this_ptr);
41683 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41685 this_ptr_conv.is_owned = false;
41686 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41687 memcpy(ret_arr->elems, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
41691 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) {
41692 LDKRevokeAndACK this_ptr_conv;
41693 this_ptr_conv.inner = untag_ptr(this_ptr);
41694 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41695 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41696 this_ptr_conv.is_owned = false;
41697 LDKPublicKey val_ref;
41698 CHECK(val->arr_len == 33);
41699 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
41700 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
41703 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) {
41704 LDKThirtyTwoBytes channel_id_arg_ref;
41705 CHECK(channel_id_arg->arr_len == 32);
41706 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
41707 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
41708 CHECK(per_commitment_secret_arg->arr_len == 32);
41709 memcpy(per_commitment_secret_arg_ref.data, per_commitment_secret_arg->elems, 32); FREE(per_commitment_secret_arg);
41710 LDKPublicKey next_per_commitment_point_arg_ref;
41711 CHECK(next_per_commitment_point_arg->arr_len == 33);
41712 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
41713 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
41714 uint64_t ret_ref = 0;
41715 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41716 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41720 static inline uint64_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
41721 LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
41722 uint64_t ret_ref = 0;
41723 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41724 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41727 int64_t __attribute__((export_name("TS_RevokeAndACK_clone_ptr"))) TS_RevokeAndACK_clone_ptr(uint64_t arg) {
41728 LDKRevokeAndACK arg_conv;
41729 arg_conv.inner = untag_ptr(arg);
41730 arg_conv.is_owned = ptr_is_owned(arg);
41731 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41732 arg_conv.is_owned = false;
41733 int64_t ret_conv = RevokeAndACK_clone_ptr(&arg_conv);
41737 uint64_t __attribute__((export_name("TS_RevokeAndACK_clone"))) TS_RevokeAndACK_clone(uint64_t orig) {
41738 LDKRevokeAndACK orig_conv;
41739 orig_conv.inner = untag_ptr(orig);
41740 orig_conv.is_owned = ptr_is_owned(orig);
41741 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41742 orig_conv.is_owned = false;
41743 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
41744 uint64_t ret_ref = 0;
41745 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41746 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41750 jboolean __attribute__((export_name("TS_RevokeAndACK_eq"))) TS_RevokeAndACK_eq(uint64_t a, uint64_t b) {
41751 LDKRevokeAndACK a_conv;
41752 a_conv.inner = untag_ptr(a);
41753 a_conv.is_owned = ptr_is_owned(a);
41754 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41755 a_conv.is_owned = false;
41756 LDKRevokeAndACK b_conv;
41757 b_conv.inner = untag_ptr(b);
41758 b_conv.is_owned = ptr_is_owned(b);
41759 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41760 b_conv.is_owned = false;
41761 jboolean ret_conv = RevokeAndACK_eq(&a_conv, &b_conv);
41765 void __attribute__((export_name("TS_UpdateFee_free"))) TS_UpdateFee_free(uint64_t this_obj) {
41766 LDKUpdateFee this_obj_conv;
41767 this_obj_conv.inner = untag_ptr(this_obj);
41768 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41770 UpdateFee_free(this_obj_conv);
41773 int8_tArray __attribute__((export_name("TS_UpdateFee_get_channel_id"))) TS_UpdateFee_get_channel_id(uint64_t this_ptr) {
41774 LDKUpdateFee this_ptr_conv;
41775 this_ptr_conv.inner = untag_ptr(this_ptr);
41776 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41778 this_ptr_conv.is_owned = false;
41779 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41780 memcpy(ret_arr->elems, *UpdateFee_get_channel_id(&this_ptr_conv), 32);
41784 void __attribute__((export_name("TS_UpdateFee_set_channel_id"))) TS_UpdateFee_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41785 LDKUpdateFee this_ptr_conv;
41786 this_ptr_conv.inner = untag_ptr(this_ptr);
41787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41789 this_ptr_conv.is_owned = false;
41790 LDKThirtyTwoBytes val_ref;
41791 CHECK(val->arr_len == 32);
41792 memcpy(val_ref.data, val->elems, 32); FREE(val);
41793 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
41796 int32_t __attribute__((export_name("TS_UpdateFee_get_feerate_per_kw"))) TS_UpdateFee_get_feerate_per_kw(uint64_t this_ptr) {
41797 LDKUpdateFee this_ptr_conv;
41798 this_ptr_conv.inner = untag_ptr(this_ptr);
41799 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41801 this_ptr_conv.is_owned = false;
41802 int32_t ret_conv = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
41806 void __attribute__((export_name("TS_UpdateFee_set_feerate_per_kw"))) TS_UpdateFee_set_feerate_per_kw(uint64_t this_ptr, int32_t val) {
41807 LDKUpdateFee this_ptr_conv;
41808 this_ptr_conv.inner = untag_ptr(this_ptr);
41809 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41811 this_ptr_conv.is_owned = false;
41812 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
41815 uint64_t __attribute__((export_name("TS_UpdateFee_new"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
41816 LDKThirtyTwoBytes channel_id_arg_ref;
41817 CHECK(channel_id_arg->arr_len == 32);
41818 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
41819 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
41820 uint64_t ret_ref = 0;
41821 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41822 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41826 static inline uint64_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
41827 LDKUpdateFee ret_var = UpdateFee_clone(arg);
41828 uint64_t ret_ref = 0;
41829 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41830 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41833 int64_t __attribute__((export_name("TS_UpdateFee_clone_ptr"))) TS_UpdateFee_clone_ptr(uint64_t arg) {
41834 LDKUpdateFee arg_conv;
41835 arg_conv.inner = untag_ptr(arg);
41836 arg_conv.is_owned = ptr_is_owned(arg);
41837 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41838 arg_conv.is_owned = false;
41839 int64_t ret_conv = UpdateFee_clone_ptr(&arg_conv);
41843 uint64_t __attribute__((export_name("TS_UpdateFee_clone"))) TS_UpdateFee_clone(uint64_t orig) {
41844 LDKUpdateFee orig_conv;
41845 orig_conv.inner = untag_ptr(orig);
41846 orig_conv.is_owned = ptr_is_owned(orig);
41847 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41848 orig_conv.is_owned = false;
41849 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
41850 uint64_t ret_ref = 0;
41851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41852 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
41856 jboolean __attribute__((export_name("TS_UpdateFee_eq"))) TS_UpdateFee_eq(uint64_t a, uint64_t b) {
41857 LDKUpdateFee a_conv;
41858 a_conv.inner = untag_ptr(a);
41859 a_conv.is_owned = ptr_is_owned(a);
41860 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41861 a_conv.is_owned = false;
41862 LDKUpdateFee b_conv;
41863 b_conv.inner = untag_ptr(b);
41864 b_conv.is_owned = ptr_is_owned(b);
41865 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41866 b_conv.is_owned = false;
41867 jboolean ret_conv = UpdateFee_eq(&a_conv, &b_conv);
41871 void __attribute__((export_name("TS_ChannelReestablish_free"))) TS_ChannelReestablish_free(uint64_t this_obj) {
41872 LDKChannelReestablish this_obj_conv;
41873 this_obj_conv.inner = untag_ptr(this_obj);
41874 this_obj_conv.is_owned = ptr_is_owned(this_obj);
41875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41876 ChannelReestablish_free(this_obj_conv);
41879 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_channel_id"))) TS_ChannelReestablish_get_channel_id(uint64_t this_ptr) {
41880 LDKChannelReestablish this_ptr_conv;
41881 this_ptr_conv.inner = untag_ptr(this_ptr);
41882 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41883 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41884 this_ptr_conv.is_owned = false;
41885 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41886 memcpy(ret_arr->elems, *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
41890 void __attribute__((export_name("TS_ChannelReestablish_set_channel_id"))) TS_ChannelReestablish_set_channel_id(uint64_t this_ptr, int8_tArray val) {
41891 LDKChannelReestablish this_ptr_conv;
41892 this_ptr_conv.inner = untag_ptr(this_ptr);
41893 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41895 this_ptr_conv.is_owned = false;
41896 LDKThirtyTwoBytes val_ref;
41897 CHECK(val->arr_len == 32);
41898 memcpy(val_ref.data, val->elems, 32); FREE(val);
41899 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
41902 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_local_commitment_number"))) TS_ChannelReestablish_get_next_local_commitment_number(uint64_t this_ptr) {
41903 LDKChannelReestablish this_ptr_conv;
41904 this_ptr_conv.inner = untag_ptr(this_ptr);
41905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41907 this_ptr_conv.is_owned = false;
41908 int64_t ret_conv = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
41912 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) {
41913 LDKChannelReestablish this_ptr_conv;
41914 this_ptr_conv.inner = untag_ptr(this_ptr);
41915 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41917 this_ptr_conv.is_owned = false;
41918 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
41921 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_remote_commitment_number"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint64_t this_ptr) {
41922 LDKChannelReestablish this_ptr_conv;
41923 this_ptr_conv.inner = untag_ptr(this_ptr);
41924 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41926 this_ptr_conv.is_owned = false;
41927 int64_t ret_conv = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
41931 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) {
41932 LDKChannelReestablish this_ptr_conv;
41933 this_ptr_conv.inner = untag_ptr(this_ptr);
41934 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41936 this_ptr_conv.is_owned = false;
41937 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
41940 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_your_last_per_commitment_secret"))) TS_ChannelReestablish_get_your_last_per_commitment_secret(uint64_t this_ptr) {
41941 LDKChannelReestablish this_ptr_conv;
41942 this_ptr_conv.inner = untag_ptr(this_ptr);
41943 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41945 this_ptr_conv.is_owned = false;
41946 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
41947 memcpy(ret_arr->elems, *ChannelReestablish_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
41951 void __attribute__((export_name("TS_ChannelReestablish_set_your_last_per_commitment_secret"))) TS_ChannelReestablish_set_your_last_per_commitment_secret(uint64_t this_ptr, int8_tArray val) {
41952 LDKChannelReestablish this_ptr_conv;
41953 this_ptr_conv.inner = untag_ptr(this_ptr);
41954 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41956 this_ptr_conv.is_owned = false;
41957 LDKThirtyTwoBytes val_ref;
41958 CHECK(val->arr_len == 32);
41959 memcpy(val_ref.data, val->elems, 32); FREE(val);
41960 ChannelReestablish_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
41963 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_my_current_per_commitment_point"))) TS_ChannelReestablish_get_my_current_per_commitment_point(uint64_t this_ptr) {
41964 LDKChannelReestablish this_ptr_conv;
41965 this_ptr_conv.inner = untag_ptr(this_ptr);
41966 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41968 this_ptr_conv.is_owned = false;
41969 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41970 memcpy(ret_arr->elems, ChannelReestablish_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
41974 void __attribute__((export_name("TS_ChannelReestablish_set_my_current_per_commitment_point"))) TS_ChannelReestablish_set_my_current_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
41975 LDKChannelReestablish this_ptr_conv;
41976 this_ptr_conv.inner = untag_ptr(this_ptr);
41977 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41979 this_ptr_conv.is_owned = false;
41980 LDKPublicKey val_ref;
41981 CHECK(val->arr_len == 33);
41982 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
41983 ChannelReestablish_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
41986 uint64_t __attribute__((export_name("TS_ChannelReestablish_get_next_funding_txid"))) TS_ChannelReestablish_get_next_funding_txid(uint64_t this_ptr) {
41987 LDKChannelReestablish this_ptr_conv;
41988 this_ptr_conv.inner = untag_ptr(this_ptr);
41989 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
41990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41991 this_ptr_conv.is_owned = false;
41992 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
41993 *ret_copy = ChannelReestablish_get_next_funding_txid(&this_ptr_conv);
41994 uint64_t ret_ref = tag_ptr(ret_copy, true);
41998 void __attribute__((export_name("TS_ChannelReestablish_set_next_funding_txid"))) TS_ChannelReestablish_set_next_funding_txid(uint64_t this_ptr, uint64_t val) {
41999 LDKChannelReestablish this_ptr_conv;
42000 this_ptr_conv.inner = untag_ptr(this_ptr);
42001 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42003 this_ptr_conv.is_owned = false;
42004 void* val_ptr = untag_ptr(val);
42005 CHECK_ACCESS(val_ptr);
42006 LDKCOption_ThirtyTwoBytesZ val_conv = *(LDKCOption_ThirtyTwoBytesZ*)(val_ptr);
42007 val_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(val));
42008 ChannelReestablish_set_next_funding_txid(&this_ptr_conv, val_conv);
42011 uint64_t __attribute__((export_name("TS_ChannelReestablish_new"))) TS_ChannelReestablish_new(int8_tArray channel_id_arg, int64_t next_local_commitment_number_arg, int64_t next_remote_commitment_number_arg, int8_tArray your_last_per_commitment_secret_arg, int8_tArray my_current_per_commitment_point_arg, uint64_t next_funding_txid_arg) {
42012 LDKThirtyTwoBytes channel_id_arg_ref;
42013 CHECK(channel_id_arg->arr_len == 32);
42014 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
42015 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
42016 CHECK(your_last_per_commitment_secret_arg->arr_len == 32);
42017 memcpy(your_last_per_commitment_secret_arg_ref.data, your_last_per_commitment_secret_arg->elems, 32); FREE(your_last_per_commitment_secret_arg);
42018 LDKPublicKey my_current_per_commitment_point_arg_ref;
42019 CHECK(my_current_per_commitment_point_arg->arr_len == 33);
42020 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);
42021 void* next_funding_txid_arg_ptr = untag_ptr(next_funding_txid_arg);
42022 CHECK_ACCESS(next_funding_txid_arg_ptr);
42023 LDKCOption_ThirtyTwoBytesZ next_funding_txid_arg_conv = *(LDKCOption_ThirtyTwoBytesZ*)(next_funding_txid_arg_ptr);
42024 next_funding_txid_arg_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(next_funding_txid_arg));
42025 LDKChannelReestablish ret_var = ChannelReestablish_new(channel_id_arg_ref, next_local_commitment_number_arg, next_remote_commitment_number_arg, your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref, next_funding_txid_arg_conv);
42026 uint64_t ret_ref = 0;
42027 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42028 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42032 static inline uint64_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
42033 LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
42034 uint64_t ret_ref = 0;
42035 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42036 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42039 int64_t __attribute__((export_name("TS_ChannelReestablish_clone_ptr"))) TS_ChannelReestablish_clone_ptr(uint64_t arg) {
42040 LDKChannelReestablish arg_conv;
42041 arg_conv.inner = untag_ptr(arg);
42042 arg_conv.is_owned = ptr_is_owned(arg);
42043 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42044 arg_conv.is_owned = false;
42045 int64_t ret_conv = ChannelReestablish_clone_ptr(&arg_conv);
42049 uint64_t __attribute__((export_name("TS_ChannelReestablish_clone"))) TS_ChannelReestablish_clone(uint64_t orig) {
42050 LDKChannelReestablish orig_conv;
42051 orig_conv.inner = untag_ptr(orig);
42052 orig_conv.is_owned = ptr_is_owned(orig);
42053 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42054 orig_conv.is_owned = false;
42055 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
42056 uint64_t ret_ref = 0;
42057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42058 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42062 jboolean __attribute__((export_name("TS_ChannelReestablish_eq"))) TS_ChannelReestablish_eq(uint64_t a, uint64_t b) {
42063 LDKChannelReestablish a_conv;
42064 a_conv.inner = untag_ptr(a);
42065 a_conv.is_owned = ptr_is_owned(a);
42066 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42067 a_conv.is_owned = false;
42068 LDKChannelReestablish b_conv;
42069 b_conv.inner = untag_ptr(b);
42070 b_conv.is_owned = ptr_is_owned(b);
42071 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42072 b_conv.is_owned = false;
42073 jboolean ret_conv = ChannelReestablish_eq(&a_conv, &b_conv);
42077 void __attribute__((export_name("TS_AnnouncementSignatures_free"))) TS_AnnouncementSignatures_free(uint64_t this_obj) {
42078 LDKAnnouncementSignatures this_obj_conv;
42079 this_obj_conv.inner = untag_ptr(this_obj);
42080 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42082 AnnouncementSignatures_free(this_obj_conv);
42085 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_channel_id"))) TS_AnnouncementSignatures_get_channel_id(uint64_t this_ptr) {
42086 LDKAnnouncementSignatures this_ptr_conv;
42087 this_ptr_conv.inner = untag_ptr(this_ptr);
42088 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42090 this_ptr_conv.is_owned = false;
42091 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
42092 memcpy(ret_arr->elems, *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
42096 void __attribute__((export_name("TS_AnnouncementSignatures_set_channel_id"))) TS_AnnouncementSignatures_set_channel_id(uint64_t this_ptr, int8_tArray val) {
42097 LDKAnnouncementSignatures this_ptr_conv;
42098 this_ptr_conv.inner = untag_ptr(this_ptr);
42099 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42101 this_ptr_conv.is_owned = false;
42102 LDKThirtyTwoBytes val_ref;
42103 CHECK(val->arr_len == 32);
42104 memcpy(val_ref.data, val->elems, 32); FREE(val);
42105 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
42108 int64_t __attribute__((export_name("TS_AnnouncementSignatures_get_short_channel_id"))) TS_AnnouncementSignatures_get_short_channel_id(uint64_t this_ptr) {
42109 LDKAnnouncementSignatures this_ptr_conv;
42110 this_ptr_conv.inner = untag_ptr(this_ptr);
42111 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42112 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42113 this_ptr_conv.is_owned = false;
42114 int64_t ret_conv = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
42118 void __attribute__((export_name("TS_AnnouncementSignatures_set_short_channel_id"))) TS_AnnouncementSignatures_set_short_channel_id(uint64_t this_ptr, int64_t val) {
42119 LDKAnnouncementSignatures this_ptr_conv;
42120 this_ptr_conv.inner = untag_ptr(this_ptr);
42121 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42123 this_ptr_conv.is_owned = false;
42124 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
42127 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_node_signature"))) TS_AnnouncementSignatures_get_node_signature(uint64_t this_ptr) {
42128 LDKAnnouncementSignatures this_ptr_conv;
42129 this_ptr_conv.inner = untag_ptr(this_ptr);
42130 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42132 this_ptr_conv.is_owned = false;
42133 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
42134 memcpy(ret_arr->elems, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
42138 void __attribute__((export_name("TS_AnnouncementSignatures_set_node_signature"))) TS_AnnouncementSignatures_set_node_signature(uint64_t this_ptr, int8_tArray val) {
42139 LDKAnnouncementSignatures this_ptr_conv;
42140 this_ptr_conv.inner = untag_ptr(this_ptr);
42141 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42143 this_ptr_conv.is_owned = false;
42144 LDKECDSASignature val_ref;
42145 CHECK(val->arr_len == 64);
42146 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
42147 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
42150 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_bitcoin_signature"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint64_t this_ptr) {
42151 LDKAnnouncementSignatures this_ptr_conv;
42152 this_ptr_conv.inner = untag_ptr(this_ptr);
42153 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42155 this_ptr_conv.is_owned = false;
42156 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
42157 memcpy(ret_arr->elems, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
42161 void __attribute__((export_name("TS_AnnouncementSignatures_set_bitcoin_signature"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint64_t this_ptr, int8_tArray val) {
42162 LDKAnnouncementSignatures this_ptr_conv;
42163 this_ptr_conv.inner = untag_ptr(this_ptr);
42164 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42166 this_ptr_conv.is_owned = false;
42167 LDKECDSASignature val_ref;
42168 CHECK(val->arr_len == 64);
42169 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
42170 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
42173 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) {
42174 LDKThirtyTwoBytes channel_id_arg_ref;
42175 CHECK(channel_id_arg->arr_len == 32);
42176 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
42177 LDKECDSASignature node_signature_arg_ref;
42178 CHECK(node_signature_arg->arr_len == 64);
42179 memcpy(node_signature_arg_ref.compact_form, node_signature_arg->elems, 64); FREE(node_signature_arg);
42180 LDKECDSASignature bitcoin_signature_arg_ref;
42181 CHECK(bitcoin_signature_arg->arr_len == 64);
42182 memcpy(bitcoin_signature_arg_ref.compact_form, bitcoin_signature_arg->elems, 64); FREE(bitcoin_signature_arg);
42183 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
42184 uint64_t ret_ref = 0;
42185 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42186 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42190 static inline uint64_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
42191 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
42192 uint64_t ret_ref = 0;
42193 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42194 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42197 int64_t __attribute__((export_name("TS_AnnouncementSignatures_clone_ptr"))) TS_AnnouncementSignatures_clone_ptr(uint64_t arg) {
42198 LDKAnnouncementSignatures arg_conv;
42199 arg_conv.inner = untag_ptr(arg);
42200 arg_conv.is_owned = ptr_is_owned(arg);
42201 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42202 arg_conv.is_owned = false;
42203 int64_t ret_conv = AnnouncementSignatures_clone_ptr(&arg_conv);
42207 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_clone"))) TS_AnnouncementSignatures_clone(uint64_t orig) {
42208 LDKAnnouncementSignatures orig_conv;
42209 orig_conv.inner = untag_ptr(orig);
42210 orig_conv.is_owned = ptr_is_owned(orig);
42211 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42212 orig_conv.is_owned = false;
42213 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
42214 uint64_t ret_ref = 0;
42215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42216 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42220 jboolean __attribute__((export_name("TS_AnnouncementSignatures_eq"))) TS_AnnouncementSignatures_eq(uint64_t a, uint64_t b) {
42221 LDKAnnouncementSignatures a_conv;
42222 a_conv.inner = untag_ptr(a);
42223 a_conv.is_owned = ptr_is_owned(a);
42224 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42225 a_conv.is_owned = false;
42226 LDKAnnouncementSignatures b_conv;
42227 b_conv.inner = untag_ptr(b);
42228 b_conv.is_owned = ptr_is_owned(b);
42229 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42230 b_conv.is_owned = false;
42231 jboolean ret_conv = AnnouncementSignatures_eq(&a_conv, &b_conv);
42235 void __attribute__((export_name("TS_SocketAddress_free"))) TS_SocketAddress_free(uint64_t this_ptr) {
42236 if (!ptr_is_owned(this_ptr)) return;
42237 void* this_ptr_ptr = untag_ptr(this_ptr);
42238 CHECK_ACCESS(this_ptr_ptr);
42239 LDKSocketAddress this_ptr_conv = *(LDKSocketAddress*)(this_ptr_ptr);
42240 FREE(untag_ptr(this_ptr));
42241 SocketAddress_free(this_ptr_conv);
42244 static inline uint64_t SocketAddress_clone_ptr(LDKSocketAddress *NONNULL_PTR arg) {
42245 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42246 *ret_copy = SocketAddress_clone(arg);
42247 uint64_t ret_ref = tag_ptr(ret_copy, true);
42250 int64_t __attribute__((export_name("TS_SocketAddress_clone_ptr"))) TS_SocketAddress_clone_ptr(uint64_t arg) {
42251 LDKSocketAddress* arg_conv = (LDKSocketAddress*)untag_ptr(arg);
42252 int64_t ret_conv = SocketAddress_clone_ptr(arg_conv);
42256 uint64_t __attribute__((export_name("TS_SocketAddress_clone"))) TS_SocketAddress_clone(uint64_t orig) {
42257 LDKSocketAddress* orig_conv = (LDKSocketAddress*)untag_ptr(orig);
42258 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42259 *ret_copy = SocketAddress_clone(orig_conv);
42260 uint64_t ret_ref = tag_ptr(ret_copy, true);
42264 uint64_t __attribute__((export_name("TS_SocketAddress_tcp_ip_v4"))) TS_SocketAddress_tcp_ip_v4(int8_tArray addr, int16_t port) {
42265 LDKFourBytes addr_ref;
42266 CHECK(addr->arr_len == 4);
42267 memcpy(addr_ref.data, addr->elems, 4); FREE(addr);
42268 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42269 *ret_copy = SocketAddress_tcp_ip_v4(addr_ref, port);
42270 uint64_t ret_ref = tag_ptr(ret_copy, true);
42274 uint64_t __attribute__((export_name("TS_SocketAddress_tcp_ip_v6"))) TS_SocketAddress_tcp_ip_v6(int8_tArray addr, int16_t port) {
42275 LDKSixteenBytes addr_ref;
42276 CHECK(addr->arr_len == 16);
42277 memcpy(addr_ref.data, addr->elems, 16); FREE(addr);
42278 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42279 *ret_copy = SocketAddress_tcp_ip_v6(addr_ref, port);
42280 uint64_t ret_ref = tag_ptr(ret_copy, true);
42284 uint64_t __attribute__((export_name("TS_SocketAddress_onion_v2"))) TS_SocketAddress_onion_v2(int8_tArray a) {
42285 LDKTwelveBytes a_ref;
42286 CHECK(a->arr_len == 12);
42287 memcpy(a_ref.data, a->elems, 12); FREE(a);
42288 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42289 *ret_copy = SocketAddress_onion_v2(a_ref);
42290 uint64_t ret_ref = tag_ptr(ret_copy, true);
42294 uint64_t __attribute__((export_name("TS_SocketAddress_onion_v3"))) TS_SocketAddress_onion_v3(int8_tArray ed25519_pubkey, int16_t checksum, int8_t version, int16_t port) {
42295 LDKThirtyTwoBytes ed25519_pubkey_ref;
42296 CHECK(ed25519_pubkey->arr_len == 32);
42297 memcpy(ed25519_pubkey_ref.data, ed25519_pubkey->elems, 32); FREE(ed25519_pubkey);
42298 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42299 *ret_copy = SocketAddress_onion_v3(ed25519_pubkey_ref, checksum, version, port);
42300 uint64_t ret_ref = tag_ptr(ret_copy, true);
42304 uint64_t __attribute__((export_name("TS_SocketAddress_hostname"))) TS_SocketAddress_hostname(uint64_t hostname, int16_t port) {
42305 LDKHostname hostname_conv;
42306 hostname_conv.inner = untag_ptr(hostname);
42307 hostname_conv.is_owned = ptr_is_owned(hostname);
42308 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_conv);
42309 hostname_conv = Hostname_clone(&hostname_conv);
42310 LDKSocketAddress *ret_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42311 *ret_copy = SocketAddress_hostname(hostname_conv, port);
42312 uint64_t ret_ref = tag_ptr(ret_copy, true);
42316 jboolean __attribute__((export_name("TS_SocketAddress_eq"))) TS_SocketAddress_eq(uint64_t a, uint64_t b) {
42317 LDKSocketAddress* a_conv = (LDKSocketAddress*)untag_ptr(a);
42318 LDKSocketAddress* b_conv = (LDKSocketAddress*)untag_ptr(b);
42319 jboolean ret_conv = SocketAddress_eq(a_conv, b_conv);
42323 int8_tArray __attribute__((export_name("TS_SocketAddress_write"))) TS_SocketAddress_write(uint64_t obj) {
42324 LDKSocketAddress* obj_conv = (LDKSocketAddress*)untag_ptr(obj);
42325 LDKCVec_u8Z ret_var = SocketAddress_write(obj_conv);
42326 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42327 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42328 CVec_u8Z_free(ret_var);
42332 uint64_t __attribute__((export_name("TS_SocketAddress_read"))) TS_SocketAddress_read(int8_tArray ser) {
42333 LDKu8slice ser_ref;
42334 ser_ref.datalen = ser->arr_len;
42335 ser_ref.data = ser->elems;
42336 LDKCResult_SocketAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressDecodeErrorZ), "LDKCResult_SocketAddressDecodeErrorZ");
42337 *ret_conv = SocketAddress_read(ser_ref);
42339 return tag_ptr(ret_conv, true);
42342 uint32_t __attribute__((export_name("TS_SocketAddressParseError_clone"))) TS_SocketAddressParseError_clone(uint64_t orig) {
42343 LDKSocketAddressParseError* orig_conv = (LDKSocketAddressParseError*)untag_ptr(orig);
42344 uint32_t ret_conv = LDKSocketAddressParseError_to_js(SocketAddressParseError_clone(orig_conv));
42348 uint32_t __attribute__((export_name("TS_SocketAddressParseError_socket_addr_parse"))) TS_SocketAddressParseError_socket_addr_parse() {
42349 uint32_t ret_conv = LDKSocketAddressParseError_to_js(SocketAddressParseError_socket_addr_parse());
42353 uint32_t __attribute__((export_name("TS_SocketAddressParseError_invalid_input"))) TS_SocketAddressParseError_invalid_input() {
42354 uint32_t ret_conv = LDKSocketAddressParseError_to_js(SocketAddressParseError_invalid_input());
42358 uint32_t __attribute__((export_name("TS_SocketAddressParseError_invalid_port"))) TS_SocketAddressParseError_invalid_port() {
42359 uint32_t ret_conv = LDKSocketAddressParseError_to_js(SocketAddressParseError_invalid_port());
42363 uint32_t __attribute__((export_name("TS_SocketAddressParseError_invalid_onion_v3"))) TS_SocketAddressParseError_invalid_onion_v3() {
42364 uint32_t ret_conv = LDKSocketAddressParseError_to_js(SocketAddressParseError_invalid_onion_v3());
42368 jboolean __attribute__((export_name("TS_SocketAddressParseError_eq"))) TS_SocketAddressParseError_eq(uint64_t a, uint64_t b) {
42369 LDKSocketAddressParseError* a_conv = (LDKSocketAddressParseError*)untag_ptr(a);
42370 LDKSocketAddressParseError* b_conv = (LDKSocketAddressParseError*)untag_ptr(b);
42371 jboolean ret_conv = SocketAddressParseError_eq(a_conv, b_conv);
42375 uint64_t __attribute__((export_name("TS_parse_onion_address"))) TS_parse_onion_address(jstring host, int16_t port) {
42376 LDKStr host_conv = str_ref_to_owned_c(host);
42377 LDKCResult_SocketAddressSocketAddressParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SocketAddressSocketAddressParseErrorZ), "LDKCResult_SocketAddressSocketAddressParseErrorZ");
42378 *ret_conv = parse_onion_address(host_conv, port);
42379 return tag_ptr(ret_conv, true);
42382 void __attribute__((export_name("TS_UnsignedGossipMessage_free"))) TS_UnsignedGossipMessage_free(uint64_t this_ptr) {
42383 if (!ptr_is_owned(this_ptr)) return;
42384 void* this_ptr_ptr = untag_ptr(this_ptr);
42385 CHECK_ACCESS(this_ptr_ptr);
42386 LDKUnsignedGossipMessage this_ptr_conv = *(LDKUnsignedGossipMessage*)(this_ptr_ptr);
42387 FREE(untag_ptr(this_ptr));
42388 UnsignedGossipMessage_free(this_ptr_conv);
42391 static inline uint64_t UnsignedGossipMessage_clone_ptr(LDKUnsignedGossipMessage *NONNULL_PTR arg) {
42392 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
42393 *ret_copy = UnsignedGossipMessage_clone(arg);
42394 uint64_t ret_ref = tag_ptr(ret_copy, true);
42397 int64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone_ptr"))) TS_UnsignedGossipMessage_clone_ptr(uint64_t arg) {
42398 LDKUnsignedGossipMessage* arg_conv = (LDKUnsignedGossipMessage*)untag_ptr(arg);
42399 int64_t ret_conv = UnsignedGossipMessage_clone_ptr(arg_conv);
42403 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_clone"))) TS_UnsignedGossipMessage_clone(uint64_t orig) {
42404 LDKUnsignedGossipMessage* orig_conv = (LDKUnsignedGossipMessage*)untag_ptr(orig);
42405 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
42406 *ret_copy = UnsignedGossipMessage_clone(orig_conv);
42407 uint64_t ret_ref = tag_ptr(ret_copy, true);
42411 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_announcement"))) TS_UnsignedGossipMessage_channel_announcement(uint64_t a) {
42412 LDKUnsignedChannelAnnouncement a_conv;
42413 a_conv.inner = untag_ptr(a);
42414 a_conv.is_owned = ptr_is_owned(a);
42415 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42416 a_conv = UnsignedChannelAnnouncement_clone(&a_conv);
42417 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
42418 *ret_copy = UnsignedGossipMessage_channel_announcement(a_conv);
42419 uint64_t ret_ref = tag_ptr(ret_copy, true);
42423 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_channel_update"))) TS_UnsignedGossipMessage_channel_update(uint64_t a) {
42424 LDKUnsignedChannelUpdate a_conv;
42425 a_conv.inner = untag_ptr(a);
42426 a_conv.is_owned = ptr_is_owned(a);
42427 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42428 a_conv = UnsignedChannelUpdate_clone(&a_conv);
42429 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
42430 *ret_copy = UnsignedGossipMessage_channel_update(a_conv);
42431 uint64_t ret_ref = tag_ptr(ret_copy, true);
42435 uint64_t __attribute__((export_name("TS_UnsignedGossipMessage_node_announcement"))) TS_UnsignedGossipMessage_node_announcement(uint64_t a) {
42436 LDKUnsignedNodeAnnouncement a_conv;
42437 a_conv.inner = untag_ptr(a);
42438 a_conv.is_owned = ptr_is_owned(a);
42439 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42440 a_conv = UnsignedNodeAnnouncement_clone(&a_conv);
42441 LDKUnsignedGossipMessage *ret_copy = MALLOC(sizeof(LDKUnsignedGossipMessage), "LDKUnsignedGossipMessage");
42442 *ret_copy = UnsignedGossipMessage_node_announcement(a_conv);
42443 uint64_t ret_ref = tag_ptr(ret_copy, true);
42447 int8_tArray __attribute__((export_name("TS_UnsignedGossipMessage_write"))) TS_UnsignedGossipMessage_write(uint64_t obj) {
42448 LDKUnsignedGossipMessage* obj_conv = (LDKUnsignedGossipMessage*)untag_ptr(obj);
42449 LDKCVec_u8Z ret_var = UnsignedGossipMessage_write(obj_conv);
42450 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42451 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42452 CVec_u8Z_free(ret_var);
42456 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_free"))) TS_UnsignedNodeAnnouncement_free(uint64_t this_obj) {
42457 LDKUnsignedNodeAnnouncement this_obj_conv;
42458 this_obj_conv.inner = untag_ptr(this_obj);
42459 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42460 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42461 UnsignedNodeAnnouncement_free(this_obj_conv);
42464 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_features"))) TS_UnsignedNodeAnnouncement_get_features(uint64_t this_ptr) {
42465 LDKUnsignedNodeAnnouncement this_ptr_conv;
42466 this_ptr_conv.inner = untag_ptr(this_ptr);
42467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42469 this_ptr_conv.is_owned = false;
42470 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
42471 uint64_t ret_ref = 0;
42472 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42473 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42477 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_features"))) TS_UnsignedNodeAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
42478 LDKUnsignedNodeAnnouncement this_ptr_conv;
42479 this_ptr_conv.inner = untag_ptr(this_ptr);
42480 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42482 this_ptr_conv.is_owned = false;
42483 LDKNodeFeatures val_conv;
42484 val_conv.inner = untag_ptr(val);
42485 val_conv.is_owned = ptr_is_owned(val);
42486 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42487 val_conv = NodeFeatures_clone(&val_conv);
42488 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
42491 int32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_timestamp"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint64_t this_ptr) {
42492 LDKUnsignedNodeAnnouncement this_ptr_conv;
42493 this_ptr_conv.inner = untag_ptr(this_ptr);
42494 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42496 this_ptr_conv.is_owned = false;
42497 int32_t ret_conv = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
42501 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_timestamp"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint64_t this_ptr, int32_t val) {
42502 LDKUnsignedNodeAnnouncement this_ptr_conv;
42503 this_ptr_conv.inner = untag_ptr(this_ptr);
42504 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42506 this_ptr_conv.is_owned = false;
42507 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
42510 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_node_id"))) TS_UnsignedNodeAnnouncement_get_node_id(uint64_t this_ptr) {
42511 LDKUnsignedNodeAnnouncement this_ptr_conv;
42512 this_ptr_conv.inner = untag_ptr(this_ptr);
42513 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42515 this_ptr_conv.is_owned = false;
42516 LDKNodeId ret_var = UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv);
42517 uint64_t ret_ref = 0;
42518 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42519 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42523 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_node_id"))) TS_UnsignedNodeAnnouncement_set_node_id(uint64_t this_ptr, uint64_t val) {
42524 LDKUnsignedNodeAnnouncement this_ptr_conv;
42525 this_ptr_conv.inner = untag_ptr(this_ptr);
42526 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42528 this_ptr_conv.is_owned = false;
42529 LDKNodeId val_conv;
42530 val_conv.inner = untag_ptr(val);
42531 val_conv.is_owned = ptr_is_owned(val);
42532 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42533 val_conv = NodeId_clone(&val_conv);
42534 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_conv);
42537 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_rgb"))) TS_UnsignedNodeAnnouncement_get_rgb(uint64_t this_ptr) {
42538 LDKUnsignedNodeAnnouncement this_ptr_conv;
42539 this_ptr_conv.inner = untag_ptr(this_ptr);
42540 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42542 this_ptr_conv.is_owned = false;
42543 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
42544 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
42548 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_rgb"))) TS_UnsignedNodeAnnouncement_set_rgb(uint64_t this_ptr, int8_tArray val) {
42549 LDKUnsignedNodeAnnouncement this_ptr_conv;
42550 this_ptr_conv.inner = untag_ptr(this_ptr);
42551 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42552 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42553 this_ptr_conv.is_owned = false;
42554 LDKThreeBytes val_ref;
42555 CHECK(val->arr_len == 3);
42556 memcpy(val_ref.data, val->elems, 3); FREE(val);
42557 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
42560 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_alias"))) TS_UnsignedNodeAnnouncement_get_alias(uint64_t this_ptr) {
42561 LDKUnsignedNodeAnnouncement this_ptr_conv;
42562 this_ptr_conv.inner = untag_ptr(this_ptr);
42563 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42564 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42565 this_ptr_conv.is_owned = false;
42566 LDKNodeAlias ret_var = UnsignedNodeAnnouncement_get_alias(&this_ptr_conv);
42567 uint64_t ret_ref = 0;
42568 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42569 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42573 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_alias"))) TS_UnsignedNodeAnnouncement_set_alias(uint64_t this_ptr, uint64_t val) {
42574 LDKUnsignedNodeAnnouncement this_ptr_conv;
42575 this_ptr_conv.inner = untag_ptr(this_ptr);
42576 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42578 this_ptr_conv.is_owned = false;
42579 LDKNodeAlias val_conv;
42580 val_conv.inner = untag_ptr(val);
42581 val_conv.is_owned = ptr_is_owned(val);
42582 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42583 val_conv = NodeAlias_clone(&val_conv);
42584 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_conv);
42587 uint64_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_addresses"))) TS_UnsignedNodeAnnouncement_get_addresses(uint64_t this_ptr) {
42588 LDKUnsignedNodeAnnouncement this_ptr_conv;
42589 this_ptr_conv.inner = untag_ptr(this_ptr);
42590 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42592 this_ptr_conv.is_owned = false;
42593 LDKCVec_SocketAddressZ ret_var = UnsignedNodeAnnouncement_get_addresses(&this_ptr_conv);
42594 uint64_tArray ret_arr = NULL;
42595 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
42596 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
42597 for (size_t p = 0; p < ret_var.datalen; p++) {
42598 LDKSocketAddress *ret_conv_15_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
42599 *ret_conv_15_copy = ret_var.data[p];
42600 uint64_t ret_conv_15_ref = tag_ptr(ret_conv_15_copy, true);
42601 ret_arr_ptr[p] = ret_conv_15_ref;
42604 FREE(ret_var.data);
42608 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_addresses"))) TS_UnsignedNodeAnnouncement_set_addresses(uint64_t this_ptr, uint64_tArray val) {
42609 LDKUnsignedNodeAnnouncement this_ptr_conv;
42610 this_ptr_conv.inner = untag_ptr(this_ptr);
42611 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42613 this_ptr_conv.is_owned = false;
42614 LDKCVec_SocketAddressZ val_constr;
42615 val_constr.datalen = val->arr_len;
42616 if (val_constr.datalen > 0)
42617 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSocketAddress), "LDKCVec_SocketAddressZ Elements");
42619 val_constr.data = NULL;
42620 uint64_t* val_vals = val->elems;
42621 for (size_t p = 0; p < val_constr.datalen; p++) {
42622 uint64_t val_conv_15 = val_vals[p];
42623 void* val_conv_15_ptr = untag_ptr(val_conv_15);
42624 CHECK_ACCESS(val_conv_15_ptr);
42625 LDKSocketAddress val_conv_15_conv = *(LDKSocketAddress*)(val_conv_15_ptr);
42626 val_conv_15_conv = SocketAddress_clone((LDKSocketAddress*)untag_ptr(val_conv_15));
42627 val_constr.data[p] = val_conv_15_conv;
42630 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
42633 static inline uint64_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
42634 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
42635 uint64_t ret_ref = 0;
42636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42637 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42640 int64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone_ptr"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint64_t arg) {
42641 LDKUnsignedNodeAnnouncement arg_conv;
42642 arg_conv.inner = untag_ptr(arg);
42643 arg_conv.is_owned = ptr_is_owned(arg);
42644 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42645 arg_conv.is_owned = false;
42646 int64_t ret_conv = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
42650 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone"))) TS_UnsignedNodeAnnouncement_clone(uint64_t orig) {
42651 LDKUnsignedNodeAnnouncement orig_conv;
42652 orig_conv.inner = untag_ptr(orig);
42653 orig_conv.is_owned = ptr_is_owned(orig);
42654 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42655 orig_conv.is_owned = false;
42656 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
42657 uint64_t ret_ref = 0;
42658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42659 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42663 jboolean __attribute__((export_name("TS_UnsignedNodeAnnouncement_eq"))) TS_UnsignedNodeAnnouncement_eq(uint64_t a, uint64_t b) {
42664 LDKUnsignedNodeAnnouncement a_conv;
42665 a_conv.inner = untag_ptr(a);
42666 a_conv.is_owned = ptr_is_owned(a);
42667 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42668 a_conv.is_owned = false;
42669 LDKUnsignedNodeAnnouncement b_conv;
42670 b_conv.inner = untag_ptr(b);
42671 b_conv.is_owned = ptr_is_owned(b);
42672 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42673 b_conv.is_owned = false;
42674 jboolean ret_conv = UnsignedNodeAnnouncement_eq(&a_conv, &b_conv);
42678 void __attribute__((export_name("TS_NodeAnnouncement_free"))) TS_NodeAnnouncement_free(uint64_t this_obj) {
42679 LDKNodeAnnouncement this_obj_conv;
42680 this_obj_conv.inner = untag_ptr(this_obj);
42681 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42683 NodeAnnouncement_free(this_obj_conv);
42686 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_get_signature"))) TS_NodeAnnouncement_get_signature(uint64_t this_ptr) {
42687 LDKNodeAnnouncement this_ptr_conv;
42688 this_ptr_conv.inner = untag_ptr(this_ptr);
42689 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42691 this_ptr_conv.is_owned = false;
42692 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
42693 memcpy(ret_arr->elems, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
42697 void __attribute__((export_name("TS_NodeAnnouncement_set_signature"))) TS_NodeAnnouncement_set_signature(uint64_t this_ptr, int8_tArray val) {
42698 LDKNodeAnnouncement this_ptr_conv;
42699 this_ptr_conv.inner = untag_ptr(this_ptr);
42700 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42702 this_ptr_conv.is_owned = false;
42703 LDKECDSASignature val_ref;
42704 CHECK(val->arr_len == 64);
42705 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
42706 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
42709 uint64_t __attribute__((export_name("TS_NodeAnnouncement_get_contents"))) TS_NodeAnnouncement_get_contents(uint64_t this_ptr) {
42710 LDKNodeAnnouncement this_ptr_conv;
42711 this_ptr_conv.inner = untag_ptr(this_ptr);
42712 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42713 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42714 this_ptr_conv.is_owned = false;
42715 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
42716 uint64_t ret_ref = 0;
42717 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42718 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42722 void __attribute__((export_name("TS_NodeAnnouncement_set_contents"))) TS_NodeAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
42723 LDKNodeAnnouncement this_ptr_conv;
42724 this_ptr_conv.inner = untag_ptr(this_ptr);
42725 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42727 this_ptr_conv.is_owned = false;
42728 LDKUnsignedNodeAnnouncement val_conv;
42729 val_conv.inner = untag_ptr(val);
42730 val_conv.is_owned = ptr_is_owned(val);
42731 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42732 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
42733 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
42736 uint64_t __attribute__((export_name("TS_NodeAnnouncement_new"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint64_t contents_arg) {
42737 LDKECDSASignature signature_arg_ref;
42738 CHECK(signature_arg->arr_len == 64);
42739 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
42740 LDKUnsignedNodeAnnouncement contents_arg_conv;
42741 contents_arg_conv.inner = untag_ptr(contents_arg);
42742 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
42743 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
42744 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
42745 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
42746 uint64_t ret_ref = 0;
42747 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42748 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42752 static inline uint64_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
42753 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
42754 uint64_t ret_ref = 0;
42755 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42756 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42759 int64_t __attribute__((export_name("TS_NodeAnnouncement_clone_ptr"))) TS_NodeAnnouncement_clone_ptr(uint64_t arg) {
42760 LDKNodeAnnouncement arg_conv;
42761 arg_conv.inner = untag_ptr(arg);
42762 arg_conv.is_owned = ptr_is_owned(arg);
42763 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42764 arg_conv.is_owned = false;
42765 int64_t ret_conv = NodeAnnouncement_clone_ptr(&arg_conv);
42769 uint64_t __attribute__((export_name("TS_NodeAnnouncement_clone"))) TS_NodeAnnouncement_clone(uint64_t orig) {
42770 LDKNodeAnnouncement orig_conv;
42771 orig_conv.inner = untag_ptr(orig);
42772 orig_conv.is_owned = ptr_is_owned(orig);
42773 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42774 orig_conv.is_owned = false;
42775 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
42776 uint64_t ret_ref = 0;
42777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42782 jboolean __attribute__((export_name("TS_NodeAnnouncement_eq"))) TS_NodeAnnouncement_eq(uint64_t a, uint64_t b) {
42783 LDKNodeAnnouncement a_conv;
42784 a_conv.inner = untag_ptr(a);
42785 a_conv.is_owned = ptr_is_owned(a);
42786 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42787 a_conv.is_owned = false;
42788 LDKNodeAnnouncement b_conv;
42789 b_conv.inner = untag_ptr(b);
42790 b_conv.is_owned = ptr_is_owned(b);
42791 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42792 b_conv.is_owned = false;
42793 jboolean ret_conv = NodeAnnouncement_eq(&a_conv, &b_conv);
42797 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_free"))) TS_UnsignedChannelAnnouncement_free(uint64_t this_obj) {
42798 LDKUnsignedChannelAnnouncement this_obj_conv;
42799 this_obj_conv.inner = untag_ptr(this_obj);
42800 this_obj_conv.is_owned = ptr_is_owned(this_obj);
42801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42802 UnsignedChannelAnnouncement_free(this_obj_conv);
42805 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_features"))) TS_UnsignedChannelAnnouncement_get_features(uint64_t this_ptr) {
42806 LDKUnsignedChannelAnnouncement this_ptr_conv;
42807 this_ptr_conv.inner = untag_ptr(this_ptr);
42808 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42810 this_ptr_conv.is_owned = false;
42811 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
42812 uint64_t ret_ref = 0;
42813 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42814 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42818 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_features"))) TS_UnsignedChannelAnnouncement_set_features(uint64_t this_ptr, uint64_t val) {
42819 LDKUnsignedChannelAnnouncement this_ptr_conv;
42820 this_ptr_conv.inner = untag_ptr(this_ptr);
42821 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42823 this_ptr_conv.is_owned = false;
42824 LDKChannelFeatures val_conv;
42825 val_conv.inner = untag_ptr(val);
42826 val_conv.is_owned = ptr_is_owned(val);
42827 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42828 val_conv = ChannelFeatures_clone(&val_conv);
42829 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
42832 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_chain_hash"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint64_t this_ptr) {
42833 LDKUnsignedChannelAnnouncement this_ptr_conv;
42834 this_ptr_conv.inner = untag_ptr(this_ptr);
42835 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42837 this_ptr_conv.is_owned = false;
42838 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
42839 memcpy(ret_arr->elems, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
42843 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_chain_hash"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
42844 LDKUnsignedChannelAnnouncement this_ptr_conv;
42845 this_ptr_conv.inner = untag_ptr(this_ptr);
42846 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42847 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42848 this_ptr_conv.is_owned = false;
42849 LDKThirtyTwoBytes val_ref;
42850 CHECK(val->arr_len == 32);
42851 memcpy(val_ref.data, val->elems, 32); FREE(val);
42852 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
42855 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_short_channel_id"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint64_t this_ptr) {
42856 LDKUnsignedChannelAnnouncement this_ptr_conv;
42857 this_ptr_conv.inner = untag_ptr(this_ptr);
42858 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42860 this_ptr_conv.is_owned = false;
42861 int64_t ret_conv = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
42865 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_short_channel_id"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint64_t this_ptr, int64_t val) {
42866 LDKUnsignedChannelAnnouncement this_ptr_conv;
42867 this_ptr_conv.inner = untag_ptr(this_ptr);
42868 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42869 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42870 this_ptr_conv.is_owned = false;
42871 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
42874 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_1"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint64_t this_ptr) {
42875 LDKUnsignedChannelAnnouncement this_ptr_conv;
42876 this_ptr_conv.inner = untag_ptr(this_ptr);
42877 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42879 this_ptr_conv.is_owned = false;
42880 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv);
42881 uint64_t ret_ref = 0;
42882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42883 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42887 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_1"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint64_t this_ptr, uint64_t val) {
42888 LDKUnsignedChannelAnnouncement this_ptr_conv;
42889 this_ptr_conv.inner = untag_ptr(this_ptr);
42890 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42891 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42892 this_ptr_conv.is_owned = false;
42893 LDKNodeId val_conv;
42894 val_conv.inner = untag_ptr(val);
42895 val_conv.is_owned = ptr_is_owned(val);
42896 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42897 val_conv = NodeId_clone(&val_conv);
42898 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_conv);
42901 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_2"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint64_t this_ptr) {
42902 LDKUnsignedChannelAnnouncement this_ptr_conv;
42903 this_ptr_conv.inner = untag_ptr(this_ptr);
42904 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42906 this_ptr_conv.is_owned = false;
42907 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv);
42908 uint64_t ret_ref = 0;
42909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42914 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_2"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint64_t this_ptr, uint64_t val) {
42915 LDKUnsignedChannelAnnouncement this_ptr_conv;
42916 this_ptr_conv.inner = untag_ptr(this_ptr);
42917 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42919 this_ptr_conv.is_owned = false;
42920 LDKNodeId val_conv;
42921 val_conv.inner = untag_ptr(val);
42922 val_conv.is_owned = ptr_is_owned(val);
42923 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42924 val_conv = NodeId_clone(&val_conv);
42925 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_conv);
42928 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint64_t this_ptr) {
42929 LDKUnsignedChannelAnnouncement this_ptr_conv;
42930 this_ptr_conv.inner = untag_ptr(this_ptr);
42931 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42933 this_ptr_conv.is_owned = false;
42934 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv);
42935 uint64_t ret_ref = 0;
42936 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42937 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42941 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint64_t this_ptr, uint64_t val) {
42942 LDKUnsignedChannelAnnouncement this_ptr_conv;
42943 this_ptr_conv.inner = untag_ptr(this_ptr);
42944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42946 this_ptr_conv.is_owned = false;
42947 LDKNodeId val_conv;
42948 val_conv.inner = untag_ptr(val);
42949 val_conv.is_owned = ptr_is_owned(val);
42950 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42951 val_conv = NodeId_clone(&val_conv);
42952 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_conv);
42955 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint64_t this_ptr) {
42956 LDKUnsignedChannelAnnouncement this_ptr_conv;
42957 this_ptr_conv.inner = untag_ptr(this_ptr);
42958 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42960 this_ptr_conv.is_owned = false;
42961 LDKNodeId ret_var = UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv);
42962 uint64_t ret_ref = 0;
42963 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42964 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
42968 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint64_t this_ptr, uint64_t val) {
42969 LDKUnsignedChannelAnnouncement this_ptr_conv;
42970 this_ptr_conv.inner = untag_ptr(this_ptr);
42971 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42973 this_ptr_conv.is_owned = false;
42974 LDKNodeId val_conv;
42975 val_conv.inner = untag_ptr(val);
42976 val_conv.is_owned = ptr_is_owned(val);
42977 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42978 val_conv = NodeId_clone(&val_conv);
42979 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_conv);
42982 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_excess_data"))) TS_UnsignedChannelAnnouncement_get_excess_data(uint64_t this_ptr) {
42983 LDKUnsignedChannelAnnouncement 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 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_get_excess_data(&this_ptr_conv);
42989 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42990 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42991 CVec_u8Z_free(ret_var);
42995 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_excess_data"))) TS_UnsignedChannelAnnouncement_set_excess_data(uint64_t this_ptr, int8_tArray val) {
42996 LDKUnsignedChannelAnnouncement this_ptr_conv;
42997 this_ptr_conv.inner = untag_ptr(this_ptr);
42998 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
42999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43000 this_ptr_conv.is_owned = false;
43001 LDKCVec_u8Z val_ref;
43002 val_ref.datalen = val->arr_len;
43003 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
43004 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
43005 UnsignedChannelAnnouncement_set_excess_data(&this_ptr_conv, val_ref);
43008 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_new"))) TS_UnsignedChannelAnnouncement_new(uint64_t features_arg, int8_tArray chain_hash_arg, int64_t short_channel_id_arg, uint64_t node_id_1_arg, uint64_t node_id_2_arg, uint64_t bitcoin_key_1_arg, uint64_t bitcoin_key_2_arg, int8_tArray excess_data_arg) {
43009 LDKChannelFeatures features_arg_conv;
43010 features_arg_conv.inner = untag_ptr(features_arg);
43011 features_arg_conv.is_owned = ptr_is_owned(features_arg);
43012 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
43013 features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
43014 LDKThirtyTwoBytes chain_hash_arg_ref;
43015 CHECK(chain_hash_arg->arr_len == 32);
43016 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
43017 LDKNodeId node_id_1_arg_conv;
43018 node_id_1_arg_conv.inner = untag_ptr(node_id_1_arg);
43019 node_id_1_arg_conv.is_owned = ptr_is_owned(node_id_1_arg);
43020 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_1_arg_conv);
43021 node_id_1_arg_conv = NodeId_clone(&node_id_1_arg_conv);
43022 LDKNodeId node_id_2_arg_conv;
43023 node_id_2_arg_conv.inner = untag_ptr(node_id_2_arg);
43024 node_id_2_arg_conv.is_owned = ptr_is_owned(node_id_2_arg);
43025 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_2_arg_conv);
43026 node_id_2_arg_conv = NodeId_clone(&node_id_2_arg_conv);
43027 LDKNodeId bitcoin_key_1_arg_conv;
43028 bitcoin_key_1_arg_conv.inner = untag_ptr(bitcoin_key_1_arg);
43029 bitcoin_key_1_arg_conv.is_owned = ptr_is_owned(bitcoin_key_1_arg);
43030 CHECK_INNER_FIELD_ACCESS_OR_NULL(bitcoin_key_1_arg_conv);
43031 bitcoin_key_1_arg_conv = NodeId_clone(&bitcoin_key_1_arg_conv);
43032 LDKNodeId bitcoin_key_2_arg_conv;
43033 bitcoin_key_2_arg_conv.inner = untag_ptr(bitcoin_key_2_arg);
43034 bitcoin_key_2_arg_conv.is_owned = ptr_is_owned(bitcoin_key_2_arg);
43035 CHECK_INNER_FIELD_ACCESS_OR_NULL(bitcoin_key_2_arg_conv);
43036 bitcoin_key_2_arg_conv = NodeId_clone(&bitcoin_key_2_arg_conv);
43037 LDKCVec_u8Z excess_data_arg_ref;
43038 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
43039 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
43040 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
43041 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_new(features_arg_conv, chain_hash_arg_ref, short_channel_id_arg, node_id_1_arg_conv, node_id_2_arg_conv, bitcoin_key_1_arg_conv, bitcoin_key_2_arg_conv, excess_data_arg_ref);
43042 uint64_t ret_ref = 0;
43043 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43044 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43048 static inline uint64_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
43049 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
43050 uint64_t ret_ref = 0;
43051 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43052 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43055 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone_ptr"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint64_t arg) {
43056 LDKUnsignedChannelAnnouncement arg_conv;
43057 arg_conv.inner = untag_ptr(arg);
43058 arg_conv.is_owned = ptr_is_owned(arg);
43059 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43060 arg_conv.is_owned = false;
43061 int64_t ret_conv = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
43065 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone"))) TS_UnsignedChannelAnnouncement_clone(uint64_t orig) {
43066 LDKUnsignedChannelAnnouncement orig_conv;
43067 orig_conv.inner = untag_ptr(orig);
43068 orig_conv.is_owned = ptr_is_owned(orig);
43069 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43070 orig_conv.is_owned = false;
43071 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
43072 uint64_t ret_ref = 0;
43073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43078 jboolean __attribute__((export_name("TS_UnsignedChannelAnnouncement_eq"))) TS_UnsignedChannelAnnouncement_eq(uint64_t a, uint64_t b) {
43079 LDKUnsignedChannelAnnouncement a_conv;
43080 a_conv.inner = untag_ptr(a);
43081 a_conv.is_owned = ptr_is_owned(a);
43082 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43083 a_conv.is_owned = false;
43084 LDKUnsignedChannelAnnouncement b_conv;
43085 b_conv.inner = untag_ptr(b);
43086 b_conv.is_owned = ptr_is_owned(b);
43087 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43088 b_conv.is_owned = false;
43089 jboolean ret_conv = UnsignedChannelAnnouncement_eq(&a_conv, &b_conv);
43093 void __attribute__((export_name("TS_ChannelAnnouncement_free"))) TS_ChannelAnnouncement_free(uint64_t this_obj) {
43094 LDKChannelAnnouncement this_obj_conv;
43095 this_obj_conv.inner = untag_ptr(this_obj);
43096 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43098 ChannelAnnouncement_free(this_obj_conv);
43101 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_1"))) TS_ChannelAnnouncement_get_node_signature_1(uint64_t this_ptr) {
43102 LDKChannelAnnouncement this_ptr_conv;
43103 this_ptr_conv.inner = untag_ptr(this_ptr);
43104 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43106 this_ptr_conv.is_owned = false;
43107 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
43108 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
43112 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_1"))) TS_ChannelAnnouncement_set_node_signature_1(uint64_t this_ptr, int8_tArray val) {
43113 LDKChannelAnnouncement this_ptr_conv;
43114 this_ptr_conv.inner = untag_ptr(this_ptr);
43115 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43117 this_ptr_conv.is_owned = false;
43118 LDKECDSASignature val_ref;
43119 CHECK(val->arr_len == 64);
43120 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
43121 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
43124 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_2"))) TS_ChannelAnnouncement_get_node_signature_2(uint64_t this_ptr) {
43125 LDKChannelAnnouncement this_ptr_conv;
43126 this_ptr_conv.inner = untag_ptr(this_ptr);
43127 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43129 this_ptr_conv.is_owned = false;
43130 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
43131 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
43135 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_2"))) TS_ChannelAnnouncement_set_node_signature_2(uint64_t this_ptr, int8_tArray val) {
43136 LDKChannelAnnouncement this_ptr_conv;
43137 this_ptr_conv.inner = untag_ptr(this_ptr);
43138 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43140 this_ptr_conv.is_owned = false;
43141 LDKECDSASignature val_ref;
43142 CHECK(val->arr_len == 64);
43143 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
43144 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
43147 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_1"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint64_t this_ptr) {
43148 LDKChannelAnnouncement this_ptr_conv;
43149 this_ptr_conv.inner = untag_ptr(this_ptr);
43150 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43152 this_ptr_conv.is_owned = false;
43153 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
43154 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
43158 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_1"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint64_t this_ptr, int8_tArray val) {
43159 LDKChannelAnnouncement this_ptr_conv;
43160 this_ptr_conv.inner = untag_ptr(this_ptr);
43161 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43163 this_ptr_conv.is_owned = false;
43164 LDKECDSASignature val_ref;
43165 CHECK(val->arr_len == 64);
43166 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
43167 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
43170 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_2"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint64_t this_ptr) {
43171 LDKChannelAnnouncement this_ptr_conv;
43172 this_ptr_conv.inner = untag_ptr(this_ptr);
43173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43175 this_ptr_conv.is_owned = false;
43176 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
43177 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
43181 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_2"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint64_t this_ptr, int8_tArray val) {
43182 LDKChannelAnnouncement this_ptr_conv;
43183 this_ptr_conv.inner = untag_ptr(this_ptr);
43184 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43186 this_ptr_conv.is_owned = false;
43187 LDKECDSASignature val_ref;
43188 CHECK(val->arr_len == 64);
43189 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
43190 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
43193 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_get_contents"))) TS_ChannelAnnouncement_get_contents(uint64_t this_ptr) {
43194 LDKChannelAnnouncement this_ptr_conv;
43195 this_ptr_conv.inner = untag_ptr(this_ptr);
43196 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43198 this_ptr_conv.is_owned = false;
43199 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
43200 uint64_t ret_ref = 0;
43201 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43202 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43206 void __attribute__((export_name("TS_ChannelAnnouncement_set_contents"))) TS_ChannelAnnouncement_set_contents(uint64_t this_ptr, uint64_t val) {
43207 LDKChannelAnnouncement this_ptr_conv;
43208 this_ptr_conv.inner = untag_ptr(this_ptr);
43209 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43211 this_ptr_conv.is_owned = false;
43212 LDKUnsignedChannelAnnouncement val_conv;
43213 val_conv.inner = untag_ptr(val);
43214 val_conv.is_owned = ptr_is_owned(val);
43215 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43216 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
43217 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
43220 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) {
43221 LDKECDSASignature node_signature_1_arg_ref;
43222 CHECK(node_signature_1_arg->arr_len == 64);
43223 memcpy(node_signature_1_arg_ref.compact_form, node_signature_1_arg->elems, 64); FREE(node_signature_1_arg);
43224 LDKECDSASignature node_signature_2_arg_ref;
43225 CHECK(node_signature_2_arg->arr_len == 64);
43226 memcpy(node_signature_2_arg_ref.compact_form, node_signature_2_arg->elems, 64); FREE(node_signature_2_arg);
43227 LDKECDSASignature bitcoin_signature_1_arg_ref;
43228 CHECK(bitcoin_signature_1_arg->arr_len == 64);
43229 memcpy(bitcoin_signature_1_arg_ref.compact_form, bitcoin_signature_1_arg->elems, 64); FREE(bitcoin_signature_1_arg);
43230 LDKECDSASignature bitcoin_signature_2_arg_ref;
43231 CHECK(bitcoin_signature_2_arg->arr_len == 64);
43232 memcpy(bitcoin_signature_2_arg_ref.compact_form, bitcoin_signature_2_arg->elems, 64); FREE(bitcoin_signature_2_arg);
43233 LDKUnsignedChannelAnnouncement contents_arg_conv;
43234 contents_arg_conv.inner = untag_ptr(contents_arg);
43235 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
43236 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
43237 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
43238 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);
43239 uint64_t ret_ref = 0;
43240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43241 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43245 static inline uint64_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
43246 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
43247 uint64_t ret_ref = 0;
43248 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43249 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43252 int64_t __attribute__((export_name("TS_ChannelAnnouncement_clone_ptr"))) TS_ChannelAnnouncement_clone_ptr(uint64_t arg) {
43253 LDKChannelAnnouncement arg_conv;
43254 arg_conv.inner = untag_ptr(arg);
43255 arg_conv.is_owned = ptr_is_owned(arg);
43256 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43257 arg_conv.is_owned = false;
43258 int64_t ret_conv = ChannelAnnouncement_clone_ptr(&arg_conv);
43262 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_clone"))) TS_ChannelAnnouncement_clone(uint64_t orig) {
43263 LDKChannelAnnouncement orig_conv;
43264 orig_conv.inner = untag_ptr(orig);
43265 orig_conv.is_owned = ptr_is_owned(orig);
43266 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43267 orig_conv.is_owned = false;
43268 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
43269 uint64_t ret_ref = 0;
43270 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43271 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43275 jboolean __attribute__((export_name("TS_ChannelAnnouncement_eq"))) TS_ChannelAnnouncement_eq(uint64_t a, uint64_t b) {
43276 LDKChannelAnnouncement a_conv;
43277 a_conv.inner = untag_ptr(a);
43278 a_conv.is_owned = ptr_is_owned(a);
43279 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43280 a_conv.is_owned = false;
43281 LDKChannelAnnouncement b_conv;
43282 b_conv.inner = untag_ptr(b);
43283 b_conv.is_owned = ptr_is_owned(b);
43284 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43285 b_conv.is_owned = false;
43286 jboolean ret_conv = ChannelAnnouncement_eq(&a_conv, &b_conv);
43290 void __attribute__((export_name("TS_UnsignedChannelUpdate_free"))) TS_UnsignedChannelUpdate_free(uint64_t this_obj) {
43291 LDKUnsignedChannelUpdate this_obj_conv;
43292 this_obj_conv.inner = untag_ptr(this_obj);
43293 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43294 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43295 UnsignedChannelUpdate_free(this_obj_conv);
43298 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_chain_hash"))) TS_UnsignedChannelUpdate_get_chain_hash(uint64_t this_ptr) {
43299 LDKUnsignedChannelUpdate this_ptr_conv;
43300 this_ptr_conv.inner = untag_ptr(this_ptr);
43301 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43303 this_ptr_conv.is_owned = false;
43304 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43305 memcpy(ret_arr->elems, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
43309 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_chain_hash"))) TS_UnsignedChannelUpdate_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
43310 LDKUnsignedChannelUpdate this_ptr_conv;
43311 this_ptr_conv.inner = untag_ptr(this_ptr);
43312 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43314 this_ptr_conv.is_owned = false;
43315 LDKThirtyTwoBytes val_ref;
43316 CHECK(val->arr_len == 32);
43317 memcpy(val_ref.data, val->elems, 32); FREE(val);
43318 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
43321 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_short_channel_id"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint64_t this_ptr) {
43322 LDKUnsignedChannelUpdate this_ptr_conv;
43323 this_ptr_conv.inner = untag_ptr(this_ptr);
43324 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43326 this_ptr_conv.is_owned = false;
43327 int64_t ret_conv = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
43331 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_short_channel_id"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint64_t this_ptr, int64_t val) {
43332 LDKUnsignedChannelUpdate this_ptr_conv;
43333 this_ptr_conv.inner = untag_ptr(this_ptr);
43334 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43335 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43336 this_ptr_conv.is_owned = false;
43337 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
43340 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_timestamp"))) TS_UnsignedChannelUpdate_get_timestamp(uint64_t this_ptr) {
43341 LDKUnsignedChannelUpdate this_ptr_conv;
43342 this_ptr_conv.inner = untag_ptr(this_ptr);
43343 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43345 this_ptr_conv.is_owned = false;
43346 int32_t ret_conv = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
43350 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_timestamp"))) TS_UnsignedChannelUpdate_set_timestamp(uint64_t this_ptr, int32_t val) {
43351 LDKUnsignedChannelUpdate this_ptr_conv;
43352 this_ptr_conv.inner = untag_ptr(this_ptr);
43353 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43355 this_ptr_conv.is_owned = false;
43356 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
43359 int8_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_flags"))) TS_UnsignedChannelUpdate_get_flags(uint64_t this_ptr) {
43360 LDKUnsignedChannelUpdate this_ptr_conv;
43361 this_ptr_conv.inner = untag_ptr(this_ptr);
43362 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43364 this_ptr_conv.is_owned = false;
43365 int8_t ret_conv = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
43369 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_flags"))) TS_UnsignedChannelUpdate_set_flags(uint64_t this_ptr, int8_t val) {
43370 LDKUnsignedChannelUpdate this_ptr_conv;
43371 this_ptr_conv.inner = untag_ptr(this_ptr);
43372 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43374 this_ptr_conv.is_owned = false;
43375 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
43378 int16_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint64_t this_ptr) {
43379 LDKUnsignedChannelUpdate this_ptr_conv;
43380 this_ptr_conv.inner = untag_ptr(this_ptr);
43381 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43383 this_ptr_conv.is_owned = false;
43384 int16_t ret_conv = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
43388 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
43389 LDKUnsignedChannelUpdate this_ptr_conv;
43390 this_ptr_conv.inner = untag_ptr(this_ptr);
43391 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43393 this_ptr_conv.is_owned = false;
43394 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
43397 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint64_t this_ptr) {
43398 LDKUnsignedChannelUpdate this_ptr_conv;
43399 this_ptr_conv.inner = untag_ptr(this_ptr);
43400 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43401 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43402 this_ptr_conv.is_owned = false;
43403 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
43407 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
43408 LDKUnsignedChannelUpdate this_ptr_conv;
43409 this_ptr_conv.inner = untag_ptr(this_ptr);
43410 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43412 this_ptr_conv.is_owned = false;
43413 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
43416 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_get_htlc_maximum_msat(uint64_t this_ptr) {
43417 LDKUnsignedChannelUpdate this_ptr_conv;
43418 this_ptr_conv.inner = untag_ptr(this_ptr);
43419 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43420 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43421 this_ptr_conv.is_owned = false;
43422 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_maximum_msat(&this_ptr_conv);
43426 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
43427 LDKUnsignedChannelUpdate this_ptr_conv;
43428 this_ptr_conv.inner = untag_ptr(this_ptr);
43429 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43431 this_ptr_conv.is_owned = false;
43432 UnsignedChannelUpdate_set_htlc_maximum_msat(&this_ptr_conv, val);
43435 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_base_msat"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint64_t this_ptr) {
43436 LDKUnsignedChannelUpdate this_ptr_conv;
43437 this_ptr_conv.inner = untag_ptr(this_ptr);
43438 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43440 this_ptr_conv.is_owned = false;
43441 int32_t ret_conv = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
43445 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_base_msat"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
43446 LDKUnsignedChannelUpdate this_ptr_conv;
43447 this_ptr_conv.inner = untag_ptr(this_ptr);
43448 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43450 this_ptr_conv.is_owned = false;
43451 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
43454 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint64_t this_ptr) {
43455 LDKUnsignedChannelUpdate this_ptr_conv;
43456 this_ptr_conv.inner = untag_ptr(this_ptr);
43457 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43458 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43459 this_ptr_conv.is_owned = false;
43460 int32_t ret_conv = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
43464 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
43465 LDKUnsignedChannelUpdate this_ptr_conv;
43466 this_ptr_conv.inner = untag_ptr(this_ptr);
43467 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43469 this_ptr_conv.is_owned = false;
43470 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
43473 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_excess_data"))) TS_UnsignedChannelUpdate_get_excess_data(uint64_t this_ptr) {
43474 LDKUnsignedChannelUpdate this_ptr_conv;
43475 this_ptr_conv.inner = untag_ptr(this_ptr);
43476 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43478 this_ptr_conv.is_owned = false;
43479 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_get_excess_data(&this_ptr_conv);
43480 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43481 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43482 CVec_u8Z_free(ret_var);
43486 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_excess_data"))) TS_UnsignedChannelUpdate_set_excess_data(uint64_t this_ptr, int8_tArray val) {
43487 LDKUnsignedChannelUpdate this_ptr_conv;
43488 this_ptr_conv.inner = untag_ptr(this_ptr);
43489 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43491 this_ptr_conv.is_owned = false;
43492 LDKCVec_u8Z val_ref;
43493 val_ref.datalen = val->arr_len;
43494 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
43495 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
43496 UnsignedChannelUpdate_set_excess_data(&this_ptr_conv, val_ref);
43499 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) {
43500 LDKThirtyTwoBytes chain_hash_arg_ref;
43501 CHECK(chain_hash_arg->arr_len == 32);
43502 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
43503 LDKCVec_u8Z excess_data_arg_ref;
43504 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
43505 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
43506 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
43507 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);
43508 uint64_t ret_ref = 0;
43509 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43510 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43514 static inline uint64_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
43515 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
43516 uint64_t ret_ref = 0;
43517 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43518 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43521 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone_ptr"))) TS_UnsignedChannelUpdate_clone_ptr(uint64_t arg) {
43522 LDKUnsignedChannelUpdate arg_conv;
43523 arg_conv.inner = untag_ptr(arg);
43524 arg_conv.is_owned = ptr_is_owned(arg);
43525 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43526 arg_conv.is_owned = false;
43527 int64_t ret_conv = UnsignedChannelUpdate_clone_ptr(&arg_conv);
43531 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone"))) TS_UnsignedChannelUpdate_clone(uint64_t orig) {
43532 LDKUnsignedChannelUpdate orig_conv;
43533 orig_conv.inner = untag_ptr(orig);
43534 orig_conv.is_owned = ptr_is_owned(orig);
43535 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43536 orig_conv.is_owned = false;
43537 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
43538 uint64_t ret_ref = 0;
43539 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43540 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43544 jboolean __attribute__((export_name("TS_UnsignedChannelUpdate_eq"))) TS_UnsignedChannelUpdate_eq(uint64_t a, uint64_t b) {
43545 LDKUnsignedChannelUpdate a_conv;
43546 a_conv.inner = untag_ptr(a);
43547 a_conv.is_owned = ptr_is_owned(a);
43548 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43549 a_conv.is_owned = false;
43550 LDKUnsignedChannelUpdate b_conv;
43551 b_conv.inner = untag_ptr(b);
43552 b_conv.is_owned = ptr_is_owned(b);
43553 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43554 b_conv.is_owned = false;
43555 jboolean ret_conv = UnsignedChannelUpdate_eq(&a_conv, &b_conv);
43559 void __attribute__((export_name("TS_ChannelUpdate_free"))) TS_ChannelUpdate_free(uint64_t this_obj) {
43560 LDKChannelUpdate this_obj_conv;
43561 this_obj_conv.inner = untag_ptr(this_obj);
43562 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43563 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43564 ChannelUpdate_free(this_obj_conv);
43567 int8_tArray __attribute__((export_name("TS_ChannelUpdate_get_signature"))) TS_ChannelUpdate_get_signature(uint64_t this_ptr) {
43568 LDKChannelUpdate this_ptr_conv;
43569 this_ptr_conv.inner = untag_ptr(this_ptr);
43570 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43572 this_ptr_conv.is_owned = false;
43573 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
43574 memcpy(ret_arr->elems, ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
43578 void __attribute__((export_name("TS_ChannelUpdate_set_signature"))) TS_ChannelUpdate_set_signature(uint64_t this_ptr, int8_tArray val) {
43579 LDKChannelUpdate this_ptr_conv;
43580 this_ptr_conv.inner = untag_ptr(this_ptr);
43581 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43583 this_ptr_conv.is_owned = false;
43584 LDKECDSASignature val_ref;
43585 CHECK(val->arr_len == 64);
43586 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
43587 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
43590 uint64_t __attribute__((export_name("TS_ChannelUpdate_get_contents"))) TS_ChannelUpdate_get_contents(uint64_t this_ptr) {
43591 LDKChannelUpdate this_ptr_conv;
43592 this_ptr_conv.inner = untag_ptr(this_ptr);
43593 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43595 this_ptr_conv.is_owned = false;
43596 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
43597 uint64_t ret_ref = 0;
43598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43599 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43603 void __attribute__((export_name("TS_ChannelUpdate_set_contents"))) TS_ChannelUpdate_set_contents(uint64_t this_ptr, uint64_t val) {
43604 LDKChannelUpdate this_ptr_conv;
43605 this_ptr_conv.inner = untag_ptr(this_ptr);
43606 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43607 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43608 this_ptr_conv.is_owned = false;
43609 LDKUnsignedChannelUpdate val_conv;
43610 val_conv.inner = untag_ptr(val);
43611 val_conv.is_owned = ptr_is_owned(val);
43612 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43613 val_conv = UnsignedChannelUpdate_clone(&val_conv);
43614 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
43617 uint64_t __attribute__((export_name("TS_ChannelUpdate_new"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint64_t contents_arg) {
43618 LDKECDSASignature signature_arg_ref;
43619 CHECK(signature_arg->arr_len == 64);
43620 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
43621 LDKUnsignedChannelUpdate contents_arg_conv;
43622 contents_arg_conv.inner = untag_ptr(contents_arg);
43623 contents_arg_conv.is_owned = ptr_is_owned(contents_arg);
43624 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
43625 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
43626 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
43627 uint64_t ret_ref = 0;
43628 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43629 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43633 static inline uint64_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
43634 LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
43635 uint64_t ret_ref = 0;
43636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43637 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43640 int64_t __attribute__((export_name("TS_ChannelUpdate_clone_ptr"))) TS_ChannelUpdate_clone_ptr(uint64_t arg) {
43641 LDKChannelUpdate arg_conv;
43642 arg_conv.inner = untag_ptr(arg);
43643 arg_conv.is_owned = ptr_is_owned(arg);
43644 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43645 arg_conv.is_owned = false;
43646 int64_t ret_conv = ChannelUpdate_clone_ptr(&arg_conv);
43650 uint64_t __attribute__((export_name("TS_ChannelUpdate_clone"))) TS_ChannelUpdate_clone(uint64_t orig) {
43651 LDKChannelUpdate orig_conv;
43652 orig_conv.inner = untag_ptr(orig);
43653 orig_conv.is_owned = ptr_is_owned(orig);
43654 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43655 orig_conv.is_owned = false;
43656 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
43657 uint64_t ret_ref = 0;
43658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43659 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43663 jboolean __attribute__((export_name("TS_ChannelUpdate_eq"))) TS_ChannelUpdate_eq(uint64_t a, uint64_t b) {
43664 LDKChannelUpdate a_conv;
43665 a_conv.inner = untag_ptr(a);
43666 a_conv.is_owned = ptr_is_owned(a);
43667 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43668 a_conv.is_owned = false;
43669 LDKChannelUpdate b_conv;
43670 b_conv.inner = untag_ptr(b);
43671 b_conv.is_owned = ptr_is_owned(b);
43672 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43673 b_conv.is_owned = false;
43674 jboolean ret_conv = ChannelUpdate_eq(&a_conv, &b_conv);
43678 void __attribute__((export_name("TS_QueryChannelRange_free"))) TS_QueryChannelRange_free(uint64_t this_obj) {
43679 LDKQueryChannelRange this_obj_conv;
43680 this_obj_conv.inner = untag_ptr(this_obj);
43681 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43683 QueryChannelRange_free(this_obj_conv);
43686 int8_tArray __attribute__((export_name("TS_QueryChannelRange_get_chain_hash"))) TS_QueryChannelRange_get_chain_hash(uint64_t this_ptr) {
43687 LDKQueryChannelRange this_ptr_conv;
43688 this_ptr_conv.inner = untag_ptr(this_ptr);
43689 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43691 this_ptr_conv.is_owned = false;
43692 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43693 memcpy(ret_arr->elems, *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
43697 void __attribute__((export_name("TS_QueryChannelRange_set_chain_hash"))) TS_QueryChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
43698 LDKQueryChannelRange this_ptr_conv;
43699 this_ptr_conv.inner = untag_ptr(this_ptr);
43700 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43702 this_ptr_conv.is_owned = false;
43703 LDKThirtyTwoBytes val_ref;
43704 CHECK(val->arr_len == 32);
43705 memcpy(val_ref.data, val->elems, 32); FREE(val);
43706 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
43709 int32_t __attribute__((export_name("TS_QueryChannelRange_get_first_blocknum"))) TS_QueryChannelRange_get_first_blocknum(uint64_t this_ptr) {
43710 LDKQueryChannelRange this_ptr_conv;
43711 this_ptr_conv.inner = untag_ptr(this_ptr);
43712 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43713 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43714 this_ptr_conv.is_owned = false;
43715 int32_t ret_conv = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
43719 void __attribute__((export_name("TS_QueryChannelRange_set_first_blocknum"))) TS_QueryChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
43720 LDKQueryChannelRange this_ptr_conv;
43721 this_ptr_conv.inner = untag_ptr(this_ptr);
43722 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43724 this_ptr_conv.is_owned = false;
43725 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
43728 int32_t __attribute__((export_name("TS_QueryChannelRange_get_number_of_blocks"))) TS_QueryChannelRange_get_number_of_blocks(uint64_t this_ptr) {
43729 LDKQueryChannelRange this_ptr_conv;
43730 this_ptr_conv.inner = untag_ptr(this_ptr);
43731 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43733 this_ptr_conv.is_owned = false;
43734 int32_t ret_conv = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
43738 void __attribute__((export_name("TS_QueryChannelRange_set_number_of_blocks"))) TS_QueryChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
43739 LDKQueryChannelRange this_ptr_conv;
43740 this_ptr_conv.inner = untag_ptr(this_ptr);
43741 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43742 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43743 this_ptr_conv.is_owned = false;
43744 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
43747 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) {
43748 LDKThirtyTwoBytes chain_hash_arg_ref;
43749 CHECK(chain_hash_arg->arr_len == 32);
43750 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
43751 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
43752 uint64_t ret_ref = 0;
43753 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43754 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43758 static inline uint64_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
43759 LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
43760 uint64_t ret_ref = 0;
43761 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43762 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43765 int64_t __attribute__((export_name("TS_QueryChannelRange_clone_ptr"))) TS_QueryChannelRange_clone_ptr(uint64_t arg) {
43766 LDKQueryChannelRange arg_conv;
43767 arg_conv.inner = untag_ptr(arg);
43768 arg_conv.is_owned = ptr_is_owned(arg);
43769 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43770 arg_conv.is_owned = false;
43771 int64_t ret_conv = QueryChannelRange_clone_ptr(&arg_conv);
43775 uint64_t __attribute__((export_name("TS_QueryChannelRange_clone"))) TS_QueryChannelRange_clone(uint64_t orig) {
43776 LDKQueryChannelRange orig_conv;
43777 orig_conv.inner = untag_ptr(orig);
43778 orig_conv.is_owned = ptr_is_owned(orig);
43779 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43780 orig_conv.is_owned = false;
43781 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
43782 uint64_t ret_ref = 0;
43783 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43784 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43788 jboolean __attribute__((export_name("TS_QueryChannelRange_eq"))) TS_QueryChannelRange_eq(uint64_t a, uint64_t b) {
43789 LDKQueryChannelRange a_conv;
43790 a_conv.inner = untag_ptr(a);
43791 a_conv.is_owned = ptr_is_owned(a);
43792 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43793 a_conv.is_owned = false;
43794 LDKQueryChannelRange b_conv;
43795 b_conv.inner = untag_ptr(b);
43796 b_conv.is_owned = ptr_is_owned(b);
43797 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43798 b_conv.is_owned = false;
43799 jboolean ret_conv = QueryChannelRange_eq(&a_conv, &b_conv);
43803 void __attribute__((export_name("TS_ReplyChannelRange_free"))) TS_ReplyChannelRange_free(uint64_t this_obj) {
43804 LDKReplyChannelRange this_obj_conv;
43805 this_obj_conv.inner = untag_ptr(this_obj);
43806 this_obj_conv.is_owned = ptr_is_owned(this_obj);
43807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43808 ReplyChannelRange_free(this_obj_conv);
43811 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_get_chain_hash"))) TS_ReplyChannelRange_get_chain_hash(uint64_t this_ptr) {
43812 LDKReplyChannelRange this_ptr_conv;
43813 this_ptr_conv.inner = untag_ptr(this_ptr);
43814 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43816 this_ptr_conv.is_owned = false;
43817 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
43818 memcpy(ret_arr->elems, *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
43822 void __attribute__((export_name("TS_ReplyChannelRange_set_chain_hash"))) TS_ReplyChannelRange_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
43823 LDKReplyChannelRange this_ptr_conv;
43824 this_ptr_conv.inner = untag_ptr(this_ptr);
43825 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43827 this_ptr_conv.is_owned = false;
43828 LDKThirtyTwoBytes val_ref;
43829 CHECK(val->arr_len == 32);
43830 memcpy(val_ref.data, val->elems, 32); FREE(val);
43831 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
43834 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_first_blocknum"))) TS_ReplyChannelRange_get_first_blocknum(uint64_t this_ptr) {
43835 LDKReplyChannelRange this_ptr_conv;
43836 this_ptr_conv.inner = untag_ptr(this_ptr);
43837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43839 this_ptr_conv.is_owned = false;
43840 int32_t ret_conv = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
43844 void __attribute__((export_name("TS_ReplyChannelRange_set_first_blocknum"))) TS_ReplyChannelRange_set_first_blocknum(uint64_t this_ptr, int32_t val) {
43845 LDKReplyChannelRange this_ptr_conv;
43846 this_ptr_conv.inner = untag_ptr(this_ptr);
43847 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43849 this_ptr_conv.is_owned = false;
43850 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
43853 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_number_of_blocks"))) TS_ReplyChannelRange_get_number_of_blocks(uint64_t this_ptr) {
43854 LDKReplyChannelRange this_ptr_conv;
43855 this_ptr_conv.inner = untag_ptr(this_ptr);
43856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43858 this_ptr_conv.is_owned = false;
43859 int32_t ret_conv = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
43863 void __attribute__((export_name("TS_ReplyChannelRange_set_number_of_blocks"))) TS_ReplyChannelRange_set_number_of_blocks(uint64_t this_ptr, int32_t val) {
43864 LDKReplyChannelRange this_ptr_conv;
43865 this_ptr_conv.inner = untag_ptr(this_ptr);
43866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43868 this_ptr_conv.is_owned = false;
43869 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
43872 jboolean __attribute__((export_name("TS_ReplyChannelRange_get_sync_complete"))) TS_ReplyChannelRange_get_sync_complete(uint64_t this_ptr) {
43873 LDKReplyChannelRange this_ptr_conv;
43874 this_ptr_conv.inner = untag_ptr(this_ptr);
43875 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43877 this_ptr_conv.is_owned = false;
43878 jboolean ret_conv = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
43882 void __attribute__((export_name("TS_ReplyChannelRange_set_sync_complete"))) TS_ReplyChannelRange_set_sync_complete(uint64_t this_ptr, jboolean val) {
43883 LDKReplyChannelRange this_ptr_conv;
43884 this_ptr_conv.inner = untag_ptr(this_ptr);
43885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43887 this_ptr_conv.is_owned = false;
43888 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
43891 int64_tArray __attribute__((export_name("TS_ReplyChannelRange_get_short_channel_ids"))) TS_ReplyChannelRange_get_short_channel_ids(uint64_t this_ptr) {
43892 LDKReplyChannelRange this_ptr_conv;
43893 this_ptr_conv.inner = untag_ptr(this_ptr);
43894 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43896 this_ptr_conv.is_owned = false;
43897 LDKCVec_u64Z ret_var = ReplyChannelRange_get_short_channel_ids(&this_ptr_conv);
43898 int64_tArray ret_arr = NULL;
43899 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
43900 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
43901 for (size_t i = 0; i < ret_var.datalen; i++) {
43902 int64_t ret_conv_8_conv = ret_var.data[i];
43903 ret_arr_ptr[i] = ret_conv_8_conv;
43906 FREE(ret_var.data);
43910 void __attribute__((export_name("TS_ReplyChannelRange_set_short_channel_ids"))) TS_ReplyChannelRange_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
43911 LDKReplyChannelRange this_ptr_conv;
43912 this_ptr_conv.inner = untag_ptr(this_ptr);
43913 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
43914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43915 this_ptr_conv.is_owned = false;
43916 LDKCVec_u64Z val_constr;
43917 val_constr.datalen = val->arr_len;
43918 if (val_constr.datalen > 0)
43919 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
43921 val_constr.data = NULL;
43922 int64_t* val_vals = val->elems;
43923 for (size_t i = 0; i < val_constr.datalen; i++) {
43924 int64_t val_conv_8 = val_vals[i];
43925 val_constr.data[i] = val_conv_8;
43928 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
43931 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) {
43932 LDKThirtyTwoBytes chain_hash_arg_ref;
43933 CHECK(chain_hash_arg->arr_len == 32);
43934 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
43935 LDKCVec_u64Z short_channel_ids_arg_constr;
43936 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
43937 if (short_channel_ids_arg_constr.datalen > 0)
43938 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
43940 short_channel_ids_arg_constr.data = NULL;
43941 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
43942 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
43943 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
43944 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
43946 FREE(short_channel_ids_arg);
43947 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
43948 uint64_t ret_ref = 0;
43949 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43950 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43954 static inline uint64_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
43955 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
43956 uint64_t ret_ref = 0;
43957 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43958 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43961 int64_t __attribute__((export_name("TS_ReplyChannelRange_clone_ptr"))) TS_ReplyChannelRange_clone_ptr(uint64_t arg) {
43962 LDKReplyChannelRange arg_conv;
43963 arg_conv.inner = untag_ptr(arg);
43964 arg_conv.is_owned = ptr_is_owned(arg);
43965 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43966 arg_conv.is_owned = false;
43967 int64_t ret_conv = ReplyChannelRange_clone_ptr(&arg_conv);
43971 uint64_t __attribute__((export_name("TS_ReplyChannelRange_clone"))) TS_ReplyChannelRange_clone(uint64_t orig) {
43972 LDKReplyChannelRange orig_conv;
43973 orig_conv.inner = untag_ptr(orig);
43974 orig_conv.is_owned = ptr_is_owned(orig);
43975 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43976 orig_conv.is_owned = false;
43977 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
43978 uint64_t ret_ref = 0;
43979 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43980 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
43984 jboolean __attribute__((export_name("TS_ReplyChannelRange_eq"))) TS_ReplyChannelRange_eq(uint64_t a, uint64_t b) {
43985 LDKReplyChannelRange a_conv;
43986 a_conv.inner = untag_ptr(a);
43987 a_conv.is_owned = ptr_is_owned(a);
43988 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43989 a_conv.is_owned = false;
43990 LDKReplyChannelRange b_conv;
43991 b_conv.inner = untag_ptr(b);
43992 b_conv.is_owned = ptr_is_owned(b);
43993 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43994 b_conv.is_owned = false;
43995 jboolean ret_conv = ReplyChannelRange_eq(&a_conv, &b_conv);
43999 void __attribute__((export_name("TS_QueryShortChannelIds_free"))) TS_QueryShortChannelIds_free(uint64_t this_obj) {
44000 LDKQueryShortChannelIds this_obj_conv;
44001 this_obj_conv.inner = untag_ptr(this_obj);
44002 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44004 QueryShortChannelIds_free(this_obj_conv);
44007 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_chain_hash"))) TS_QueryShortChannelIds_get_chain_hash(uint64_t this_ptr) {
44008 LDKQueryShortChannelIds this_ptr_conv;
44009 this_ptr_conv.inner = untag_ptr(this_ptr);
44010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44012 this_ptr_conv.is_owned = false;
44013 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44014 memcpy(ret_arr->elems, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
44018 void __attribute__((export_name("TS_QueryShortChannelIds_set_chain_hash"))) TS_QueryShortChannelIds_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
44019 LDKQueryShortChannelIds this_ptr_conv;
44020 this_ptr_conv.inner = untag_ptr(this_ptr);
44021 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44023 this_ptr_conv.is_owned = false;
44024 LDKThirtyTwoBytes val_ref;
44025 CHECK(val->arr_len == 32);
44026 memcpy(val_ref.data, val->elems, 32); FREE(val);
44027 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
44030 int64_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_short_channel_ids"))) TS_QueryShortChannelIds_get_short_channel_ids(uint64_t this_ptr) {
44031 LDKQueryShortChannelIds this_ptr_conv;
44032 this_ptr_conv.inner = untag_ptr(this_ptr);
44033 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44035 this_ptr_conv.is_owned = false;
44036 LDKCVec_u64Z ret_var = QueryShortChannelIds_get_short_channel_ids(&this_ptr_conv);
44037 int64_tArray ret_arr = NULL;
44038 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
44039 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
44040 for (size_t i = 0; i < ret_var.datalen; i++) {
44041 int64_t ret_conv_8_conv = ret_var.data[i];
44042 ret_arr_ptr[i] = ret_conv_8_conv;
44045 FREE(ret_var.data);
44049 void __attribute__((export_name("TS_QueryShortChannelIds_set_short_channel_ids"))) TS_QueryShortChannelIds_set_short_channel_ids(uint64_t this_ptr, int64_tArray val) {
44050 LDKQueryShortChannelIds this_ptr_conv;
44051 this_ptr_conv.inner = untag_ptr(this_ptr);
44052 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44053 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44054 this_ptr_conv.is_owned = false;
44055 LDKCVec_u64Z val_constr;
44056 val_constr.datalen = val->arr_len;
44057 if (val_constr.datalen > 0)
44058 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
44060 val_constr.data = NULL;
44061 int64_t* val_vals = val->elems;
44062 for (size_t i = 0; i < val_constr.datalen; i++) {
44063 int64_t val_conv_8 = val_vals[i];
44064 val_constr.data[i] = val_conv_8;
44067 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
44070 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_new"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
44071 LDKThirtyTwoBytes chain_hash_arg_ref;
44072 CHECK(chain_hash_arg->arr_len == 32);
44073 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
44074 LDKCVec_u64Z short_channel_ids_arg_constr;
44075 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
44076 if (short_channel_ids_arg_constr.datalen > 0)
44077 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
44079 short_channel_ids_arg_constr.data = NULL;
44080 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
44081 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
44082 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
44083 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
44085 FREE(short_channel_ids_arg);
44086 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
44087 uint64_t ret_ref = 0;
44088 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44089 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44093 static inline uint64_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
44094 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
44095 uint64_t ret_ref = 0;
44096 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44097 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44100 int64_t __attribute__((export_name("TS_QueryShortChannelIds_clone_ptr"))) TS_QueryShortChannelIds_clone_ptr(uint64_t arg) {
44101 LDKQueryShortChannelIds arg_conv;
44102 arg_conv.inner = untag_ptr(arg);
44103 arg_conv.is_owned = ptr_is_owned(arg);
44104 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44105 arg_conv.is_owned = false;
44106 int64_t ret_conv = QueryShortChannelIds_clone_ptr(&arg_conv);
44110 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_clone"))) TS_QueryShortChannelIds_clone(uint64_t orig) {
44111 LDKQueryShortChannelIds orig_conv;
44112 orig_conv.inner = untag_ptr(orig);
44113 orig_conv.is_owned = ptr_is_owned(orig);
44114 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44115 orig_conv.is_owned = false;
44116 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
44117 uint64_t ret_ref = 0;
44118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44123 jboolean __attribute__((export_name("TS_QueryShortChannelIds_eq"))) TS_QueryShortChannelIds_eq(uint64_t a, uint64_t b) {
44124 LDKQueryShortChannelIds a_conv;
44125 a_conv.inner = untag_ptr(a);
44126 a_conv.is_owned = ptr_is_owned(a);
44127 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44128 a_conv.is_owned = false;
44129 LDKQueryShortChannelIds b_conv;
44130 b_conv.inner = untag_ptr(b);
44131 b_conv.is_owned = ptr_is_owned(b);
44132 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44133 b_conv.is_owned = false;
44134 jboolean ret_conv = QueryShortChannelIds_eq(&a_conv, &b_conv);
44138 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_free"))) TS_ReplyShortChannelIdsEnd_free(uint64_t this_obj) {
44139 LDKReplyShortChannelIdsEnd this_obj_conv;
44140 this_obj_conv.inner = untag_ptr(this_obj);
44141 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44143 ReplyShortChannelIdsEnd_free(this_obj_conv);
44146 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_chain_hash"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint64_t this_ptr) {
44147 LDKReplyShortChannelIdsEnd this_ptr_conv;
44148 this_ptr_conv.inner = untag_ptr(this_ptr);
44149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44151 this_ptr_conv.is_owned = false;
44152 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44153 memcpy(ret_arr->elems, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
44157 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_chain_hash"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
44158 LDKReplyShortChannelIdsEnd this_ptr_conv;
44159 this_ptr_conv.inner = untag_ptr(this_ptr);
44160 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44162 this_ptr_conv.is_owned = false;
44163 LDKThirtyTwoBytes val_ref;
44164 CHECK(val->arr_len == 32);
44165 memcpy(val_ref.data, val->elems, 32); FREE(val);
44166 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
44169 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_full_information"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint64_t this_ptr) {
44170 LDKReplyShortChannelIdsEnd this_ptr_conv;
44171 this_ptr_conv.inner = untag_ptr(this_ptr);
44172 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44174 this_ptr_conv.is_owned = false;
44175 jboolean ret_conv = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
44179 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_full_information"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint64_t this_ptr, jboolean val) {
44180 LDKReplyShortChannelIdsEnd this_ptr_conv;
44181 this_ptr_conv.inner = untag_ptr(this_ptr);
44182 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44184 this_ptr_conv.is_owned = false;
44185 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
44188 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_new"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
44189 LDKThirtyTwoBytes chain_hash_arg_ref;
44190 CHECK(chain_hash_arg->arr_len == 32);
44191 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
44192 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
44193 uint64_t ret_ref = 0;
44194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44195 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44199 static inline uint64_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
44200 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
44201 uint64_t ret_ref = 0;
44202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44203 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44206 int64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone_ptr"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint64_t arg) {
44207 LDKReplyShortChannelIdsEnd arg_conv;
44208 arg_conv.inner = untag_ptr(arg);
44209 arg_conv.is_owned = ptr_is_owned(arg);
44210 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44211 arg_conv.is_owned = false;
44212 int64_t ret_conv = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
44216 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone"))) TS_ReplyShortChannelIdsEnd_clone(uint64_t orig) {
44217 LDKReplyShortChannelIdsEnd orig_conv;
44218 orig_conv.inner = untag_ptr(orig);
44219 orig_conv.is_owned = ptr_is_owned(orig);
44220 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44221 orig_conv.is_owned = false;
44222 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
44223 uint64_t ret_ref = 0;
44224 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44225 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44229 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_eq"))) TS_ReplyShortChannelIdsEnd_eq(uint64_t a, uint64_t b) {
44230 LDKReplyShortChannelIdsEnd a_conv;
44231 a_conv.inner = untag_ptr(a);
44232 a_conv.is_owned = ptr_is_owned(a);
44233 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44234 a_conv.is_owned = false;
44235 LDKReplyShortChannelIdsEnd b_conv;
44236 b_conv.inner = untag_ptr(b);
44237 b_conv.is_owned = ptr_is_owned(b);
44238 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44239 b_conv.is_owned = false;
44240 jboolean ret_conv = ReplyShortChannelIdsEnd_eq(&a_conv, &b_conv);
44244 void __attribute__((export_name("TS_GossipTimestampFilter_free"))) TS_GossipTimestampFilter_free(uint64_t this_obj) {
44245 LDKGossipTimestampFilter this_obj_conv;
44246 this_obj_conv.inner = untag_ptr(this_obj);
44247 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44249 GossipTimestampFilter_free(this_obj_conv);
44252 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_get_chain_hash"))) TS_GossipTimestampFilter_get_chain_hash(uint64_t this_ptr) {
44253 LDKGossipTimestampFilter this_ptr_conv;
44254 this_ptr_conv.inner = untag_ptr(this_ptr);
44255 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44257 this_ptr_conv.is_owned = false;
44258 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44259 memcpy(ret_arr->elems, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
44263 void __attribute__((export_name("TS_GossipTimestampFilter_set_chain_hash"))) TS_GossipTimestampFilter_set_chain_hash(uint64_t this_ptr, int8_tArray val) {
44264 LDKGossipTimestampFilter this_ptr_conv;
44265 this_ptr_conv.inner = untag_ptr(this_ptr);
44266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44268 this_ptr_conv.is_owned = false;
44269 LDKThirtyTwoBytes val_ref;
44270 CHECK(val->arr_len == 32);
44271 memcpy(val_ref.data, val->elems, 32); FREE(val);
44272 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
44275 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_first_timestamp"))) TS_GossipTimestampFilter_get_first_timestamp(uint64_t this_ptr) {
44276 LDKGossipTimestampFilter this_ptr_conv;
44277 this_ptr_conv.inner = untag_ptr(this_ptr);
44278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44280 this_ptr_conv.is_owned = false;
44281 int32_t ret_conv = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
44285 void __attribute__((export_name("TS_GossipTimestampFilter_set_first_timestamp"))) TS_GossipTimestampFilter_set_first_timestamp(uint64_t this_ptr, int32_t val) {
44286 LDKGossipTimestampFilter this_ptr_conv;
44287 this_ptr_conv.inner = untag_ptr(this_ptr);
44288 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44290 this_ptr_conv.is_owned = false;
44291 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
44294 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_timestamp_range"))) TS_GossipTimestampFilter_get_timestamp_range(uint64_t this_ptr) {
44295 LDKGossipTimestampFilter this_ptr_conv;
44296 this_ptr_conv.inner = untag_ptr(this_ptr);
44297 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44299 this_ptr_conv.is_owned = false;
44300 int32_t ret_conv = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
44304 void __attribute__((export_name("TS_GossipTimestampFilter_set_timestamp_range"))) TS_GossipTimestampFilter_set_timestamp_range(uint64_t this_ptr, int32_t val) {
44305 LDKGossipTimestampFilter this_ptr_conv;
44306 this_ptr_conv.inner = untag_ptr(this_ptr);
44307 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44309 this_ptr_conv.is_owned = false;
44310 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
44313 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) {
44314 LDKThirtyTwoBytes chain_hash_arg_ref;
44315 CHECK(chain_hash_arg->arr_len == 32);
44316 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
44317 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
44318 uint64_t ret_ref = 0;
44319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44320 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44324 static inline uint64_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
44325 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
44326 uint64_t ret_ref = 0;
44327 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44328 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44331 int64_t __attribute__((export_name("TS_GossipTimestampFilter_clone_ptr"))) TS_GossipTimestampFilter_clone_ptr(uint64_t arg) {
44332 LDKGossipTimestampFilter arg_conv;
44333 arg_conv.inner = untag_ptr(arg);
44334 arg_conv.is_owned = ptr_is_owned(arg);
44335 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44336 arg_conv.is_owned = false;
44337 int64_t ret_conv = GossipTimestampFilter_clone_ptr(&arg_conv);
44341 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_clone"))) TS_GossipTimestampFilter_clone(uint64_t orig) {
44342 LDKGossipTimestampFilter orig_conv;
44343 orig_conv.inner = untag_ptr(orig);
44344 orig_conv.is_owned = ptr_is_owned(orig);
44345 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44346 orig_conv.is_owned = false;
44347 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
44348 uint64_t ret_ref = 0;
44349 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44350 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44354 jboolean __attribute__((export_name("TS_GossipTimestampFilter_eq"))) TS_GossipTimestampFilter_eq(uint64_t a, uint64_t b) {
44355 LDKGossipTimestampFilter a_conv;
44356 a_conv.inner = untag_ptr(a);
44357 a_conv.is_owned = ptr_is_owned(a);
44358 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44359 a_conv.is_owned = false;
44360 LDKGossipTimestampFilter b_conv;
44361 b_conv.inner = untag_ptr(b);
44362 b_conv.is_owned = ptr_is_owned(b);
44363 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44364 b_conv.is_owned = false;
44365 jboolean ret_conv = GossipTimestampFilter_eq(&a_conv, &b_conv);
44369 void __attribute__((export_name("TS_ErrorAction_free"))) TS_ErrorAction_free(uint64_t this_ptr) {
44370 if (!ptr_is_owned(this_ptr)) return;
44371 void* this_ptr_ptr = untag_ptr(this_ptr);
44372 CHECK_ACCESS(this_ptr_ptr);
44373 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(this_ptr_ptr);
44374 FREE(untag_ptr(this_ptr));
44375 ErrorAction_free(this_ptr_conv);
44378 static inline uint64_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
44379 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44380 *ret_copy = ErrorAction_clone(arg);
44381 uint64_t ret_ref = tag_ptr(ret_copy, true);
44384 int64_t __attribute__((export_name("TS_ErrorAction_clone_ptr"))) TS_ErrorAction_clone_ptr(uint64_t arg) {
44385 LDKErrorAction* arg_conv = (LDKErrorAction*)untag_ptr(arg);
44386 int64_t ret_conv = ErrorAction_clone_ptr(arg_conv);
44390 uint64_t __attribute__((export_name("TS_ErrorAction_clone"))) TS_ErrorAction_clone(uint64_t orig) {
44391 LDKErrorAction* orig_conv = (LDKErrorAction*)untag_ptr(orig);
44392 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44393 *ret_copy = ErrorAction_clone(orig_conv);
44394 uint64_t ret_ref = tag_ptr(ret_copy, true);
44398 uint64_t __attribute__((export_name("TS_ErrorAction_disconnect_peer"))) TS_ErrorAction_disconnect_peer(uint64_t msg) {
44399 LDKErrorMessage msg_conv;
44400 msg_conv.inner = untag_ptr(msg);
44401 msg_conv.is_owned = ptr_is_owned(msg);
44402 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44403 msg_conv = ErrorMessage_clone(&msg_conv);
44404 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44405 *ret_copy = ErrorAction_disconnect_peer(msg_conv);
44406 uint64_t ret_ref = tag_ptr(ret_copy, true);
44410 uint64_t __attribute__((export_name("TS_ErrorAction_disconnect_peer_with_warning"))) TS_ErrorAction_disconnect_peer_with_warning(uint64_t msg) {
44411 LDKWarningMessage msg_conv;
44412 msg_conv.inner = untag_ptr(msg);
44413 msg_conv.is_owned = ptr_is_owned(msg);
44414 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44415 msg_conv = WarningMessage_clone(&msg_conv);
44416 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44417 *ret_copy = ErrorAction_disconnect_peer_with_warning(msg_conv);
44418 uint64_t ret_ref = tag_ptr(ret_copy, true);
44422 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_error"))) TS_ErrorAction_ignore_error() {
44423 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44424 *ret_copy = ErrorAction_ignore_error();
44425 uint64_t ret_ref = tag_ptr(ret_copy, true);
44429 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_and_log"))) TS_ErrorAction_ignore_and_log(uint32_t a) {
44430 LDKLevel a_conv = LDKLevel_from_js(a);
44431 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44432 *ret_copy = ErrorAction_ignore_and_log(a_conv);
44433 uint64_t ret_ref = tag_ptr(ret_copy, true);
44437 uint64_t __attribute__((export_name("TS_ErrorAction_ignore_duplicate_gossip"))) TS_ErrorAction_ignore_duplicate_gossip() {
44438 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44439 *ret_copy = ErrorAction_ignore_duplicate_gossip();
44440 uint64_t ret_ref = tag_ptr(ret_copy, true);
44444 uint64_t __attribute__((export_name("TS_ErrorAction_send_error_message"))) TS_ErrorAction_send_error_message(uint64_t msg) {
44445 LDKErrorMessage msg_conv;
44446 msg_conv.inner = untag_ptr(msg);
44447 msg_conv.is_owned = ptr_is_owned(msg);
44448 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44449 msg_conv = ErrorMessage_clone(&msg_conv);
44450 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44451 *ret_copy = ErrorAction_send_error_message(msg_conv);
44452 uint64_t ret_ref = tag_ptr(ret_copy, true);
44456 uint64_t __attribute__((export_name("TS_ErrorAction_send_warning_message"))) TS_ErrorAction_send_warning_message(uint64_t msg, uint32_t log_level) {
44457 LDKWarningMessage msg_conv;
44458 msg_conv.inner = untag_ptr(msg);
44459 msg_conv.is_owned = ptr_is_owned(msg);
44460 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
44461 msg_conv = WarningMessage_clone(&msg_conv);
44462 LDKLevel log_level_conv = LDKLevel_from_js(log_level);
44463 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44464 *ret_copy = ErrorAction_send_warning_message(msg_conv, log_level_conv);
44465 uint64_t ret_ref = tag_ptr(ret_copy, true);
44469 void __attribute__((export_name("TS_LightningError_free"))) TS_LightningError_free(uint64_t this_obj) {
44470 LDKLightningError this_obj_conv;
44471 this_obj_conv.inner = untag_ptr(this_obj);
44472 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44473 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44474 LightningError_free(this_obj_conv);
44477 jstring __attribute__((export_name("TS_LightningError_get_err"))) TS_LightningError_get_err(uint64_t this_ptr) {
44478 LDKLightningError this_ptr_conv;
44479 this_ptr_conv.inner = untag_ptr(this_ptr);
44480 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44482 this_ptr_conv.is_owned = false;
44483 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
44484 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
44489 void __attribute__((export_name("TS_LightningError_set_err"))) TS_LightningError_set_err(uint64_t this_ptr, jstring val) {
44490 LDKLightningError this_ptr_conv;
44491 this_ptr_conv.inner = untag_ptr(this_ptr);
44492 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44494 this_ptr_conv.is_owned = false;
44495 LDKStr val_conv = str_ref_to_owned_c(val);
44496 LightningError_set_err(&this_ptr_conv, val_conv);
44499 uint64_t __attribute__((export_name("TS_LightningError_get_action"))) TS_LightningError_get_action(uint64_t this_ptr) {
44500 LDKLightningError this_ptr_conv;
44501 this_ptr_conv.inner = untag_ptr(this_ptr);
44502 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44504 this_ptr_conv.is_owned = false;
44505 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
44506 *ret_copy = LightningError_get_action(&this_ptr_conv);
44507 uint64_t ret_ref = tag_ptr(ret_copy, true);
44511 void __attribute__((export_name("TS_LightningError_set_action"))) TS_LightningError_set_action(uint64_t this_ptr, uint64_t val) {
44512 LDKLightningError this_ptr_conv;
44513 this_ptr_conv.inner = untag_ptr(this_ptr);
44514 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44516 this_ptr_conv.is_owned = false;
44517 void* val_ptr = untag_ptr(val);
44518 CHECK_ACCESS(val_ptr);
44519 LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
44520 val_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(val));
44521 LightningError_set_action(&this_ptr_conv, val_conv);
44524 uint64_t __attribute__((export_name("TS_LightningError_new"))) TS_LightningError_new(jstring err_arg, uint64_t action_arg) {
44525 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
44526 void* action_arg_ptr = untag_ptr(action_arg);
44527 CHECK_ACCESS(action_arg_ptr);
44528 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(action_arg_ptr);
44529 action_arg_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action_arg));
44530 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
44531 uint64_t ret_ref = 0;
44532 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44533 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44537 static inline uint64_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
44538 LDKLightningError ret_var = LightningError_clone(arg);
44539 uint64_t ret_ref = 0;
44540 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44541 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44544 int64_t __attribute__((export_name("TS_LightningError_clone_ptr"))) TS_LightningError_clone_ptr(uint64_t arg) {
44545 LDKLightningError arg_conv;
44546 arg_conv.inner = untag_ptr(arg);
44547 arg_conv.is_owned = ptr_is_owned(arg);
44548 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44549 arg_conv.is_owned = false;
44550 int64_t ret_conv = LightningError_clone_ptr(&arg_conv);
44554 uint64_t __attribute__((export_name("TS_LightningError_clone"))) TS_LightningError_clone(uint64_t orig) {
44555 LDKLightningError orig_conv;
44556 orig_conv.inner = untag_ptr(orig);
44557 orig_conv.is_owned = ptr_is_owned(orig);
44558 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44559 orig_conv.is_owned = false;
44560 LDKLightningError ret_var = LightningError_clone(&orig_conv);
44561 uint64_t ret_ref = 0;
44562 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44563 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44567 void __attribute__((export_name("TS_CommitmentUpdate_free"))) TS_CommitmentUpdate_free(uint64_t this_obj) {
44568 LDKCommitmentUpdate this_obj_conv;
44569 this_obj_conv.inner = untag_ptr(this_obj);
44570 this_obj_conv.is_owned = ptr_is_owned(this_obj);
44571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44572 CommitmentUpdate_free(this_obj_conv);
44575 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_add_htlcs"))) TS_CommitmentUpdate_get_update_add_htlcs(uint64_t this_ptr) {
44576 LDKCommitmentUpdate this_ptr_conv;
44577 this_ptr_conv.inner = untag_ptr(this_ptr);
44578 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44580 this_ptr_conv.is_owned = false;
44581 LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
44582 uint64_tArray ret_arr = NULL;
44583 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44584 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44585 for (size_t p = 0; p < ret_var.datalen; p++) {
44586 LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p];
44587 uint64_t ret_conv_15_ref = 0;
44588 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
44589 ret_conv_15_ref = tag_ptr(ret_conv_15_var.inner, ret_conv_15_var.is_owned);
44590 ret_arr_ptr[p] = ret_conv_15_ref;
44593 FREE(ret_var.data);
44597 void __attribute__((export_name("TS_CommitmentUpdate_set_update_add_htlcs"))) TS_CommitmentUpdate_set_update_add_htlcs(uint64_t this_ptr, uint64_tArray val) {
44598 LDKCommitmentUpdate this_ptr_conv;
44599 this_ptr_conv.inner = untag_ptr(this_ptr);
44600 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44602 this_ptr_conv.is_owned = false;
44603 LDKCVec_UpdateAddHTLCZ val_constr;
44604 val_constr.datalen = val->arr_len;
44605 if (val_constr.datalen > 0)
44606 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
44608 val_constr.data = NULL;
44609 uint64_t* val_vals = val->elems;
44610 for (size_t p = 0; p < val_constr.datalen; p++) {
44611 uint64_t val_conv_15 = val_vals[p];
44612 LDKUpdateAddHTLC val_conv_15_conv;
44613 val_conv_15_conv.inner = untag_ptr(val_conv_15);
44614 val_conv_15_conv.is_owned = ptr_is_owned(val_conv_15);
44615 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
44616 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
44617 val_constr.data[p] = val_conv_15_conv;
44620 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
44623 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fulfill_htlcs"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint64_t this_ptr) {
44624 LDKCommitmentUpdate this_ptr_conv;
44625 this_ptr_conv.inner = untag_ptr(this_ptr);
44626 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44628 this_ptr_conv.is_owned = false;
44629 LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
44630 uint64_tArray ret_arr = NULL;
44631 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44632 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44633 for (size_t t = 0; t < ret_var.datalen; t++) {
44634 LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t];
44635 uint64_t ret_conv_19_ref = 0;
44636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
44637 ret_conv_19_ref = tag_ptr(ret_conv_19_var.inner, ret_conv_19_var.is_owned);
44638 ret_arr_ptr[t] = ret_conv_19_ref;
44641 FREE(ret_var.data);
44645 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fulfill_htlcs"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint64_t this_ptr, uint64_tArray val) {
44646 LDKCommitmentUpdate this_ptr_conv;
44647 this_ptr_conv.inner = untag_ptr(this_ptr);
44648 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44650 this_ptr_conv.is_owned = false;
44651 LDKCVec_UpdateFulfillHTLCZ val_constr;
44652 val_constr.datalen = val->arr_len;
44653 if (val_constr.datalen > 0)
44654 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
44656 val_constr.data = NULL;
44657 uint64_t* val_vals = val->elems;
44658 for (size_t t = 0; t < val_constr.datalen; t++) {
44659 uint64_t val_conv_19 = val_vals[t];
44660 LDKUpdateFulfillHTLC val_conv_19_conv;
44661 val_conv_19_conv.inner = untag_ptr(val_conv_19);
44662 val_conv_19_conv.is_owned = ptr_is_owned(val_conv_19);
44663 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
44664 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
44665 val_constr.data[t] = val_conv_19_conv;
44668 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
44671 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_htlcs"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint64_t this_ptr) {
44672 LDKCommitmentUpdate this_ptr_conv;
44673 this_ptr_conv.inner = untag_ptr(this_ptr);
44674 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44675 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44676 this_ptr_conv.is_owned = false;
44677 LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
44678 uint64_tArray ret_arr = NULL;
44679 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44680 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44681 for (size_t q = 0; q < ret_var.datalen; q++) {
44682 LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q];
44683 uint64_t ret_conv_16_ref = 0;
44684 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
44685 ret_conv_16_ref = tag_ptr(ret_conv_16_var.inner, ret_conv_16_var.is_owned);
44686 ret_arr_ptr[q] = ret_conv_16_ref;
44689 FREE(ret_var.data);
44693 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_htlcs"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint64_t this_ptr, uint64_tArray val) {
44694 LDKCommitmentUpdate this_ptr_conv;
44695 this_ptr_conv.inner = untag_ptr(this_ptr);
44696 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44698 this_ptr_conv.is_owned = false;
44699 LDKCVec_UpdateFailHTLCZ val_constr;
44700 val_constr.datalen = val->arr_len;
44701 if (val_constr.datalen > 0)
44702 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
44704 val_constr.data = NULL;
44705 uint64_t* val_vals = val->elems;
44706 for (size_t q = 0; q < val_constr.datalen; q++) {
44707 uint64_t val_conv_16 = val_vals[q];
44708 LDKUpdateFailHTLC val_conv_16_conv;
44709 val_conv_16_conv.inner = untag_ptr(val_conv_16);
44710 val_conv_16_conv.is_owned = ptr_is_owned(val_conv_16);
44711 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
44712 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
44713 val_constr.data[q] = val_conv_16_conv;
44716 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
44719 uint64_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint64_t this_ptr) {
44720 LDKCommitmentUpdate this_ptr_conv;
44721 this_ptr_conv.inner = untag_ptr(this_ptr);
44722 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44723 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44724 this_ptr_conv.is_owned = false;
44725 LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
44726 uint64_tArray ret_arr = NULL;
44727 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
44728 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
44729 for (size_t z = 0; z < ret_var.datalen; z++) {
44730 LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z];
44731 uint64_t ret_conv_25_ref = 0;
44732 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
44733 ret_conv_25_ref = tag_ptr(ret_conv_25_var.inner, ret_conv_25_var.is_owned);
44734 ret_arr_ptr[z] = ret_conv_25_ref;
44737 FREE(ret_var.data);
44741 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) {
44742 LDKCommitmentUpdate this_ptr_conv;
44743 this_ptr_conv.inner = untag_ptr(this_ptr);
44744 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44746 this_ptr_conv.is_owned = false;
44747 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
44748 val_constr.datalen = val->arr_len;
44749 if (val_constr.datalen > 0)
44750 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
44752 val_constr.data = NULL;
44753 uint64_t* val_vals = val->elems;
44754 for (size_t z = 0; z < val_constr.datalen; z++) {
44755 uint64_t val_conv_25 = val_vals[z];
44756 LDKUpdateFailMalformedHTLC val_conv_25_conv;
44757 val_conv_25_conv.inner = untag_ptr(val_conv_25);
44758 val_conv_25_conv.is_owned = ptr_is_owned(val_conv_25);
44759 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
44760 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
44761 val_constr.data[z] = val_conv_25_conv;
44764 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
44767 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_update_fee"))) TS_CommitmentUpdate_get_update_fee(uint64_t this_ptr) {
44768 LDKCommitmentUpdate this_ptr_conv;
44769 this_ptr_conv.inner = untag_ptr(this_ptr);
44770 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44772 this_ptr_conv.is_owned = false;
44773 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
44774 uint64_t ret_ref = 0;
44775 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44776 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44780 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fee"))) TS_CommitmentUpdate_set_update_fee(uint64_t this_ptr, uint64_t val) {
44781 LDKCommitmentUpdate this_ptr_conv;
44782 this_ptr_conv.inner = untag_ptr(this_ptr);
44783 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44784 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44785 this_ptr_conv.is_owned = false;
44786 LDKUpdateFee val_conv;
44787 val_conv.inner = untag_ptr(val);
44788 val_conv.is_owned = ptr_is_owned(val);
44789 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44790 val_conv = UpdateFee_clone(&val_conv);
44791 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
44794 uint64_t __attribute__((export_name("TS_CommitmentUpdate_get_commitment_signed"))) TS_CommitmentUpdate_get_commitment_signed(uint64_t this_ptr) {
44795 LDKCommitmentUpdate this_ptr_conv;
44796 this_ptr_conv.inner = untag_ptr(this_ptr);
44797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44799 this_ptr_conv.is_owned = false;
44800 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
44801 uint64_t ret_ref = 0;
44802 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44803 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44807 void __attribute__((export_name("TS_CommitmentUpdate_set_commitment_signed"))) TS_CommitmentUpdate_set_commitment_signed(uint64_t this_ptr, uint64_t val) {
44808 LDKCommitmentUpdate this_ptr_conv;
44809 this_ptr_conv.inner = untag_ptr(this_ptr);
44810 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
44811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44812 this_ptr_conv.is_owned = false;
44813 LDKCommitmentSigned val_conv;
44814 val_conv.inner = untag_ptr(val);
44815 val_conv.is_owned = ptr_is_owned(val);
44816 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
44817 val_conv = CommitmentSigned_clone(&val_conv);
44818 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
44821 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) {
44822 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
44823 update_add_htlcs_arg_constr.datalen = update_add_htlcs_arg->arr_len;
44824 if (update_add_htlcs_arg_constr.datalen > 0)
44825 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
44827 update_add_htlcs_arg_constr.data = NULL;
44828 uint64_t* update_add_htlcs_arg_vals = update_add_htlcs_arg->elems;
44829 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
44830 uint64_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
44831 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
44832 update_add_htlcs_arg_conv_15_conv.inner = untag_ptr(update_add_htlcs_arg_conv_15);
44833 update_add_htlcs_arg_conv_15_conv.is_owned = ptr_is_owned(update_add_htlcs_arg_conv_15);
44834 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
44835 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
44836 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
44838 FREE(update_add_htlcs_arg);
44839 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
44840 update_fulfill_htlcs_arg_constr.datalen = update_fulfill_htlcs_arg->arr_len;
44841 if (update_fulfill_htlcs_arg_constr.datalen > 0)
44842 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
44844 update_fulfill_htlcs_arg_constr.data = NULL;
44845 uint64_t* update_fulfill_htlcs_arg_vals = update_fulfill_htlcs_arg->elems;
44846 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
44847 uint64_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
44848 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
44849 update_fulfill_htlcs_arg_conv_19_conv.inner = untag_ptr(update_fulfill_htlcs_arg_conv_19);
44850 update_fulfill_htlcs_arg_conv_19_conv.is_owned = ptr_is_owned(update_fulfill_htlcs_arg_conv_19);
44851 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
44852 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
44853 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
44855 FREE(update_fulfill_htlcs_arg);
44856 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
44857 update_fail_htlcs_arg_constr.datalen = update_fail_htlcs_arg->arr_len;
44858 if (update_fail_htlcs_arg_constr.datalen > 0)
44859 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
44861 update_fail_htlcs_arg_constr.data = NULL;
44862 uint64_t* update_fail_htlcs_arg_vals = update_fail_htlcs_arg->elems;
44863 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
44864 uint64_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
44865 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
44866 update_fail_htlcs_arg_conv_16_conv.inner = untag_ptr(update_fail_htlcs_arg_conv_16);
44867 update_fail_htlcs_arg_conv_16_conv.is_owned = ptr_is_owned(update_fail_htlcs_arg_conv_16);
44868 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
44869 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
44870 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
44872 FREE(update_fail_htlcs_arg);
44873 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
44874 update_fail_malformed_htlcs_arg_constr.datalen = update_fail_malformed_htlcs_arg->arr_len;
44875 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
44876 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
44878 update_fail_malformed_htlcs_arg_constr.data = NULL;
44879 uint64_t* update_fail_malformed_htlcs_arg_vals = update_fail_malformed_htlcs_arg->elems;
44880 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
44881 uint64_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
44882 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
44883 update_fail_malformed_htlcs_arg_conv_25_conv.inner = untag_ptr(update_fail_malformed_htlcs_arg_conv_25);
44884 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = ptr_is_owned(update_fail_malformed_htlcs_arg_conv_25);
44885 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
44886 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
44887 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
44889 FREE(update_fail_malformed_htlcs_arg);
44890 LDKUpdateFee update_fee_arg_conv;
44891 update_fee_arg_conv.inner = untag_ptr(update_fee_arg);
44892 update_fee_arg_conv.is_owned = ptr_is_owned(update_fee_arg);
44893 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
44894 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
44895 LDKCommitmentSigned commitment_signed_arg_conv;
44896 commitment_signed_arg_conv.inner = untag_ptr(commitment_signed_arg);
44897 commitment_signed_arg_conv.is_owned = ptr_is_owned(commitment_signed_arg);
44898 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
44899 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
44900 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);
44901 uint64_t ret_ref = 0;
44902 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44903 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44907 static inline uint64_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
44908 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
44909 uint64_t ret_ref = 0;
44910 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44911 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44914 int64_t __attribute__((export_name("TS_CommitmentUpdate_clone_ptr"))) TS_CommitmentUpdate_clone_ptr(uint64_t arg) {
44915 LDKCommitmentUpdate arg_conv;
44916 arg_conv.inner = untag_ptr(arg);
44917 arg_conv.is_owned = ptr_is_owned(arg);
44918 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44919 arg_conv.is_owned = false;
44920 int64_t ret_conv = CommitmentUpdate_clone_ptr(&arg_conv);
44924 uint64_t __attribute__((export_name("TS_CommitmentUpdate_clone"))) TS_CommitmentUpdate_clone(uint64_t orig) {
44925 LDKCommitmentUpdate orig_conv;
44926 orig_conv.inner = untag_ptr(orig);
44927 orig_conv.is_owned = ptr_is_owned(orig);
44928 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44929 orig_conv.is_owned = false;
44930 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
44931 uint64_t ret_ref = 0;
44932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44933 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
44937 jboolean __attribute__((export_name("TS_CommitmentUpdate_eq"))) TS_CommitmentUpdate_eq(uint64_t a, uint64_t b) {
44938 LDKCommitmentUpdate a_conv;
44939 a_conv.inner = untag_ptr(a);
44940 a_conv.is_owned = ptr_is_owned(a);
44941 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44942 a_conv.is_owned = false;
44943 LDKCommitmentUpdate b_conv;
44944 b_conv.inner = untag_ptr(b);
44945 b_conv.is_owned = ptr_is_owned(b);
44946 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44947 b_conv.is_owned = false;
44948 jboolean ret_conv = CommitmentUpdate_eq(&a_conv, &b_conv);
44952 void __attribute__((export_name("TS_ChannelMessageHandler_free"))) TS_ChannelMessageHandler_free(uint64_t this_ptr) {
44953 if (!ptr_is_owned(this_ptr)) return;
44954 void* this_ptr_ptr = untag_ptr(this_ptr);
44955 CHECK_ACCESS(this_ptr_ptr);
44956 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(this_ptr_ptr);
44957 FREE(untag_ptr(this_ptr));
44958 ChannelMessageHandler_free(this_ptr_conv);
44961 void __attribute__((export_name("TS_RoutingMessageHandler_free"))) TS_RoutingMessageHandler_free(uint64_t this_ptr) {
44962 if (!ptr_is_owned(this_ptr)) return;
44963 void* this_ptr_ptr = untag_ptr(this_ptr);
44964 CHECK_ACCESS(this_ptr_ptr);
44965 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(this_ptr_ptr);
44966 FREE(untag_ptr(this_ptr));
44967 RoutingMessageHandler_free(this_ptr_conv);
44970 void __attribute__((export_name("TS_OnionMessageHandler_free"))) TS_OnionMessageHandler_free(uint64_t this_ptr) {
44971 if (!ptr_is_owned(this_ptr)) return;
44972 void* this_ptr_ptr = untag_ptr(this_ptr);
44973 CHECK_ACCESS(this_ptr_ptr);
44974 LDKOnionMessageHandler this_ptr_conv = *(LDKOnionMessageHandler*)(this_ptr_ptr);
44975 FREE(untag_ptr(this_ptr));
44976 OnionMessageHandler_free(this_ptr_conv);
44979 int8_tArray __attribute__((export_name("TS_AcceptChannel_write"))) TS_AcceptChannel_write(uint64_t obj) {
44980 LDKAcceptChannel obj_conv;
44981 obj_conv.inner = untag_ptr(obj);
44982 obj_conv.is_owned = ptr_is_owned(obj);
44983 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
44984 obj_conv.is_owned = false;
44985 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
44986 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
44987 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
44988 CVec_u8Z_free(ret_var);
44992 uint64_t __attribute__((export_name("TS_AcceptChannel_read"))) TS_AcceptChannel_read(int8_tArray ser) {
44993 LDKu8slice ser_ref;
44994 ser_ref.datalen = ser->arr_len;
44995 ser_ref.data = ser->elems;
44996 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
44997 *ret_conv = AcceptChannel_read(ser_ref);
44999 return tag_ptr(ret_conv, true);
45002 int8_tArray __attribute__((export_name("TS_AcceptChannelV2_write"))) TS_AcceptChannelV2_write(uint64_t obj) {
45003 LDKAcceptChannelV2 obj_conv;
45004 obj_conv.inner = untag_ptr(obj);
45005 obj_conv.is_owned = ptr_is_owned(obj);
45006 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45007 obj_conv.is_owned = false;
45008 LDKCVec_u8Z ret_var = AcceptChannelV2_write(&obj_conv);
45009 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45010 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45011 CVec_u8Z_free(ret_var);
45015 uint64_t __attribute__((export_name("TS_AcceptChannelV2_read"))) TS_AcceptChannelV2_read(int8_tArray ser) {
45016 LDKu8slice ser_ref;
45017 ser_ref.datalen = ser->arr_len;
45018 ser_ref.data = ser->elems;
45019 LDKCResult_AcceptChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelV2DecodeErrorZ), "LDKCResult_AcceptChannelV2DecodeErrorZ");
45020 *ret_conv = AcceptChannelV2_read(ser_ref);
45022 return tag_ptr(ret_conv, true);
45025 int8_tArray __attribute__((export_name("TS_TxAddInput_write"))) TS_TxAddInput_write(uint64_t obj) {
45026 LDKTxAddInput obj_conv;
45027 obj_conv.inner = untag_ptr(obj);
45028 obj_conv.is_owned = ptr_is_owned(obj);
45029 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45030 obj_conv.is_owned = false;
45031 LDKCVec_u8Z ret_var = TxAddInput_write(&obj_conv);
45032 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45033 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45034 CVec_u8Z_free(ret_var);
45038 uint64_t __attribute__((export_name("TS_TxAddInput_read"))) TS_TxAddInput_read(int8_tArray ser) {
45039 LDKu8slice ser_ref;
45040 ser_ref.datalen = ser->arr_len;
45041 ser_ref.data = ser->elems;
45042 LDKCResult_TxAddInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddInputDecodeErrorZ), "LDKCResult_TxAddInputDecodeErrorZ");
45043 *ret_conv = TxAddInput_read(ser_ref);
45045 return tag_ptr(ret_conv, true);
45048 int8_tArray __attribute__((export_name("TS_TxAddOutput_write"))) TS_TxAddOutput_write(uint64_t obj) {
45049 LDKTxAddOutput obj_conv;
45050 obj_conv.inner = untag_ptr(obj);
45051 obj_conv.is_owned = ptr_is_owned(obj);
45052 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45053 obj_conv.is_owned = false;
45054 LDKCVec_u8Z ret_var = TxAddOutput_write(&obj_conv);
45055 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45056 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45057 CVec_u8Z_free(ret_var);
45061 uint64_t __attribute__((export_name("TS_TxAddOutput_read"))) TS_TxAddOutput_read(int8_tArray ser) {
45062 LDKu8slice ser_ref;
45063 ser_ref.datalen = ser->arr_len;
45064 ser_ref.data = ser->elems;
45065 LDKCResult_TxAddOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAddOutputDecodeErrorZ), "LDKCResult_TxAddOutputDecodeErrorZ");
45066 *ret_conv = TxAddOutput_read(ser_ref);
45068 return tag_ptr(ret_conv, true);
45071 int8_tArray __attribute__((export_name("TS_TxRemoveInput_write"))) TS_TxRemoveInput_write(uint64_t obj) {
45072 LDKTxRemoveInput obj_conv;
45073 obj_conv.inner = untag_ptr(obj);
45074 obj_conv.is_owned = ptr_is_owned(obj);
45075 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45076 obj_conv.is_owned = false;
45077 LDKCVec_u8Z ret_var = TxRemoveInput_write(&obj_conv);
45078 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45079 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45080 CVec_u8Z_free(ret_var);
45084 uint64_t __attribute__((export_name("TS_TxRemoveInput_read"))) TS_TxRemoveInput_read(int8_tArray ser) {
45085 LDKu8slice ser_ref;
45086 ser_ref.datalen = ser->arr_len;
45087 ser_ref.data = ser->elems;
45088 LDKCResult_TxRemoveInputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveInputDecodeErrorZ), "LDKCResult_TxRemoveInputDecodeErrorZ");
45089 *ret_conv = TxRemoveInput_read(ser_ref);
45091 return tag_ptr(ret_conv, true);
45094 int8_tArray __attribute__((export_name("TS_TxRemoveOutput_write"))) TS_TxRemoveOutput_write(uint64_t obj) {
45095 LDKTxRemoveOutput obj_conv;
45096 obj_conv.inner = untag_ptr(obj);
45097 obj_conv.is_owned = ptr_is_owned(obj);
45098 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45099 obj_conv.is_owned = false;
45100 LDKCVec_u8Z ret_var = TxRemoveOutput_write(&obj_conv);
45101 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45102 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45103 CVec_u8Z_free(ret_var);
45107 uint64_t __attribute__((export_name("TS_TxRemoveOutput_read"))) TS_TxRemoveOutput_read(int8_tArray ser) {
45108 LDKu8slice ser_ref;
45109 ser_ref.datalen = ser->arr_len;
45110 ser_ref.data = ser->elems;
45111 LDKCResult_TxRemoveOutputDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxRemoveOutputDecodeErrorZ), "LDKCResult_TxRemoveOutputDecodeErrorZ");
45112 *ret_conv = TxRemoveOutput_read(ser_ref);
45114 return tag_ptr(ret_conv, true);
45117 int8_tArray __attribute__((export_name("TS_TxComplete_write"))) TS_TxComplete_write(uint64_t obj) {
45118 LDKTxComplete obj_conv;
45119 obj_conv.inner = untag_ptr(obj);
45120 obj_conv.is_owned = ptr_is_owned(obj);
45121 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45122 obj_conv.is_owned = false;
45123 LDKCVec_u8Z ret_var = TxComplete_write(&obj_conv);
45124 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45125 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45126 CVec_u8Z_free(ret_var);
45130 uint64_t __attribute__((export_name("TS_TxComplete_read"))) TS_TxComplete_read(int8_tArray ser) {
45131 LDKu8slice ser_ref;
45132 ser_ref.datalen = ser->arr_len;
45133 ser_ref.data = ser->elems;
45134 LDKCResult_TxCompleteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCompleteDecodeErrorZ), "LDKCResult_TxCompleteDecodeErrorZ");
45135 *ret_conv = TxComplete_read(ser_ref);
45137 return tag_ptr(ret_conv, true);
45140 int8_tArray __attribute__((export_name("TS_TxSignatures_write"))) TS_TxSignatures_write(uint64_t obj) {
45141 LDKTxSignatures obj_conv;
45142 obj_conv.inner = untag_ptr(obj);
45143 obj_conv.is_owned = ptr_is_owned(obj);
45144 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45145 obj_conv.is_owned = false;
45146 LDKCVec_u8Z ret_var = TxSignatures_write(&obj_conv);
45147 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45148 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45149 CVec_u8Z_free(ret_var);
45153 uint64_t __attribute__((export_name("TS_TxSignatures_read"))) TS_TxSignatures_read(int8_tArray ser) {
45154 LDKu8slice ser_ref;
45155 ser_ref.datalen = ser->arr_len;
45156 ser_ref.data = ser->elems;
45157 LDKCResult_TxSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxSignaturesDecodeErrorZ), "LDKCResult_TxSignaturesDecodeErrorZ");
45158 *ret_conv = TxSignatures_read(ser_ref);
45160 return tag_ptr(ret_conv, true);
45163 int8_tArray __attribute__((export_name("TS_TxInitRbf_write"))) TS_TxInitRbf_write(uint64_t obj) {
45164 LDKTxInitRbf obj_conv;
45165 obj_conv.inner = untag_ptr(obj);
45166 obj_conv.is_owned = ptr_is_owned(obj);
45167 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45168 obj_conv.is_owned = false;
45169 LDKCVec_u8Z ret_var = TxInitRbf_write(&obj_conv);
45170 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45171 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45172 CVec_u8Z_free(ret_var);
45176 uint64_t __attribute__((export_name("TS_TxInitRbf_read"))) TS_TxInitRbf_read(int8_tArray ser) {
45177 LDKu8slice ser_ref;
45178 ser_ref.datalen = ser->arr_len;
45179 ser_ref.data = ser->elems;
45180 LDKCResult_TxInitRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxInitRbfDecodeErrorZ), "LDKCResult_TxInitRbfDecodeErrorZ");
45181 *ret_conv = TxInitRbf_read(ser_ref);
45183 return tag_ptr(ret_conv, true);
45186 int8_tArray __attribute__((export_name("TS_TxAckRbf_write"))) TS_TxAckRbf_write(uint64_t obj) {
45187 LDKTxAckRbf obj_conv;
45188 obj_conv.inner = untag_ptr(obj);
45189 obj_conv.is_owned = ptr_is_owned(obj);
45190 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45191 obj_conv.is_owned = false;
45192 LDKCVec_u8Z ret_var = TxAckRbf_write(&obj_conv);
45193 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45194 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45195 CVec_u8Z_free(ret_var);
45199 uint64_t __attribute__((export_name("TS_TxAckRbf_read"))) TS_TxAckRbf_read(int8_tArray ser) {
45200 LDKu8slice ser_ref;
45201 ser_ref.datalen = ser->arr_len;
45202 ser_ref.data = ser->elems;
45203 LDKCResult_TxAckRbfDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAckRbfDecodeErrorZ), "LDKCResult_TxAckRbfDecodeErrorZ");
45204 *ret_conv = TxAckRbf_read(ser_ref);
45206 return tag_ptr(ret_conv, true);
45209 int8_tArray __attribute__((export_name("TS_TxAbort_write"))) TS_TxAbort_write(uint64_t obj) {
45210 LDKTxAbort obj_conv;
45211 obj_conv.inner = untag_ptr(obj);
45212 obj_conv.is_owned = ptr_is_owned(obj);
45213 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45214 obj_conv.is_owned = false;
45215 LDKCVec_u8Z ret_var = TxAbort_write(&obj_conv);
45216 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45217 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45218 CVec_u8Z_free(ret_var);
45222 uint64_t __attribute__((export_name("TS_TxAbort_read"))) TS_TxAbort_read(int8_tArray ser) {
45223 LDKu8slice ser_ref;
45224 ser_ref.datalen = ser->arr_len;
45225 ser_ref.data = ser->elems;
45226 LDKCResult_TxAbortDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxAbortDecodeErrorZ), "LDKCResult_TxAbortDecodeErrorZ");
45227 *ret_conv = TxAbort_read(ser_ref);
45229 return tag_ptr(ret_conv, true);
45232 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_write"))) TS_AnnouncementSignatures_write(uint64_t obj) {
45233 LDKAnnouncementSignatures obj_conv;
45234 obj_conv.inner = untag_ptr(obj);
45235 obj_conv.is_owned = ptr_is_owned(obj);
45236 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45237 obj_conv.is_owned = false;
45238 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
45239 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45240 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45241 CVec_u8Z_free(ret_var);
45245 uint64_t __attribute__((export_name("TS_AnnouncementSignatures_read"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
45246 LDKu8slice ser_ref;
45247 ser_ref.datalen = ser->arr_len;
45248 ser_ref.data = ser->elems;
45249 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
45250 *ret_conv = AnnouncementSignatures_read(ser_ref);
45252 return tag_ptr(ret_conv, true);
45255 int8_tArray __attribute__((export_name("TS_ChannelReestablish_write"))) TS_ChannelReestablish_write(uint64_t obj) {
45256 LDKChannelReestablish obj_conv;
45257 obj_conv.inner = untag_ptr(obj);
45258 obj_conv.is_owned = ptr_is_owned(obj);
45259 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45260 obj_conv.is_owned = false;
45261 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
45262 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45263 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45264 CVec_u8Z_free(ret_var);
45268 uint64_t __attribute__((export_name("TS_ChannelReestablish_read"))) TS_ChannelReestablish_read(int8_tArray ser) {
45269 LDKu8slice ser_ref;
45270 ser_ref.datalen = ser->arr_len;
45271 ser_ref.data = ser->elems;
45272 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
45273 *ret_conv = ChannelReestablish_read(ser_ref);
45275 return tag_ptr(ret_conv, true);
45278 int8_tArray __attribute__((export_name("TS_ClosingSigned_write"))) TS_ClosingSigned_write(uint64_t obj) {
45279 LDKClosingSigned obj_conv;
45280 obj_conv.inner = untag_ptr(obj);
45281 obj_conv.is_owned = ptr_is_owned(obj);
45282 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45283 obj_conv.is_owned = false;
45284 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
45285 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45286 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45287 CVec_u8Z_free(ret_var);
45291 uint64_t __attribute__((export_name("TS_ClosingSigned_read"))) TS_ClosingSigned_read(int8_tArray ser) {
45292 LDKu8slice ser_ref;
45293 ser_ref.datalen = ser->arr_len;
45294 ser_ref.data = ser->elems;
45295 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
45296 *ret_conv = ClosingSigned_read(ser_ref);
45298 return tag_ptr(ret_conv, true);
45301 int8_tArray __attribute__((export_name("TS_ClosingSignedFeeRange_write"))) TS_ClosingSignedFeeRange_write(uint64_t obj) {
45302 LDKClosingSignedFeeRange obj_conv;
45303 obj_conv.inner = untag_ptr(obj);
45304 obj_conv.is_owned = ptr_is_owned(obj);
45305 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45306 obj_conv.is_owned = false;
45307 LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
45308 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45309 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45310 CVec_u8Z_free(ret_var);
45314 uint64_t __attribute__((export_name("TS_ClosingSignedFeeRange_read"))) TS_ClosingSignedFeeRange_read(int8_tArray ser) {
45315 LDKu8slice ser_ref;
45316 ser_ref.datalen = ser->arr_len;
45317 ser_ref.data = ser->elems;
45318 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
45319 *ret_conv = ClosingSignedFeeRange_read(ser_ref);
45321 return tag_ptr(ret_conv, true);
45324 int8_tArray __attribute__((export_name("TS_CommitmentSigned_write"))) TS_CommitmentSigned_write(uint64_t obj) {
45325 LDKCommitmentSigned obj_conv;
45326 obj_conv.inner = untag_ptr(obj);
45327 obj_conv.is_owned = ptr_is_owned(obj);
45328 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45329 obj_conv.is_owned = false;
45330 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
45331 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45332 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45333 CVec_u8Z_free(ret_var);
45337 uint64_t __attribute__((export_name("TS_CommitmentSigned_read"))) TS_CommitmentSigned_read(int8_tArray ser) {
45338 LDKu8slice ser_ref;
45339 ser_ref.datalen = ser->arr_len;
45340 ser_ref.data = ser->elems;
45341 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
45342 *ret_conv = CommitmentSigned_read(ser_ref);
45344 return tag_ptr(ret_conv, true);
45347 int8_tArray __attribute__((export_name("TS_FundingCreated_write"))) TS_FundingCreated_write(uint64_t obj) {
45348 LDKFundingCreated obj_conv;
45349 obj_conv.inner = untag_ptr(obj);
45350 obj_conv.is_owned = ptr_is_owned(obj);
45351 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45352 obj_conv.is_owned = false;
45353 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
45354 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45355 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45356 CVec_u8Z_free(ret_var);
45360 uint64_t __attribute__((export_name("TS_FundingCreated_read"))) TS_FundingCreated_read(int8_tArray ser) {
45361 LDKu8slice ser_ref;
45362 ser_ref.datalen = ser->arr_len;
45363 ser_ref.data = ser->elems;
45364 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
45365 *ret_conv = FundingCreated_read(ser_ref);
45367 return tag_ptr(ret_conv, true);
45370 int8_tArray __attribute__((export_name("TS_FundingSigned_write"))) TS_FundingSigned_write(uint64_t obj) {
45371 LDKFundingSigned obj_conv;
45372 obj_conv.inner = untag_ptr(obj);
45373 obj_conv.is_owned = ptr_is_owned(obj);
45374 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45375 obj_conv.is_owned = false;
45376 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
45377 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45378 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45379 CVec_u8Z_free(ret_var);
45383 uint64_t __attribute__((export_name("TS_FundingSigned_read"))) TS_FundingSigned_read(int8_tArray ser) {
45384 LDKu8slice ser_ref;
45385 ser_ref.datalen = ser->arr_len;
45386 ser_ref.data = ser->elems;
45387 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
45388 *ret_conv = FundingSigned_read(ser_ref);
45390 return tag_ptr(ret_conv, true);
45393 int8_tArray __attribute__((export_name("TS_ChannelReady_write"))) TS_ChannelReady_write(uint64_t obj) {
45394 LDKChannelReady obj_conv;
45395 obj_conv.inner = untag_ptr(obj);
45396 obj_conv.is_owned = ptr_is_owned(obj);
45397 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45398 obj_conv.is_owned = false;
45399 LDKCVec_u8Z ret_var = ChannelReady_write(&obj_conv);
45400 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45401 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45402 CVec_u8Z_free(ret_var);
45406 uint64_t __attribute__((export_name("TS_ChannelReady_read"))) TS_ChannelReady_read(int8_tArray ser) {
45407 LDKu8slice ser_ref;
45408 ser_ref.datalen = ser->arr_len;
45409 ser_ref.data = ser->elems;
45410 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
45411 *ret_conv = ChannelReady_read(ser_ref);
45413 return tag_ptr(ret_conv, true);
45416 int8_tArray __attribute__((export_name("TS_Init_write"))) TS_Init_write(uint64_t obj) {
45418 obj_conv.inner = untag_ptr(obj);
45419 obj_conv.is_owned = ptr_is_owned(obj);
45420 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45421 obj_conv.is_owned = false;
45422 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
45423 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45424 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45425 CVec_u8Z_free(ret_var);
45429 uint64_t __attribute__((export_name("TS_Init_read"))) TS_Init_read(int8_tArray ser) {
45430 LDKu8slice ser_ref;
45431 ser_ref.datalen = ser->arr_len;
45432 ser_ref.data = ser->elems;
45433 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
45434 *ret_conv = Init_read(ser_ref);
45436 return tag_ptr(ret_conv, true);
45439 int8_tArray __attribute__((export_name("TS_OpenChannel_write"))) TS_OpenChannel_write(uint64_t obj) {
45440 LDKOpenChannel obj_conv;
45441 obj_conv.inner = untag_ptr(obj);
45442 obj_conv.is_owned = ptr_is_owned(obj);
45443 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45444 obj_conv.is_owned = false;
45445 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
45446 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45447 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45448 CVec_u8Z_free(ret_var);
45452 uint64_t __attribute__((export_name("TS_OpenChannel_read"))) TS_OpenChannel_read(int8_tArray ser) {
45453 LDKu8slice ser_ref;
45454 ser_ref.datalen = ser->arr_len;
45455 ser_ref.data = ser->elems;
45456 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
45457 *ret_conv = OpenChannel_read(ser_ref);
45459 return tag_ptr(ret_conv, true);
45462 int8_tArray __attribute__((export_name("TS_OpenChannelV2_write"))) TS_OpenChannelV2_write(uint64_t obj) {
45463 LDKOpenChannelV2 obj_conv;
45464 obj_conv.inner = untag_ptr(obj);
45465 obj_conv.is_owned = ptr_is_owned(obj);
45466 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45467 obj_conv.is_owned = false;
45468 LDKCVec_u8Z ret_var = OpenChannelV2_write(&obj_conv);
45469 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45470 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45471 CVec_u8Z_free(ret_var);
45475 uint64_t __attribute__((export_name("TS_OpenChannelV2_read"))) TS_OpenChannelV2_read(int8_tArray ser) {
45476 LDKu8slice ser_ref;
45477 ser_ref.datalen = ser->arr_len;
45478 ser_ref.data = ser->elems;
45479 LDKCResult_OpenChannelV2DecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelV2DecodeErrorZ), "LDKCResult_OpenChannelV2DecodeErrorZ");
45480 *ret_conv = OpenChannelV2_read(ser_ref);
45482 return tag_ptr(ret_conv, true);
45485 int8_tArray __attribute__((export_name("TS_RevokeAndACK_write"))) TS_RevokeAndACK_write(uint64_t obj) {
45486 LDKRevokeAndACK obj_conv;
45487 obj_conv.inner = untag_ptr(obj);
45488 obj_conv.is_owned = ptr_is_owned(obj);
45489 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45490 obj_conv.is_owned = false;
45491 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
45492 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45493 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45494 CVec_u8Z_free(ret_var);
45498 uint64_t __attribute__((export_name("TS_RevokeAndACK_read"))) TS_RevokeAndACK_read(int8_tArray ser) {
45499 LDKu8slice ser_ref;
45500 ser_ref.datalen = ser->arr_len;
45501 ser_ref.data = ser->elems;
45502 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
45503 *ret_conv = RevokeAndACK_read(ser_ref);
45505 return tag_ptr(ret_conv, true);
45508 int8_tArray __attribute__((export_name("TS_Shutdown_write"))) TS_Shutdown_write(uint64_t obj) {
45509 LDKShutdown obj_conv;
45510 obj_conv.inner = untag_ptr(obj);
45511 obj_conv.is_owned = ptr_is_owned(obj);
45512 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45513 obj_conv.is_owned = false;
45514 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
45515 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45516 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45517 CVec_u8Z_free(ret_var);
45521 uint64_t __attribute__((export_name("TS_Shutdown_read"))) TS_Shutdown_read(int8_tArray ser) {
45522 LDKu8slice ser_ref;
45523 ser_ref.datalen = ser->arr_len;
45524 ser_ref.data = ser->elems;
45525 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
45526 *ret_conv = Shutdown_read(ser_ref);
45528 return tag_ptr(ret_conv, true);
45531 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_write"))) TS_UpdateFailHTLC_write(uint64_t obj) {
45532 LDKUpdateFailHTLC obj_conv;
45533 obj_conv.inner = untag_ptr(obj);
45534 obj_conv.is_owned = ptr_is_owned(obj);
45535 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45536 obj_conv.is_owned = false;
45537 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
45538 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45539 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45540 CVec_u8Z_free(ret_var);
45544 uint64_t __attribute__((export_name("TS_UpdateFailHTLC_read"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
45545 LDKu8slice ser_ref;
45546 ser_ref.datalen = ser->arr_len;
45547 ser_ref.data = ser->elems;
45548 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
45549 *ret_conv = UpdateFailHTLC_read(ser_ref);
45551 return tag_ptr(ret_conv, true);
45554 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_write"))) TS_UpdateFailMalformedHTLC_write(uint64_t obj) {
45555 LDKUpdateFailMalformedHTLC obj_conv;
45556 obj_conv.inner = untag_ptr(obj);
45557 obj_conv.is_owned = ptr_is_owned(obj);
45558 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45559 obj_conv.is_owned = false;
45560 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
45561 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45562 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45563 CVec_u8Z_free(ret_var);
45567 uint64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_read"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
45568 LDKu8slice ser_ref;
45569 ser_ref.datalen = ser->arr_len;
45570 ser_ref.data = ser->elems;
45571 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
45572 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
45574 return tag_ptr(ret_conv, true);
45577 int8_tArray __attribute__((export_name("TS_UpdateFee_write"))) TS_UpdateFee_write(uint64_t obj) {
45578 LDKUpdateFee obj_conv;
45579 obj_conv.inner = untag_ptr(obj);
45580 obj_conv.is_owned = ptr_is_owned(obj);
45581 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45582 obj_conv.is_owned = false;
45583 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
45584 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45585 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45586 CVec_u8Z_free(ret_var);
45590 uint64_t __attribute__((export_name("TS_UpdateFee_read"))) TS_UpdateFee_read(int8_tArray ser) {
45591 LDKu8slice ser_ref;
45592 ser_ref.datalen = ser->arr_len;
45593 ser_ref.data = ser->elems;
45594 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
45595 *ret_conv = UpdateFee_read(ser_ref);
45597 return tag_ptr(ret_conv, true);
45600 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_write"))) TS_UpdateFulfillHTLC_write(uint64_t obj) {
45601 LDKUpdateFulfillHTLC obj_conv;
45602 obj_conv.inner = untag_ptr(obj);
45603 obj_conv.is_owned = ptr_is_owned(obj);
45604 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45605 obj_conv.is_owned = false;
45606 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
45607 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45608 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45609 CVec_u8Z_free(ret_var);
45613 uint64_t __attribute__((export_name("TS_UpdateFulfillHTLC_read"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
45614 LDKu8slice ser_ref;
45615 ser_ref.datalen = ser->arr_len;
45616 ser_ref.data = ser->elems;
45617 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
45618 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
45620 return tag_ptr(ret_conv, true);
45623 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_write"))) TS_UpdateAddHTLC_write(uint64_t obj) {
45624 LDKUpdateAddHTLC obj_conv;
45625 obj_conv.inner = untag_ptr(obj);
45626 obj_conv.is_owned = ptr_is_owned(obj);
45627 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45628 obj_conv.is_owned = false;
45629 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
45630 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45631 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45632 CVec_u8Z_free(ret_var);
45636 uint64_t __attribute__((export_name("TS_UpdateAddHTLC_read"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
45637 LDKu8slice ser_ref;
45638 ser_ref.datalen = ser->arr_len;
45639 ser_ref.data = ser->elems;
45640 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
45641 *ret_conv = UpdateAddHTLC_read(ser_ref);
45643 return tag_ptr(ret_conv, true);
45646 uint64_t __attribute__((export_name("TS_OnionMessage_read"))) TS_OnionMessage_read(int8_tArray ser) {
45647 LDKu8slice ser_ref;
45648 ser_ref.datalen = ser->arr_len;
45649 ser_ref.data = ser->elems;
45650 LDKCResult_OnionMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OnionMessageDecodeErrorZ), "LDKCResult_OnionMessageDecodeErrorZ");
45651 *ret_conv = OnionMessage_read(ser_ref);
45653 return tag_ptr(ret_conv, true);
45656 int8_tArray __attribute__((export_name("TS_OnionMessage_write"))) TS_OnionMessage_write(uint64_t obj) {
45657 LDKOnionMessage obj_conv;
45658 obj_conv.inner = untag_ptr(obj);
45659 obj_conv.is_owned = ptr_is_owned(obj);
45660 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45661 obj_conv.is_owned = false;
45662 LDKCVec_u8Z ret_var = OnionMessage_write(&obj_conv);
45663 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45664 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45665 CVec_u8Z_free(ret_var);
45669 int8_tArray __attribute__((export_name("TS_Ping_write"))) TS_Ping_write(uint64_t obj) {
45671 obj_conv.inner = untag_ptr(obj);
45672 obj_conv.is_owned = ptr_is_owned(obj);
45673 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45674 obj_conv.is_owned = false;
45675 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
45676 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45677 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45678 CVec_u8Z_free(ret_var);
45682 uint64_t __attribute__((export_name("TS_Ping_read"))) TS_Ping_read(int8_tArray ser) {
45683 LDKu8slice ser_ref;
45684 ser_ref.datalen = ser->arr_len;
45685 ser_ref.data = ser->elems;
45686 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
45687 *ret_conv = Ping_read(ser_ref);
45689 return tag_ptr(ret_conv, true);
45692 int8_tArray __attribute__((export_name("TS_Pong_write"))) TS_Pong_write(uint64_t obj) {
45694 obj_conv.inner = untag_ptr(obj);
45695 obj_conv.is_owned = ptr_is_owned(obj);
45696 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45697 obj_conv.is_owned = false;
45698 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
45699 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45700 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45701 CVec_u8Z_free(ret_var);
45705 uint64_t __attribute__((export_name("TS_Pong_read"))) TS_Pong_read(int8_tArray ser) {
45706 LDKu8slice ser_ref;
45707 ser_ref.datalen = ser->arr_len;
45708 ser_ref.data = ser->elems;
45709 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
45710 *ret_conv = Pong_read(ser_ref);
45712 return tag_ptr(ret_conv, true);
45715 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_write"))) TS_UnsignedChannelAnnouncement_write(uint64_t obj) {
45716 LDKUnsignedChannelAnnouncement obj_conv;
45717 obj_conv.inner = untag_ptr(obj);
45718 obj_conv.is_owned = ptr_is_owned(obj);
45719 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45720 obj_conv.is_owned = false;
45721 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
45722 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45723 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45724 CVec_u8Z_free(ret_var);
45728 uint64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_read"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
45729 LDKu8slice ser_ref;
45730 ser_ref.datalen = ser->arr_len;
45731 ser_ref.data = ser->elems;
45732 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
45733 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
45735 return tag_ptr(ret_conv, true);
45738 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_write"))) TS_ChannelAnnouncement_write(uint64_t obj) {
45739 LDKChannelAnnouncement obj_conv;
45740 obj_conv.inner = untag_ptr(obj);
45741 obj_conv.is_owned = ptr_is_owned(obj);
45742 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45743 obj_conv.is_owned = false;
45744 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
45745 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45746 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45747 CVec_u8Z_free(ret_var);
45751 uint64_t __attribute__((export_name("TS_ChannelAnnouncement_read"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
45752 LDKu8slice ser_ref;
45753 ser_ref.datalen = ser->arr_len;
45754 ser_ref.data = ser->elems;
45755 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
45756 *ret_conv = ChannelAnnouncement_read(ser_ref);
45758 return tag_ptr(ret_conv, true);
45761 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_write"))) TS_UnsignedChannelUpdate_write(uint64_t obj) {
45762 LDKUnsignedChannelUpdate obj_conv;
45763 obj_conv.inner = untag_ptr(obj);
45764 obj_conv.is_owned = ptr_is_owned(obj);
45765 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45766 obj_conv.is_owned = false;
45767 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
45768 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45769 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45770 CVec_u8Z_free(ret_var);
45774 uint64_t __attribute__((export_name("TS_UnsignedChannelUpdate_read"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
45775 LDKu8slice ser_ref;
45776 ser_ref.datalen = ser->arr_len;
45777 ser_ref.data = ser->elems;
45778 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
45779 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
45781 return tag_ptr(ret_conv, true);
45784 int8_tArray __attribute__((export_name("TS_ChannelUpdate_write"))) TS_ChannelUpdate_write(uint64_t obj) {
45785 LDKChannelUpdate obj_conv;
45786 obj_conv.inner = untag_ptr(obj);
45787 obj_conv.is_owned = ptr_is_owned(obj);
45788 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45789 obj_conv.is_owned = false;
45790 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
45791 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45792 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45793 CVec_u8Z_free(ret_var);
45797 uint64_t __attribute__((export_name("TS_ChannelUpdate_read"))) TS_ChannelUpdate_read(int8_tArray ser) {
45798 LDKu8slice ser_ref;
45799 ser_ref.datalen = ser->arr_len;
45800 ser_ref.data = ser->elems;
45801 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
45802 *ret_conv = ChannelUpdate_read(ser_ref);
45804 return tag_ptr(ret_conv, true);
45807 int8_tArray __attribute__((export_name("TS_ErrorMessage_write"))) TS_ErrorMessage_write(uint64_t obj) {
45808 LDKErrorMessage obj_conv;
45809 obj_conv.inner = untag_ptr(obj);
45810 obj_conv.is_owned = ptr_is_owned(obj);
45811 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45812 obj_conv.is_owned = false;
45813 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
45814 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45815 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45816 CVec_u8Z_free(ret_var);
45820 uint64_t __attribute__((export_name("TS_ErrorMessage_read"))) TS_ErrorMessage_read(int8_tArray ser) {
45821 LDKu8slice ser_ref;
45822 ser_ref.datalen = ser->arr_len;
45823 ser_ref.data = ser->elems;
45824 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
45825 *ret_conv = ErrorMessage_read(ser_ref);
45827 return tag_ptr(ret_conv, true);
45830 int8_tArray __attribute__((export_name("TS_WarningMessage_write"))) TS_WarningMessage_write(uint64_t obj) {
45831 LDKWarningMessage obj_conv;
45832 obj_conv.inner = untag_ptr(obj);
45833 obj_conv.is_owned = ptr_is_owned(obj);
45834 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45835 obj_conv.is_owned = false;
45836 LDKCVec_u8Z ret_var = WarningMessage_write(&obj_conv);
45837 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45838 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45839 CVec_u8Z_free(ret_var);
45843 uint64_t __attribute__((export_name("TS_WarningMessage_read"))) TS_WarningMessage_read(int8_tArray ser) {
45844 LDKu8slice ser_ref;
45845 ser_ref.datalen = ser->arr_len;
45846 ser_ref.data = ser->elems;
45847 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
45848 *ret_conv = WarningMessage_read(ser_ref);
45850 return tag_ptr(ret_conv, true);
45853 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_write"))) TS_UnsignedNodeAnnouncement_write(uint64_t obj) {
45854 LDKUnsignedNodeAnnouncement obj_conv;
45855 obj_conv.inner = untag_ptr(obj);
45856 obj_conv.is_owned = ptr_is_owned(obj);
45857 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45858 obj_conv.is_owned = false;
45859 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
45860 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45861 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45862 CVec_u8Z_free(ret_var);
45866 uint64_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_read"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
45867 LDKu8slice ser_ref;
45868 ser_ref.datalen = ser->arr_len;
45869 ser_ref.data = ser->elems;
45870 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
45871 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
45873 return tag_ptr(ret_conv, true);
45876 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_write"))) TS_NodeAnnouncement_write(uint64_t obj) {
45877 LDKNodeAnnouncement obj_conv;
45878 obj_conv.inner = untag_ptr(obj);
45879 obj_conv.is_owned = ptr_is_owned(obj);
45880 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45881 obj_conv.is_owned = false;
45882 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
45883 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45884 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45885 CVec_u8Z_free(ret_var);
45889 uint64_t __attribute__((export_name("TS_NodeAnnouncement_read"))) TS_NodeAnnouncement_read(int8_tArray ser) {
45890 LDKu8slice ser_ref;
45891 ser_ref.datalen = ser->arr_len;
45892 ser_ref.data = ser->elems;
45893 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
45894 *ret_conv = NodeAnnouncement_read(ser_ref);
45896 return tag_ptr(ret_conv, true);
45899 uint64_t __attribute__((export_name("TS_QueryShortChannelIds_read"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
45900 LDKu8slice ser_ref;
45901 ser_ref.datalen = ser->arr_len;
45902 ser_ref.data = ser->elems;
45903 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
45904 *ret_conv = QueryShortChannelIds_read(ser_ref);
45906 return tag_ptr(ret_conv, true);
45909 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_write"))) TS_QueryShortChannelIds_write(uint64_t obj) {
45910 LDKQueryShortChannelIds obj_conv;
45911 obj_conv.inner = untag_ptr(obj);
45912 obj_conv.is_owned = ptr_is_owned(obj);
45913 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45914 obj_conv.is_owned = false;
45915 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
45916 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45917 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45918 CVec_u8Z_free(ret_var);
45922 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_write"))) TS_ReplyShortChannelIdsEnd_write(uint64_t obj) {
45923 LDKReplyShortChannelIdsEnd obj_conv;
45924 obj_conv.inner = untag_ptr(obj);
45925 obj_conv.is_owned = ptr_is_owned(obj);
45926 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45927 obj_conv.is_owned = false;
45928 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
45929 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45930 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45931 CVec_u8Z_free(ret_var);
45935 uint64_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_read"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
45936 LDKu8slice ser_ref;
45937 ser_ref.datalen = ser->arr_len;
45938 ser_ref.data = ser->elems;
45939 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
45940 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
45942 return tag_ptr(ret_conv, true);
45945 int32_t __attribute__((export_name("TS_QueryChannelRange_end_blocknum"))) TS_QueryChannelRange_end_blocknum(uint64_t this_arg) {
45946 LDKQueryChannelRange this_arg_conv;
45947 this_arg_conv.inner = untag_ptr(this_arg);
45948 this_arg_conv.is_owned = ptr_is_owned(this_arg);
45949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45950 this_arg_conv.is_owned = false;
45951 int32_t ret_conv = QueryChannelRange_end_blocknum(&this_arg_conv);
45955 int8_tArray __attribute__((export_name("TS_QueryChannelRange_write"))) TS_QueryChannelRange_write(uint64_t obj) {
45956 LDKQueryChannelRange obj_conv;
45957 obj_conv.inner = untag_ptr(obj);
45958 obj_conv.is_owned = ptr_is_owned(obj);
45959 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45960 obj_conv.is_owned = false;
45961 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
45962 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45963 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45964 CVec_u8Z_free(ret_var);
45968 uint64_t __attribute__((export_name("TS_QueryChannelRange_read"))) TS_QueryChannelRange_read(int8_tArray ser) {
45969 LDKu8slice ser_ref;
45970 ser_ref.datalen = ser->arr_len;
45971 ser_ref.data = ser->elems;
45972 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
45973 *ret_conv = QueryChannelRange_read(ser_ref);
45975 return tag_ptr(ret_conv, true);
45978 uint64_t __attribute__((export_name("TS_ReplyChannelRange_read"))) TS_ReplyChannelRange_read(int8_tArray ser) {
45979 LDKu8slice ser_ref;
45980 ser_ref.datalen = ser->arr_len;
45981 ser_ref.data = ser->elems;
45982 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
45983 *ret_conv = ReplyChannelRange_read(ser_ref);
45985 return tag_ptr(ret_conv, true);
45988 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_write"))) TS_ReplyChannelRange_write(uint64_t obj) {
45989 LDKReplyChannelRange obj_conv;
45990 obj_conv.inner = untag_ptr(obj);
45991 obj_conv.is_owned = ptr_is_owned(obj);
45992 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
45993 obj_conv.is_owned = false;
45994 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
45995 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
45996 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
45997 CVec_u8Z_free(ret_var);
46001 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_write"))) TS_GossipTimestampFilter_write(uint64_t obj) {
46002 LDKGossipTimestampFilter obj_conv;
46003 obj_conv.inner = untag_ptr(obj);
46004 obj_conv.is_owned = ptr_is_owned(obj);
46005 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46006 obj_conv.is_owned = false;
46007 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
46008 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46009 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46010 CVec_u8Z_free(ret_var);
46014 uint64_t __attribute__((export_name("TS_GossipTimestampFilter_read"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
46015 LDKu8slice ser_ref;
46016 ser_ref.datalen = ser->arr_len;
46017 ser_ref.data = ser->elems;
46018 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
46019 *ret_conv = GossipTimestampFilter_read(ser_ref);
46021 return tag_ptr(ret_conv, true);
46024 void __attribute__((export_name("TS_CustomMessageHandler_free"))) TS_CustomMessageHandler_free(uint64_t this_ptr) {
46025 if (!ptr_is_owned(this_ptr)) return;
46026 void* this_ptr_ptr = untag_ptr(this_ptr);
46027 CHECK_ACCESS(this_ptr_ptr);
46028 LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(this_ptr_ptr);
46029 FREE(untag_ptr(this_ptr));
46030 CustomMessageHandler_free(this_ptr_conv);
46033 void __attribute__((export_name("TS_IgnoringMessageHandler_free"))) TS_IgnoringMessageHandler_free(uint64_t this_obj) {
46034 LDKIgnoringMessageHandler this_obj_conv;
46035 this_obj_conv.inner = untag_ptr(this_obj);
46036 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46037 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46038 IgnoringMessageHandler_free(this_obj_conv);
46041 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_new"))) TS_IgnoringMessageHandler_new() {
46042 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
46043 uint64_t ret_ref = 0;
46044 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46045 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46049 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_MessageSendEventsProvider"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
46050 LDKIgnoringMessageHandler this_arg_conv;
46051 this_arg_conv.inner = untag_ptr(this_arg);
46052 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46053 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46054 this_arg_conv.is_owned = false;
46055 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
46056 *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
46057 return tag_ptr(ret_ret, true);
46060 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_RoutingMessageHandler"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint64_t this_arg) {
46061 LDKIgnoringMessageHandler this_arg_conv;
46062 this_arg_conv.inner = untag_ptr(this_arg);
46063 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46064 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46065 this_arg_conv.is_owned = false;
46066 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
46067 *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
46068 return tag_ptr(ret_ret, true);
46071 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageProvider"))) TS_IgnoringMessageHandler_as_OnionMessageProvider(uint64_t this_arg) {
46072 LDKIgnoringMessageHandler this_arg_conv;
46073 this_arg_conv.inner = untag_ptr(this_arg);
46074 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46075 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46076 this_arg_conv.is_owned = false;
46077 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
46078 *ret_ret = IgnoringMessageHandler_as_OnionMessageProvider(&this_arg_conv);
46079 return tag_ptr(ret_ret, true);
46082 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OnionMessageHandler"))) TS_IgnoringMessageHandler_as_OnionMessageHandler(uint64_t this_arg) {
46083 LDKIgnoringMessageHandler this_arg_conv;
46084 this_arg_conv.inner = untag_ptr(this_arg);
46085 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46087 this_arg_conv.is_owned = false;
46088 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
46089 *ret_ret = IgnoringMessageHandler_as_OnionMessageHandler(&this_arg_conv);
46090 return tag_ptr(ret_ret, true);
46093 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_OffersMessageHandler"))) TS_IgnoringMessageHandler_as_OffersMessageHandler(uint64_t this_arg) {
46094 LDKIgnoringMessageHandler this_arg_conv;
46095 this_arg_conv.inner = untag_ptr(this_arg);
46096 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46098 this_arg_conv.is_owned = false;
46099 LDKOffersMessageHandler* ret_ret = MALLOC(sizeof(LDKOffersMessageHandler), "LDKOffersMessageHandler");
46100 *ret_ret = IgnoringMessageHandler_as_OffersMessageHandler(&this_arg_conv);
46101 return tag_ptr(ret_ret, true);
46104 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomOnionMessageHandler"))) TS_IgnoringMessageHandler_as_CustomOnionMessageHandler(uint64_t this_arg) {
46105 LDKIgnoringMessageHandler this_arg_conv;
46106 this_arg_conv.inner = untag_ptr(this_arg);
46107 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46109 this_arg_conv.is_owned = false;
46110 LDKCustomOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageHandler), "LDKCustomOnionMessageHandler");
46111 *ret_ret = IgnoringMessageHandler_as_CustomOnionMessageHandler(&this_arg_conv);
46112 return tag_ptr(ret_ret, true);
46115 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageReader"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint64_t this_arg) {
46116 LDKIgnoringMessageHandler this_arg_conv;
46117 this_arg_conv.inner = untag_ptr(this_arg);
46118 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46120 this_arg_conv.is_owned = false;
46121 LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
46122 *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
46123 return tag_ptr(ret_ret, true);
46126 uint64_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageHandler"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint64_t this_arg) {
46127 LDKIgnoringMessageHandler this_arg_conv;
46128 this_arg_conv.inner = untag_ptr(this_arg);
46129 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46131 this_arg_conv.is_owned = false;
46132 LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
46133 *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
46134 return tag_ptr(ret_ret, true);
46137 void __attribute__((export_name("TS_ErroringMessageHandler_free"))) TS_ErroringMessageHandler_free(uint64_t this_obj) {
46138 LDKErroringMessageHandler this_obj_conv;
46139 this_obj_conv.inner = untag_ptr(this_obj);
46140 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46142 ErroringMessageHandler_free(this_obj_conv);
46145 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_new"))) TS_ErroringMessageHandler_new() {
46146 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
46147 uint64_t ret_ref = 0;
46148 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46149 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46153 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_MessageSendEventsProvider"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint64_t this_arg) {
46154 LDKErroringMessageHandler this_arg_conv;
46155 this_arg_conv.inner = untag_ptr(this_arg);
46156 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46158 this_arg_conv.is_owned = false;
46159 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
46160 *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
46161 return tag_ptr(ret_ret, true);
46164 uint64_t __attribute__((export_name("TS_ErroringMessageHandler_as_ChannelMessageHandler"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint64_t this_arg) {
46165 LDKErroringMessageHandler this_arg_conv;
46166 this_arg_conv.inner = untag_ptr(this_arg);
46167 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46169 this_arg_conv.is_owned = false;
46170 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
46171 *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
46172 return tag_ptr(ret_ret, true);
46175 void __attribute__((export_name("TS_MessageHandler_free"))) TS_MessageHandler_free(uint64_t this_obj) {
46176 LDKMessageHandler this_obj_conv;
46177 this_obj_conv.inner = untag_ptr(this_obj);
46178 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46180 MessageHandler_free(this_obj_conv);
46183 uint64_t __attribute__((export_name("TS_MessageHandler_get_chan_handler"))) TS_MessageHandler_get_chan_handler(uint64_t this_ptr) {
46184 LDKMessageHandler this_ptr_conv;
46185 this_ptr_conv.inner = untag_ptr(this_ptr);
46186 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46188 this_ptr_conv.is_owned = false;
46189 // WARNING: This object doesn't live past this scope, needs clone!
46190 uint64_t ret_ret = tag_ptr(MessageHandler_get_chan_handler(&this_ptr_conv), false);
46194 void __attribute__((export_name("TS_MessageHandler_set_chan_handler"))) TS_MessageHandler_set_chan_handler(uint64_t this_ptr, uint64_t val) {
46195 LDKMessageHandler 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 void* val_ptr = untag_ptr(val);
46201 CHECK_ACCESS(val_ptr);
46202 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
46203 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
46204 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46205 LDKChannelMessageHandler_JCalls_cloned(&val_conv);
46207 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
46210 uint64_t __attribute__((export_name("TS_MessageHandler_get_route_handler"))) TS_MessageHandler_get_route_handler(uint64_t this_ptr) {
46211 LDKMessageHandler this_ptr_conv;
46212 this_ptr_conv.inner = untag_ptr(this_ptr);
46213 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46214 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46215 this_ptr_conv.is_owned = false;
46216 // WARNING: This object doesn't live past this scope, needs clone!
46217 uint64_t ret_ret = tag_ptr(MessageHandler_get_route_handler(&this_ptr_conv), false);
46221 void __attribute__((export_name("TS_MessageHandler_set_route_handler"))) TS_MessageHandler_set_route_handler(uint64_t this_ptr, uint64_t val) {
46222 LDKMessageHandler this_ptr_conv;
46223 this_ptr_conv.inner = untag_ptr(this_ptr);
46224 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46226 this_ptr_conv.is_owned = false;
46227 void* val_ptr = untag_ptr(val);
46228 CHECK_ACCESS(val_ptr);
46229 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
46230 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
46231 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46232 LDKRoutingMessageHandler_JCalls_cloned(&val_conv);
46234 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
46237 uint64_t __attribute__((export_name("TS_MessageHandler_get_onion_message_handler"))) TS_MessageHandler_get_onion_message_handler(uint64_t this_ptr) {
46238 LDKMessageHandler this_ptr_conv;
46239 this_ptr_conv.inner = untag_ptr(this_ptr);
46240 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46241 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46242 this_ptr_conv.is_owned = false;
46243 // WARNING: This object doesn't live past this scope, needs clone!
46244 uint64_t ret_ret = tag_ptr(MessageHandler_get_onion_message_handler(&this_ptr_conv), false);
46248 void __attribute__((export_name("TS_MessageHandler_set_onion_message_handler"))) TS_MessageHandler_set_onion_message_handler(uint64_t this_ptr, uint64_t val) {
46249 LDKMessageHandler this_ptr_conv;
46250 this_ptr_conv.inner = untag_ptr(this_ptr);
46251 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46253 this_ptr_conv.is_owned = false;
46254 void* val_ptr = untag_ptr(val);
46255 CHECK_ACCESS(val_ptr);
46256 LDKOnionMessageHandler val_conv = *(LDKOnionMessageHandler*)(val_ptr);
46257 if (val_conv.free == LDKOnionMessageHandler_JCalls_free) {
46258 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46259 LDKOnionMessageHandler_JCalls_cloned(&val_conv);
46261 MessageHandler_set_onion_message_handler(&this_ptr_conv, val_conv);
46264 uint64_t __attribute__((export_name("TS_MessageHandler_get_custom_message_handler"))) TS_MessageHandler_get_custom_message_handler(uint64_t this_ptr) {
46265 LDKMessageHandler this_ptr_conv;
46266 this_ptr_conv.inner = untag_ptr(this_ptr);
46267 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46269 this_ptr_conv.is_owned = false;
46270 // WARNING: This object doesn't live past this scope, needs clone!
46271 uint64_t ret_ret = tag_ptr(MessageHandler_get_custom_message_handler(&this_ptr_conv), false);
46275 void __attribute__((export_name("TS_MessageHandler_set_custom_message_handler"))) TS_MessageHandler_set_custom_message_handler(uint64_t this_ptr, uint64_t val) {
46276 LDKMessageHandler this_ptr_conv;
46277 this_ptr_conv.inner = untag_ptr(this_ptr);
46278 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46280 this_ptr_conv.is_owned = false;
46281 void* val_ptr = untag_ptr(val);
46282 CHECK_ACCESS(val_ptr);
46283 LDKCustomMessageHandler val_conv = *(LDKCustomMessageHandler*)(val_ptr);
46284 if (val_conv.free == LDKCustomMessageHandler_JCalls_free) {
46285 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46286 LDKCustomMessageHandler_JCalls_cloned(&val_conv);
46288 MessageHandler_set_custom_message_handler(&this_ptr_conv, val_conv);
46291 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, uint64_t custom_message_handler_arg) {
46292 void* chan_handler_arg_ptr = untag_ptr(chan_handler_arg);
46293 CHECK_ACCESS(chan_handler_arg_ptr);
46294 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
46295 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
46296 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46297 LDKChannelMessageHandler_JCalls_cloned(&chan_handler_arg_conv);
46299 void* route_handler_arg_ptr = untag_ptr(route_handler_arg);
46300 CHECK_ACCESS(route_handler_arg_ptr);
46301 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(route_handler_arg_ptr);
46302 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
46303 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46304 LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
46306 void* onion_message_handler_arg_ptr = untag_ptr(onion_message_handler_arg);
46307 CHECK_ACCESS(onion_message_handler_arg_ptr);
46308 LDKOnionMessageHandler onion_message_handler_arg_conv = *(LDKOnionMessageHandler*)(onion_message_handler_arg_ptr);
46309 if (onion_message_handler_arg_conv.free == LDKOnionMessageHandler_JCalls_free) {
46310 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46311 LDKOnionMessageHandler_JCalls_cloned(&onion_message_handler_arg_conv);
46313 void* custom_message_handler_arg_ptr = untag_ptr(custom_message_handler_arg);
46314 CHECK_ACCESS(custom_message_handler_arg_ptr);
46315 LDKCustomMessageHandler custom_message_handler_arg_conv = *(LDKCustomMessageHandler*)(custom_message_handler_arg_ptr);
46316 if (custom_message_handler_arg_conv.free == LDKCustomMessageHandler_JCalls_free) {
46317 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46318 LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_arg_conv);
46320 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv, onion_message_handler_arg_conv, custom_message_handler_arg_conv);
46321 uint64_t ret_ref = 0;
46322 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46323 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46327 static inline uint64_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
46328 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
46329 *ret_ret = SocketDescriptor_clone(arg);
46330 return tag_ptr(ret_ret, true);
46332 int64_t __attribute__((export_name("TS_SocketDescriptor_clone_ptr"))) TS_SocketDescriptor_clone_ptr(uint64_t arg) {
46333 void* arg_ptr = untag_ptr(arg);
46334 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
46335 LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
46336 int64_t ret_conv = SocketDescriptor_clone_ptr(arg_conv);
46340 uint64_t __attribute__((export_name("TS_SocketDescriptor_clone"))) TS_SocketDescriptor_clone(uint64_t orig) {
46341 void* orig_ptr = untag_ptr(orig);
46342 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
46343 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)orig_ptr;
46344 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
46345 *ret_ret = SocketDescriptor_clone(orig_conv);
46346 return tag_ptr(ret_ret, true);
46349 void __attribute__((export_name("TS_SocketDescriptor_free"))) TS_SocketDescriptor_free(uint64_t this_ptr) {
46350 if (!ptr_is_owned(this_ptr)) return;
46351 void* this_ptr_ptr = untag_ptr(this_ptr);
46352 CHECK_ACCESS(this_ptr_ptr);
46353 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(this_ptr_ptr);
46354 FREE(untag_ptr(this_ptr));
46355 SocketDescriptor_free(this_ptr_conv);
46358 void __attribute__((export_name("TS_PeerHandleError_free"))) TS_PeerHandleError_free(uint64_t this_obj) {
46359 LDKPeerHandleError this_obj_conv;
46360 this_obj_conv.inner = untag_ptr(this_obj);
46361 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46363 PeerHandleError_free(this_obj_conv);
46366 uint64_t __attribute__((export_name("TS_PeerHandleError_new"))) TS_PeerHandleError_new() {
46367 LDKPeerHandleError ret_var = PeerHandleError_new();
46368 uint64_t ret_ref = 0;
46369 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46370 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46374 static inline uint64_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
46375 LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
46376 uint64_t ret_ref = 0;
46377 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46378 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46381 int64_t __attribute__((export_name("TS_PeerHandleError_clone_ptr"))) TS_PeerHandleError_clone_ptr(uint64_t arg) {
46382 LDKPeerHandleError arg_conv;
46383 arg_conv.inner = untag_ptr(arg);
46384 arg_conv.is_owned = ptr_is_owned(arg);
46385 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46386 arg_conv.is_owned = false;
46387 int64_t ret_conv = PeerHandleError_clone_ptr(&arg_conv);
46391 uint64_t __attribute__((export_name("TS_PeerHandleError_clone"))) TS_PeerHandleError_clone(uint64_t orig) {
46392 LDKPeerHandleError orig_conv;
46393 orig_conv.inner = untag_ptr(orig);
46394 orig_conv.is_owned = ptr_is_owned(orig);
46395 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46396 orig_conv.is_owned = false;
46397 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
46398 uint64_t ret_ref = 0;
46399 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46400 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46404 void __attribute__((export_name("TS_PeerManager_free"))) TS_PeerManager_free(uint64_t this_obj) {
46405 LDKPeerManager this_obj_conv;
46406 this_obj_conv.inner = untag_ptr(this_obj);
46407 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46408 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46409 PeerManager_free(this_obj_conv);
46412 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 node_signer) {
46413 LDKMessageHandler message_handler_conv;
46414 message_handler_conv.inner = untag_ptr(message_handler);
46415 message_handler_conv.is_owned = ptr_is_owned(message_handler);
46416 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
46417 // WARNING: we need a move here but no clone is available for LDKMessageHandler
46419 uint8_t ephemeral_random_data_arr[32];
46420 CHECK(ephemeral_random_data->arr_len == 32);
46421 memcpy(ephemeral_random_data_arr, ephemeral_random_data->elems, 32); FREE(ephemeral_random_data);
46422 uint8_t (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
46423 void* logger_ptr = untag_ptr(logger);
46424 CHECK_ACCESS(logger_ptr);
46425 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
46426 if (logger_conv.free == LDKLogger_JCalls_free) {
46427 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46428 LDKLogger_JCalls_cloned(&logger_conv);
46430 void* node_signer_ptr = untag_ptr(node_signer);
46431 CHECK_ACCESS(node_signer_ptr);
46432 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
46433 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
46434 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46435 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
46437 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, current_time, ephemeral_random_data_ref, logger_conv, node_signer_conv);
46438 uint64_t ret_ref = 0;
46439 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46440 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46444 uint64_tArray __attribute__((export_name("TS_PeerManager_get_peer_node_ids"))) TS_PeerManager_get_peer_node_ids(uint64_t this_arg) {
46445 LDKPeerManager this_arg_conv;
46446 this_arg_conv.inner = untag_ptr(this_arg);
46447 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46448 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46449 this_arg_conv.is_owned = false;
46450 LDKCVec_C2Tuple_PublicKeyCOption_SocketAddressZZZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
46451 uint64_tArray ret_arr = NULL;
46452 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
46453 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
46454 for (size_t r = 0; r < ret_var.datalen; r++) {
46455 LDKC2Tuple_PublicKeyCOption_SocketAddressZZ* ret_conv_43_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyCOption_SocketAddressZZ), "LDKC2Tuple_PublicKeyCOption_SocketAddressZZ");
46456 *ret_conv_43_conv = ret_var.data[r];
46457 ret_arr_ptr[r] = tag_ptr(ret_conv_43_conv, true);
46460 FREE(ret_var.data);
46464 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) {
46465 LDKPeerManager this_arg_conv;
46466 this_arg_conv.inner = untag_ptr(this_arg);
46467 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46469 this_arg_conv.is_owned = false;
46470 LDKPublicKey their_node_id_ref;
46471 CHECK(their_node_id->arr_len == 33);
46472 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
46473 void* descriptor_ptr = untag_ptr(descriptor);
46474 CHECK_ACCESS(descriptor_ptr);
46475 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
46476 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
46477 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46478 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
46480 void* remote_network_address_ptr = untag_ptr(remote_network_address);
46481 CHECK_ACCESS(remote_network_address_ptr);
46482 LDKCOption_SocketAddressZ remote_network_address_conv = *(LDKCOption_SocketAddressZ*)(remote_network_address_ptr);
46483 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
46484 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv, remote_network_address_conv);
46485 return tag_ptr(ret_conv, true);
46488 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) {
46489 LDKPeerManager this_arg_conv;
46490 this_arg_conv.inner = untag_ptr(this_arg);
46491 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46492 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46493 this_arg_conv.is_owned = false;
46494 void* descriptor_ptr = untag_ptr(descriptor);
46495 CHECK_ACCESS(descriptor_ptr);
46496 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
46497 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
46498 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
46499 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
46501 void* remote_network_address_ptr = untag_ptr(remote_network_address);
46502 CHECK_ACCESS(remote_network_address_ptr);
46503 LDKCOption_SocketAddressZ remote_network_address_conv = *(LDKCOption_SocketAddressZ*)(remote_network_address_ptr);
46504 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
46505 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv, remote_network_address_conv);
46506 return tag_ptr(ret_conv, true);
46509 uint64_t __attribute__((export_name("TS_PeerManager_write_buffer_space_avail"))) TS_PeerManager_write_buffer_space_avail(uint64_t this_arg, uint64_t descriptor) {
46510 LDKPeerManager this_arg_conv;
46511 this_arg_conv.inner = untag_ptr(this_arg);
46512 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46514 this_arg_conv.is_owned = false;
46515 void* descriptor_ptr = untag_ptr(descriptor);
46516 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
46517 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
46518 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
46519 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
46520 return tag_ptr(ret_conv, true);
46523 uint64_t __attribute__((export_name("TS_PeerManager_read_event"))) TS_PeerManager_read_event(uint64_t this_arg, uint64_t peer_descriptor, int8_tArray data) {
46524 LDKPeerManager this_arg_conv;
46525 this_arg_conv.inner = untag_ptr(this_arg);
46526 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46528 this_arg_conv.is_owned = false;
46529 void* peer_descriptor_ptr = untag_ptr(peer_descriptor);
46530 if (ptr_is_owned(peer_descriptor)) { CHECK_ACCESS(peer_descriptor_ptr); }
46531 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
46532 LDKu8slice data_ref;
46533 data_ref.datalen = data->arr_len;
46534 data_ref.data = data->elems;
46535 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
46536 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
46538 return tag_ptr(ret_conv, true);
46541 void __attribute__((export_name("TS_PeerManager_process_events"))) TS_PeerManager_process_events(uint64_t this_arg) {
46542 LDKPeerManager this_arg_conv;
46543 this_arg_conv.inner = untag_ptr(this_arg);
46544 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46546 this_arg_conv.is_owned = false;
46547 PeerManager_process_events(&this_arg_conv);
46550 void __attribute__((export_name("TS_PeerManager_socket_disconnected"))) TS_PeerManager_socket_disconnected(uint64_t this_arg, uint64_t descriptor) {
46551 LDKPeerManager this_arg_conv;
46552 this_arg_conv.inner = untag_ptr(this_arg);
46553 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46555 this_arg_conv.is_owned = false;
46556 void* descriptor_ptr = untag_ptr(descriptor);
46557 if (ptr_is_owned(descriptor)) { CHECK_ACCESS(descriptor_ptr); }
46558 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
46559 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
46562 void __attribute__((export_name("TS_PeerManager_disconnect_by_node_id"))) TS_PeerManager_disconnect_by_node_id(uint64_t this_arg, int8_tArray node_id) {
46563 LDKPeerManager this_arg_conv;
46564 this_arg_conv.inner = untag_ptr(this_arg);
46565 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46567 this_arg_conv.is_owned = false;
46568 LDKPublicKey node_id_ref;
46569 CHECK(node_id->arr_len == 33);
46570 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
46571 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref);
46574 void __attribute__((export_name("TS_PeerManager_disconnect_all_peers"))) TS_PeerManager_disconnect_all_peers(uint64_t this_arg) {
46575 LDKPeerManager this_arg_conv;
46576 this_arg_conv.inner = untag_ptr(this_arg);
46577 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46578 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46579 this_arg_conv.is_owned = false;
46580 PeerManager_disconnect_all_peers(&this_arg_conv);
46583 void __attribute__((export_name("TS_PeerManager_timer_tick_occurred"))) TS_PeerManager_timer_tick_occurred(uint64_t this_arg) {
46584 LDKPeerManager this_arg_conv;
46585 this_arg_conv.inner = untag_ptr(this_arg);
46586 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46588 this_arg_conv.is_owned = false;
46589 PeerManager_timer_tick_occurred(&this_arg_conv);
46592 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) {
46593 LDKPeerManager this_arg_conv;
46594 this_arg_conv.inner = untag_ptr(this_arg);
46595 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46597 this_arg_conv.is_owned = false;
46598 LDKThreeBytes rgb_ref;
46599 CHECK(rgb->arr_len == 3);
46600 memcpy(rgb_ref.data, rgb->elems, 3); FREE(rgb);
46601 LDKThirtyTwoBytes alias_ref;
46602 CHECK(alias->arr_len == 32);
46603 memcpy(alias_ref.data, alias->elems, 32); FREE(alias);
46604 LDKCVec_SocketAddressZ addresses_constr;
46605 addresses_constr.datalen = addresses->arr_len;
46606 if (addresses_constr.datalen > 0)
46607 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKSocketAddress), "LDKCVec_SocketAddressZ Elements");
46609 addresses_constr.data = NULL;
46610 uint64_t* addresses_vals = addresses->elems;
46611 for (size_t p = 0; p < addresses_constr.datalen; p++) {
46612 uint64_t addresses_conv_15 = addresses_vals[p];
46613 void* addresses_conv_15_ptr = untag_ptr(addresses_conv_15);
46614 CHECK_ACCESS(addresses_conv_15_ptr);
46615 LDKSocketAddress addresses_conv_15_conv = *(LDKSocketAddress*)(addresses_conv_15_ptr);
46616 addresses_constr.data[p] = addresses_conv_15_conv;
46619 PeerManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
46622 int64_t __attribute__((export_name("TS_htlc_success_tx_weight"))) TS_htlc_success_tx_weight(uint64_t channel_type_features) {
46623 LDKChannelTypeFeatures channel_type_features_conv;
46624 channel_type_features_conv.inner = untag_ptr(channel_type_features);
46625 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
46626 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
46627 channel_type_features_conv.is_owned = false;
46628 int64_t ret_conv = htlc_success_tx_weight(&channel_type_features_conv);
46632 int64_t __attribute__((export_name("TS_htlc_timeout_tx_weight"))) TS_htlc_timeout_tx_weight(uint64_t channel_type_features) {
46633 LDKChannelTypeFeatures channel_type_features_conv;
46634 channel_type_features_conv.inner = untag_ptr(channel_type_features);
46635 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
46636 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
46637 channel_type_features_conv.is_owned = false;
46638 int64_t ret_conv = htlc_timeout_tx_weight(&channel_type_features_conv);
46642 uint32_t __attribute__((export_name("TS_HTLCClaim_clone"))) TS_HTLCClaim_clone(uint64_t orig) {
46643 LDKHTLCClaim* orig_conv = (LDKHTLCClaim*)untag_ptr(orig);
46644 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_clone(orig_conv));
46648 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_timeout"))) TS_HTLCClaim_offered_timeout() {
46649 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_timeout());
46653 uint32_t __attribute__((export_name("TS_HTLCClaim_offered_preimage"))) TS_HTLCClaim_offered_preimage() {
46654 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_offered_preimage());
46658 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_timeout"))) TS_HTLCClaim_accepted_timeout() {
46659 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_timeout());
46663 uint32_t __attribute__((export_name("TS_HTLCClaim_accepted_preimage"))) TS_HTLCClaim_accepted_preimage() {
46664 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_accepted_preimage());
46668 uint32_t __attribute__((export_name("TS_HTLCClaim_revocation"))) TS_HTLCClaim_revocation() {
46669 uint32_t ret_conv = LDKHTLCClaim_to_js(HTLCClaim_revocation());
46673 jboolean __attribute__((export_name("TS_HTLCClaim_eq"))) TS_HTLCClaim_eq(uint64_t a, uint64_t b) {
46674 LDKHTLCClaim* a_conv = (LDKHTLCClaim*)untag_ptr(a);
46675 LDKHTLCClaim* b_conv = (LDKHTLCClaim*)untag_ptr(b);
46676 jboolean ret_conv = HTLCClaim_eq(a_conv, b_conv);
46680 uint64_t __attribute__((export_name("TS_HTLCClaim_from_witness"))) TS_HTLCClaim_from_witness(int8_tArray witness) {
46681 LDKWitness witness_ref;
46682 witness_ref.datalen = witness->arr_len;
46683 witness_ref.data = MALLOC(witness_ref.datalen, "LDKWitness Bytes");
46684 memcpy(witness_ref.data, witness->elems, witness_ref.datalen); FREE(witness);
46685 witness_ref.data_is_owned = true;
46686 LDKCOption_HTLCClaimZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCClaimZ), "LDKCOption_HTLCClaimZ");
46687 *ret_copy = HTLCClaim_from_witness(witness_ref);
46688 uint64_t ret_ref = tag_ptr(ret_copy, true);
46692 int8_tArray __attribute__((export_name("TS_build_commitment_secret"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
46693 uint8_t commitment_seed_arr[32];
46694 CHECK(commitment_seed->arr_len == 32);
46695 memcpy(commitment_seed_arr, commitment_seed->elems, 32); FREE(commitment_seed);
46696 uint8_t (*commitment_seed_ref)[32] = &commitment_seed_arr;
46697 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
46698 memcpy(ret_arr->elems, build_commitment_secret(commitment_seed_ref, idx).data, 32);
46702 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) {
46703 LDKCVec_u8Z to_holder_script_ref;
46704 to_holder_script_ref.datalen = to_holder_script->arr_len;
46705 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
46706 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
46707 LDKCVec_u8Z to_counterparty_script_ref;
46708 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
46709 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
46710 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
46711 LDKOutPoint funding_outpoint_conv;
46712 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
46713 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
46714 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
46715 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
46716 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);
46717 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46718 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46719 Transaction_free(ret_var);
46723 void __attribute__((export_name("TS_CounterpartyCommitmentSecrets_free"))) TS_CounterpartyCommitmentSecrets_free(uint64_t this_obj) {
46724 LDKCounterpartyCommitmentSecrets this_obj_conv;
46725 this_obj_conv.inner = untag_ptr(this_obj);
46726 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46728 CounterpartyCommitmentSecrets_free(this_obj_conv);
46731 static inline uint64_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg) {
46732 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(arg);
46733 uint64_t ret_ref = 0;
46734 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46735 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46738 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone_ptr"))) TS_CounterpartyCommitmentSecrets_clone_ptr(uint64_t arg) {
46739 LDKCounterpartyCommitmentSecrets arg_conv;
46740 arg_conv.inner = untag_ptr(arg);
46741 arg_conv.is_owned = ptr_is_owned(arg);
46742 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
46743 arg_conv.is_owned = false;
46744 int64_t ret_conv = CounterpartyCommitmentSecrets_clone_ptr(&arg_conv);
46748 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone"))) TS_CounterpartyCommitmentSecrets_clone(uint64_t orig) {
46749 LDKCounterpartyCommitmentSecrets orig_conv;
46750 orig_conv.inner = untag_ptr(orig);
46751 orig_conv.is_owned = ptr_is_owned(orig);
46752 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
46753 orig_conv.is_owned = false;
46754 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(&orig_conv);
46755 uint64_t ret_ref = 0;
46756 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46757 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46761 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_new"))) TS_CounterpartyCommitmentSecrets_new() {
46762 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_new();
46763 uint64_t ret_ref = 0;
46764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
46765 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
46769 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_min_seen_secret"))) TS_CounterpartyCommitmentSecrets_get_min_seen_secret(uint64_t this_arg) {
46770 LDKCounterpartyCommitmentSecrets this_arg_conv;
46771 this_arg_conv.inner = untag_ptr(this_arg);
46772 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46774 this_arg_conv.is_owned = false;
46775 int64_t ret_conv = CounterpartyCommitmentSecrets_get_min_seen_secret(&this_arg_conv);
46779 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_provide_secret"))) TS_CounterpartyCommitmentSecrets_provide_secret(uint64_t this_arg, int64_t idx, int8_tArray secret) {
46780 LDKCounterpartyCommitmentSecrets this_arg_conv;
46781 this_arg_conv.inner = untag_ptr(this_arg);
46782 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46783 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46784 this_arg_conv.is_owned = false;
46785 LDKThirtyTwoBytes secret_ref;
46786 CHECK(secret->arr_len == 32);
46787 memcpy(secret_ref.data, secret->elems, 32); FREE(secret);
46788 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
46789 *ret_conv = CounterpartyCommitmentSecrets_provide_secret(&this_arg_conv, idx, secret_ref);
46790 return tag_ptr(ret_conv, true);
46793 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_secret"))) TS_CounterpartyCommitmentSecrets_get_secret(uint64_t this_arg, int64_t idx) {
46794 LDKCounterpartyCommitmentSecrets this_arg_conv;
46795 this_arg_conv.inner = untag_ptr(this_arg);
46796 this_arg_conv.is_owned = ptr_is_owned(this_arg);
46797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
46798 this_arg_conv.is_owned = false;
46799 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
46800 memcpy(ret_arr->elems, CounterpartyCommitmentSecrets_get_secret(&this_arg_conv, idx).data, 32);
46804 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_write"))) TS_CounterpartyCommitmentSecrets_write(uint64_t obj) {
46805 LDKCounterpartyCommitmentSecrets obj_conv;
46806 obj_conv.inner = untag_ptr(obj);
46807 obj_conv.is_owned = ptr_is_owned(obj);
46808 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
46809 obj_conv.is_owned = false;
46810 LDKCVec_u8Z ret_var = CounterpartyCommitmentSecrets_write(&obj_conv);
46811 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
46812 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
46813 CVec_u8Z_free(ret_var);
46817 uint64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_read"))) TS_CounterpartyCommitmentSecrets_read(int8_tArray ser) {
46818 LDKu8slice ser_ref;
46819 ser_ref.datalen = ser->arr_len;
46820 ser_ref.data = ser->elems;
46821 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
46822 *ret_conv = CounterpartyCommitmentSecrets_read(ser_ref);
46824 return tag_ptr(ret_conv, true);
46827 int8_tArray __attribute__((export_name("TS_derive_private_key"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
46828 LDKPublicKey per_commitment_point_ref;
46829 CHECK(per_commitment_point->arr_len == 33);
46830 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
46831 uint8_t base_secret_arr[32];
46832 CHECK(base_secret->arr_len == 32);
46833 memcpy(base_secret_arr, base_secret->elems, 32); FREE(base_secret);
46834 uint8_t (*base_secret_ref)[32] = &base_secret_arr;
46835 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
46836 memcpy(ret_arr->elems, derive_private_key(per_commitment_point_ref, base_secret_ref).bytes, 32);
46840 int8_tArray __attribute__((export_name("TS_derive_public_key"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
46841 LDKPublicKey per_commitment_point_ref;
46842 CHECK(per_commitment_point->arr_len == 33);
46843 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
46844 LDKPublicKey base_point_ref;
46845 CHECK(base_point->arr_len == 33);
46846 memcpy(base_point_ref.compressed_form, base_point->elems, 33); FREE(base_point);
46847 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46848 memcpy(ret_arr->elems, derive_public_key(per_commitment_point_ref, base_point_ref).compressed_form, 33);
46852 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) {
46853 uint8_t per_commitment_secret_arr[32];
46854 CHECK(per_commitment_secret->arr_len == 32);
46855 memcpy(per_commitment_secret_arr, per_commitment_secret->elems, 32); FREE(per_commitment_secret);
46856 uint8_t (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
46857 uint8_t countersignatory_revocation_base_secret_arr[32];
46858 CHECK(countersignatory_revocation_base_secret->arr_len == 32);
46859 memcpy(countersignatory_revocation_base_secret_arr, countersignatory_revocation_base_secret->elems, 32); FREE(countersignatory_revocation_base_secret);
46860 uint8_t (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
46861 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
46862 memcpy(ret_arr->elems, derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref).bytes, 32);
46866 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) {
46867 LDKPublicKey per_commitment_point_ref;
46868 CHECK(per_commitment_point->arr_len == 33);
46869 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
46870 LDKPublicKey countersignatory_revocation_base_point_ref;
46871 CHECK(countersignatory_revocation_base_point->arr_len == 33);
46872 memcpy(countersignatory_revocation_base_point_ref.compressed_form, countersignatory_revocation_base_point->elems, 33); FREE(countersignatory_revocation_base_point);
46873 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46874 memcpy(ret_arr->elems, derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref).compressed_form, 33);
46878 void __attribute__((export_name("TS_TxCreationKeys_free"))) TS_TxCreationKeys_free(uint64_t this_obj) {
46879 LDKTxCreationKeys this_obj_conv;
46880 this_obj_conv.inner = untag_ptr(this_obj);
46881 this_obj_conv.is_owned = ptr_is_owned(this_obj);
46882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
46883 TxCreationKeys_free(this_obj_conv);
46886 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_per_commitment_point"))) TS_TxCreationKeys_get_per_commitment_point(uint64_t this_ptr) {
46887 LDKTxCreationKeys this_ptr_conv;
46888 this_ptr_conv.inner = untag_ptr(this_ptr);
46889 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46891 this_ptr_conv.is_owned = false;
46892 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46893 memcpy(ret_arr->elems, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
46897 void __attribute__((export_name("TS_TxCreationKeys_set_per_commitment_point"))) TS_TxCreationKeys_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
46898 LDKTxCreationKeys this_ptr_conv;
46899 this_ptr_conv.inner = untag_ptr(this_ptr);
46900 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46901 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46902 this_ptr_conv.is_owned = false;
46903 LDKPublicKey val_ref;
46904 CHECK(val->arr_len == 33);
46905 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46906 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
46909 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_revocation_key"))) TS_TxCreationKeys_get_revocation_key(uint64_t this_ptr) {
46910 LDKTxCreationKeys this_ptr_conv;
46911 this_ptr_conv.inner = untag_ptr(this_ptr);
46912 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46913 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46914 this_ptr_conv.is_owned = false;
46915 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46916 memcpy(ret_arr->elems, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
46920 void __attribute__((export_name("TS_TxCreationKeys_set_revocation_key"))) TS_TxCreationKeys_set_revocation_key(uint64_t this_ptr, int8_tArray val) {
46921 LDKTxCreationKeys this_ptr_conv;
46922 this_ptr_conv.inner = untag_ptr(this_ptr);
46923 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46925 this_ptr_conv.is_owned = false;
46926 LDKPublicKey val_ref;
46927 CHECK(val->arr_len == 33);
46928 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46929 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
46932 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_htlc_key"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint64_t this_ptr) {
46933 LDKTxCreationKeys this_ptr_conv;
46934 this_ptr_conv.inner = untag_ptr(this_ptr);
46935 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46936 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46937 this_ptr_conv.is_owned = false;
46938 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46939 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
46943 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_htlc_key"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint64_t this_ptr, int8_tArray val) {
46944 LDKTxCreationKeys this_ptr_conv;
46945 this_ptr_conv.inner = untag_ptr(this_ptr);
46946 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46948 this_ptr_conv.is_owned = false;
46949 LDKPublicKey val_ref;
46950 CHECK(val->arr_len == 33);
46951 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46952 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
46955 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_countersignatory_htlc_key"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint64_t this_ptr) {
46956 LDKTxCreationKeys this_ptr_conv;
46957 this_ptr_conv.inner = untag_ptr(this_ptr);
46958 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46959 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46960 this_ptr_conv.is_owned = false;
46961 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46962 memcpy(ret_arr->elems, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
46966 void __attribute__((export_name("TS_TxCreationKeys_set_countersignatory_htlc_key"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint64_t this_ptr, int8_tArray val) {
46967 LDKTxCreationKeys this_ptr_conv;
46968 this_ptr_conv.inner = untag_ptr(this_ptr);
46969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46971 this_ptr_conv.is_owned = false;
46972 LDKPublicKey val_ref;
46973 CHECK(val->arr_len == 33);
46974 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46975 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
46978 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint64_t this_ptr) {
46979 LDKTxCreationKeys this_ptr_conv;
46980 this_ptr_conv.inner = untag_ptr(this_ptr);
46981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46983 this_ptr_conv.is_owned = false;
46984 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
46985 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
46989 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) {
46990 LDKTxCreationKeys this_ptr_conv;
46991 this_ptr_conv.inner = untag_ptr(this_ptr);
46992 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
46993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
46994 this_ptr_conv.is_owned = false;
46995 LDKPublicKey val_ref;
46996 CHECK(val->arr_len == 33);
46997 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
46998 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
47001 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) {
47002 LDKPublicKey per_commitment_point_arg_ref;
47003 CHECK(per_commitment_point_arg->arr_len == 33);
47004 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
47005 LDKPublicKey revocation_key_arg_ref;
47006 CHECK(revocation_key_arg->arr_len == 33);
47007 memcpy(revocation_key_arg_ref.compressed_form, revocation_key_arg->elems, 33); FREE(revocation_key_arg);
47008 LDKPublicKey broadcaster_htlc_key_arg_ref;
47009 CHECK(broadcaster_htlc_key_arg->arr_len == 33);
47010 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, broadcaster_htlc_key_arg->elems, 33); FREE(broadcaster_htlc_key_arg);
47011 LDKPublicKey countersignatory_htlc_key_arg_ref;
47012 CHECK(countersignatory_htlc_key_arg->arr_len == 33);
47013 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, countersignatory_htlc_key_arg->elems, 33); FREE(countersignatory_htlc_key_arg);
47014 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
47015 CHECK(broadcaster_delayed_payment_key_arg->arr_len == 33);
47016 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, broadcaster_delayed_payment_key_arg->elems, 33); FREE(broadcaster_delayed_payment_key_arg);
47017 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);
47018 uint64_t ret_ref = 0;
47019 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47020 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47024 jboolean __attribute__((export_name("TS_TxCreationKeys_eq"))) TS_TxCreationKeys_eq(uint64_t a, uint64_t b) {
47025 LDKTxCreationKeys a_conv;
47026 a_conv.inner = untag_ptr(a);
47027 a_conv.is_owned = ptr_is_owned(a);
47028 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47029 a_conv.is_owned = false;
47030 LDKTxCreationKeys b_conv;
47031 b_conv.inner = untag_ptr(b);
47032 b_conv.is_owned = ptr_is_owned(b);
47033 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47034 b_conv.is_owned = false;
47035 jboolean ret_conv = TxCreationKeys_eq(&a_conv, &b_conv);
47039 static inline uint64_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
47040 LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
47041 uint64_t ret_ref = 0;
47042 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47043 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47046 int64_t __attribute__((export_name("TS_TxCreationKeys_clone_ptr"))) TS_TxCreationKeys_clone_ptr(uint64_t arg) {
47047 LDKTxCreationKeys arg_conv;
47048 arg_conv.inner = untag_ptr(arg);
47049 arg_conv.is_owned = ptr_is_owned(arg);
47050 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47051 arg_conv.is_owned = false;
47052 int64_t ret_conv = TxCreationKeys_clone_ptr(&arg_conv);
47056 uint64_t __attribute__((export_name("TS_TxCreationKeys_clone"))) TS_TxCreationKeys_clone(uint64_t orig) {
47057 LDKTxCreationKeys orig_conv;
47058 orig_conv.inner = untag_ptr(orig);
47059 orig_conv.is_owned = ptr_is_owned(orig);
47060 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47061 orig_conv.is_owned = false;
47062 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
47063 uint64_t ret_ref = 0;
47064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47065 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47069 int8_tArray __attribute__((export_name("TS_TxCreationKeys_write"))) TS_TxCreationKeys_write(uint64_t obj) {
47070 LDKTxCreationKeys obj_conv;
47071 obj_conv.inner = untag_ptr(obj);
47072 obj_conv.is_owned = ptr_is_owned(obj);
47073 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47074 obj_conv.is_owned = false;
47075 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
47076 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47077 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47078 CVec_u8Z_free(ret_var);
47082 uint64_t __attribute__((export_name("TS_TxCreationKeys_read"))) TS_TxCreationKeys_read(int8_tArray ser) {
47083 LDKu8slice ser_ref;
47084 ser_ref.datalen = ser->arr_len;
47085 ser_ref.data = ser->elems;
47086 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
47087 *ret_conv = TxCreationKeys_read(ser_ref);
47089 return tag_ptr(ret_conv, true);
47092 void __attribute__((export_name("TS_ChannelPublicKeys_free"))) TS_ChannelPublicKeys_free(uint64_t this_obj) {
47093 LDKChannelPublicKeys this_obj_conv;
47094 this_obj_conv.inner = untag_ptr(this_obj);
47095 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47096 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47097 ChannelPublicKeys_free(this_obj_conv);
47100 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_funding_pubkey"))) TS_ChannelPublicKeys_get_funding_pubkey(uint64_t this_ptr) {
47101 LDKChannelPublicKeys this_ptr_conv;
47102 this_ptr_conv.inner = untag_ptr(this_ptr);
47103 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47105 this_ptr_conv.is_owned = false;
47106 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47107 memcpy(ret_arr->elems, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
47111 void __attribute__((export_name("TS_ChannelPublicKeys_set_funding_pubkey"))) TS_ChannelPublicKeys_set_funding_pubkey(uint64_t this_ptr, int8_tArray val) {
47112 LDKChannelPublicKeys this_ptr_conv;
47113 this_ptr_conv.inner = untag_ptr(this_ptr);
47114 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47116 this_ptr_conv.is_owned = false;
47117 LDKPublicKey val_ref;
47118 CHECK(val->arr_len == 33);
47119 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47120 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
47123 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_revocation_basepoint"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint64_t this_ptr) {
47124 LDKChannelPublicKeys this_ptr_conv;
47125 this_ptr_conv.inner = untag_ptr(this_ptr);
47126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47128 this_ptr_conv.is_owned = false;
47129 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47130 memcpy(ret_arr->elems, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
47134 void __attribute__((export_name("TS_ChannelPublicKeys_set_revocation_basepoint"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint64_t this_ptr, int8_tArray val) {
47135 LDKChannelPublicKeys this_ptr_conv;
47136 this_ptr_conv.inner = untag_ptr(this_ptr);
47137 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47139 this_ptr_conv.is_owned = false;
47140 LDKPublicKey val_ref;
47141 CHECK(val->arr_len == 33);
47142 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47143 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
47146 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_payment_point"))) TS_ChannelPublicKeys_get_payment_point(uint64_t this_ptr) {
47147 LDKChannelPublicKeys this_ptr_conv;
47148 this_ptr_conv.inner = untag_ptr(this_ptr);
47149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47151 this_ptr_conv.is_owned = false;
47152 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47153 memcpy(ret_arr->elems, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
47157 void __attribute__((export_name("TS_ChannelPublicKeys_set_payment_point"))) TS_ChannelPublicKeys_set_payment_point(uint64_t this_ptr, int8_tArray val) {
47158 LDKChannelPublicKeys this_ptr_conv;
47159 this_ptr_conv.inner = untag_ptr(this_ptr);
47160 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47161 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47162 this_ptr_conv.is_owned = false;
47163 LDKPublicKey val_ref;
47164 CHECK(val->arr_len == 33);
47165 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47166 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
47169 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_delayed_payment_basepoint"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint64_t this_ptr) {
47170 LDKChannelPublicKeys this_ptr_conv;
47171 this_ptr_conv.inner = untag_ptr(this_ptr);
47172 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47174 this_ptr_conv.is_owned = false;
47175 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47176 memcpy(ret_arr->elems, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
47180 void __attribute__((export_name("TS_ChannelPublicKeys_set_delayed_payment_basepoint"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint64_t this_ptr, int8_tArray val) {
47181 LDKChannelPublicKeys 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 LDKPublicKey val_ref;
47187 CHECK(val->arr_len == 33);
47188 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47189 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
47192 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_htlc_basepoint"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint64_t this_ptr) {
47193 LDKChannelPublicKeys this_ptr_conv;
47194 this_ptr_conv.inner = untag_ptr(this_ptr);
47195 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47196 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47197 this_ptr_conv.is_owned = false;
47198 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
47199 memcpy(ret_arr->elems, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
47203 void __attribute__((export_name("TS_ChannelPublicKeys_set_htlc_basepoint"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint64_t this_ptr, int8_tArray val) {
47204 LDKChannelPublicKeys this_ptr_conv;
47205 this_ptr_conv.inner = untag_ptr(this_ptr);
47206 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47208 this_ptr_conv.is_owned = false;
47209 LDKPublicKey val_ref;
47210 CHECK(val->arr_len == 33);
47211 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
47212 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
47215 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) {
47216 LDKPublicKey funding_pubkey_arg_ref;
47217 CHECK(funding_pubkey_arg->arr_len == 33);
47218 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
47219 LDKPublicKey revocation_basepoint_arg_ref;
47220 CHECK(revocation_basepoint_arg->arr_len == 33);
47221 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
47222 LDKPublicKey payment_point_arg_ref;
47223 CHECK(payment_point_arg->arr_len == 33);
47224 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
47225 LDKPublicKey delayed_payment_basepoint_arg_ref;
47226 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
47227 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
47228 LDKPublicKey htlc_basepoint_arg_ref;
47229 CHECK(htlc_basepoint_arg->arr_len == 33);
47230 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
47231 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);
47232 uint64_t ret_ref = 0;
47233 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47234 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47238 static inline uint64_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
47239 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
47240 uint64_t ret_ref = 0;
47241 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47242 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47245 int64_t __attribute__((export_name("TS_ChannelPublicKeys_clone_ptr"))) TS_ChannelPublicKeys_clone_ptr(uint64_t arg) {
47246 LDKChannelPublicKeys arg_conv;
47247 arg_conv.inner = untag_ptr(arg);
47248 arg_conv.is_owned = ptr_is_owned(arg);
47249 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47250 arg_conv.is_owned = false;
47251 int64_t ret_conv = ChannelPublicKeys_clone_ptr(&arg_conv);
47255 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_clone"))) TS_ChannelPublicKeys_clone(uint64_t orig) {
47256 LDKChannelPublicKeys orig_conv;
47257 orig_conv.inner = untag_ptr(orig);
47258 orig_conv.is_owned = ptr_is_owned(orig);
47259 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47260 orig_conv.is_owned = false;
47261 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
47262 uint64_t ret_ref = 0;
47263 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47264 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47268 int64_t __attribute__((export_name("TS_ChannelPublicKeys_hash"))) TS_ChannelPublicKeys_hash(uint64_t o) {
47269 LDKChannelPublicKeys o_conv;
47270 o_conv.inner = untag_ptr(o);
47271 o_conv.is_owned = ptr_is_owned(o);
47272 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47273 o_conv.is_owned = false;
47274 int64_t ret_conv = ChannelPublicKeys_hash(&o_conv);
47278 jboolean __attribute__((export_name("TS_ChannelPublicKeys_eq"))) TS_ChannelPublicKeys_eq(uint64_t a, uint64_t b) {
47279 LDKChannelPublicKeys a_conv;
47280 a_conv.inner = untag_ptr(a);
47281 a_conv.is_owned = ptr_is_owned(a);
47282 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47283 a_conv.is_owned = false;
47284 LDKChannelPublicKeys b_conv;
47285 b_conv.inner = untag_ptr(b);
47286 b_conv.is_owned = ptr_is_owned(b);
47287 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47288 b_conv.is_owned = false;
47289 jboolean ret_conv = ChannelPublicKeys_eq(&a_conv, &b_conv);
47293 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_write"))) TS_ChannelPublicKeys_write(uint64_t obj) {
47294 LDKChannelPublicKeys obj_conv;
47295 obj_conv.inner = untag_ptr(obj);
47296 obj_conv.is_owned = ptr_is_owned(obj);
47297 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47298 obj_conv.is_owned = false;
47299 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
47300 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47301 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47302 CVec_u8Z_free(ret_var);
47306 uint64_t __attribute__((export_name("TS_ChannelPublicKeys_read"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
47307 LDKu8slice ser_ref;
47308 ser_ref.datalen = ser->arr_len;
47309 ser_ref.data = ser->elems;
47310 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
47311 *ret_conv = ChannelPublicKeys_read(ser_ref);
47313 return tag_ptr(ret_conv, true);
47316 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) {
47317 LDKPublicKey per_commitment_point_ref;
47318 CHECK(per_commitment_point->arr_len == 33);
47319 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
47320 LDKPublicKey broadcaster_delayed_payment_base_ref;
47321 CHECK(broadcaster_delayed_payment_base->arr_len == 33);
47322 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, broadcaster_delayed_payment_base->elems, 33); FREE(broadcaster_delayed_payment_base);
47323 LDKPublicKey broadcaster_htlc_base_ref;
47324 CHECK(broadcaster_htlc_base->arr_len == 33);
47325 memcpy(broadcaster_htlc_base_ref.compressed_form, broadcaster_htlc_base->elems, 33); FREE(broadcaster_htlc_base);
47326 LDKPublicKey countersignatory_revocation_base_ref;
47327 CHECK(countersignatory_revocation_base->arr_len == 33);
47328 memcpy(countersignatory_revocation_base_ref.compressed_form, countersignatory_revocation_base->elems, 33); FREE(countersignatory_revocation_base);
47329 LDKPublicKey countersignatory_htlc_base_ref;
47330 CHECK(countersignatory_htlc_base->arr_len == 33);
47331 memcpy(countersignatory_htlc_base_ref.compressed_form, countersignatory_htlc_base->elems, 33); FREE(countersignatory_htlc_base);
47332 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);
47333 uint64_t ret_ref = 0;
47334 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47335 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47339 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) {
47340 LDKPublicKey per_commitment_point_ref;
47341 CHECK(per_commitment_point->arr_len == 33);
47342 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
47343 LDKChannelPublicKeys broadcaster_keys_conv;
47344 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
47345 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
47346 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
47347 broadcaster_keys_conv.is_owned = false;
47348 LDKChannelPublicKeys countersignatory_keys_conv;
47349 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
47350 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
47351 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
47352 countersignatory_keys_conv.is_owned = false;
47353 LDKTxCreationKeys ret_var = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
47354 uint64_t ret_ref = 0;
47355 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47356 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47360 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) {
47361 LDKPublicKey revocation_key_ref;
47362 CHECK(revocation_key->arr_len == 33);
47363 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
47364 LDKPublicKey broadcaster_delayed_payment_key_ref;
47365 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
47366 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
47367 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
47368 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47369 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47370 CVec_u8Z_free(ret_var);
47374 int8_tArray __attribute__((export_name("TS_get_counterparty_payment_script"))) TS_get_counterparty_payment_script(uint64_t channel_type_features, int8_tArray payment_key) {
47375 LDKChannelTypeFeatures channel_type_features_conv;
47376 channel_type_features_conv.inner = untag_ptr(channel_type_features);
47377 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
47378 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
47379 channel_type_features_conv.is_owned = false;
47380 LDKPublicKey payment_key_ref;
47381 CHECK(payment_key->arr_len == 33);
47382 memcpy(payment_key_ref.compressed_form, payment_key->elems, 33); FREE(payment_key);
47383 LDKCVec_u8Z ret_var = get_counterparty_payment_script(&channel_type_features_conv, payment_key_ref);
47384 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47385 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47386 CVec_u8Z_free(ret_var);
47390 void __attribute__((export_name("TS_HTLCOutputInCommitment_free"))) TS_HTLCOutputInCommitment_free(uint64_t this_obj) {
47391 LDKHTLCOutputInCommitment this_obj_conv;
47392 this_obj_conv.inner = untag_ptr(this_obj);
47393 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47395 HTLCOutputInCommitment_free(this_obj_conv);
47398 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_get_offered"))) TS_HTLCOutputInCommitment_get_offered(uint64_t this_ptr) {
47399 LDKHTLCOutputInCommitment this_ptr_conv;
47400 this_ptr_conv.inner = untag_ptr(this_ptr);
47401 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47402 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47403 this_ptr_conv.is_owned = false;
47404 jboolean ret_conv = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
47408 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_offered"))) TS_HTLCOutputInCommitment_set_offered(uint64_t this_ptr, jboolean val) {
47409 LDKHTLCOutputInCommitment this_ptr_conv;
47410 this_ptr_conv.inner = untag_ptr(this_ptr);
47411 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47412 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47413 this_ptr_conv.is_owned = false;
47414 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
47417 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_amount_msat"))) TS_HTLCOutputInCommitment_get_amount_msat(uint64_t this_ptr) {
47418 LDKHTLCOutputInCommitment this_ptr_conv;
47419 this_ptr_conv.inner = untag_ptr(this_ptr);
47420 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47422 this_ptr_conv.is_owned = false;
47423 int64_t ret_conv = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
47427 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_amount_msat"))) TS_HTLCOutputInCommitment_set_amount_msat(uint64_t this_ptr, int64_t val) {
47428 LDKHTLCOutputInCommitment this_ptr_conv;
47429 this_ptr_conv.inner = untag_ptr(this_ptr);
47430 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47432 this_ptr_conv.is_owned = false;
47433 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
47436 int32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_cltv_expiry"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint64_t this_ptr) {
47437 LDKHTLCOutputInCommitment this_ptr_conv;
47438 this_ptr_conv.inner = untag_ptr(this_ptr);
47439 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47441 this_ptr_conv.is_owned = false;
47442 int32_t ret_conv = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
47446 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_cltv_expiry"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
47447 LDKHTLCOutputInCommitment this_ptr_conv;
47448 this_ptr_conv.inner = untag_ptr(this_ptr);
47449 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47451 this_ptr_conv.is_owned = false;
47452 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
47455 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_get_payment_hash"))) TS_HTLCOutputInCommitment_get_payment_hash(uint64_t this_ptr) {
47456 LDKHTLCOutputInCommitment this_ptr_conv;
47457 this_ptr_conv.inner = untag_ptr(this_ptr);
47458 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47460 this_ptr_conv.is_owned = false;
47461 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
47462 memcpy(ret_arr->elems, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
47466 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_payment_hash"))) TS_HTLCOutputInCommitment_set_payment_hash(uint64_t this_ptr, int8_tArray val) {
47467 LDKHTLCOutputInCommitment this_ptr_conv;
47468 this_ptr_conv.inner = untag_ptr(this_ptr);
47469 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47471 this_ptr_conv.is_owned = false;
47472 LDKThirtyTwoBytes val_ref;
47473 CHECK(val->arr_len == 32);
47474 memcpy(val_ref.data, val->elems, 32); FREE(val);
47475 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
47478 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_transaction_output_index"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint64_t this_ptr) {
47479 LDKHTLCOutputInCommitment this_ptr_conv;
47480 this_ptr_conv.inner = untag_ptr(this_ptr);
47481 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47482 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47483 this_ptr_conv.is_owned = false;
47484 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
47485 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
47486 uint64_t ret_ref = tag_ptr(ret_copy, true);
47490 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_transaction_output_index"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint64_t this_ptr, uint64_t val) {
47491 LDKHTLCOutputInCommitment this_ptr_conv;
47492 this_ptr_conv.inner = untag_ptr(this_ptr);
47493 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47495 this_ptr_conv.is_owned = false;
47496 void* val_ptr = untag_ptr(val);
47497 CHECK_ACCESS(val_ptr);
47498 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
47499 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(val));
47500 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
47503 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) {
47504 LDKThirtyTwoBytes payment_hash_arg_ref;
47505 CHECK(payment_hash_arg->arr_len == 32);
47506 memcpy(payment_hash_arg_ref.data, payment_hash_arg->elems, 32); FREE(payment_hash_arg);
47507 void* transaction_output_index_arg_ptr = untag_ptr(transaction_output_index_arg);
47508 CHECK_ACCESS(transaction_output_index_arg_ptr);
47509 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(transaction_output_index_arg_ptr);
47510 transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(transaction_output_index_arg));
47511 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
47512 uint64_t ret_ref = 0;
47513 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47514 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47518 static inline uint64_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
47519 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
47520 uint64_t ret_ref = 0;
47521 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47522 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47525 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone_ptr"))) TS_HTLCOutputInCommitment_clone_ptr(uint64_t arg) {
47526 LDKHTLCOutputInCommitment arg_conv;
47527 arg_conv.inner = untag_ptr(arg);
47528 arg_conv.is_owned = ptr_is_owned(arg);
47529 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47530 arg_conv.is_owned = false;
47531 int64_t ret_conv = HTLCOutputInCommitment_clone_ptr(&arg_conv);
47535 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone"))) TS_HTLCOutputInCommitment_clone(uint64_t orig) {
47536 LDKHTLCOutputInCommitment orig_conv;
47537 orig_conv.inner = untag_ptr(orig);
47538 orig_conv.is_owned = ptr_is_owned(orig);
47539 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47540 orig_conv.is_owned = false;
47541 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
47542 uint64_t ret_ref = 0;
47543 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47544 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47548 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_eq"))) TS_HTLCOutputInCommitment_eq(uint64_t a, uint64_t b) {
47549 LDKHTLCOutputInCommitment a_conv;
47550 a_conv.inner = untag_ptr(a);
47551 a_conv.is_owned = ptr_is_owned(a);
47552 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47553 a_conv.is_owned = false;
47554 LDKHTLCOutputInCommitment b_conv;
47555 b_conv.inner = untag_ptr(b);
47556 b_conv.is_owned = ptr_is_owned(b);
47557 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47558 b_conv.is_owned = false;
47559 jboolean ret_conv = HTLCOutputInCommitment_eq(&a_conv, &b_conv);
47563 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_write"))) TS_HTLCOutputInCommitment_write(uint64_t obj) {
47564 LDKHTLCOutputInCommitment obj_conv;
47565 obj_conv.inner = untag_ptr(obj);
47566 obj_conv.is_owned = ptr_is_owned(obj);
47567 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
47568 obj_conv.is_owned = false;
47569 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
47570 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47571 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47572 CVec_u8Z_free(ret_var);
47576 uint64_t __attribute__((export_name("TS_HTLCOutputInCommitment_read"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
47577 LDKu8slice ser_ref;
47578 ser_ref.datalen = ser->arr_len;
47579 ser_ref.data = ser->elems;
47580 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
47581 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
47583 return tag_ptr(ret_conv, true);
47586 int8_tArray __attribute__((export_name("TS_get_htlc_redeemscript"))) TS_get_htlc_redeemscript(uint64_t htlc, uint64_t channel_type_features, uint64_t keys) {
47587 LDKHTLCOutputInCommitment htlc_conv;
47588 htlc_conv.inner = untag_ptr(htlc);
47589 htlc_conv.is_owned = ptr_is_owned(htlc);
47590 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
47591 htlc_conv.is_owned = false;
47592 LDKChannelTypeFeatures channel_type_features_conv;
47593 channel_type_features_conv.inner = untag_ptr(channel_type_features);
47594 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
47595 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
47596 channel_type_features_conv.is_owned = false;
47597 LDKTxCreationKeys keys_conv;
47598 keys_conv.inner = untag_ptr(keys);
47599 keys_conv.is_owned = ptr_is_owned(keys);
47600 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
47601 keys_conv.is_owned = false;
47602 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &channel_type_features_conv, &keys_conv);
47603 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47604 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47605 CVec_u8Z_free(ret_var);
47609 int8_tArray __attribute__((export_name("TS_make_funding_redeemscript"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
47610 LDKPublicKey broadcaster_ref;
47611 CHECK(broadcaster->arr_len == 33);
47612 memcpy(broadcaster_ref.compressed_form, broadcaster->elems, 33); FREE(broadcaster);
47613 LDKPublicKey countersignatory_ref;
47614 CHECK(countersignatory->arr_len == 33);
47615 memcpy(countersignatory_ref.compressed_form, countersignatory->elems, 33); FREE(countersignatory);
47616 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
47617 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47618 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47619 CVec_u8Z_free(ret_var);
47623 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, uint64_t channel_type_features, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
47624 uint8_t commitment_txid_arr[32];
47625 CHECK(commitment_txid->arr_len == 32);
47626 memcpy(commitment_txid_arr, commitment_txid->elems, 32); FREE(commitment_txid);
47627 uint8_t (*commitment_txid_ref)[32] = &commitment_txid_arr;
47628 LDKHTLCOutputInCommitment htlc_conv;
47629 htlc_conv.inner = untag_ptr(htlc);
47630 htlc_conv.is_owned = ptr_is_owned(htlc);
47631 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
47632 htlc_conv.is_owned = false;
47633 LDKChannelTypeFeatures channel_type_features_conv;
47634 channel_type_features_conv.inner = untag_ptr(channel_type_features);
47635 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
47636 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
47637 channel_type_features_conv.is_owned = false;
47638 LDKPublicKey broadcaster_delayed_payment_key_ref;
47639 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
47640 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
47641 LDKPublicKey revocation_key_ref;
47642 CHECK(revocation_key->arr_len == 33);
47643 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
47644 LDKTransaction ret_var = build_htlc_transaction(commitment_txid_ref, feerate_per_kw, contest_delay, &htlc_conv, &channel_type_features_conv, broadcaster_delayed_payment_key_ref, revocation_key_ref);
47645 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47646 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47647 Transaction_free(ret_var);
47651 int8_tArray __attribute__((export_name("TS_build_htlc_input_witness"))) TS_build_htlc_input_witness(int8_tArray local_sig, int8_tArray remote_sig, uint64_t preimage, int8_tArray redeem_script, uint64_t channel_type_features) {
47652 LDKECDSASignature local_sig_ref;
47653 CHECK(local_sig->arr_len == 64);
47654 memcpy(local_sig_ref.compact_form, local_sig->elems, 64); FREE(local_sig);
47655 LDKECDSASignature remote_sig_ref;
47656 CHECK(remote_sig->arr_len == 64);
47657 memcpy(remote_sig_ref.compact_form, remote_sig->elems, 64); FREE(remote_sig);
47658 void* preimage_ptr = untag_ptr(preimage);
47659 CHECK_ACCESS(preimage_ptr);
47660 LDKCOption_ThirtyTwoBytesZ preimage_conv = *(LDKCOption_ThirtyTwoBytesZ*)(preimage_ptr);
47661 preimage_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(preimage));
47662 LDKu8slice redeem_script_ref;
47663 redeem_script_ref.datalen = redeem_script->arr_len;
47664 redeem_script_ref.data = redeem_script->elems;
47665 LDKChannelTypeFeatures channel_type_features_conv;
47666 channel_type_features_conv.inner = untag_ptr(channel_type_features);
47667 channel_type_features_conv.is_owned = ptr_is_owned(channel_type_features);
47668 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_conv);
47669 channel_type_features_conv.is_owned = false;
47670 LDKWitness ret_var = build_htlc_input_witness(local_sig_ref, remote_sig_ref, preimage_conv, redeem_script_ref, &channel_type_features_conv);
47671 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47672 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47673 Witness_free(ret_var);
47674 FREE(redeem_script);
47678 int8_tArray __attribute__((export_name("TS_get_to_countersignatory_with_anchors_redeemscript"))) TS_get_to_countersignatory_with_anchors_redeemscript(int8_tArray payment_point) {
47679 LDKPublicKey payment_point_ref;
47680 CHECK(payment_point->arr_len == 33);
47681 memcpy(payment_point_ref.compressed_form, payment_point->elems, 33); FREE(payment_point);
47682 LDKCVec_u8Z ret_var = get_to_countersignatory_with_anchors_redeemscript(payment_point_ref);
47683 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47684 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47685 CVec_u8Z_free(ret_var);
47689 int8_tArray __attribute__((export_name("TS_get_anchor_redeemscript"))) TS_get_anchor_redeemscript(int8_tArray funding_pubkey) {
47690 LDKPublicKey funding_pubkey_ref;
47691 CHECK(funding_pubkey->arr_len == 33);
47692 memcpy(funding_pubkey_ref.compressed_form, funding_pubkey->elems, 33); FREE(funding_pubkey);
47693 LDKCVec_u8Z ret_var = get_anchor_redeemscript(funding_pubkey_ref);
47694 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47695 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47696 CVec_u8Z_free(ret_var);
47700 int8_tArray __attribute__((export_name("TS_build_anchor_input_witness"))) TS_build_anchor_input_witness(int8_tArray funding_key, int8_tArray funding_sig) {
47701 LDKPublicKey funding_key_ref;
47702 CHECK(funding_key->arr_len == 33);
47703 memcpy(funding_key_ref.compressed_form, funding_key->elems, 33); FREE(funding_key);
47704 LDKECDSASignature funding_sig_ref;
47705 CHECK(funding_sig->arr_len == 64);
47706 memcpy(funding_sig_ref.compact_form, funding_sig->elems, 64); FREE(funding_sig);
47707 LDKWitness ret_var = build_anchor_input_witness(funding_key_ref, funding_sig_ref);
47708 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
47709 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
47710 Witness_free(ret_var);
47714 void __attribute__((export_name("TS_ChannelTransactionParameters_free"))) TS_ChannelTransactionParameters_free(uint64_t this_obj) {
47715 LDKChannelTransactionParameters this_obj_conv;
47716 this_obj_conv.inner = untag_ptr(this_obj);
47717 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47718 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47719 ChannelTransactionParameters_free(this_obj_conv);
47722 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_pubkeys"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint64_t this_ptr) {
47723 LDKChannelTransactionParameters this_ptr_conv;
47724 this_ptr_conv.inner = untag_ptr(this_ptr);
47725 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47727 this_ptr_conv.is_owned = false;
47728 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
47729 uint64_t ret_ref = 0;
47730 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47731 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47735 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_pubkeys"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint64_t this_ptr, uint64_t val) {
47736 LDKChannelTransactionParameters this_ptr_conv;
47737 this_ptr_conv.inner = untag_ptr(this_ptr);
47738 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47740 this_ptr_conv.is_owned = false;
47741 LDKChannelPublicKeys val_conv;
47742 val_conv.inner = untag_ptr(val);
47743 val_conv.is_owned = ptr_is_owned(val);
47744 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47745 val_conv = ChannelPublicKeys_clone(&val_conv);
47746 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
47749 int16_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint64_t this_ptr) {
47750 LDKChannelTransactionParameters this_ptr_conv;
47751 this_ptr_conv.inner = untag_ptr(this_ptr);
47752 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47754 this_ptr_conv.is_owned = false;
47755 int16_t ret_conv = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
47759 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) {
47760 LDKChannelTransactionParameters this_ptr_conv;
47761 this_ptr_conv.inner = untag_ptr(this_ptr);
47762 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47763 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47764 this_ptr_conv.is_owned = false;
47765 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
47768 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_get_is_outbound_from_holder"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint64_t this_ptr) {
47769 LDKChannelTransactionParameters this_ptr_conv;
47770 this_ptr_conv.inner = untag_ptr(this_ptr);
47771 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47772 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47773 this_ptr_conv.is_owned = false;
47774 jboolean ret_conv = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
47778 void __attribute__((export_name("TS_ChannelTransactionParameters_set_is_outbound_from_holder"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint64_t this_ptr, jboolean val) {
47779 LDKChannelTransactionParameters this_ptr_conv;
47780 this_ptr_conv.inner = untag_ptr(this_ptr);
47781 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47782 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47783 this_ptr_conv.is_owned = false;
47784 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
47787 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_counterparty_parameters"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint64_t this_ptr) {
47788 LDKChannelTransactionParameters this_ptr_conv;
47789 this_ptr_conv.inner = untag_ptr(this_ptr);
47790 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47792 this_ptr_conv.is_owned = false;
47793 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
47794 uint64_t ret_ref = 0;
47795 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47796 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47800 void __attribute__((export_name("TS_ChannelTransactionParameters_set_counterparty_parameters"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint64_t this_ptr, uint64_t val) {
47801 LDKChannelTransactionParameters this_ptr_conv;
47802 this_ptr_conv.inner = untag_ptr(this_ptr);
47803 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47805 this_ptr_conv.is_owned = false;
47806 LDKCounterpartyChannelTransactionParameters val_conv;
47807 val_conv.inner = untag_ptr(val);
47808 val_conv.is_owned = ptr_is_owned(val);
47809 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47810 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
47811 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
47814 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_funding_outpoint"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint64_t this_ptr) {
47815 LDKChannelTransactionParameters this_ptr_conv;
47816 this_ptr_conv.inner = untag_ptr(this_ptr);
47817 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47818 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47819 this_ptr_conv.is_owned = false;
47820 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
47821 uint64_t ret_ref = 0;
47822 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47823 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47827 void __attribute__((export_name("TS_ChannelTransactionParameters_set_funding_outpoint"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint64_t this_ptr, uint64_t val) {
47828 LDKChannelTransactionParameters this_ptr_conv;
47829 this_ptr_conv.inner = untag_ptr(this_ptr);
47830 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47832 this_ptr_conv.is_owned = false;
47833 LDKOutPoint val_conv;
47834 val_conv.inner = untag_ptr(val);
47835 val_conv.is_owned = ptr_is_owned(val);
47836 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47837 val_conv = OutPoint_clone(&val_conv);
47838 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
47841 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_get_channel_type_features"))) TS_ChannelTransactionParameters_get_channel_type_features(uint64_t this_ptr) {
47842 LDKChannelTransactionParameters this_ptr_conv;
47843 this_ptr_conv.inner = untag_ptr(this_ptr);
47844 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47846 this_ptr_conv.is_owned = false;
47847 LDKChannelTypeFeatures ret_var = ChannelTransactionParameters_get_channel_type_features(&this_ptr_conv);
47848 uint64_t ret_ref = 0;
47849 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47850 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47854 void __attribute__((export_name("TS_ChannelTransactionParameters_set_channel_type_features"))) TS_ChannelTransactionParameters_set_channel_type_features(uint64_t this_ptr, uint64_t val) {
47855 LDKChannelTransactionParameters this_ptr_conv;
47856 this_ptr_conv.inner = untag_ptr(this_ptr);
47857 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47858 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47859 this_ptr_conv.is_owned = false;
47860 LDKChannelTypeFeatures val_conv;
47861 val_conv.inner = untag_ptr(val);
47862 val_conv.is_owned = ptr_is_owned(val);
47863 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47864 val_conv = ChannelTypeFeatures_clone(&val_conv);
47865 ChannelTransactionParameters_set_channel_type_features(&this_ptr_conv, val_conv);
47868 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, uint64_t channel_type_features_arg) {
47869 LDKChannelPublicKeys holder_pubkeys_arg_conv;
47870 holder_pubkeys_arg_conv.inner = untag_ptr(holder_pubkeys_arg);
47871 holder_pubkeys_arg_conv.is_owned = ptr_is_owned(holder_pubkeys_arg);
47872 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
47873 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
47874 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
47875 counterparty_parameters_arg_conv.inner = untag_ptr(counterparty_parameters_arg);
47876 counterparty_parameters_arg_conv.is_owned = ptr_is_owned(counterparty_parameters_arg);
47877 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
47878 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
47879 LDKOutPoint funding_outpoint_arg_conv;
47880 funding_outpoint_arg_conv.inner = untag_ptr(funding_outpoint_arg);
47881 funding_outpoint_arg_conv.is_owned = ptr_is_owned(funding_outpoint_arg);
47882 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
47883 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
47884 LDKChannelTypeFeatures channel_type_features_arg_conv;
47885 channel_type_features_arg_conv.inner = untag_ptr(channel_type_features_arg);
47886 channel_type_features_arg_conv.is_owned = ptr_is_owned(channel_type_features_arg);
47887 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_features_arg_conv);
47888 channel_type_features_arg_conv = ChannelTypeFeatures_clone(&channel_type_features_arg_conv);
47889 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, channel_type_features_arg_conv);
47890 uint64_t ret_ref = 0;
47891 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47892 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47896 static inline uint64_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
47897 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
47898 uint64_t ret_ref = 0;
47899 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47900 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47903 int64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone_ptr"))) TS_ChannelTransactionParameters_clone_ptr(uint64_t arg) {
47904 LDKChannelTransactionParameters arg_conv;
47905 arg_conv.inner = untag_ptr(arg);
47906 arg_conv.is_owned = ptr_is_owned(arg);
47907 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
47908 arg_conv.is_owned = false;
47909 int64_t ret_conv = ChannelTransactionParameters_clone_ptr(&arg_conv);
47913 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_clone"))) TS_ChannelTransactionParameters_clone(uint64_t orig) {
47914 LDKChannelTransactionParameters orig_conv;
47915 orig_conv.inner = untag_ptr(orig);
47916 orig_conv.is_owned = ptr_is_owned(orig);
47917 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
47918 orig_conv.is_owned = false;
47919 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
47920 uint64_t ret_ref = 0;
47921 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47922 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47926 int64_t __attribute__((export_name("TS_ChannelTransactionParameters_hash"))) TS_ChannelTransactionParameters_hash(uint64_t o) {
47927 LDKChannelTransactionParameters o_conv;
47928 o_conv.inner = untag_ptr(o);
47929 o_conv.is_owned = ptr_is_owned(o);
47930 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
47931 o_conv.is_owned = false;
47932 int64_t ret_conv = ChannelTransactionParameters_hash(&o_conv);
47936 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_eq"))) TS_ChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
47937 LDKChannelTransactionParameters a_conv;
47938 a_conv.inner = untag_ptr(a);
47939 a_conv.is_owned = ptr_is_owned(a);
47940 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
47941 a_conv.is_owned = false;
47942 LDKChannelTransactionParameters b_conv;
47943 b_conv.inner = untag_ptr(b);
47944 b_conv.is_owned = ptr_is_owned(b);
47945 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
47946 b_conv.is_owned = false;
47947 jboolean ret_conv = ChannelTransactionParameters_eq(&a_conv, &b_conv);
47951 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_free"))) TS_CounterpartyChannelTransactionParameters_free(uint64_t this_obj) {
47952 LDKCounterpartyChannelTransactionParameters this_obj_conv;
47953 this_obj_conv.inner = untag_ptr(this_obj);
47954 this_obj_conv.is_owned = ptr_is_owned(this_obj);
47955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
47956 CounterpartyChannelTransactionParameters_free(this_obj_conv);
47959 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_pubkeys"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint64_t this_ptr) {
47960 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
47961 this_ptr_conv.inner = untag_ptr(this_ptr);
47962 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47964 this_ptr_conv.is_owned = false;
47965 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
47966 uint64_t ret_ref = 0;
47967 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
47968 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
47972 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_pubkeys"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint64_t this_ptr, uint64_t val) {
47973 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
47974 this_ptr_conv.inner = untag_ptr(this_ptr);
47975 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47977 this_ptr_conv.is_owned = false;
47978 LDKChannelPublicKeys val_conv;
47979 val_conv.inner = untag_ptr(val);
47980 val_conv.is_owned = ptr_is_owned(val);
47981 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
47982 val_conv = ChannelPublicKeys_clone(&val_conv);
47983 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
47986 int16_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint64_t this_ptr) {
47987 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
47988 this_ptr_conv.inner = untag_ptr(this_ptr);
47989 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
47990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
47991 this_ptr_conv.is_owned = false;
47992 int16_t ret_conv = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
47996 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint64_t this_ptr, int16_t val) {
47997 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
47998 this_ptr_conv.inner = untag_ptr(this_ptr);
47999 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48000 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48001 this_ptr_conv.is_owned = false;
48002 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
48005 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_new"))) TS_CounterpartyChannelTransactionParameters_new(uint64_t pubkeys_arg, int16_t selected_contest_delay_arg) {
48006 LDKChannelPublicKeys pubkeys_arg_conv;
48007 pubkeys_arg_conv.inner = untag_ptr(pubkeys_arg);
48008 pubkeys_arg_conv.is_owned = ptr_is_owned(pubkeys_arg);
48009 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
48010 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
48011 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
48012 uint64_t ret_ref = 0;
48013 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48014 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48018 static inline uint64_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
48019 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
48020 uint64_t ret_ref = 0;
48021 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48022 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48025 int64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone_ptr"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint64_t arg) {
48026 LDKCounterpartyChannelTransactionParameters arg_conv;
48027 arg_conv.inner = untag_ptr(arg);
48028 arg_conv.is_owned = ptr_is_owned(arg);
48029 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48030 arg_conv.is_owned = false;
48031 int64_t ret_conv = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
48035 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone"))) TS_CounterpartyChannelTransactionParameters_clone(uint64_t orig) {
48036 LDKCounterpartyChannelTransactionParameters orig_conv;
48037 orig_conv.inner = untag_ptr(orig);
48038 orig_conv.is_owned = ptr_is_owned(orig);
48039 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48040 orig_conv.is_owned = false;
48041 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
48042 uint64_t ret_ref = 0;
48043 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48044 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48048 int64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_hash"))) TS_CounterpartyChannelTransactionParameters_hash(uint64_t o) {
48049 LDKCounterpartyChannelTransactionParameters o_conv;
48050 o_conv.inner = untag_ptr(o);
48051 o_conv.is_owned = ptr_is_owned(o);
48052 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
48053 o_conv.is_owned = false;
48054 int64_t ret_conv = CounterpartyChannelTransactionParameters_hash(&o_conv);
48058 jboolean __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_eq"))) TS_CounterpartyChannelTransactionParameters_eq(uint64_t a, uint64_t b) {
48059 LDKCounterpartyChannelTransactionParameters a_conv;
48060 a_conv.inner = untag_ptr(a);
48061 a_conv.is_owned = ptr_is_owned(a);
48062 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
48063 a_conv.is_owned = false;
48064 LDKCounterpartyChannelTransactionParameters b_conv;
48065 b_conv.inner = untag_ptr(b);
48066 b_conv.is_owned = ptr_is_owned(b);
48067 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
48068 b_conv.is_owned = false;
48069 jboolean ret_conv = CounterpartyChannelTransactionParameters_eq(&a_conv, &b_conv);
48073 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_is_populated"))) TS_ChannelTransactionParameters_is_populated(uint64_t this_arg) {
48074 LDKChannelTransactionParameters this_arg_conv;
48075 this_arg_conv.inner = untag_ptr(this_arg);
48076 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48077 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48078 this_arg_conv.is_owned = false;
48079 jboolean ret_conv = ChannelTransactionParameters_is_populated(&this_arg_conv);
48083 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_holder_broadcastable"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint64_t this_arg) {
48084 LDKChannelTransactionParameters this_arg_conv;
48085 this_arg_conv.inner = untag_ptr(this_arg);
48086 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48088 this_arg_conv.is_owned = false;
48089 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
48090 uint64_t ret_ref = 0;
48091 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48092 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48096 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_as_counterparty_broadcastable"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint64_t this_arg) {
48097 LDKChannelTransactionParameters this_arg_conv;
48098 this_arg_conv.inner = untag_ptr(this_arg);
48099 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48101 this_arg_conv.is_owned = false;
48102 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
48103 uint64_t ret_ref = 0;
48104 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48105 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48109 int8_tArray __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_write"))) TS_CounterpartyChannelTransactionParameters_write(uint64_t obj) {
48110 LDKCounterpartyChannelTransactionParameters obj_conv;
48111 obj_conv.inner = untag_ptr(obj);
48112 obj_conv.is_owned = ptr_is_owned(obj);
48113 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48114 obj_conv.is_owned = false;
48115 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
48116 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48117 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48118 CVec_u8Z_free(ret_var);
48122 uint64_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_read"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
48123 LDKu8slice ser_ref;
48124 ser_ref.datalen = ser->arr_len;
48125 ser_ref.data = ser->elems;
48126 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
48127 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
48129 return tag_ptr(ret_conv, true);
48132 int8_tArray __attribute__((export_name("TS_ChannelTransactionParameters_write"))) TS_ChannelTransactionParameters_write(uint64_t obj) {
48133 LDKChannelTransactionParameters obj_conv;
48134 obj_conv.inner = untag_ptr(obj);
48135 obj_conv.is_owned = ptr_is_owned(obj);
48136 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48137 obj_conv.is_owned = false;
48138 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
48139 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48140 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48141 CVec_u8Z_free(ret_var);
48145 uint64_t __attribute__((export_name("TS_ChannelTransactionParameters_read"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
48146 LDKu8slice ser_ref;
48147 ser_ref.datalen = ser->arr_len;
48148 ser_ref.data = ser->elems;
48149 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
48150 *ret_conv = ChannelTransactionParameters_read(ser_ref);
48152 return tag_ptr(ret_conv, true);
48155 void __attribute__((export_name("TS_DirectedChannelTransactionParameters_free"))) TS_DirectedChannelTransactionParameters_free(uint64_t this_obj) {
48156 LDKDirectedChannelTransactionParameters this_obj_conv;
48157 this_obj_conv.inner = untag_ptr(this_obj);
48158 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48160 DirectedChannelTransactionParameters_free(this_obj_conv);
48163 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_broadcaster_pubkeys"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint64_t this_arg) {
48164 LDKDirectedChannelTransactionParameters this_arg_conv;
48165 this_arg_conv.inner = untag_ptr(this_arg);
48166 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48168 this_arg_conv.is_owned = false;
48169 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
48170 uint64_t ret_ref = 0;
48171 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48172 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48176 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_countersignatory_pubkeys"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint64_t this_arg) {
48177 LDKDirectedChannelTransactionParameters this_arg_conv;
48178 this_arg_conv.inner = untag_ptr(this_arg);
48179 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48180 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48181 this_arg_conv.is_owned = false;
48182 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
48183 uint64_t ret_ref = 0;
48184 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48185 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48189 int16_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_contest_delay"))) TS_DirectedChannelTransactionParameters_contest_delay(uint64_t this_arg) {
48190 LDKDirectedChannelTransactionParameters this_arg_conv;
48191 this_arg_conv.inner = untag_ptr(this_arg);
48192 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48194 this_arg_conv.is_owned = false;
48195 int16_t ret_conv = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
48199 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_is_outbound"))) TS_DirectedChannelTransactionParameters_is_outbound(uint64_t this_arg) {
48200 LDKDirectedChannelTransactionParameters this_arg_conv;
48201 this_arg_conv.inner = untag_ptr(this_arg);
48202 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48204 this_arg_conv.is_owned = false;
48205 jboolean ret_conv = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
48209 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_funding_outpoint"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint64_t this_arg) {
48210 LDKDirectedChannelTransactionParameters this_arg_conv;
48211 this_arg_conv.inner = untag_ptr(this_arg);
48212 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48213 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48214 this_arg_conv.is_owned = false;
48215 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
48216 uint64_t ret_ref = 0;
48217 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48218 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48222 uint64_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_channel_type_features"))) TS_DirectedChannelTransactionParameters_channel_type_features(uint64_t this_arg) {
48223 LDKDirectedChannelTransactionParameters this_arg_conv;
48224 this_arg_conv.inner = untag_ptr(this_arg);
48225 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48226 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48227 this_arg_conv.is_owned = false;
48228 LDKChannelTypeFeatures ret_var = DirectedChannelTransactionParameters_channel_type_features(&this_arg_conv);
48229 uint64_t ret_ref = 0;
48230 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48231 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48235 void __attribute__((export_name("TS_HolderCommitmentTransaction_free"))) TS_HolderCommitmentTransaction_free(uint64_t this_obj) {
48236 LDKHolderCommitmentTransaction this_obj_conv;
48237 this_obj_conv.inner = untag_ptr(this_obj);
48238 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48239 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48240 HolderCommitmentTransaction_free(this_obj_conv);
48243 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_sig"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint64_t this_ptr) {
48244 LDKHolderCommitmentTransaction this_ptr_conv;
48245 this_ptr_conv.inner = untag_ptr(this_ptr);
48246 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48248 this_ptr_conv.is_owned = false;
48249 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
48250 memcpy(ret_arr->elems, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
48254 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_sig"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint64_t this_ptr, int8_tArray val) {
48255 LDKHolderCommitmentTransaction this_ptr_conv;
48256 this_ptr_conv.inner = untag_ptr(this_ptr);
48257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48259 this_ptr_conv.is_owned = false;
48260 LDKECDSASignature val_ref;
48261 CHECK(val->arr_len == 64);
48262 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
48263 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
48266 ptrArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_get_counterparty_htlc_sigs(uint64_t this_ptr) {
48267 LDKHolderCommitmentTransaction this_ptr_conv;
48268 this_ptr_conv.inner = untag_ptr(this_ptr);
48269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48271 this_ptr_conv.is_owned = false;
48272 LDKCVec_ECDSASignatureZ ret_var = HolderCommitmentTransaction_get_counterparty_htlc_sigs(&this_ptr_conv);
48273 ptrArray ret_arr = NULL;
48274 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
48275 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
48276 for (size_t m = 0; m < ret_var.datalen; m++) {
48277 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
48278 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
48279 ret_arr_ptr[m] = ret_conv_12_arr;
48282 FREE(ret_var.data);
48286 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint64_t this_ptr, ptrArray val) {
48287 LDKHolderCommitmentTransaction this_ptr_conv;
48288 this_ptr_conv.inner = untag_ptr(this_ptr);
48289 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48291 this_ptr_conv.is_owned = false;
48292 LDKCVec_ECDSASignatureZ val_constr;
48293 val_constr.datalen = val->arr_len;
48294 if (val_constr.datalen > 0)
48295 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
48297 val_constr.data = NULL;
48298 int8_tArray* val_vals = (void*) val->elems;
48299 for (size_t m = 0; m < val_constr.datalen; m++) {
48300 int8_tArray val_conv_12 = val_vals[m];
48301 LDKECDSASignature val_conv_12_ref;
48302 CHECK(val_conv_12->arr_len == 64);
48303 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
48304 val_constr.data[m] = val_conv_12_ref;
48307 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
48310 static inline uint64_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
48311 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
48312 uint64_t ret_ref = 0;
48313 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48314 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48317 int64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone_ptr"))) TS_HolderCommitmentTransaction_clone_ptr(uint64_t arg) {
48318 LDKHolderCommitmentTransaction arg_conv;
48319 arg_conv.inner = untag_ptr(arg);
48320 arg_conv.is_owned = ptr_is_owned(arg);
48321 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48322 arg_conv.is_owned = false;
48323 int64_t ret_conv = HolderCommitmentTransaction_clone_ptr(&arg_conv);
48327 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone"))) TS_HolderCommitmentTransaction_clone(uint64_t orig) {
48328 LDKHolderCommitmentTransaction orig_conv;
48329 orig_conv.inner = untag_ptr(orig);
48330 orig_conv.is_owned = ptr_is_owned(orig);
48331 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48332 orig_conv.is_owned = false;
48333 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
48334 uint64_t ret_ref = 0;
48335 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48336 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48340 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_write"))) TS_HolderCommitmentTransaction_write(uint64_t obj) {
48341 LDKHolderCommitmentTransaction obj_conv;
48342 obj_conv.inner = untag_ptr(obj);
48343 obj_conv.is_owned = ptr_is_owned(obj);
48344 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48345 obj_conv.is_owned = false;
48346 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
48347 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48348 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48349 CVec_u8Z_free(ret_var);
48353 uint64_t __attribute__((export_name("TS_HolderCommitmentTransaction_read"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
48354 LDKu8slice ser_ref;
48355 ser_ref.datalen = ser->arr_len;
48356 ser_ref.data = ser->elems;
48357 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
48358 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
48360 return tag_ptr(ret_conv, true);
48363 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) {
48364 LDKCommitmentTransaction commitment_tx_conv;
48365 commitment_tx_conv.inner = untag_ptr(commitment_tx);
48366 commitment_tx_conv.is_owned = ptr_is_owned(commitment_tx);
48367 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
48368 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
48369 LDKECDSASignature counterparty_sig_ref;
48370 CHECK(counterparty_sig->arr_len == 64);
48371 memcpy(counterparty_sig_ref.compact_form, counterparty_sig->elems, 64); FREE(counterparty_sig);
48372 LDKCVec_ECDSASignatureZ counterparty_htlc_sigs_constr;
48373 counterparty_htlc_sigs_constr.datalen = counterparty_htlc_sigs->arr_len;
48374 if (counterparty_htlc_sigs_constr.datalen > 0)
48375 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKECDSASignature), "LDKCVec_ECDSASignatureZ Elements");
48377 counterparty_htlc_sigs_constr.data = NULL;
48378 int8_tArray* counterparty_htlc_sigs_vals = (void*) counterparty_htlc_sigs->elems;
48379 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
48380 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
48381 LDKECDSASignature counterparty_htlc_sigs_conv_12_ref;
48382 CHECK(counterparty_htlc_sigs_conv_12->arr_len == 64);
48383 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, counterparty_htlc_sigs_conv_12->elems, 64); FREE(counterparty_htlc_sigs_conv_12);
48384 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
48386 FREE(counterparty_htlc_sigs);
48387 LDKPublicKey holder_funding_key_ref;
48388 CHECK(holder_funding_key->arr_len == 33);
48389 memcpy(holder_funding_key_ref.compressed_form, holder_funding_key->elems, 33); FREE(holder_funding_key);
48390 LDKPublicKey counterparty_funding_key_ref;
48391 CHECK(counterparty_funding_key->arr_len == 33);
48392 memcpy(counterparty_funding_key_ref.compressed_form, counterparty_funding_key->elems, 33); FREE(counterparty_funding_key);
48393 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
48394 uint64_t ret_ref = 0;
48395 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48396 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48400 void __attribute__((export_name("TS_BuiltCommitmentTransaction_free"))) TS_BuiltCommitmentTransaction_free(uint64_t this_obj) {
48401 LDKBuiltCommitmentTransaction this_obj_conv;
48402 this_obj_conv.inner = untag_ptr(this_obj);
48403 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48404 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48405 BuiltCommitmentTransaction_free(this_obj_conv);
48408 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_transaction"))) TS_BuiltCommitmentTransaction_get_transaction(uint64_t this_ptr) {
48409 LDKBuiltCommitmentTransaction this_ptr_conv;
48410 this_ptr_conv.inner = untag_ptr(this_ptr);
48411 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48412 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48413 this_ptr_conv.is_owned = false;
48414 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
48415 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48416 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48417 Transaction_free(ret_var);
48421 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_transaction"))) TS_BuiltCommitmentTransaction_set_transaction(uint64_t this_ptr, int8_tArray val) {
48422 LDKBuiltCommitmentTransaction this_ptr_conv;
48423 this_ptr_conv.inner = untag_ptr(this_ptr);
48424 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48425 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48426 this_ptr_conv.is_owned = false;
48427 LDKTransaction val_ref;
48428 val_ref.datalen = val->arr_len;
48429 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
48430 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
48431 val_ref.data_is_owned = true;
48432 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
48435 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_txid"))) TS_BuiltCommitmentTransaction_get_txid(uint64_t this_ptr) {
48436 LDKBuiltCommitmentTransaction this_ptr_conv;
48437 this_ptr_conv.inner = untag_ptr(this_ptr);
48438 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48439 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48440 this_ptr_conv.is_owned = false;
48441 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48442 memcpy(ret_arr->elems, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
48446 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_txid"))) TS_BuiltCommitmentTransaction_set_txid(uint64_t this_ptr, int8_tArray val) {
48447 LDKBuiltCommitmentTransaction this_ptr_conv;
48448 this_ptr_conv.inner = untag_ptr(this_ptr);
48449 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
48450 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
48451 this_ptr_conv.is_owned = false;
48452 LDKThirtyTwoBytes val_ref;
48453 CHECK(val->arr_len == 32);
48454 memcpy(val_ref.data, val->elems, 32); FREE(val);
48455 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
48458 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_new"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
48459 LDKTransaction transaction_arg_ref;
48460 transaction_arg_ref.datalen = transaction_arg->arr_len;
48461 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
48462 memcpy(transaction_arg_ref.data, transaction_arg->elems, transaction_arg_ref.datalen); FREE(transaction_arg);
48463 transaction_arg_ref.data_is_owned = true;
48464 LDKThirtyTwoBytes txid_arg_ref;
48465 CHECK(txid_arg->arr_len == 32);
48466 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
48467 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
48468 uint64_t ret_ref = 0;
48469 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48470 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48474 static inline uint64_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
48475 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
48476 uint64_t ret_ref = 0;
48477 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48478 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48481 int64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone_ptr"))) TS_BuiltCommitmentTransaction_clone_ptr(uint64_t arg) {
48482 LDKBuiltCommitmentTransaction arg_conv;
48483 arg_conv.inner = untag_ptr(arg);
48484 arg_conv.is_owned = ptr_is_owned(arg);
48485 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48486 arg_conv.is_owned = false;
48487 int64_t ret_conv = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
48491 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone"))) TS_BuiltCommitmentTransaction_clone(uint64_t orig) {
48492 LDKBuiltCommitmentTransaction orig_conv;
48493 orig_conv.inner = untag_ptr(orig);
48494 orig_conv.is_owned = ptr_is_owned(orig);
48495 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48496 orig_conv.is_owned = false;
48497 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
48498 uint64_t ret_ref = 0;
48499 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48500 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48504 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_write"))) TS_BuiltCommitmentTransaction_write(uint64_t obj) {
48505 LDKBuiltCommitmentTransaction obj_conv;
48506 obj_conv.inner = untag_ptr(obj);
48507 obj_conv.is_owned = ptr_is_owned(obj);
48508 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48509 obj_conv.is_owned = false;
48510 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
48511 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48512 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48513 CVec_u8Z_free(ret_var);
48517 uint64_t __attribute__((export_name("TS_BuiltCommitmentTransaction_read"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
48518 LDKu8slice ser_ref;
48519 ser_ref.datalen = ser->arr_len;
48520 ser_ref.data = ser->elems;
48521 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
48522 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
48524 return tag_ptr(ret_conv, true);
48527 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) {
48528 LDKBuiltCommitmentTransaction this_arg_conv;
48529 this_arg_conv.inner = untag_ptr(this_arg);
48530 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48531 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48532 this_arg_conv.is_owned = false;
48533 LDKu8slice funding_redeemscript_ref;
48534 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
48535 funding_redeemscript_ref.data = funding_redeemscript->elems;
48536 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48537 memcpy(ret_arr->elems, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
48538 FREE(funding_redeemscript);
48542 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) {
48543 LDKBuiltCommitmentTransaction this_arg_conv;
48544 this_arg_conv.inner = untag_ptr(this_arg);
48545 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48547 this_arg_conv.is_owned = false;
48548 uint8_t funding_key_arr[32];
48549 CHECK(funding_key->arr_len == 32);
48550 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
48551 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
48552 LDKu8slice funding_redeemscript_ref;
48553 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
48554 funding_redeemscript_ref.data = funding_redeemscript->elems;
48555 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
48556 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign_counterparty_commitment(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
48557 FREE(funding_redeemscript);
48561 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) {
48562 LDKBuiltCommitmentTransaction this_arg_conv;
48563 this_arg_conv.inner = untag_ptr(this_arg);
48564 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48566 this_arg_conv.is_owned = false;
48567 uint8_t funding_key_arr[32];
48568 CHECK(funding_key->arr_len == 32);
48569 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
48570 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
48571 LDKu8slice funding_redeemscript_ref;
48572 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
48573 funding_redeemscript_ref.data = funding_redeemscript->elems;
48574 void* entropy_source_ptr = untag_ptr(entropy_source);
48575 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
48576 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
48577 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
48578 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);
48579 FREE(funding_redeemscript);
48583 void __attribute__((export_name("TS_ClosingTransaction_free"))) TS_ClosingTransaction_free(uint64_t this_obj) {
48584 LDKClosingTransaction this_obj_conv;
48585 this_obj_conv.inner = untag_ptr(this_obj);
48586 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48588 ClosingTransaction_free(this_obj_conv);
48591 static inline uint64_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
48592 LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
48593 uint64_t ret_ref = 0;
48594 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48595 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48598 int64_t __attribute__((export_name("TS_ClosingTransaction_clone_ptr"))) TS_ClosingTransaction_clone_ptr(uint64_t arg) {
48599 LDKClosingTransaction arg_conv;
48600 arg_conv.inner = untag_ptr(arg);
48601 arg_conv.is_owned = ptr_is_owned(arg);
48602 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48603 arg_conv.is_owned = false;
48604 int64_t ret_conv = ClosingTransaction_clone_ptr(&arg_conv);
48608 uint64_t __attribute__((export_name("TS_ClosingTransaction_clone"))) TS_ClosingTransaction_clone(uint64_t orig) {
48609 LDKClosingTransaction orig_conv;
48610 orig_conv.inner = untag_ptr(orig);
48611 orig_conv.is_owned = ptr_is_owned(orig);
48612 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48613 orig_conv.is_owned = false;
48614 LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
48615 uint64_t ret_ref = 0;
48616 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48617 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48621 int64_t __attribute__((export_name("TS_ClosingTransaction_hash"))) TS_ClosingTransaction_hash(uint64_t o) {
48622 LDKClosingTransaction o_conv;
48623 o_conv.inner = untag_ptr(o);
48624 o_conv.is_owned = ptr_is_owned(o);
48625 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
48626 o_conv.is_owned = false;
48627 int64_t ret_conv = ClosingTransaction_hash(&o_conv);
48631 jboolean __attribute__((export_name("TS_ClosingTransaction_eq"))) TS_ClosingTransaction_eq(uint64_t a, uint64_t b) {
48632 LDKClosingTransaction a_conv;
48633 a_conv.inner = untag_ptr(a);
48634 a_conv.is_owned = ptr_is_owned(a);
48635 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
48636 a_conv.is_owned = false;
48637 LDKClosingTransaction b_conv;
48638 b_conv.inner = untag_ptr(b);
48639 b_conv.is_owned = ptr_is_owned(b);
48640 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
48641 b_conv.is_owned = false;
48642 jboolean ret_conv = ClosingTransaction_eq(&a_conv, &b_conv);
48646 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) {
48647 LDKCVec_u8Z to_holder_script_ref;
48648 to_holder_script_ref.datalen = to_holder_script->arr_len;
48649 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
48650 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
48651 LDKCVec_u8Z to_counterparty_script_ref;
48652 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
48653 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
48654 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
48655 LDKOutPoint funding_outpoint_conv;
48656 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
48657 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
48658 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
48659 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
48660 LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
48661 uint64_t ret_ref = 0;
48662 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48663 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48667 uint64_t __attribute__((export_name("TS_ClosingTransaction_trust"))) TS_ClosingTransaction_trust(uint64_t this_arg) {
48668 LDKClosingTransaction this_arg_conv;
48669 this_arg_conv.inner = untag_ptr(this_arg);
48670 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48672 this_arg_conv.is_owned = false;
48673 LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
48674 uint64_t ret_ref = 0;
48675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48676 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48680 uint64_t __attribute__((export_name("TS_ClosingTransaction_verify"))) TS_ClosingTransaction_verify(uint64_t this_arg, uint64_t funding_outpoint) {
48681 LDKClosingTransaction this_arg_conv;
48682 this_arg_conv.inner = untag_ptr(this_arg);
48683 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48685 this_arg_conv.is_owned = false;
48686 LDKOutPoint funding_outpoint_conv;
48687 funding_outpoint_conv.inner = untag_ptr(funding_outpoint);
48688 funding_outpoint_conv.is_owned = ptr_is_owned(funding_outpoint);
48689 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
48690 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
48691 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
48692 *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
48693 return tag_ptr(ret_conv, true);
48696 int64_t __attribute__((export_name("TS_ClosingTransaction_to_holder_value_sat"))) TS_ClosingTransaction_to_holder_value_sat(uint64_t this_arg) {
48697 LDKClosingTransaction this_arg_conv;
48698 this_arg_conv.inner = untag_ptr(this_arg);
48699 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48700 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48701 this_arg_conv.is_owned = false;
48702 int64_t ret_conv = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
48706 int64_t __attribute__((export_name("TS_ClosingTransaction_to_counterparty_value_sat"))) TS_ClosingTransaction_to_counterparty_value_sat(uint64_t this_arg) {
48707 LDKClosingTransaction 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 int64_t ret_conv = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
48716 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_holder_script"))) TS_ClosingTransaction_to_holder_script(uint64_t this_arg) {
48717 LDKClosingTransaction this_arg_conv;
48718 this_arg_conv.inner = untag_ptr(this_arg);
48719 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48721 this_arg_conv.is_owned = false;
48722 LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
48723 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48724 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48728 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_counterparty_script"))) TS_ClosingTransaction_to_counterparty_script(uint64_t this_arg) {
48729 LDKClosingTransaction this_arg_conv;
48730 this_arg_conv.inner = untag_ptr(this_arg);
48731 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48733 this_arg_conv.is_owned = false;
48734 LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
48735 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48736 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48740 void __attribute__((export_name("TS_TrustedClosingTransaction_free"))) TS_TrustedClosingTransaction_free(uint64_t this_obj) {
48741 LDKTrustedClosingTransaction this_obj_conv;
48742 this_obj_conv.inner = untag_ptr(this_obj);
48743 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48744 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48745 TrustedClosingTransaction_free(this_obj_conv);
48748 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_built_transaction"))) TS_TrustedClosingTransaction_built_transaction(uint64_t this_arg) {
48749 LDKTrustedClosingTransaction 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 LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
48755 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48756 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48757 Transaction_free(ret_var);
48761 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) {
48762 LDKTrustedClosingTransaction this_arg_conv;
48763 this_arg_conv.inner = untag_ptr(this_arg);
48764 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48766 this_arg_conv.is_owned = false;
48767 LDKu8slice funding_redeemscript_ref;
48768 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
48769 funding_redeemscript_ref.data = funding_redeemscript->elems;
48770 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48771 memcpy(ret_arr->elems, TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
48772 FREE(funding_redeemscript);
48776 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) {
48777 LDKTrustedClosingTransaction this_arg_conv;
48778 this_arg_conv.inner = untag_ptr(this_arg);
48779 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48781 this_arg_conv.is_owned = false;
48782 uint8_t funding_key_arr[32];
48783 CHECK(funding_key->arr_len == 32);
48784 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
48785 uint8_t (*funding_key_ref)[32] = &funding_key_arr;
48786 LDKu8slice funding_redeemscript_ref;
48787 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
48788 funding_redeemscript_ref.data = funding_redeemscript->elems;
48789 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
48790 memcpy(ret_arr->elems, TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
48791 FREE(funding_redeemscript);
48795 void __attribute__((export_name("TS_CommitmentTransaction_free"))) TS_CommitmentTransaction_free(uint64_t this_obj) {
48796 LDKCommitmentTransaction this_obj_conv;
48797 this_obj_conv.inner = untag_ptr(this_obj);
48798 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48799 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48800 CommitmentTransaction_free(this_obj_conv);
48803 static inline uint64_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
48804 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
48805 uint64_t ret_ref = 0;
48806 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48807 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48810 int64_t __attribute__((export_name("TS_CommitmentTransaction_clone_ptr"))) TS_CommitmentTransaction_clone_ptr(uint64_t arg) {
48811 LDKCommitmentTransaction arg_conv;
48812 arg_conv.inner = untag_ptr(arg);
48813 arg_conv.is_owned = ptr_is_owned(arg);
48814 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
48815 arg_conv.is_owned = false;
48816 int64_t ret_conv = CommitmentTransaction_clone_ptr(&arg_conv);
48820 uint64_t __attribute__((export_name("TS_CommitmentTransaction_clone"))) TS_CommitmentTransaction_clone(uint64_t orig) {
48821 LDKCommitmentTransaction orig_conv;
48822 orig_conv.inner = untag_ptr(orig);
48823 orig_conv.is_owned = ptr_is_owned(orig);
48824 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
48825 orig_conv.is_owned = false;
48826 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
48827 uint64_t ret_ref = 0;
48828 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48829 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48833 int8_tArray __attribute__((export_name("TS_CommitmentTransaction_write"))) TS_CommitmentTransaction_write(uint64_t obj) {
48834 LDKCommitmentTransaction obj_conv;
48835 obj_conv.inner = untag_ptr(obj);
48836 obj_conv.is_owned = ptr_is_owned(obj);
48837 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
48838 obj_conv.is_owned = false;
48839 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
48840 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
48841 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
48842 CVec_u8Z_free(ret_var);
48846 uint64_t __attribute__((export_name("TS_CommitmentTransaction_read"))) TS_CommitmentTransaction_read(int8_tArray ser) {
48847 LDKu8slice ser_ref;
48848 ser_ref.datalen = ser->arr_len;
48849 ser_ref.data = ser->elems;
48850 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
48851 *ret_conv = CommitmentTransaction_read(ser_ref);
48853 return tag_ptr(ret_conv, true);
48856 int64_t __attribute__((export_name("TS_CommitmentTransaction_commitment_number"))) TS_CommitmentTransaction_commitment_number(uint64_t this_arg) {
48857 LDKCommitmentTransaction this_arg_conv;
48858 this_arg_conv.inner = untag_ptr(this_arg);
48859 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48861 this_arg_conv.is_owned = false;
48862 int64_t ret_conv = CommitmentTransaction_commitment_number(&this_arg_conv);
48866 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_broadcaster_value_sat"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint64_t this_arg) {
48867 LDKCommitmentTransaction this_arg_conv;
48868 this_arg_conv.inner = untag_ptr(this_arg);
48869 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48871 this_arg_conv.is_owned = false;
48872 int64_t ret_conv = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
48876 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_countersignatory_value_sat"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint64_t this_arg) {
48877 LDKCommitmentTransaction this_arg_conv;
48878 this_arg_conv.inner = untag_ptr(this_arg);
48879 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48881 this_arg_conv.is_owned = false;
48882 int64_t ret_conv = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
48886 int32_t __attribute__((export_name("TS_CommitmentTransaction_feerate_per_kw"))) TS_CommitmentTransaction_feerate_per_kw(uint64_t this_arg) {
48887 LDKCommitmentTransaction this_arg_conv;
48888 this_arg_conv.inner = untag_ptr(this_arg);
48889 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48891 this_arg_conv.is_owned = false;
48892 int32_t ret_conv = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
48896 uint64_t __attribute__((export_name("TS_CommitmentTransaction_trust"))) TS_CommitmentTransaction_trust(uint64_t this_arg) {
48897 LDKCommitmentTransaction this_arg_conv;
48898 this_arg_conv.inner = untag_ptr(this_arg);
48899 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48900 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48901 this_arg_conv.is_owned = false;
48902 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
48903 uint64_t ret_ref = 0;
48904 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48905 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48909 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) {
48910 LDKCommitmentTransaction this_arg_conv;
48911 this_arg_conv.inner = untag_ptr(this_arg);
48912 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48913 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48914 this_arg_conv.is_owned = false;
48915 LDKDirectedChannelTransactionParameters channel_parameters_conv;
48916 channel_parameters_conv.inner = untag_ptr(channel_parameters);
48917 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
48918 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
48919 channel_parameters_conv.is_owned = false;
48920 LDKChannelPublicKeys broadcaster_keys_conv;
48921 broadcaster_keys_conv.inner = untag_ptr(broadcaster_keys);
48922 broadcaster_keys_conv.is_owned = ptr_is_owned(broadcaster_keys);
48923 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
48924 broadcaster_keys_conv.is_owned = false;
48925 LDKChannelPublicKeys countersignatory_keys_conv;
48926 countersignatory_keys_conv.inner = untag_ptr(countersignatory_keys);
48927 countersignatory_keys_conv.is_owned = ptr_is_owned(countersignatory_keys);
48928 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
48929 countersignatory_keys_conv.is_owned = false;
48930 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
48931 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
48932 return tag_ptr(ret_conv, true);
48935 void __attribute__((export_name("TS_TrustedCommitmentTransaction_free"))) TS_TrustedCommitmentTransaction_free(uint64_t this_obj) {
48936 LDKTrustedCommitmentTransaction this_obj_conv;
48937 this_obj_conv.inner = untag_ptr(this_obj);
48938 this_obj_conv.is_owned = ptr_is_owned(this_obj);
48939 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
48940 TrustedCommitmentTransaction_free(this_obj_conv);
48943 int8_tArray __attribute__((export_name("TS_TrustedCommitmentTransaction_txid"))) TS_TrustedCommitmentTransaction_txid(uint64_t this_arg) {
48944 LDKTrustedCommitmentTransaction this_arg_conv;
48945 this_arg_conv.inner = untag_ptr(this_arg);
48946 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48948 this_arg_conv.is_owned = false;
48949 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
48950 memcpy(ret_arr->elems, TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
48954 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_built_transaction"))) TS_TrustedCommitmentTransaction_built_transaction(uint64_t this_arg) {
48955 LDKTrustedCommitmentTransaction this_arg_conv;
48956 this_arg_conv.inner = untag_ptr(this_arg);
48957 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48959 this_arg_conv.is_owned = false;
48960 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
48961 uint64_t ret_ref = 0;
48962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48963 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48967 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_keys"))) TS_TrustedCommitmentTransaction_keys(uint64_t this_arg) {
48968 LDKTrustedCommitmentTransaction this_arg_conv;
48969 this_arg_conv.inner = untag_ptr(this_arg);
48970 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48972 this_arg_conv.is_owned = false;
48973 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
48974 uint64_t ret_ref = 0;
48975 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48976 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48980 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_channel_type_features"))) TS_TrustedCommitmentTransaction_channel_type_features(uint64_t this_arg) {
48981 LDKTrustedCommitmentTransaction this_arg_conv;
48982 this_arg_conv.inner = untag_ptr(this_arg);
48983 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48985 this_arg_conv.is_owned = false;
48986 LDKChannelTypeFeatures ret_var = TrustedCommitmentTransaction_channel_type_features(&this_arg_conv);
48987 uint64_t ret_ref = 0;
48988 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
48989 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
48993 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) {
48994 LDKTrustedCommitmentTransaction this_arg_conv;
48995 this_arg_conv.inner = untag_ptr(this_arg);
48996 this_arg_conv.is_owned = ptr_is_owned(this_arg);
48997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
48998 this_arg_conv.is_owned = false;
48999 uint8_t htlc_base_key_arr[32];
49000 CHECK(htlc_base_key->arr_len == 32);
49001 memcpy(htlc_base_key_arr, htlc_base_key->elems, 32); FREE(htlc_base_key);
49002 uint8_t (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
49003 LDKDirectedChannelTransactionParameters channel_parameters_conv;
49004 channel_parameters_conv.inner = untag_ptr(channel_parameters);
49005 channel_parameters_conv.is_owned = ptr_is_owned(channel_parameters);
49006 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
49007 channel_parameters_conv.is_owned = false;
49008 void* entropy_source_ptr = untag_ptr(entropy_source);
49009 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
49010 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
49011 LDKCResult_CVec_ECDSASignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_ECDSASignatureZNoneZ), "LDKCResult_CVec_ECDSASignatureZNoneZ");
49012 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv, entropy_source_conv);
49013 return tag_ptr(ret_conv, true);
49016 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_revokeable_output_index"))) TS_TrustedCommitmentTransaction_revokeable_output_index(uint64_t this_arg) {
49017 LDKTrustedCommitmentTransaction this_arg_conv;
49018 this_arg_conv.inner = untag_ptr(this_arg);
49019 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49021 this_arg_conv.is_owned = false;
49022 LDKCOption_usizeZ *ret_copy = MALLOC(sizeof(LDKCOption_usizeZ), "LDKCOption_usizeZ");
49023 *ret_copy = TrustedCommitmentTransaction_revokeable_output_index(&this_arg_conv);
49024 uint64_t ret_ref = tag_ptr(ret_copy, true);
49028 uint64_t __attribute__((export_name("TS_TrustedCommitmentTransaction_build_to_local_justice_tx"))) TS_TrustedCommitmentTransaction_build_to_local_justice_tx(uint64_t this_arg, int64_t feerate_per_kw, int8_tArray destination_script) {
49029 LDKTrustedCommitmentTransaction this_arg_conv;
49030 this_arg_conv.inner = untag_ptr(this_arg);
49031 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49033 this_arg_conv.is_owned = false;
49034 LDKCVec_u8Z destination_script_ref;
49035 destination_script_ref.datalen = destination_script->arr_len;
49036 destination_script_ref.data = MALLOC(destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
49037 memcpy(destination_script_ref.data, destination_script->elems, destination_script_ref.datalen); FREE(destination_script);
49038 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
49039 *ret_conv = TrustedCommitmentTransaction_build_to_local_justice_tx(&this_arg_conv, feerate_per_kw, destination_script_ref);
49040 return tag_ptr(ret_conv, true);
49043 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) {
49044 LDKPublicKey broadcaster_payment_basepoint_ref;
49045 CHECK(broadcaster_payment_basepoint->arr_len == 33);
49046 memcpy(broadcaster_payment_basepoint_ref.compressed_form, broadcaster_payment_basepoint->elems, 33); FREE(broadcaster_payment_basepoint);
49047 LDKPublicKey countersignatory_payment_basepoint_ref;
49048 CHECK(countersignatory_payment_basepoint->arr_len == 33);
49049 memcpy(countersignatory_payment_basepoint_ref.compressed_form, countersignatory_payment_basepoint->elems, 33); FREE(countersignatory_payment_basepoint);
49050 int64_t ret_conv = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
49054 jboolean __attribute__((export_name("TS_InitFeatures_eq"))) TS_InitFeatures_eq(uint64_t a, uint64_t b) {
49055 LDKInitFeatures a_conv;
49056 a_conv.inner = untag_ptr(a);
49057 a_conv.is_owned = ptr_is_owned(a);
49058 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49059 a_conv.is_owned = false;
49060 LDKInitFeatures b_conv;
49061 b_conv.inner = untag_ptr(b);
49062 b_conv.is_owned = ptr_is_owned(b);
49063 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49064 b_conv.is_owned = false;
49065 jboolean ret_conv = InitFeatures_eq(&a_conv, &b_conv);
49069 jboolean __attribute__((export_name("TS_NodeFeatures_eq"))) TS_NodeFeatures_eq(uint64_t a, uint64_t b) {
49070 LDKNodeFeatures a_conv;
49071 a_conv.inner = untag_ptr(a);
49072 a_conv.is_owned = ptr_is_owned(a);
49073 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49074 a_conv.is_owned = false;
49075 LDKNodeFeatures b_conv;
49076 b_conv.inner = untag_ptr(b);
49077 b_conv.is_owned = ptr_is_owned(b);
49078 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49079 b_conv.is_owned = false;
49080 jboolean ret_conv = NodeFeatures_eq(&a_conv, &b_conv);
49084 jboolean __attribute__((export_name("TS_ChannelFeatures_eq"))) TS_ChannelFeatures_eq(uint64_t a, uint64_t b) {
49085 LDKChannelFeatures a_conv;
49086 a_conv.inner = untag_ptr(a);
49087 a_conv.is_owned = ptr_is_owned(a);
49088 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49089 a_conv.is_owned = false;
49090 LDKChannelFeatures b_conv;
49091 b_conv.inner = untag_ptr(b);
49092 b_conv.is_owned = ptr_is_owned(b);
49093 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49094 b_conv.is_owned = false;
49095 jboolean ret_conv = ChannelFeatures_eq(&a_conv, &b_conv);
49099 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_eq"))) TS_Bolt11InvoiceFeatures_eq(uint64_t a, uint64_t b) {
49100 LDKBolt11InvoiceFeatures a_conv;
49101 a_conv.inner = untag_ptr(a);
49102 a_conv.is_owned = ptr_is_owned(a);
49103 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49104 a_conv.is_owned = false;
49105 LDKBolt11InvoiceFeatures b_conv;
49106 b_conv.inner = untag_ptr(b);
49107 b_conv.is_owned = ptr_is_owned(b);
49108 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49109 b_conv.is_owned = false;
49110 jboolean ret_conv = Bolt11InvoiceFeatures_eq(&a_conv, &b_conv);
49114 jboolean __attribute__((export_name("TS_OfferFeatures_eq"))) TS_OfferFeatures_eq(uint64_t a, uint64_t b) {
49115 LDKOfferFeatures a_conv;
49116 a_conv.inner = untag_ptr(a);
49117 a_conv.is_owned = ptr_is_owned(a);
49118 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49119 a_conv.is_owned = false;
49120 LDKOfferFeatures b_conv;
49121 b_conv.inner = untag_ptr(b);
49122 b_conv.is_owned = ptr_is_owned(b);
49123 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49124 b_conv.is_owned = false;
49125 jboolean ret_conv = OfferFeatures_eq(&a_conv, &b_conv);
49129 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_eq"))) TS_InvoiceRequestFeatures_eq(uint64_t a, uint64_t b) {
49130 LDKInvoiceRequestFeatures a_conv;
49131 a_conv.inner = untag_ptr(a);
49132 a_conv.is_owned = ptr_is_owned(a);
49133 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49134 a_conv.is_owned = false;
49135 LDKInvoiceRequestFeatures b_conv;
49136 b_conv.inner = untag_ptr(b);
49137 b_conv.is_owned = ptr_is_owned(b);
49138 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49139 b_conv.is_owned = false;
49140 jboolean ret_conv = InvoiceRequestFeatures_eq(&a_conv, &b_conv);
49144 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_eq"))) TS_Bolt12InvoiceFeatures_eq(uint64_t a, uint64_t b) {
49145 LDKBolt12InvoiceFeatures a_conv;
49146 a_conv.inner = untag_ptr(a);
49147 a_conv.is_owned = ptr_is_owned(a);
49148 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49149 a_conv.is_owned = false;
49150 LDKBolt12InvoiceFeatures b_conv;
49151 b_conv.inner = untag_ptr(b);
49152 b_conv.is_owned = ptr_is_owned(b);
49153 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49154 b_conv.is_owned = false;
49155 jboolean ret_conv = Bolt12InvoiceFeatures_eq(&a_conv, &b_conv);
49159 jboolean __attribute__((export_name("TS_BlindedHopFeatures_eq"))) TS_BlindedHopFeatures_eq(uint64_t a, uint64_t b) {
49160 LDKBlindedHopFeatures a_conv;
49161 a_conv.inner = untag_ptr(a);
49162 a_conv.is_owned = ptr_is_owned(a);
49163 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49164 a_conv.is_owned = false;
49165 LDKBlindedHopFeatures b_conv;
49166 b_conv.inner = untag_ptr(b);
49167 b_conv.is_owned = ptr_is_owned(b);
49168 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49169 b_conv.is_owned = false;
49170 jboolean ret_conv = BlindedHopFeatures_eq(&a_conv, &b_conv);
49174 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_eq"))) TS_ChannelTypeFeatures_eq(uint64_t a, uint64_t b) {
49175 LDKChannelTypeFeatures a_conv;
49176 a_conv.inner = untag_ptr(a);
49177 a_conv.is_owned = ptr_is_owned(a);
49178 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
49179 a_conv.is_owned = false;
49180 LDKChannelTypeFeatures b_conv;
49181 b_conv.inner = untag_ptr(b);
49182 b_conv.is_owned = ptr_is_owned(b);
49183 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
49184 b_conv.is_owned = false;
49185 jboolean ret_conv = ChannelTypeFeatures_eq(&a_conv, &b_conv);
49189 static inline uint64_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
49190 LDKInitFeatures ret_var = InitFeatures_clone(arg);
49191 uint64_t ret_ref = 0;
49192 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49193 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49196 int64_t __attribute__((export_name("TS_InitFeatures_clone_ptr"))) TS_InitFeatures_clone_ptr(uint64_t arg) {
49197 LDKInitFeatures arg_conv;
49198 arg_conv.inner = untag_ptr(arg);
49199 arg_conv.is_owned = ptr_is_owned(arg);
49200 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49201 arg_conv.is_owned = false;
49202 int64_t ret_conv = InitFeatures_clone_ptr(&arg_conv);
49206 uint64_t __attribute__((export_name("TS_InitFeatures_clone"))) TS_InitFeatures_clone(uint64_t orig) {
49207 LDKInitFeatures orig_conv;
49208 orig_conv.inner = untag_ptr(orig);
49209 orig_conv.is_owned = ptr_is_owned(orig);
49210 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49211 orig_conv.is_owned = false;
49212 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
49213 uint64_t ret_ref = 0;
49214 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49215 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49219 static inline uint64_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
49220 LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
49221 uint64_t ret_ref = 0;
49222 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49223 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49226 int64_t __attribute__((export_name("TS_NodeFeatures_clone_ptr"))) TS_NodeFeatures_clone_ptr(uint64_t arg) {
49227 LDKNodeFeatures arg_conv;
49228 arg_conv.inner = untag_ptr(arg);
49229 arg_conv.is_owned = ptr_is_owned(arg);
49230 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49231 arg_conv.is_owned = false;
49232 int64_t ret_conv = NodeFeatures_clone_ptr(&arg_conv);
49236 uint64_t __attribute__((export_name("TS_NodeFeatures_clone"))) TS_NodeFeatures_clone(uint64_t orig) {
49237 LDKNodeFeatures orig_conv;
49238 orig_conv.inner = untag_ptr(orig);
49239 orig_conv.is_owned = ptr_is_owned(orig);
49240 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49241 orig_conv.is_owned = false;
49242 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
49243 uint64_t ret_ref = 0;
49244 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49245 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49249 static inline uint64_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
49250 LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
49251 uint64_t ret_ref = 0;
49252 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49253 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49256 int64_t __attribute__((export_name("TS_ChannelFeatures_clone_ptr"))) TS_ChannelFeatures_clone_ptr(uint64_t arg) {
49257 LDKChannelFeatures arg_conv;
49258 arg_conv.inner = untag_ptr(arg);
49259 arg_conv.is_owned = ptr_is_owned(arg);
49260 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49261 arg_conv.is_owned = false;
49262 int64_t ret_conv = ChannelFeatures_clone_ptr(&arg_conv);
49266 uint64_t __attribute__((export_name("TS_ChannelFeatures_clone"))) TS_ChannelFeatures_clone(uint64_t orig) {
49267 LDKChannelFeatures orig_conv;
49268 orig_conv.inner = untag_ptr(orig);
49269 orig_conv.is_owned = ptr_is_owned(orig);
49270 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49271 orig_conv.is_owned = false;
49272 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
49273 uint64_t ret_ref = 0;
49274 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49275 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49279 static inline uint64_t Bolt11InvoiceFeatures_clone_ptr(LDKBolt11InvoiceFeatures *NONNULL_PTR arg) {
49280 LDKBolt11InvoiceFeatures ret_var = Bolt11InvoiceFeatures_clone(arg);
49281 uint64_t ret_ref = 0;
49282 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49283 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49286 int64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_clone_ptr"))) TS_Bolt11InvoiceFeatures_clone_ptr(uint64_t arg) {
49287 LDKBolt11InvoiceFeatures arg_conv;
49288 arg_conv.inner = untag_ptr(arg);
49289 arg_conv.is_owned = ptr_is_owned(arg);
49290 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49291 arg_conv.is_owned = false;
49292 int64_t ret_conv = Bolt11InvoiceFeatures_clone_ptr(&arg_conv);
49296 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_clone"))) TS_Bolt11InvoiceFeatures_clone(uint64_t orig) {
49297 LDKBolt11InvoiceFeatures orig_conv;
49298 orig_conv.inner = untag_ptr(orig);
49299 orig_conv.is_owned = ptr_is_owned(orig);
49300 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49301 orig_conv.is_owned = false;
49302 LDKBolt11InvoiceFeatures ret_var = Bolt11InvoiceFeatures_clone(&orig_conv);
49303 uint64_t ret_ref = 0;
49304 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49305 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49309 static inline uint64_t OfferFeatures_clone_ptr(LDKOfferFeatures *NONNULL_PTR arg) {
49310 LDKOfferFeatures ret_var = OfferFeatures_clone(arg);
49311 uint64_t ret_ref = 0;
49312 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49313 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49316 int64_t __attribute__((export_name("TS_OfferFeatures_clone_ptr"))) TS_OfferFeatures_clone_ptr(uint64_t arg) {
49317 LDKOfferFeatures arg_conv;
49318 arg_conv.inner = untag_ptr(arg);
49319 arg_conv.is_owned = ptr_is_owned(arg);
49320 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49321 arg_conv.is_owned = false;
49322 int64_t ret_conv = OfferFeatures_clone_ptr(&arg_conv);
49326 uint64_t __attribute__((export_name("TS_OfferFeatures_clone"))) TS_OfferFeatures_clone(uint64_t orig) {
49327 LDKOfferFeatures orig_conv;
49328 orig_conv.inner = untag_ptr(orig);
49329 orig_conv.is_owned = ptr_is_owned(orig);
49330 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49331 orig_conv.is_owned = false;
49332 LDKOfferFeatures ret_var = OfferFeatures_clone(&orig_conv);
49333 uint64_t ret_ref = 0;
49334 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49335 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49339 static inline uint64_t InvoiceRequestFeatures_clone_ptr(LDKInvoiceRequestFeatures *NONNULL_PTR arg) {
49340 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(arg);
49341 uint64_t ret_ref = 0;
49342 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49343 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49346 int64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone_ptr"))) TS_InvoiceRequestFeatures_clone_ptr(uint64_t arg) {
49347 LDKInvoiceRequestFeatures arg_conv;
49348 arg_conv.inner = untag_ptr(arg);
49349 arg_conv.is_owned = ptr_is_owned(arg);
49350 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49351 arg_conv.is_owned = false;
49352 int64_t ret_conv = InvoiceRequestFeatures_clone_ptr(&arg_conv);
49356 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_clone"))) TS_InvoiceRequestFeatures_clone(uint64_t orig) {
49357 LDKInvoiceRequestFeatures orig_conv;
49358 orig_conv.inner = untag_ptr(orig);
49359 orig_conv.is_owned = ptr_is_owned(orig);
49360 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49361 orig_conv.is_owned = false;
49362 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_clone(&orig_conv);
49363 uint64_t ret_ref = 0;
49364 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49365 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49369 static inline uint64_t Bolt12InvoiceFeatures_clone_ptr(LDKBolt12InvoiceFeatures *NONNULL_PTR arg) {
49370 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(arg);
49371 uint64_t ret_ref = 0;
49372 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49373 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49376 int64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone_ptr"))) TS_Bolt12InvoiceFeatures_clone_ptr(uint64_t arg) {
49377 LDKBolt12InvoiceFeatures arg_conv;
49378 arg_conv.inner = untag_ptr(arg);
49379 arg_conv.is_owned = ptr_is_owned(arg);
49380 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49381 arg_conv.is_owned = false;
49382 int64_t ret_conv = Bolt12InvoiceFeatures_clone_ptr(&arg_conv);
49386 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_clone"))) TS_Bolt12InvoiceFeatures_clone(uint64_t orig) {
49387 LDKBolt12InvoiceFeatures orig_conv;
49388 orig_conv.inner = untag_ptr(orig);
49389 orig_conv.is_owned = ptr_is_owned(orig);
49390 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49391 orig_conv.is_owned = false;
49392 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_clone(&orig_conv);
49393 uint64_t ret_ref = 0;
49394 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49395 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49399 static inline uint64_t BlindedHopFeatures_clone_ptr(LDKBlindedHopFeatures *NONNULL_PTR arg) {
49400 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(arg);
49401 uint64_t ret_ref = 0;
49402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49406 int64_t __attribute__((export_name("TS_BlindedHopFeatures_clone_ptr"))) TS_BlindedHopFeatures_clone_ptr(uint64_t arg) {
49407 LDKBlindedHopFeatures arg_conv;
49408 arg_conv.inner = untag_ptr(arg);
49409 arg_conv.is_owned = ptr_is_owned(arg);
49410 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49411 arg_conv.is_owned = false;
49412 int64_t ret_conv = BlindedHopFeatures_clone_ptr(&arg_conv);
49416 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_clone"))) TS_BlindedHopFeatures_clone(uint64_t orig) {
49417 LDKBlindedHopFeatures orig_conv;
49418 orig_conv.inner = untag_ptr(orig);
49419 orig_conv.is_owned = ptr_is_owned(orig);
49420 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49421 orig_conv.is_owned = false;
49422 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_clone(&orig_conv);
49423 uint64_t ret_ref = 0;
49424 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49425 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49429 static inline uint64_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg) {
49430 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(arg);
49431 uint64_t ret_ref = 0;
49432 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49433 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49436 int64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone_ptr"))) TS_ChannelTypeFeatures_clone_ptr(uint64_t arg) {
49437 LDKChannelTypeFeatures arg_conv;
49438 arg_conv.inner = untag_ptr(arg);
49439 arg_conv.is_owned = ptr_is_owned(arg);
49440 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
49441 arg_conv.is_owned = false;
49442 int64_t ret_conv = ChannelTypeFeatures_clone_ptr(&arg_conv);
49446 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_clone"))) TS_ChannelTypeFeatures_clone(uint64_t orig) {
49447 LDKChannelTypeFeatures orig_conv;
49448 orig_conv.inner = untag_ptr(orig);
49449 orig_conv.is_owned = ptr_is_owned(orig);
49450 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
49451 orig_conv.is_owned = false;
49452 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(&orig_conv);
49453 uint64_t ret_ref = 0;
49454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49459 void __attribute__((export_name("TS_InitFeatures_free"))) TS_InitFeatures_free(uint64_t this_obj) {
49460 LDKInitFeatures this_obj_conv;
49461 this_obj_conv.inner = untag_ptr(this_obj);
49462 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49463 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49464 InitFeatures_free(this_obj_conv);
49467 void __attribute__((export_name("TS_NodeFeatures_free"))) TS_NodeFeatures_free(uint64_t this_obj) {
49468 LDKNodeFeatures this_obj_conv;
49469 this_obj_conv.inner = untag_ptr(this_obj);
49470 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49472 NodeFeatures_free(this_obj_conv);
49475 void __attribute__((export_name("TS_ChannelFeatures_free"))) TS_ChannelFeatures_free(uint64_t this_obj) {
49476 LDKChannelFeatures this_obj_conv;
49477 this_obj_conv.inner = untag_ptr(this_obj);
49478 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49480 ChannelFeatures_free(this_obj_conv);
49483 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_free"))) TS_Bolt11InvoiceFeatures_free(uint64_t this_obj) {
49484 LDKBolt11InvoiceFeatures this_obj_conv;
49485 this_obj_conv.inner = untag_ptr(this_obj);
49486 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49488 Bolt11InvoiceFeatures_free(this_obj_conv);
49491 void __attribute__((export_name("TS_OfferFeatures_free"))) TS_OfferFeatures_free(uint64_t this_obj) {
49492 LDKOfferFeatures this_obj_conv;
49493 this_obj_conv.inner = untag_ptr(this_obj);
49494 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49495 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49496 OfferFeatures_free(this_obj_conv);
49499 void __attribute__((export_name("TS_InvoiceRequestFeatures_free"))) TS_InvoiceRequestFeatures_free(uint64_t this_obj) {
49500 LDKInvoiceRequestFeatures this_obj_conv;
49501 this_obj_conv.inner = untag_ptr(this_obj);
49502 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49504 InvoiceRequestFeatures_free(this_obj_conv);
49507 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_free"))) TS_Bolt12InvoiceFeatures_free(uint64_t this_obj) {
49508 LDKBolt12InvoiceFeatures this_obj_conv;
49509 this_obj_conv.inner = untag_ptr(this_obj);
49510 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49512 Bolt12InvoiceFeatures_free(this_obj_conv);
49515 void __attribute__((export_name("TS_BlindedHopFeatures_free"))) TS_BlindedHopFeatures_free(uint64_t this_obj) {
49516 LDKBlindedHopFeatures this_obj_conv;
49517 this_obj_conv.inner = untag_ptr(this_obj);
49518 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49520 BlindedHopFeatures_free(this_obj_conv);
49523 void __attribute__((export_name("TS_ChannelTypeFeatures_free"))) TS_ChannelTypeFeatures_free(uint64_t this_obj) {
49524 LDKChannelTypeFeatures this_obj_conv;
49525 this_obj_conv.inner = untag_ptr(this_obj);
49526 this_obj_conv.is_owned = ptr_is_owned(this_obj);
49527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
49528 ChannelTypeFeatures_free(this_obj_conv);
49531 uint64_t __attribute__((export_name("TS_InitFeatures_empty"))) TS_InitFeatures_empty() {
49532 LDKInitFeatures ret_var = InitFeatures_empty();
49533 uint64_t ret_ref = 0;
49534 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49535 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49539 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits_from"))) TS_InitFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49540 LDKInitFeatures this_arg_conv;
49541 this_arg_conv.inner = untag_ptr(this_arg);
49542 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49543 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49544 this_arg_conv.is_owned = false;
49545 LDKInitFeatures other_conv;
49546 other_conv.inner = untag_ptr(other);
49547 other_conv.is_owned = ptr_is_owned(other);
49548 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49549 other_conv.is_owned = false;
49550 jboolean ret_conv = InitFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49554 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits"))) TS_InitFeatures_requires_unknown_bits(uint64_t this_arg) {
49555 LDKInitFeatures this_arg_conv;
49556 this_arg_conv.inner = untag_ptr(this_arg);
49557 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49559 this_arg_conv.is_owned = false;
49560 jboolean ret_conv = InitFeatures_requires_unknown_bits(&this_arg_conv);
49564 uint64_t __attribute__((export_name("TS_InitFeatures_set_required_feature_bit"))) TS_InitFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49565 LDKInitFeatures this_arg_conv;
49566 this_arg_conv.inner = untag_ptr(this_arg);
49567 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49569 this_arg_conv.is_owned = false;
49570 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49571 *ret_conv = InitFeatures_set_required_feature_bit(&this_arg_conv, bit);
49572 return tag_ptr(ret_conv, true);
49575 uint64_t __attribute__((export_name("TS_InitFeatures_set_optional_feature_bit"))) TS_InitFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49576 LDKInitFeatures this_arg_conv;
49577 this_arg_conv.inner = untag_ptr(this_arg);
49578 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49580 this_arg_conv.is_owned = false;
49581 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49582 *ret_conv = InitFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49583 return tag_ptr(ret_conv, true);
49586 uint64_t __attribute__((export_name("TS_InitFeatures_set_required_custom_bit"))) TS_InitFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49587 LDKInitFeatures this_arg_conv;
49588 this_arg_conv.inner = untag_ptr(this_arg);
49589 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49590 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49591 this_arg_conv.is_owned = false;
49592 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49593 *ret_conv = InitFeatures_set_required_custom_bit(&this_arg_conv, bit);
49594 return tag_ptr(ret_conv, true);
49597 uint64_t __attribute__((export_name("TS_InitFeatures_set_optional_custom_bit"))) TS_InitFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49598 LDKInitFeatures this_arg_conv;
49599 this_arg_conv.inner = untag_ptr(this_arg);
49600 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49602 this_arg_conv.is_owned = false;
49603 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49604 *ret_conv = InitFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49605 return tag_ptr(ret_conv, true);
49608 uint64_t __attribute__((export_name("TS_NodeFeatures_empty"))) TS_NodeFeatures_empty() {
49609 LDKNodeFeatures ret_var = NodeFeatures_empty();
49610 uint64_t ret_ref = 0;
49611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49616 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits_from"))) TS_NodeFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49617 LDKNodeFeatures this_arg_conv;
49618 this_arg_conv.inner = untag_ptr(this_arg);
49619 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49621 this_arg_conv.is_owned = false;
49622 LDKNodeFeatures other_conv;
49623 other_conv.inner = untag_ptr(other);
49624 other_conv.is_owned = ptr_is_owned(other);
49625 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49626 other_conv.is_owned = false;
49627 jboolean ret_conv = NodeFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49631 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits"))) TS_NodeFeatures_requires_unknown_bits(uint64_t this_arg) {
49632 LDKNodeFeatures this_arg_conv;
49633 this_arg_conv.inner = untag_ptr(this_arg);
49634 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49635 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49636 this_arg_conv.is_owned = false;
49637 jboolean ret_conv = NodeFeatures_requires_unknown_bits(&this_arg_conv);
49641 uint64_t __attribute__((export_name("TS_NodeFeatures_set_required_feature_bit"))) TS_NodeFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49642 LDKNodeFeatures this_arg_conv;
49643 this_arg_conv.inner = untag_ptr(this_arg);
49644 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49646 this_arg_conv.is_owned = false;
49647 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49648 *ret_conv = NodeFeatures_set_required_feature_bit(&this_arg_conv, bit);
49649 return tag_ptr(ret_conv, true);
49652 uint64_t __attribute__((export_name("TS_NodeFeatures_set_optional_feature_bit"))) TS_NodeFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49653 LDKNodeFeatures this_arg_conv;
49654 this_arg_conv.inner = untag_ptr(this_arg);
49655 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49657 this_arg_conv.is_owned = false;
49658 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49659 *ret_conv = NodeFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49660 return tag_ptr(ret_conv, true);
49663 uint64_t __attribute__((export_name("TS_NodeFeatures_set_required_custom_bit"))) TS_NodeFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49664 LDKNodeFeatures this_arg_conv;
49665 this_arg_conv.inner = untag_ptr(this_arg);
49666 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49668 this_arg_conv.is_owned = false;
49669 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49670 *ret_conv = NodeFeatures_set_required_custom_bit(&this_arg_conv, bit);
49671 return tag_ptr(ret_conv, true);
49674 uint64_t __attribute__((export_name("TS_NodeFeatures_set_optional_custom_bit"))) TS_NodeFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49675 LDKNodeFeatures this_arg_conv;
49676 this_arg_conv.inner = untag_ptr(this_arg);
49677 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49678 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49679 this_arg_conv.is_owned = false;
49680 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49681 *ret_conv = NodeFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49682 return tag_ptr(ret_conv, true);
49685 uint64_t __attribute__((export_name("TS_ChannelFeatures_empty"))) TS_ChannelFeatures_empty() {
49686 LDKChannelFeatures ret_var = ChannelFeatures_empty();
49687 uint64_t ret_ref = 0;
49688 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49689 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49693 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits_from"))) TS_ChannelFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49694 LDKChannelFeatures this_arg_conv;
49695 this_arg_conv.inner = untag_ptr(this_arg);
49696 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49698 this_arg_conv.is_owned = false;
49699 LDKChannelFeatures other_conv;
49700 other_conv.inner = untag_ptr(other);
49701 other_conv.is_owned = ptr_is_owned(other);
49702 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49703 other_conv.is_owned = false;
49704 jboolean ret_conv = ChannelFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49708 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits"))) TS_ChannelFeatures_requires_unknown_bits(uint64_t this_arg) {
49709 LDKChannelFeatures this_arg_conv;
49710 this_arg_conv.inner = untag_ptr(this_arg);
49711 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49712 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49713 this_arg_conv.is_owned = false;
49714 jboolean ret_conv = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
49718 uint64_t __attribute__((export_name("TS_ChannelFeatures_set_required_feature_bit"))) TS_ChannelFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49719 LDKChannelFeatures this_arg_conv;
49720 this_arg_conv.inner = untag_ptr(this_arg);
49721 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49723 this_arg_conv.is_owned = false;
49724 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49725 *ret_conv = ChannelFeatures_set_required_feature_bit(&this_arg_conv, bit);
49726 return tag_ptr(ret_conv, true);
49729 uint64_t __attribute__((export_name("TS_ChannelFeatures_set_optional_feature_bit"))) TS_ChannelFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49730 LDKChannelFeatures this_arg_conv;
49731 this_arg_conv.inner = untag_ptr(this_arg);
49732 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49733 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49734 this_arg_conv.is_owned = false;
49735 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49736 *ret_conv = ChannelFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49737 return tag_ptr(ret_conv, true);
49740 uint64_t __attribute__((export_name("TS_ChannelFeatures_set_required_custom_bit"))) TS_ChannelFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49741 LDKChannelFeatures this_arg_conv;
49742 this_arg_conv.inner = untag_ptr(this_arg);
49743 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49744 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49745 this_arg_conv.is_owned = false;
49746 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49747 *ret_conv = ChannelFeatures_set_required_custom_bit(&this_arg_conv, bit);
49748 return tag_ptr(ret_conv, true);
49751 uint64_t __attribute__((export_name("TS_ChannelFeatures_set_optional_custom_bit"))) TS_ChannelFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49752 LDKChannelFeatures this_arg_conv;
49753 this_arg_conv.inner = untag_ptr(this_arg);
49754 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49756 this_arg_conv.is_owned = false;
49757 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49758 *ret_conv = ChannelFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49759 return tag_ptr(ret_conv, true);
49762 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_empty"))) TS_Bolt11InvoiceFeatures_empty() {
49763 LDKBolt11InvoiceFeatures ret_var = Bolt11InvoiceFeatures_empty();
49764 uint64_t ret_ref = 0;
49765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49766 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49770 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_unknown_bits_from"))) TS_Bolt11InvoiceFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49771 LDKBolt11InvoiceFeatures this_arg_conv;
49772 this_arg_conv.inner = untag_ptr(this_arg);
49773 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49775 this_arg_conv.is_owned = false;
49776 LDKBolt11InvoiceFeatures other_conv;
49777 other_conv.inner = untag_ptr(other);
49778 other_conv.is_owned = ptr_is_owned(other);
49779 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49780 other_conv.is_owned = false;
49781 jboolean ret_conv = Bolt11InvoiceFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49785 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_unknown_bits"))) TS_Bolt11InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
49786 LDKBolt11InvoiceFeatures this_arg_conv;
49787 this_arg_conv.inner = untag_ptr(this_arg);
49788 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49790 this_arg_conv.is_owned = false;
49791 jboolean ret_conv = Bolt11InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
49795 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_required_feature_bit"))) TS_Bolt11InvoiceFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49796 LDKBolt11InvoiceFeatures this_arg_conv;
49797 this_arg_conv.inner = untag_ptr(this_arg);
49798 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49799 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49800 this_arg_conv.is_owned = false;
49801 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49802 *ret_conv = Bolt11InvoiceFeatures_set_required_feature_bit(&this_arg_conv, bit);
49803 return tag_ptr(ret_conv, true);
49806 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_optional_feature_bit"))) TS_Bolt11InvoiceFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49807 LDKBolt11InvoiceFeatures this_arg_conv;
49808 this_arg_conv.inner = untag_ptr(this_arg);
49809 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49811 this_arg_conv.is_owned = false;
49812 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49813 *ret_conv = Bolt11InvoiceFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49814 return tag_ptr(ret_conv, true);
49817 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_required_custom_bit"))) TS_Bolt11InvoiceFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49818 LDKBolt11InvoiceFeatures this_arg_conv;
49819 this_arg_conv.inner = untag_ptr(this_arg);
49820 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49822 this_arg_conv.is_owned = false;
49823 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49824 *ret_conv = Bolt11InvoiceFeatures_set_required_custom_bit(&this_arg_conv, bit);
49825 return tag_ptr(ret_conv, true);
49828 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_optional_custom_bit"))) TS_Bolt11InvoiceFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49829 LDKBolt11InvoiceFeatures this_arg_conv;
49830 this_arg_conv.inner = untag_ptr(this_arg);
49831 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49833 this_arg_conv.is_owned = false;
49834 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49835 *ret_conv = Bolt11InvoiceFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49836 return tag_ptr(ret_conv, true);
49839 uint64_t __attribute__((export_name("TS_OfferFeatures_empty"))) TS_OfferFeatures_empty() {
49840 LDKOfferFeatures ret_var = OfferFeatures_empty();
49841 uint64_t ret_ref = 0;
49842 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49843 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49847 jboolean __attribute__((export_name("TS_OfferFeatures_requires_unknown_bits_from"))) TS_OfferFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49848 LDKOfferFeatures this_arg_conv;
49849 this_arg_conv.inner = untag_ptr(this_arg);
49850 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49852 this_arg_conv.is_owned = false;
49853 LDKOfferFeatures other_conv;
49854 other_conv.inner = untag_ptr(other);
49855 other_conv.is_owned = ptr_is_owned(other);
49856 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49857 other_conv.is_owned = false;
49858 jboolean ret_conv = OfferFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49862 jboolean __attribute__((export_name("TS_OfferFeatures_requires_unknown_bits"))) TS_OfferFeatures_requires_unknown_bits(uint64_t this_arg) {
49863 LDKOfferFeatures this_arg_conv;
49864 this_arg_conv.inner = untag_ptr(this_arg);
49865 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49867 this_arg_conv.is_owned = false;
49868 jboolean ret_conv = OfferFeatures_requires_unknown_bits(&this_arg_conv);
49872 uint64_t __attribute__((export_name("TS_OfferFeatures_set_required_feature_bit"))) TS_OfferFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49873 LDKOfferFeatures this_arg_conv;
49874 this_arg_conv.inner = untag_ptr(this_arg);
49875 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49877 this_arg_conv.is_owned = false;
49878 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49879 *ret_conv = OfferFeatures_set_required_feature_bit(&this_arg_conv, bit);
49880 return tag_ptr(ret_conv, true);
49883 uint64_t __attribute__((export_name("TS_OfferFeatures_set_optional_feature_bit"))) TS_OfferFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49884 LDKOfferFeatures this_arg_conv;
49885 this_arg_conv.inner = untag_ptr(this_arg);
49886 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49888 this_arg_conv.is_owned = false;
49889 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49890 *ret_conv = OfferFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49891 return tag_ptr(ret_conv, true);
49894 uint64_t __attribute__((export_name("TS_OfferFeatures_set_required_custom_bit"))) TS_OfferFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49895 LDKOfferFeatures this_arg_conv;
49896 this_arg_conv.inner = untag_ptr(this_arg);
49897 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49899 this_arg_conv.is_owned = false;
49900 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49901 *ret_conv = OfferFeatures_set_required_custom_bit(&this_arg_conv, bit);
49902 return tag_ptr(ret_conv, true);
49905 uint64_t __attribute__((export_name("TS_OfferFeatures_set_optional_custom_bit"))) TS_OfferFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49906 LDKOfferFeatures this_arg_conv;
49907 this_arg_conv.inner = untag_ptr(this_arg);
49908 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49910 this_arg_conv.is_owned = false;
49911 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49912 *ret_conv = OfferFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49913 return tag_ptr(ret_conv, true);
49916 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_empty"))) TS_InvoiceRequestFeatures_empty() {
49917 LDKInvoiceRequestFeatures ret_var = InvoiceRequestFeatures_empty();
49918 uint64_t ret_ref = 0;
49919 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49920 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
49924 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_requires_unknown_bits_from"))) TS_InvoiceRequestFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
49925 LDKInvoiceRequestFeatures this_arg_conv;
49926 this_arg_conv.inner = untag_ptr(this_arg);
49927 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49929 this_arg_conv.is_owned = false;
49930 LDKInvoiceRequestFeatures other_conv;
49931 other_conv.inner = untag_ptr(other);
49932 other_conv.is_owned = ptr_is_owned(other);
49933 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
49934 other_conv.is_owned = false;
49935 jboolean ret_conv = InvoiceRequestFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
49939 jboolean __attribute__((export_name("TS_InvoiceRequestFeatures_requires_unknown_bits"))) TS_InvoiceRequestFeatures_requires_unknown_bits(uint64_t this_arg) {
49940 LDKInvoiceRequestFeatures this_arg_conv;
49941 this_arg_conv.inner = untag_ptr(this_arg);
49942 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49944 this_arg_conv.is_owned = false;
49945 jboolean ret_conv = InvoiceRequestFeatures_requires_unknown_bits(&this_arg_conv);
49949 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_set_required_feature_bit"))) TS_InvoiceRequestFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
49950 LDKInvoiceRequestFeatures this_arg_conv;
49951 this_arg_conv.inner = untag_ptr(this_arg);
49952 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49954 this_arg_conv.is_owned = false;
49955 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49956 *ret_conv = InvoiceRequestFeatures_set_required_feature_bit(&this_arg_conv, bit);
49957 return tag_ptr(ret_conv, true);
49960 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_set_optional_feature_bit"))) TS_InvoiceRequestFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
49961 LDKInvoiceRequestFeatures this_arg_conv;
49962 this_arg_conv.inner = untag_ptr(this_arg);
49963 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49964 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49965 this_arg_conv.is_owned = false;
49966 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49967 *ret_conv = InvoiceRequestFeatures_set_optional_feature_bit(&this_arg_conv, bit);
49968 return tag_ptr(ret_conv, true);
49971 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_set_required_custom_bit"))) TS_InvoiceRequestFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
49972 LDKInvoiceRequestFeatures this_arg_conv;
49973 this_arg_conv.inner = untag_ptr(this_arg);
49974 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49976 this_arg_conv.is_owned = false;
49977 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49978 *ret_conv = InvoiceRequestFeatures_set_required_custom_bit(&this_arg_conv, bit);
49979 return tag_ptr(ret_conv, true);
49982 uint64_t __attribute__((export_name("TS_InvoiceRequestFeatures_set_optional_custom_bit"))) TS_InvoiceRequestFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
49983 LDKInvoiceRequestFeatures this_arg_conv;
49984 this_arg_conv.inner = untag_ptr(this_arg);
49985 this_arg_conv.is_owned = ptr_is_owned(this_arg);
49986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
49987 this_arg_conv.is_owned = false;
49988 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
49989 *ret_conv = InvoiceRequestFeatures_set_optional_custom_bit(&this_arg_conv, bit);
49990 return tag_ptr(ret_conv, true);
49993 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_empty"))) TS_Bolt12InvoiceFeatures_empty() {
49994 LDKBolt12InvoiceFeatures ret_var = Bolt12InvoiceFeatures_empty();
49995 uint64_t ret_ref = 0;
49996 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
49997 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
50001 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_unknown_bits_from"))) TS_Bolt12InvoiceFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
50002 LDKBolt12InvoiceFeatures this_arg_conv;
50003 this_arg_conv.inner = untag_ptr(this_arg);
50004 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50006 this_arg_conv.is_owned = false;
50007 LDKBolt12InvoiceFeatures other_conv;
50008 other_conv.inner = untag_ptr(other);
50009 other_conv.is_owned = ptr_is_owned(other);
50010 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
50011 other_conv.is_owned = false;
50012 jboolean ret_conv = Bolt12InvoiceFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
50016 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_unknown_bits"))) TS_Bolt12InvoiceFeatures_requires_unknown_bits(uint64_t this_arg) {
50017 LDKBolt12InvoiceFeatures this_arg_conv;
50018 this_arg_conv.inner = untag_ptr(this_arg);
50019 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50021 this_arg_conv.is_owned = false;
50022 jboolean ret_conv = Bolt12InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
50026 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_required_feature_bit"))) TS_Bolt12InvoiceFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
50027 LDKBolt12InvoiceFeatures this_arg_conv;
50028 this_arg_conv.inner = untag_ptr(this_arg);
50029 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50030 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50031 this_arg_conv.is_owned = false;
50032 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50033 *ret_conv = Bolt12InvoiceFeatures_set_required_feature_bit(&this_arg_conv, bit);
50034 return tag_ptr(ret_conv, true);
50037 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_optional_feature_bit"))) TS_Bolt12InvoiceFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
50038 LDKBolt12InvoiceFeatures this_arg_conv;
50039 this_arg_conv.inner = untag_ptr(this_arg);
50040 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50042 this_arg_conv.is_owned = false;
50043 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50044 *ret_conv = Bolt12InvoiceFeatures_set_optional_feature_bit(&this_arg_conv, bit);
50045 return tag_ptr(ret_conv, true);
50048 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_required_custom_bit"))) TS_Bolt12InvoiceFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
50049 LDKBolt12InvoiceFeatures this_arg_conv;
50050 this_arg_conv.inner = untag_ptr(this_arg);
50051 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50053 this_arg_conv.is_owned = false;
50054 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50055 *ret_conv = Bolt12InvoiceFeatures_set_required_custom_bit(&this_arg_conv, bit);
50056 return tag_ptr(ret_conv, true);
50059 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_optional_custom_bit"))) TS_Bolt12InvoiceFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
50060 LDKBolt12InvoiceFeatures this_arg_conv;
50061 this_arg_conv.inner = untag_ptr(this_arg);
50062 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50064 this_arg_conv.is_owned = false;
50065 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50066 *ret_conv = Bolt12InvoiceFeatures_set_optional_custom_bit(&this_arg_conv, bit);
50067 return tag_ptr(ret_conv, true);
50070 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_empty"))) TS_BlindedHopFeatures_empty() {
50071 LDKBlindedHopFeatures ret_var = BlindedHopFeatures_empty();
50072 uint64_t ret_ref = 0;
50073 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
50074 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
50078 jboolean __attribute__((export_name("TS_BlindedHopFeatures_requires_unknown_bits_from"))) TS_BlindedHopFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
50079 LDKBlindedHopFeatures this_arg_conv;
50080 this_arg_conv.inner = untag_ptr(this_arg);
50081 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50083 this_arg_conv.is_owned = false;
50084 LDKBlindedHopFeatures other_conv;
50085 other_conv.inner = untag_ptr(other);
50086 other_conv.is_owned = ptr_is_owned(other);
50087 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
50088 other_conv.is_owned = false;
50089 jboolean ret_conv = BlindedHopFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
50093 jboolean __attribute__((export_name("TS_BlindedHopFeatures_requires_unknown_bits"))) TS_BlindedHopFeatures_requires_unknown_bits(uint64_t this_arg) {
50094 LDKBlindedHopFeatures this_arg_conv;
50095 this_arg_conv.inner = untag_ptr(this_arg);
50096 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50097 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50098 this_arg_conv.is_owned = false;
50099 jboolean ret_conv = BlindedHopFeatures_requires_unknown_bits(&this_arg_conv);
50103 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_set_required_feature_bit"))) TS_BlindedHopFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
50104 LDKBlindedHopFeatures this_arg_conv;
50105 this_arg_conv.inner = untag_ptr(this_arg);
50106 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50108 this_arg_conv.is_owned = false;
50109 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50110 *ret_conv = BlindedHopFeatures_set_required_feature_bit(&this_arg_conv, bit);
50111 return tag_ptr(ret_conv, true);
50114 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_set_optional_feature_bit"))) TS_BlindedHopFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
50115 LDKBlindedHopFeatures this_arg_conv;
50116 this_arg_conv.inner = untag_ptr(this_arg);
50117 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50119 this_arg_conv.is_owned = false;
50120 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50121 *ret_conv = BlindedHopFeatures_set_optional_feature_bit(&this_arg_conv, bit);
50122 return tag_ptr(ret_conv, true);
50125 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_set_required_custom_bit"))) TS_BlindedHopFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
50126 LDKBlindedHopFeatures this_arg_conv;
50127 this_arg_conv.inner = untag_ptr(this_arg);
50128 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50130 this_arg_conv.is_owned = false;
50131 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50132 *ret_conv = BlindedHopFeatures_set_required_custom_bit(&this_arg_conv, bit);
50133 return tag_ptr(ret_conv, true);
50136 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_set_optional_custom_bit"))) TS_BlindedHopFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
50137 LDKBlindedHopFeatures this_arg_conv;
50138 this_arg_conv.inner = untag_ptr(this_arg);
50139 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50141 this_arg_conv.is_owned = false;
50142 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50143 *ret_conv = BlindedHopFeatures_set_optional_custom_bit(&this_arg_conv, bit);
50144 return tag_ptr(ret_conv, true);
50147 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_empty"))) TS_ChannelTypeFeatures_empty() {
50148 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_empty();
50149 uint64_t ret_ref = 0;
50150 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
50151 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
50155 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits_from"))) TS_ChannelTypeFeatures_requires_unknown_bits_from(uint64_t this_arg, uint64_t other) {
50156 LDKChannelTypeFeatures this_arg_conv;
50157 this_arg_conv.inner = untag_ptr(this_arg);
50158 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50160 this_arg_conv.is_owned = false;
50161 LDKChannelTypeFeatures other_conv;
50162 other_conv.inner = untag_ptr(other);
50163 other_conv.is_owned = ptr_is_owned(other);
50164 CHECK_INNER_FIELD_ACCESS_OR_NULL(other_conv);
50165 other_conv.is_owned = false;
50166 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits_from(&this_arg_conv, &other_conv);
50170 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits"))) TS_ChannelTypeFeatures_requires_unknown_bits(uint64_t this_arg) {
50171 LDKChannelTypeFeatures this_arg_conv;
50172 this_arg_conv.inner = untag_ptr(this_arg);
50173 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50175 this_arg_conv.is_owned = false;
50176 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits(&this_arg_conv);
50180 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_set_required_feature_bit"))) TS_ChannelTypeFeatures_set_required_feature_bit(uint64_t this_arg, uint32_t bit) {
50181 LDKChannelTypeFeatures this_arg_conv;
50182 this_arg_conv.inner = untag_ptr(this_arg);
50183 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50185 this_arg_conv.is_owned = false;
50186 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50187 *ret_conv = ChannelTypeFeatures_set_required_feature_bit(&this_arg_conv, bit);
50188 return tag_ptr(ret_conv, true);
50191 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_set_optional_feature_bit"))) TS_ChannelTypeFeatures_set_optional_feature_bit(uint64_t this_arg, uint32_t bit) {
50192 LDKChannelTypeFeatures this_arg_conv;
50193 this_arg_conv.inner = untag_ptr(this_arg);
50194 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50196 this_arg_conv.is_owned = false;
50197 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50198 *ret_conv = ChannelTypeFeatures_set_optional_feature_bit(&this_arg_conv, bit);
50199 return tag_ptr(ret_conv, true);
50202 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_set_required_custom_bit"))) TS_ChannelTypeFeatures_set_required_custom_bit(uint64_t this_arg, uint32_t bit) {
50203 LDKChannelTypeFeatures this_arg_conv;
50204 this_arg_conv.inner = untag_ptr(this_arg);
50205 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50207 this_arg_conv.is_owned = false;
50208 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50209 *ret_conv = ChannelTypeFeatures_set_required_custom_bit(&this_arg_conv, bit);
50210 return tag_ptr(ret_conv, true);
50213 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_set_optional_custom_bit"))) TS_ChannelTypeFeatures_set_optional_custom_bit(uint64_t this_arg, uint32_t bit) {
50214 LDKChannelTypeFeatures this_arg_conv;
50215 this_arg_conv.inner = untag_ptr(this_arg);
50216 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50218 this_arg_conv.is_owned = false;
50219 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
50220 *ret_conv = ChannelTypeFeatures_set_optional_custom_bit(&this_arg_conv, bit);
50221 return tag_ptr(ret_conv, true);
50224 int8_tArray __attribute__((export_name("TS_InitFeatures_write"))) TS_InitFeatures_write(uint64_t obj) {
50225 LDKInitFeatures obj_conv;
50226 obj_conv.inner = untag_ptr(obj);
50227 obj_conv.is_owned = ptr_is_owned(obj);
50228 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50229 obj_conv.is_owned = false;
50230 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
50231 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50232 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50233 CVec_u8Z_free(ret_var);
50237 uint64_t __attribute__((export_name("TS_InitFeatures_read"))) TS_InitFeatures_read(int8_tArray ser) {
50238 LDKu8slice ser_ref;
50239 ser_ref.datalen = ser->arr_len;
50240 ser_ref.data = ser->elems;
50241 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
50242 *ret_conv = InitFeatures_read(ser_ref);
50244 return tag_ptr(ret_conv, true);
50247 int8_tArray __attribute__((export_name("TS_ChannelFeatures_write"))) TS_ChannelFeatures_write(uint64_t obj) {
50248 LDKChannelFeatures obj_conv;
50249 obj_conv.inner = untag_ptr(obj);
50250 obj_conv.is_owned = ptr_is_owned(obj);
50251 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50252 obj_conv.is_owned = false;
50253 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
50254 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50255 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50256 CVec_u8Z_free(ret_var);
50260 uint64_t __attribute__((export_name("TS_ChannelFeatures_read"))) TS_ChannelFeatures_read(int8_tArray ser) {
50261 LDKu8slice ser_ref;
50262 ser_ref.datalen = ser->arr_len;
50263 ser_ref.data = ser->elems;
50264 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
50265 *ret_conv = ChannelFeatures_read(ser_ref);
50267 return tag_ptr(ret_conv, true);
50270 int8_tArray __attribute__((export_name("TS_NodeFeatures_write"))) TS_NodeFeatures_write(uint64_t obj) {
50271 LDKNodeFeatures obj_conv;
50272 obj_conv.inner = untag_ptr(obj);
50273 obj_conv.is_owned = ptr_is_owned(obj);
50274 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50275 obj_conv.is_owned = false;
50276 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
50277 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50278 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50279 CVec_u8Z_free(ret_var);
50283 uint64_t __attribute__((export_name("TS_NodeFeatures_read"))) TS_NodeFeatures_read(int8_tArray ser) {
50284 LDKu8slice ser_ref;
50285 ser_ref.datalen = ser->arr_len;
50286 ser_ref.data = ser->elems;
50287 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
50288 *ret_conv = NodeFeatures_read(ser_ref);
50290 return tag_ptr(ret_conv, true);
50293 int8_tArray __attribute__((export_name("TS_Bolt11InvoiceFeatures_write"))) TS_Bolt11InvoiceFeatures_write(uint64_t obj) {
50294 LDKBolt11InvoiceFeatures obj_conv;
50295 obj_conv.inner = untag_ptr(obj);
50296 obj_conv.is_owned = ptr_is_owned(obj);
50297 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50298 obj_conv.is_owned = false;
50299 LDKCVec_u8Z ret_var = Bolt11InvoiceFeatures_write(&obj_conv);
50300 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50301 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50302 CVec_u8Z_free(ret_var);
50306 uint64_t __attribute__((export_name("TS_Bolt11InvoiceFeatures_read"))) TS_Bolt11InvoiceFeatures_read(int8_tArray ser) {
50307 LDKu8slice ser_ref;
50308 ser_ref.datalen = ser->arr_len;
50309 ser_ref.data = ser->elems;
50310 LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt11InvoiceFeaturesDecodeErrorZ");
50311 *ret_conv = Bolt11InvoiceFeatures_read(ser_ref);
50313 return tag_ptr(ret_conv, true);
50316 int8_tArray __attribute__((export_name("TS_Bolt12InvoiceFeatures_write"))) TS_Bolt12InvoiceFeatures_write(uint64_t obj) {
50317 LDKBolt12InvoiceFeatures obj_conv;
50318 obj_conv.inner = untag_ptr(obj);
50319 obj_conv.is_owned = ptr_is_owned(obj);
50320 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50321 obj_conv.is_owned = false;
50322 LDKCVec_u8Z ret_var = Bolt12InvoiceFeatures_write(&obj_conv);
50323 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50324 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50325 CVec_u8Z_free(ret_var);
50329 uint64_t __attribute__((export_name("TS_Bolt12InvoiceFeatures_read"))) TS_Bolt12InvoiceFeatures_read(int8_tArray ser) {
50330 LDKu8slice ser_ref;
50331 ser_ref.datalen = ser->arr_len;
50332 ser_ref.data = ser->elems;
50333 LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ), "LDKCResult_Bolt12InvoiceFeaturesDecodeErrorZ");
50334 *ret_conv = Bolt12InvoiceFeatures_read(ser_ref);
50336 return tag_ptr(ret_conv, true);
50339 int8_tArray __attribute__((export_name("TS_BlindedHopFeatures_write"))) TS_BlindedHopFeatures_write(uint64_t obj) {
50340 LDKBlindedHopFeatures obj_conv;
50341 obj_conv.inner = untag_ptr(obj);
50342 obj_conv.is_owned = ptr_is_owned(obj);
50343 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50344 obj_conv.is_owned = false;
50345 LDKCVec_u8Z ret_var = BlindedHopFeatures_write(&obj_conv);
50346 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50347 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50348 CVec_u8Z_free(ret_var);
50352 uint64_t __attribute__((export_name("TS_BlindedHopFeatures_read"))) TS_BlindedHopFeatures_read(int8_tArray ser) {
50353 LDKu8slice ser_ref;
50354 ser_ref.datalen = ser->arr_len;
50355 ser_ref.data = ser->elems;
50356 LDKCResult_BlindedHopFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopFeaturesDecodeErrorZ), "LDKCResult_BlindedHopFeaturesDecodeErrorZ");
50357 *ret_conv = BlindedHopFeatures_read(ser_ref);
50359 return tag_ptr(ret_conv, true);
50362 int8_tArray __attribute__((export_name("TS_ChannelTypeFeatures_write"))) TS_ChannelTypeFeatures_write(uint64_t obj) {
50363 LDKChannelTypeFeatures obj_conv;
50364 obj_conv.inner = untag_ptr(obj);
50365 obj_conv.is_owned = ptr_is_owned(obj);
50366 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
50367 obj_conv.is_owned = false;
50368 LDKCVec_u8Z ret_var = ChannelTypeFeatures_write(&obj_conv);
50369 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
50370 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
50371 CVec_u8Z_free(ret_var);
50375 uint64_t __attribute__((export_name("TS_ChannelTypeFeatures_read"))) TS_ChannelTypeFeatures_read(int8_tArray ser) {
50376 LDKu8slice ser_ref;
50377 ser_ref.datalen = ser->arr_len;
50378 ser_ref.data = ser->elems;
50379 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
50380 *ret_conv = ChannelTypeFeatures_read(ser_ref);
50382 return tag_ptr(ret_conv, true);
50385 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_optional"))) TS_InitFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
50386 LDKInitFeatures this_arg_conv;
50387 this_arg_conv.inner = untag_ptr(this_arg);
50388 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50390 this_arg_conv.is_owned = false;
50391 InitFeatures_set_data_loss_protect_optional(&this_arg_conv);
50394 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_required"))) TS_InitFeatures_set_data_loss_protect_required(uint64_t this_arg) {
50395 LDKInitFeatures this_arg_conv;
50396 this_arg_conv.inner = untag_ptr(this_arg);
50397 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50399 this_arg_conv.is_owned = false;
50400 InitFeatures_set_data_loss_protect_required(&this_arg_conv);
50403 jboolean __attribute__((export_name("TS_InitFeatures_supports_data_loss_protect"))) TS_InitFeatures_supports_data_loss_protect(uint64_t this_arg) {
50404 LDKInitFeatures this_arg_conv;
50405 this_arg_conv.inner = untag_ptr(this_arg);
50406 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50408 this_arg_conv.is_owned = false;
50409 jboolean ret_conv = InitFeatures_supports_data_loss_protect(&this_arg_conv);
50413 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_optional"))) TS_NodeFeatures_set_data_loss_protect_optional(uint64_t this_arg) {
50414 LDKNodeFeatures this_arg_conv;
50415 this_arg_conv.inner = untag_ptr(this_arg);
50416 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50418 this_arg_conv.is_owned = false;
50419 NodeFeatures_set_data_loss_protect_optional(&this_arg_conv);
50422 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_required"))) TS_NodeFeatures_set_data_loss_protect_required(uint64_t this_arg) {
50423 LDKNodeFeatures this_arg_conv;
50424 this_arg_conv.inner = untag_ptr(this_arg);
50425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50427 this_arg_conv.is_owned = false;
50428 NodeFeatures_set_data_loss_protect_required(&this_arg_conv);
50431 jboolean __attribute__((export_name("TS_NodeFeatures_supports_data_loss_protect"))) TS_NodeFeatures_supports_data_loss_protect(uint64_t this_arg) {
50432 LDKNodeFeatures this_arg_conv;
50433 this_arg_conv.inner = untag_ptr(this_arg);
50434 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50436 this_arg_conv.is_owned = false;
50437 jboolean ret_conv = NodeFeatures_supports_data_loss_protect(&this_arg_conv);
50441 jboolean __attribute__((export_name("TS_InitFeatures_requires_data_loss_protect"))) TS_InitFeatures_requires_data_loss_protect(uint64_t this_arg) {
50442 LDKInitFeatures this_arg_conv;
50443 this_arg_conv.inner = untag_ptr(this_arg);
50444 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50445 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50446 this_arg_conv.is_owned = false;
50447 jboolean ret_conv = InitFeatures_requires_data_loss_protect(&this_arg_conv);
50451 jboolean __attribute__((export_name("TS_NodeFeatures_requires_data_loss_protect"))) TS_NodeFeatures_requires_data_loss_protect(uint64_t this_arg) {
50452 LDKNodeFeatures this_arg_conv;
50453 this_arg_conv.inner = untag_ptr(this_arg);
50454 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50455 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50456 this_arg_conv.is_owned = false;
50457 jboolean ret_conv = NodeFeatures_requires_data_loss_protect(&this_arg_conv);
50461 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_optional"))) TS_InitFeatures_set_initial_routing_sync_optional(uint64_t this_arg) {
50462 LDKInitFeatures this_arg_conv;
50463 this_arg_conv.inner = untag_ptr(this_arg);
50464 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50465 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50466 this_arg_conv.is_owned = false;
50467 InitFeatures_set_initial_routing_sync_optional(&this_arg_conv);
50470 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_required"))) TS_InitFeatures_set_initial_routing_sync_required(uint64_t this_arg) {
50471 LDKInitFeatures this_arg_conv;
50472 this_arg_conv.inner = untag_ptr(this_arg);
50473 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50475 this_arg_conv.is_owned = false;
50476 InitFeatures_set_initial_routing_sync_required(&this_arg_conv);
50479 jboolean __attribute__((export_name("TS_InitFeatures_initial_routing_sync"))) TS_InitFeatures_initial_routing_sync(uint64_t this_arg) {
50480 LDKInitFeatures this_arg_conv;
50481 this_arg_conv.inner = untag_ptr(this_arg);
50482 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50484 this_arg_conv.is_owned = false;
50485 jboolean ret_conv = InitFeatures_initial_routing_sync(&this_arg_conv);
50489 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_optional"))) TS_InitFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
50490 LDKInitFeatures this_arg_conv;
50491 this_arg_conv.inner = untag_ptr(this_arg);
50492 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50494 this_arg_conv.is_owned = false;
50495 InitFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
50498 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_required"))) TS_InitFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
50499 LDKInitFeatures this_arg_conv;
50500 this_arg_conv.inner = untag_ptr(this_arg);
50501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50503 this_arg_conv.is_owned = false;
50504 InitFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
50507 jboolean __attribute__((export_name("TS_InitFeatures_supports_upfront_shutdown_script"))) TS_InitFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
50508 LDKInitFeatures this_arg_conv;
50509 this_arg_conv.inner = untag_ptr(this_arg);
50510 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50512 this_arg_conv.is_owned = false;
50513 jboolean ret_conv = InitFeatures_supports_upfront_shutdown_script(&this_arg_conv);
50517 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_optional"))) TS_NodeFeatures_set_upfront_shutdown_script_optional(uint64_t this_arg) {
50518 LDKNodeFeatures this_arg_conv;
50519 this_arg_conv.inner = untag_ptr(this_arg);
50520 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50522 this_arg_conv.is_owned = false;
50523 NodeFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
50526 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_required"))) TS_NodeFeatures_set_upfront_shutdown_script_required(uint64_t this_arg) {
50527 LDKNodeFeatures this_arg_conv;
50528 this_arg_conv.inner = untag_ptr(this_arg);
50529 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50531 this_arg_conv.is_owned = false;
50532 NodeFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
50535 jboolean __attribute__((export_name("TS_NodeFeatures_supports_upfront_shutdown_script"))) TS_NodeFeatures_supports_upfront_shutdown_script(uint64_t this_arg) {
50536 LDKNodeFeatures this_arg_conv;
50537 this_arg_conv.inner = untag_ptr(this_arg);
50538 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50540 this_arg_conv.is_owned = false;
50541 jboolean ret_conv = NodeFeatures_supports_upfront_shutdown_script(&this_arg_conv);
50545 jboolean __attribute__((export_name("TS_InitFeatures_requires_upfront_shutdown_script"))) TS_InitFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
50546 LDKInitFeatures this_arg_conv;
50547 this_arg_conv.inner = untag_ptr(this_arg);
50548 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50550 this_arg_conv.is_owned = false;
50551 jboolean ret_conv = InitFeatures_requires_upfront_shutdown_script(&this_arg_conv);
50555 jboolean __attribute__((export_name("TS_NodeFeatures_requires_upfront_shutdown_script"))) TS_NodeFeatures_requires_upfront_shutdown_script(uint64_t this_arg) {
50556 LDKNodeFeatures this_arg_conv;
50557 this_arg_conv.inner = untag_ptr(this_arg);
50558 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50560 this_arg_conv.is_owned = false;
50561 jboolean ret_conv = NodeFeatures_requires_upfront_shutdown_script(&this_arg_conv);
50565 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_optional"))) TS_InitFeatures_set_gossip_queries_optional(uint64_t this_arg) {
50566 LDKInitFeatures this_arg_conv;
50567 this_arg_conv.inner = untag_ptr(this_arg);
50568 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50569 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50570 this_arg_conv.is_owned = false;
50571 InitFeatures_set_gossip_queries_optional(&this_arg_conv);
50574 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_required"))) TS_InitFeatures_set_gossip_queries_required(uint64_t this_arg) {
50575 LDKInitFeatures this_arg_conv;
50576 this_arg_conv.inner = untag_ptr(this_arg);
50577 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50578 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50579 this_arg_conv.is_owned = false;
50580 InitFeatures_set_gossip_queries_required(&this_arg_conv);
50583 jboolean __attribute__((export_name("TS_InitFeatures_supports_gossip_queries"))) TS_InitFeatures_supports_gossip_queries(uint64_t this_arg) {
50584 LDKInitFeatures this_arg_conv;
50585 this_arg_conv.inner = untag_ptr(this_arg);
50586 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50588 this_arg_conv.is_owned = false;
50589 jboolean ret_conv = InitFeatures_supports_gossip_queries(&this_arg_conv);
50593 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_optional"))) TS_NodeFeatures_set_gossip_queries_optional(uint64_t this_arg) {
50594 LDKNodeFeatures this_arg_conv;
50595 this_arg_conv.inner = untag_ptr(this_arg);
50596 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50597 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50598 this_arg_conv.is_owned = false;
50599 NodeFeatures_set_gossip_queries_optional(&this_arg_conv);
50602 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_required"))) TS_NodeFeatures_set_gossip_queries_required(uint64_t this_arg) {
50603 LDKNodeFeatures this_arg_conv;
50604 this_arg_conv.inner = untag_ptr(this_arg);
50605 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50607 this_arg_conv.is_owned = false;
50608 NodeFeatures_set_gossip_queries_required(&this_arg_conv);
50611 jboolean __attribute__((export_name("TS_NodeFeatures_supports_gossip_queries"))) TS_NodeFeatures_supports_gossip_queries(uint64_t this_arg) {
50612 LDKNodeFeatures this_arg_conv;
50613 this_arg_conv.inner = untag_ptr(this_arg);
50614 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50616 this_arg_conv.is_owned = false;
50617 jboolean ret_conv = NodeFeatures_supports_gossip_queries(&this_arg_conv);
50621 jboolean __attribute__((export_name("TS_InitFeatures_requires_gossip_queries"))) TS_InitFeatures_requires_gossip_queries(uint64_t this_arg) {
50622 LDKInitFeatures this_arg_conv;
50623 this_arg_conv.inner = untag_ptr(this_arg);
50624 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50625 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50626 this_arg_conv.is_owned = false;
50627 jboolean ret_conv = InitFeatures_requires_gossip_queries(&this_arg_conv);
50631 jboolean __attribute__((export_name("TS_NodeFeatures_requires_gossip_queries"))) TS_NodeFeatures_requires_gossip_queries(uint64_t this_arg) {
50632 LDKNodeFeatures this_arg_conv;
50633 this_arg_conv.inner = untag_ptr(this_arg);
50634 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50635 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50636 this_arg_conv.is_owned = false;
50637 jboolean ret_conv = NodeFeatures_requires_gossip_queries(&this_arg_conv);
50641 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_optional"))) TS_InitFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
50642 LDKInitFeatures this_arg_conv;
50643 this_arg_conv.inner = untag_ptr(this_arg);
50644 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50646 this_arg_conv.is_owned = false;
50647 InitFeatures_set_variable_length_onion_optional(&this_arg_conv);
50650 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_required"))) TS_InitFeatures_set_variable_length_onion_required(uint64_t this_arg) {
50651 LDKInitFeatures this_arg_conv;
50652 this_arg_conv.inner = untag_ptr(this_arg);
50653 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50654 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50655 this_arg_conv.is_owned = false;
50656 InitFeatures_set_variable_length_onion_required(&this_arg_conv);
50659 jboolean __attribute__((export_name("TS_InitFeatures_supports_variable_length_onion"))) TS_InitFeatures_supports_variable_length_onion(uint64_t this_arg) {
50660 LDKInitFeatures this_arg_conv;
50661 this_arg_conv.inner = untag_ptr(this_arg);
50662 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50664 this_arg_conv.is_owned = false;
50665 jboolean ret_conv = InitFeatures_supports_variable_length_onion(&this_arg_conv);
50669 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_optional"))) TS_NodeFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
50670 LDKNodeFeatures this_arg_conv;
50671 this_arg_conv.inner = untag_ptr(this_arg);
50672 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50674 this_arg_conv.is_owned = false;
50675 NodeFeatures_set_variable_length_onion_optional(&this_arg_conv);
50678 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_required"))) TS_NodeFeatures_set_variable_length_onion_required(uint64_t this_arg) {
50679 LDKNodeFeatures this_arg_conv;
50680 this_arg_conv.inner = untag_ptr(this_arg);
50681 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50683 this_arg_conv.is_owned = false;
50684 NodeFeatures_set_variable_length_onion_required(&this_arg_conv);
50687 jboolean __attribute__((export_name("TS_NodeFeatures_supports_variable_length_onion"))) TS_NodeFeatures_supports_variable_length_onion(uint64_t this_arg) {
50688 LDKNodeFeatures this_arg_conv;
50689 this_arg_conv.inner = untag_ptr(this_arg);
50690 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50692 this_arg_conv.is_owned = false;
50693 jboolean ret_conv = NodeFeatures_supports_variable_length_onion(&this_arg_conv);
50697 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional"))) TS_Bolt11InvoiceFeatures_set_variable_length_onion_optional(uint64_t this_arg) {
50698 LDKBolt11InvoiceFeatures this_arg_conv;
50699 this_arg_conv.inner = untag_ptr(this_arg);
50700 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50702 this_arg_conv.is_owned = false;
50703 Bolt11InvoiceFeatures_set_variable_length_onion_optional(&this_arg_conv);
50706 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_variable_length_onion_required"))) TS_Bolt11InvoiceFeatures_set_variable_length_onion_required(uint64_t this_arg) {
50707 LDKBolt11InvoiceFeatures this_arg_conv;
50708 this_arg_conv.inner = untag_ptr(this_arg);
50709 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50711 this_arg_conv.is_owned = false;
50712 Bolt11InvoiceFeatures_set_variable_length_onion_required(&this_arg_conv);
50715 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_supports_variable_length_onion"))) TS_Bolt11InvoiceFeatures_supports_variable_length_onion(uint64_t this_arg) {
50716 LDKBolt11InvoiceFeatures this_arg_conv;
50717 this_arg_conv.inner = untag_ptr(this_arg);
50718 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50720 this_arg_conv.is_owned = false;
50721 jboolean ret_conv = Bolt11InvoiceFeatures_supports_variable_length_onion(&this_arg_conv);
50725 jboolean __attribute__((export_name("TS_InitFeatures_requires_variable_length_onion"))) TS_InitFeatures_requires_variable_length_onion(uint64_t this_arg) {
50726 LDKInitFeatures this_arg_conv;
50727 this_arg_conv.inner = untag_ptr(this_arg);
50728 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50730 this_arg_conv.is_owned = false;
50731 jboolean ret_conv = InitFeatures_requires_variable_length_onion(&this_arg_conv);
50735 jboolean __attribute__((export_name("TS_NodeFeatures_requires_variable_length_onion"))) TS_NodeFeatures_requires_variable_length_onion(uint64_t this_arg) {
50736 LDKNodeFeatures this_arg_conv;
50737 this_arg_conv.inner = untag_ptr(this_arg);
50738 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50740 this_arg_conv.is_owned = false;
50741 jboolean ret_conv = NodeFeatures_requires_variable_length_onion(&this_arg_conv);
50745 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_variable_length_onion"))) TS_Bolt11InvoiceFeatures_requires_variable_length_onion(uint64_t this_arg) {
50746 LDKBolt11InvoiceFeatures this_arg_conv;
50747 this_arg_conv.inner = untag_ptr(this_arg);
50748 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50749 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50750 this_arg_conv.is_owned = false;
50751 jboolean ret_conv = Bolt11InvoiceFeatures_requires_variable_length_onion(&this_arg_conv);
50755 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_optional"))) TS_InitFeatures_set_static_remote_key_optional(uint64_t this_arg) {
50756 LDKInitFeatures this_arg_conv;
50757 this_arg_conv.inner = untag_ptr(this_arg);
50758 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50760 this_arg_conv.is_owned = false;
50761 InitFeatures_set_static_remote_key_optional(&this_arg_conv);
50764 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_required"))) TS_InitFeatures_set_static_remote_key_required(uint64_t this_arg) {
50765 LDKInitFeatures this_arg_conv;
50766 this_arg_conv.inner = untag_ptr(this_arg);
50767 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50768 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50769 this_arg_conv.is_owned = false;
50770 InitFeatures_set_static_remote_key_required(&this_arg_conv);
50773 jboolean __attribute__((export_name("TS_InitFeatures_supports_static_remote_key"))) TS_InitFeatures_supports_static_remote_key(uint64_t this_arg) {
50774 LDKInitFeatures this_arg_conv;
50775 this_arg_conv.inner = untag_ptr(this_arg);
50776 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50778 this_arg_conv.is_owned = false;
50779 jboolean ret_conv = InitFeatures_supports_static_remote_key(&this_arg_conv);
50783 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_optional"))) TS_NodeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
50784 LDKNodeFeatures this_arg_conv;
50785 this_arg_conv.inner = untag_ptr(this_arg);
50786 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50788 this_arg_conv.is_owned = false;
50789 NodeFeatures_set_static_remote_key_optional(&this_arg_conv);
50792 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_required"))) TS_NodeFeatures_set_static_remote_key_required(uint64_t this_arg) {
50793 LDKNodeFeatures this_arg_conv;
50794 this_arg_conv.inner = untag_ptr(this_arg);
50795 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50797 this_arg_conv.is_owned = false;
50798 NodeFeatures_set_static_remote_key_required(&this_arg_conv);
50801 jboolean __attribute__((export_name("TS_NodeFeatures_supports_static_remote_key"))) TS_NodeFeatures_supports_static_remote_key(uint64_t this_arg) {
50802 LDKNodeFeatures this_arg_conv;
50803 this_arg_conv.inner = untag_ptr(this_arg);
50804 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50806 this_arg_conv.is_owned = false;
50807 jboolean ret_conv = NodeFeatures_supports_static_remote_key(&this_arg_conv);
50811 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_optional"))) TS_ChannelTypeFeatures_set_static_remote_key_optional(uint64_t this_arg) {
50812 LDKChannelTypeFeatures this_arg_conv;
50813 this_arg_conv.inner = untag_ptr(this_arg);
50814 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50816 this_arg_conv.is_owned = false;
50817 ChannelTypeFeatures_set_static_remote_key_optional(&this_arg_conv);
50820 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_required"))) TS_ChannelTypeFeatures_set_static_remote_key_required(uint64_t this_arg) {
50821 LDKChannelTypeFeatures this_arg_conv;
50822 this_arg_conv.inner = untag_ptr(this_arg);
50823 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50824 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50825 this_arg_conv.is_owned = false;
50826 ChannelTypeFeatures_set_static_remote_key_required(&this_arg_conv);
50829 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_static_remote_key"))) TS_ChannelTypeFeatures_supports_static_remote_key(uint64_t this_arg) {
50830 LDKChannelTypeFeatures this_arg_conv;
50831 this_arg_conv.inner = untag_ptr(this_arg);
50832 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50833 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50834 this_arg_conv.is_owned = false;
50835 jboolean ret_conv = ChannelTypeFeatures_supports_static_remote_key(&this_arg_conv);
50839 jboolean __attribute__((export_name("TS_InitFeatures_requires_static_remote_key"))) TS_InitFeatures_requires_static_remote_key(uint64_t this_arg) {
50840 LDKInitFeatures this_arg_conv;
50841 this_arg_conv.inner = untag_ptr(this_arg);
50842 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50844 this_arg_conv.is_owned = false;
50845 jboolean ret_conv = InitFeatures_requires_static_remote_key(&this_arg_conv);
50849 jboolean __attribute__((export_name("TS_NodeFeatures_requires_static_remote_key"))) TS_NodeFeatures_requires_static_remote_key(uint64_t this_arg) {
50850 LDKNodeFeatures this_arg_conv;
50851 this_arg_conv.inner = untag_ptr(this_arg);
50852 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50854 this_arg_conv.is_owned = false;
50855 jboolean ret_conv = NodeFeatures_requires_static_remote_key(&this_arg_conv);
50859 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_static_remote_key"))) TS_ChannelTypeFeatures_requires_static_remote_key(uint64_t this_arg) {
50860 LDKChannelTypeFeatures this_arg_conv;
50861 this_arg_conv.inner = untag_ptr(this_arg);
50862 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50864 this_arg_conv.is_owned = false;
50865 jboolean ret_conv = ChannelTypeFeatures_requires_static_remote_key(&this_arg_conv);
50869 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_optional"))) TS_InitFeatures_set_payment_secret_optional(uint64_t this_arg) {
50870 LDKInitFeatures this_arg_conv;
50871 this_arg_conv.inner = untag_ptr(this_arg);
50872 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50874 this_arg_conv.is_owned = false;
50875 InitFeatures_set_payment_secret_optional(&this_arg_conv);
50878 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_required"))) TS_InitFeatures_set_payment_secret_required(uint64_t this_arg) {
50879 LDKInitFeatures this_arg_conv;
50880 this_arg_conv.inner = untag_ptr(this_arg);
50881 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50883 this_arg_conv.is_owned = false;
50884 InitFeatures_set_payment_secret_required(&this_arg_conv);
50887 jboolean __attribute__((export_name("TS_InitFeatures_supports_payment_secret"))) TS_InitFeatures_supports_payment_secret(uint64_t this_arg) {
50888 LDKInitFeatures this_arg_conv;
50889 this_arg_conv.inner = untag_ptr(this_arg);
50890 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50891 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50892 this_arg_conv.is_owned = false;
50893 jboolean ret_conv = InitFeatures_supports_payment_secret(&this_arg_conv);
50897 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_optional"))) TS_NodeFeatures_set_payment_secret_optional(uint64_t this_arg) {
50898 LDKNodeFeatures this_arg_conv;
50899 this_arg_conv.inner = untag_ptr(this_arg);
50900 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50901 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50902 this_arg_conv.is_owned = false;
50903 NodeFeatures_set_payment_secret_optional(&this_arg_conv);
50906 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_required"))) TS_NodeFeatures_set_payment_secret_required(uint64_t this_arg) {
50907 LDKNodeFeatures this_arg_conv;
50908 this_arg_conv.inner = untag_ptr(this_arg);
50909 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50911 this_arg_conv.is_owned = false;
50912 NodeFeatures_set_payment_secret_required(&this_arg_conv);
50915 jboolean __attribute__((export_name("TS_NodeFeatures_supports_payment_secret"))) TS_NodeFeatures_supports_payment_secret(uint64_t this_arg) {
50916 LDKNodeFeatures this_arg_conv;
50917 this_arg_conv.inner = untag_ptr(this_arg);
50918 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50920 this_arg_conv.is_owned = false;
50921 jboolean ret_conv = NodeFeatures_supports_payment_secret(&this_arg_conv);
50925 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_payment_secret_optional"))) TS_Bolt11InvoiceFeatures_set_payment_secret_optional(uint64_t this_arg) {
50926 LDKBolt11InvoiceFeatures this_arg_conv;
50927 this_arg_conv.inner = untag_ptr(this_arg);
50928 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50929 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50930 this_arg_conv.is_owned = false;
50931 Bolt11InvoiceFeatures_set_payment_secret_optional(&this_arg_conv);
50934 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_payment_secret_required"))) TS_Bolt11InvoiceFeatures_set_payment_secret_required(uint64_t this_arg) {
50935 LDKBolt11InvoiceFeatures this_arg_conv;
50936 this_arg_conv.inner = untag_ptr(this_arg);
50937 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50938 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50939 this_arg_conv.is_owned = false;
50940 Bolt11InvoiceFeatures_set_payment_secret_required(&this_arg_conv);
50943 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_supports_payment_secret"))) TS_Bolt11InvoiceFeatures_supports_payment_secret(uint64_t this_arg) {
50944 LDKBolt11InvoiceFeatures this_arg_conv;
50945 this_arg_conv.inner = untag_ptr(this_arg);
50946 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50948 this_arg_conv.is_owned = false;
50949 jboolean ret_conv = Bolt11InvoiceFeatures_supports_payment_secret(&this_arg_conv);
50953 jboolean __attribute__((export_name("TS_InitFeatures_requires_payment_secret"))) TS_InitFeatures_requires_payment_secret(uint64_t this_arg) {
50954 LDKInitFeatures this_arg_conv;
50955 this_arg_conv.inner = untag_ptr(this_arg);
50956 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50958 this_arg_conv.is_owned = false;
50959 jboolean ret_conv = InitFeatures_requires_payment_secret(&this_arg_conv);
50963 jboolean __attribute__((export_name("TS_NodeFeatures_requires_payment_secret"))) TS_NodeFeatures_requires_payment_secret(uint64_t this_arg) {
50964 LDKNodeFeatures this_arg_conv;
50965 this_arg_conv.inner = untag_ptr(this_arg);
50966 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50968 this_arg_conv.is_owned = false;
50969 jboolean ret_conv = NodeFeatures_requires_payment_secret(&this_arg_conv);
50973 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_payment_secret"))) TS_Bolt11InvoiceFeatures_requires_payment_secret(uint64_t this_arg) {
50974 LDKBolt11InvoiceFeatures this_arg_conv;
50975 this_arg_conv.inner = untag_ptr(this_arg);
50976 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50978 this_arg_conv.is_owned = false;
50979 jboolean ret_conv = Bolt11InvoiceFeatures_requires_payment_secret(&this_arg_conv);
50983 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_optional"))) TS_InitFeatures_set_basic_mpp_optional(uint64_t this_arg) {
50984 LDKInitFeatures this_arg_conv;
50985 this_arg_conv.inner = untag_ptr(this_arg);
50986 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50988 this_arg_conv.is_owned = false;
50989 InitFeatures_set_basic_mpp_optional(&this_arg_conv);
50992 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_required"))) TS_InitFeatures_set_basic_mpp_required(uint64_t this_arg) {
50993 LDKInitFeatures this_arg_conv;
50994 this_arg_conv.inner = untag_ptr(this_arg);
50995 this_arg_conv.is_owned = ptr_is_owned(this_arg);
50996 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
50997 this_arg_conv.is_owned = false;
50998 InitFeatures_set_basic_mpp_required(&this_arg_conv);
51001 jboolean __attribute__((export_name("TS_InitFeatures_supports_basic_mpp"))) TS_InitFeatures_supports_basic_mpp(uint64_t this_arg) {
51002 LDKInitFeatures this_arg_conv;
51003 this_arg_conv.inner = untag_ptr(this_arg);
51004 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51006 this_arg_conv.is_owned = false;
51007 jboolean ret_conv = InitFeatures_supports_basic_mpp(&this_arg_conv);
51011 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_optional"))) TS_NodeFeatures_set_basic_mpp_optional(uint64_t this_arg) {
51012 LDKNodeFeatures this_arg_conv;
51013 this_arg_conv.inner = untag_ptr(this_arg);
51014 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51016 this_arg_conv.is_owned = false;
51017 NodeFeatures_set_basic_mpp_optional(&this_arg_conv);
51020 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_required"))) TS_NodeFeatures_set_basic_mpp_required(uint64_t this_arg) {
51021 LDKNodeFeatures this_arg_conv;
51022 this_arg_conv.inner = untag_ptr(this_arg);
51023 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51025 this_arg_conv.is_owned = false;
51026 NodeFeatures_set_basic_mpp_required(&this_arg_conv);
51029 jboolean __attribute__((export_name("TS_NodeFeatures_supports_basic_mpp"))) TS_NodeFeatures_supports_basic_mpp(uint64_t this_arg) {
51030 LDKNodeFeatures this_arg_conv;
51031 this_arg_conv.inner = untag_ptr(this_arg);
51032 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51033 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51034 this_arg_conv.is_owned = false;
51035 jboolean ret_conv = NodeFeatures_supports_basic_mpp(&this_arg_conv);
51039 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_basic_mpp_optional"))) TS_Bolt11InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
51040 LDKBolt11InvoiceFeatures this_arg_conv;
51041 this_arg_conv.inner = untag_ptr(this_arg);
51042 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51043 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51044 this_arg_conv.is_owned = false;
51045 Bolt11InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
51048 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_basic_mpp_required"))) TS_Bolt11InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
51049 LDKBolt11InvoiceFeatures this_arg_conv;
51050 this_arg_conv.inner = untag_ptr(this_arg);
51051 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51053 this_arg_conv.is_owned = false;
51054 Bolt11InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
51057 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_supports_basic_mpp"))) TS_Bolt11InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
51058 LDKBolt11InvoiceFeatures this_arg_conv;
51059 this_arg_conv.inner = untag_ptr(this_arg);
51060 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51061 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51062 this_arg_conv.is_owned = false;
51063 jboolean ret_conv = Bolt11InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
51067 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_optional"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_optional(uint64_t this_arg) {
51068 LDKBolt12InvoiceFeatures this_arg_conv;
51069 this_arg_conv.inner = untag_ptr(this_arg);
51070 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51071 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51072 this_arg_conv.is_owned = false;
51073 Bolt12InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
51076 void __attribute__((export_name("TS_Bolt12InvoiceFeatures_set_basic_mpp_required"))) TS_Bolt12InvoiceFeatures_set_basic_mpp_required(uint64_t this_arg) {
51077 LDKBolt12InvoiceFeatures this_arg_conv;
51078 this_arg_conv.inner = untag_ptr(this_arg);
51079 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51080 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51081 this_arg_conv.is_owned = false;
51082 Bolt12InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
51085 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_supports_basic_mpp"))) TS_Bolt12InvoiceFeatures_supports_basic_mpp(uint64_t this_arg) {
51086 LDKBolt12InvoiceFeatures this_arg_conv;
51087 this_arg_conv.inner = untag_ptr(this_arg);
51088 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51090 this_arg_conv.is_owned = false;
51091 jboolean ret_conv = Bolt12InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
51095 jboolean __attribute__((export_name("TS_InitFeatures_requires_basic_mpp"))) TS_InitFeatures_requires_basic_mpp(uint64_t this_arg) {
51096 LDKInitFeatures this_arg_conv;
51097 this_arg_conv.inner = untag_ptr(this_arg);
51098 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51099 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51100 this_arg_conv.is_owned = false;
51101 jboolean ret_conv = InitFeatures_requires_basic_mpp(&this_arg_conv);
51105 jboolean __attribute__((export_name("TS_NodeFeatures_requires_basic_mpp"))) TS_NodeFeatures_requires_basic_mpp(uint64_t this_arg) {
51106 LDKNodeFeatures this_arg_conv;
51107 this_arg_conv.inner = untag_ptr(this_arg);
51108 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51110 this_arg_conv.is_owned = false;
51111 jboolean ret_conv = NodeFeatures_requires_basic_mpp(&this_arg_conv);
51115 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_basic_mpp"))) TS_Bolt11InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
51116 LDKBolt11InvoiceFeatures this_arg_conv;
51117 this_arg_conv.inner = untag_ptr(this_arg);
51118 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51120 this_arg_conv.is_owned = false;
51121 jboolean ret_conv = Bolt11InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
51125 jboolean __attribute__((export_name("TS_Bolt12InvoiceFeatures_requires_basic_mpp"))) TS_Bolt12InvoiceFeatures_requires_basic_mpp(uint64_t this_arg) {
51126 LDKBolt12InvoiceFeatures this_arg_conv;
51127 this_arg_conv.inner = untag_ptr(this_arg);
51128 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51130 this_arg_conv.is_owned = false;
51131 jboolean ret_conv = Bolt12InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
51135 void __attribute__((export_name("TS_InitFeatures_set_wumbo_optional"))) TS_InitFeatures_set_wumbo_optional(uint64_t this_arg) {
51136 LDKInitFeatures this_arg_conv;
51137 this_arg_conv.inner = untag_ptr(this_arg);
51138 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51140 this_arg_conv.is_owned = false;
51141 InitFeatures_set_wumbo_optional(&this_arg_conv);
51144 void __attribute__((export_name("TS_InitFeatures_set_wumbo_required"))) TS_InitFeatures_set_wumbo_required(uint64_t this_arg) {
51145 LDKInitFeatures this_arg_conv;
51146 this_arg_conv.inner = untag_ptr(this_arg);
51147 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51149 this_arg_conv.is_owned = false;
51150 InitFeatures_set_wumbo_required(&this_arg_conv);
51153 jboolean __attribute__((export_name("TS_InitFeatures_supports_wumbo"))) TS_InitFeatures_supports_wumbo(uint64_t this_arg) {
51154 LDKInitFeatures this_arg_conv;
51155 this_arg_conv.inner = untag_ptr(this_arg);
51156 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51158 this_arg_conv.is_owned = false;
51159 jboolean ret_conv = InitFeatures_supports_wumbo(&this_arg_conv);
51163 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_optional"))) TS_NodeFeatures_set_wumbo_optional(uint64_t this_arg) {
51164 LDKNodeFeatures this_arg_conv;
51165 this_arg_conv.inner = untag_ptr(this_arg);
51166 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51168 this_arg_conv.is_owned = false;
51169 NodeFeatures_set_wumbo_optional(&this_arg_conv);
51172 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_required"))) TS_NodeFeatures_set_wumbo_required(uint64_t this_arg) {
51173 LDKNodeFeatures this_arg_conv;
51174 this_arg_conv.inner = untag_ptr(this_arg);
51175 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51177 this_arg_conv.is_owned = false;
51178 NodeFeatures_set_wumbo_required(&this_arg_conv);
51181 jboolean __attribute__((export_name("TS_NodeFeatures_supports_wumbo"))) TS_NodeFeatures_supports_wumbo(uint64_t this_arg) {
51182 LDKNodeFeatures this_arg_conv;
51183 this_arg_conv.inner = untag_ptr(this_arg);
51184 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51186 this_arg_conv.is_owned = false;
51187 jboolean ret_conv = NodeFeatures_supports_wumbo(&this_arg_conv);
51191 jboolean __attribute__((export_name("TS_InitFeatures_requires_wumbo"))) TS_InitFeatures_requires_wumbo(uint64_t this_arg) {
51192 LDKInitFeatures this_arg_conv;
51193 this_arg_conv.inner = untag_ptr(this_arg);
51194 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51196 this_arg_conv.is_owned = false;
51197 jboolean ret_conv = InitFeatures_requires_wumbo(&this_arg_conv);
51201 jboolean __attribute__((export_name("TS_NodeFeatures_requires_wumbo"))) TS_NodeFeatures_requires_wumbo(uint64_t this_arg) {
51202 LDKNodeFeatures this_arg_conv;
51203 this_arg_conv.inner = untag_ptr(this_arg);
51204 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51205 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51206 this_arg_conv.is_owned = false;
51207 jboolean ret_conv = NodeFeatures_requires_wumbo(&this_arg_conv);
51211 void __attribute__((export_name("TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional"))) TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(uint64_t this_arg) {
51212 LDKInitFeatures this_arg_conv;
51213 this_arg_conv.inner = untag_ptr(this_arg);
51214 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51215 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51216 this_arg_conv.is_owned = false;
51217 InitFeatures_set_anchors_nonzero_fee_htlc_tx_optional(&this_arg_conv);
51220 void __attribute__((export_name("TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required"))) TS_InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(uint64_t this_arg) {
51221 LDKInitFeatures this_arg_conv;
51222 this_arg_conv.inner = untag_ptr(this_arg);
51223 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51225 this_arg_conv.is_owned = false;
51226 InitFeatures_set_anchors_nonzero_fee_htlc_tx_required(&this_arg_conv);
51229 jboolean __attribute__((export_name("TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx"))) TS_InitFeatures_supports_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51230 LDKInitFeatures this_arg_conv;
51231 this_arg_conv.inner = untag_ptr(this_arg);
51232 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51234 this_arg_conv.is_owned = false;
51235 jboolean ret_conv = InitFeatures_supports_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51239 void __attribute__((export_name("TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional"))) TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(uint64_t this_arg) {
51240 LDKNodeFeatures this_arg_conv;
51241 this_arg_conv.inner = untag_ptr(this_arg);
51242 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51244 this_arg_conv.is_owned = false;
51245 NodeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(&this_arg_conv);
51248 void __attribute__((export_name("TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required"))) TS_NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(uint64_t this_arg) {
51249 LDKNodeFeatures this_arg_conv;
51250 this_arg_conv.inner = untag_ptr(this_arg);
51251 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51252 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51253 this_arg_conv.is_owned = false;
51254 NodeFeatures_set_anchors_nonzero_fee_htlc_tx_required(&this_arg_conv);
51257 jboolean __attribute__((export_name("TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx"))) TS_NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51258 LDKNodeFeatures this_arg_conv;
51259 this_arg_conv.inner = untag_ptr(this_arg);
51260 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51262 this_arg_conv.is_owned = false;
51263 jboolean ret_conv = NodeFeatures_supports_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51267 void __attribute__((export_name("TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional"))) TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(uint64_t this_arg) {
51268 LDKChannelTypeFeatures this_arg_conv;
51269 this_arg_conv.inner = untag_ptr(this_arg);
51270 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51272 this_arg_conv.is_owned = false;
51273 ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_optional(&this_arg_conv);
51276 void __attribute__((export_name("TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required"))) TS_ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(uint64_t this_arg) {
51277 LDKChannelTypeFeatures this_arg_conv;
51278 this_arg_conv.inner = untag_ptr(this_arg);
51279 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51281 this_arg_conv.is_owned = false;
51282 ChannelTypeFeatures_set_anchors_nonzero_fee_htlc_tx_required(&this_arg_conv);
51285 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx"))) TS_ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51286 LDKChannelTypeFeatures this_arg_conv;
51287 this_arg_conv.inner = untag_ptr(this_arg);
51288 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51290 this_arg_conv.is_owned = false;
51291 jboolean ret_conv = ChannelTypeFeatures_supports_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51295 jboolean __attribute__((export_name("TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx"))) TS_InitFeatures_requires_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51296 LDKInitFeatures this_arg_conv;
51297 this_arg_conv.inner = untag_ptr(this_arg);
51298 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51299 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51300 this_arg_conv.is_owned = false;
51301 jboolean ret_conv = InitFeatures_requires_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51305 jboolean __attribute__((export_name("TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx"))) TS_NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51306 LDKNodeFeatures this_arg_conv;
51307 this_arg_conv.inner = untag_ptr(this_arg);
51308 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51310 this_arg_conv.is_owned = false;
51311 jboolean ret_conv = NodeFeatures_requires_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51315 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx"))) TS_ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(uint64_t this_arg) {
51316 LDKChannelTypeFeatures this_arg_conv;
51317 this_arg_conv.inner = untag_ptr(this_arg);
51318 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51319 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51320 this_arg_conv.is_owned = false;
51321 jboolean ret_conv = ChannelTypeFeatures_requires_anchors_nonzero_fee_htlc_tx(&this_arg_conv);
51325 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) {
51326 LDKInitFeatures this_arg_conv;
51327 this_arg_conv.inner = untag_ptr(this_arg);
51328 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51330 this_arg_conv.is_owned = false;
51331 InitFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
51334 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) {
51335 LDKInitFeatures this_arg_conv;
51336 this_arg_conv.inner = untag_ptr(this_arg);
51337 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51339 this_arg_conv.is_owned = false;
51340 InitFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
51343 jboolean __attribute__((export_name("TS_InitFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51344 LDKInitFeatures this_arg_conv;
51345 this_arg_conv.inner = untag_ptr(this_arg);
51346 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51348 this_arg_conv.is_owned = false;
51349 jboolean ret_conv = InitFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
51353 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) {
51354 LDKNodeFeatures this_arg_conv;
51355 this_arg_conv.inner = untag_ptr(this_arg);
51356 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51358 this_arg_conv.is_owned = false;
51359 NodeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
51362 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) {
51363 LDKNodeFeatures this_arg_conv;
51364 this_arg_conv.inner = untag_ptr(this_arg);
51365 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51367 this_arg_conv.is_owned = false;
51368 NodeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
51371 jboolean __attribute__((export_name("TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51372 LDKNodeFeatures this_arg_conv;
51373 this_arg_conv.inner = untag_ptr(this_arg);
51374 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51376 this_arg_conv.is_owned = false;
51377 jboolean ret_conv = NodeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
51381 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) {
51382 LDKChannelTypeFeatures this_arg_conv;
51383 this_arg_conv.inner = untag_ptr(this_arg);
51384 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51385 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51386 this_arg_conv.is_owned = false;
51387 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_optional(&this_arg_conv);
51390 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) {
51391 LDKChannelTypeFeatures this_arg_conv;
51392 this_arg_conv.inner = untag_ptr(this_arg);
51393 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51395 this_arg_conv.is_owned = false;
51396 ChannelTypeFeatures_set_anchors_zero_fee_htlc_tx_required(&this_arg_conv);
51399 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51400 LDKChannelTypeFeatures this_arg_conv;
51401 this_arg_conv.inner = untag_ptr(this_arg);
51402 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51403 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51404 this_arg_conv.is_owned = false;
51405 jboolean ret_conv = ChannelTypeFeatures_supports_anchors_zero_fee_htlc_tx(&this_arg_conv);
51409 jboolean __attribute__((export_name("TS_InitFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_InitFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51410 LDKInitFeatures this_arg_conv;
51411 this_arg_conv.inner = untag_ptr(this_arg);
51412 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51414 this_arg_conv.is_owned = false;
51415 jboolean ret_conv = InitFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
51419 jboolean __attribute__((export_name("TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_NodeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51420 LDKNodeFeatures this_arg_conv;
51421 this_arg_conv.inner = untag_ptr(this_arg);
51422 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51423 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51424 this_arg_conv.is_owned = false;
51425 jboolean ret_conv = NodeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
51429 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx"))) TS_ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(uint64_t this_arg) {
51430 LDKChannelTypeFeatures this_arg_conv;
51431 this_arg_conv.inner = untag_ptr(this_arg);
51432 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51433 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51434 this_arg_conv.is_owned = false;
51435 jboolean ret_conv = ChannelTypeFeatures_requires_anchors_zero_fee_htlc_tx(&this_arg_conv);
51439 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_optional"))) TS_InitFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
51440 LDKInitFeatures this_arg_conv;
51441 this_arg_conv.inner = untag_ptr(this_arg);
51442 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51444 this_arg_conv.is_owned = false;
51445 InitFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
51448 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_required"))) TS_InitFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
51449 LDKInitFeatures this_arg_conv;
51450 this_arg_conv.inner = untag_ptr(this_arg);
51451 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51452 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51453 this_arg_conv.is_owned = false;
51454 InitFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
51457 jboolean __attribute__((export_name("TS_InitFeatures_supports_shutdown_anysegwit"))) TS_InitFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
51458 LDKInitFeatures this_arg_conv;
51459 this_arg_conv.inner = untag_ptr(this_arg);
51460 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51461 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51462 this_arg_conv.is_owned = false;
51463 jboolean ret_conv = InitFeatures_supports_shutdown_anysegwit(&this_arg_conv);
51467 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_optional"))) TS_NodeFeatures_set_shutdown_any_segwit_optional(uint64_t this_arg) {
51468 LDKNodeFeatures this_arg_conv;
51469 this_arg_conv.inner = untag_ptr(this_arg);
51470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51472 this_arg_conv.is_owned = false;
51473 NodeFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
51476 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_required"))) TS_NodeFeatures_set_shutdown_any_segwit_required(uint64_t this_arg) {
51477 LDKNodeFeatures this_arg_conv;
51478 this_arg_conv.inner = untag_ptr(this_arg);
51479 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51481 this_arg_conv.is_owned = false;
51482 NodeFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
51485 jboolean __attribute__((export_name("TS_NodeFeatures_supports_shutdown_anysegwit"))) TS_NodeFeatures_supports_shutdown_anysegwit(uint64_t this_arg) {
51486 LDKNodeFeatures this_arg_conv;
51487 this_arg_conv.inner = untag_ptr(this_arg);
51488 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51490 this_arg_conv.is_owned = false;
51491 jboolean ret_conv = NodeFeatures_supports_shutdown_anysegwit(&this_arg_conv);
51495 jboolean __attribute__((export_name("TS_InitFeatures_requires_shutdown_anysegwit"))) TS_InitFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
51496 LDKInitFeatures this_arg_conv;
51497 this_arg_conv.inner = untag_ptr(this_arg);
51498 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51499 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51500 this_arg_conv.is_owned = false;
51501 jboolean ret_conv = InitFeatures_requires_shutdown_anysegwit(&this_arg_conv);
51505 jboolean __attribute__((export_name("TS_NodeFeatures_requires_shutdown_anysegwit"))) TS_NodeFeatures_requires_shutdown_anysegwit(uint64_t this_arg) {
51506 LDKNodeFeatures this_arg_conv;
51507 this_arg_conv.inner = untag_ptr(this_arg);
51508 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51510 this_arg_conv.is_owned = false;
51511 jboolean ret_conv = NodeFeatures_requires_shutdown_anysegwit(&this_arg_conv);
51515 void __attribute__((export_name("TS_InitFeatures_set_taproot_optional"))) TS_InitFeatures_set_taproot_optional(uint64_t this_arg) {
51516 LDKInitFeatures this_arg_conv;
51517 this_arg_conv.inner = untag_ptr(this_arg);
51518 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51520 this_arg_conv.is_owned = false;
51521 InitFeatures_set_taproot_optional(&this_arg_conv);
51524 void __attribute__((export_name("TS_InitFeatures_set_taproot_required"))) TS_InitFeatures_set_taproot_required(uint64_t this_arg) {
51525 LDKInitFeatures this_arg_conv;
51526 this_arg_conv.inner = untag_ptr(this_arg);
51527 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51529 this_arg_conv.is_owned = false;
51530 InitFeatures_set_taproot_required(&this_arg_conv);
51533 jboolean __attribute__((export_name("TS_InitFeatures_supports_taproot"))) TS_InitFeatures_supports_taproot(uint64_t this_arg) {
51534 LDKInitFeatures this_arg_conv;
51535 this_arg_conv.inner = untag_ptr(this_arg);
51536 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51538 this_arg_conv.is_owned = false;
51539 jboolean ret_conv = InitFeatures_supports_taproot(&this_arg_conv);
51543 void __attribute__((export_name("TS_NodeFeatures_set_taproot_optional"))) TS_NodeFeatures_set_taproot_optional(uint64_t this_arg) {
51544 LDKNodeFeatures this_arg_conv;
51545 this_arg_conv.inner = untag_ptr(this_arg);
51546 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51548 this_arg_conv.is_owned = false;
51549 NodeFeatures_set_taproot_optional(&this_arg_conv);
51552 void __attribute__((export_name("TS_NodeFeatures_set_taproot_required"))) TS_NodeFeatures_set_taproot_required(uint64_t this_arg) {
51553 LDKNodeFeatures this_arg_conv;
51554 this_arg_conv.inner = untag_ptr(this_arg);
51555 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51557 this_arg_conv.is_owned = false;
51558 NodeFeatures_set_taproot_required(&this_arg_conv);
51561 jboolean __attribute__((export_name("TS_NodeFeatures_supports_taproot"))) TS_NodeFeatures_supports_taproot(uint64_t this_arg) {
51562 LDKNodeFeatures this_arg_conv;
51563 this_arg_conv.inner = untag_ptr(this_arg);
51564 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51566 this_arg_conv.is_owned = false;
51567 jboolean ret_conv = NodeFeatures_supports_taproot(&this_arg_conv);
51571 void __attribute__((export_name("TS_ChannelTypeFeatures_set_taproot_optional"))) TS_ChannelTypeFeatures_set_taproot_optional(uint64_t this_arg) {
51572 LDKChannelTypeFeatures this_arg_conv;
51573 this_arg_conv.inner = untag_ptr(this_arg);
51574 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51576 this_arg_conv.is_owned = false;
51577 ChannelTypeFeatures_set_taproot_optional(&this_arg_conv);
51580 void __attribute__((export_name("TS_ChannelTypeFeatures_set_taproot_required"))) TS_ChannelTypeFeatures_set_taproot_required(uint64_t this_arg) {
51581 LDKChannelTypeFeatures this_arg_conv;
51582 this_arg_conv.inner = untag_ptr(this_arg);
51583 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51585 this_arg_conv.is_owned = false;
51586 ChannelTypeFeatures_set_taproot_required(&this_arg_conv);
51589 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_taproot"))) TS_ChannelTypeFeatures_supports_taproot(uint64_t this_arg) {
51590 LDKChannelTypeFeatures this_arg_conv;
51591 this_arg_conv.inner = untag_ptr(this_arg);
51592 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51594 this_arg_conv.is_owned = false;
51595 jboolean ret_conv = ChannelTypeFeatures_supports_taproot(&this_arg_conv);
51599 jboolean __attribute__((export_name("TS_InitFeatures_requires_taproot"))) TS_InitFeatures_requires_taproot(uint64_t this_arg) {
51600 LDKInitFeatures this_arg_conv;
51601 this_arg_conv.inner = untag_ptr(this_arg);
51602 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51604 this_arg_conv.is_owned = false;
51605 jboolean ret_conv = InitFeatures_requires_taproot(&this_arg_conv);
51609 jboolean __attribute__((export_name("TS_NodeFeatures_requires_taproot"))) TS_NodeFeatures_requires_taproot(uint64_t this_arg) {
51610 LDKNodeFeatures this_arg_conv;
51611 this_arg_conv.inner = untag_ptr(this_arg);
51612 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51614 this_arg_conv.is_owned = false;
51615 jboolean ret_conv = NodeFeatures_requires_taproot(&this_arg_conv);
51619 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_taproot"))) TS_ChannelTypeFeatures_requires_taproot(uint64_t this_arg) {
51620 LDKChannelTypeFeatures this_arg_conv;
51621 this_arg_conv.inner = untag_ptr(this_arg);
51622 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51624 this_arg_conv.is_owned = false;
51625 jboolean ret_conv = ChannelTypeFeatures_requires_taproot(&this_arg_conv);
51629 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_optional"))) TS_InitFeatures_set_onion_messages_optional(uint64_t this_arg) {
51630 LDKInitFeatures this_arg_conv;
51631 this_arg_conv.inner = untag_ptr(this_arg);
51632 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51634 this_arg_conv.is_owned = false;
51635 InitFeatures_set_onion_messages_optional(&this_arg_conv);
51638 void __attribute__((export_name("TS_InitFeatures_set_onion_messages_required"))) TS_InitFeatures_set_onion_messages_required(uint64_t this_arg) {
51639 LDKInitFeatures this_arg_conv;
51640 this_arg_conv.inner = untag_ptr(this_arg);
51641 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51643 this_arg_conv.is_owned = false;
51644 InitFeatures_set_onion_messages_required(&this_arg_conv);
51647 jboolean __attribute__((export_name("TS_InitFeatures_supports_onion_messages"))) TS_InitFeatures_supports_onion_messages(uint64_t this_arg) {
51648 LDKInitFeatures this_arg_conv;
51649 this_arg_conv.inner = untag_ptr(this_arg);
51650 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51651 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51652 this_arg_conv.is_owned = false;
51653 jboolean ret_conv = InitFeatures_supports_onion_messages(&this_arg_conv);
51657 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_optional"))) TS_NodeFeatures_set_onion_messages_optional(uint64_t this_arg) {
51658 LDKNodeFeatures this_arg_conv;
51659 this_arg_conv.inner = untag_ptr(this_arg);
51660 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51661 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51662 this_arg_conv.is_owned = false;
51663 NodeFeatures_set_onion_messages_optional(&this_arg_conv);
51666 void __attribute__((export_name("TS_NodeFeatures_set_onion_messages_required"))) TS_NodeFeatures_set_onion_messages_required(uint64_t this_arg) {
51667 LDKNodeFeatures this_arg_conv;
51668 this_arg_conv.inner = untag_ptr(this_arg);
51669 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51670 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51671 this_arg_conv.is_owned = false;
51672 NodeFeatures_set_onion_messages_required(&this_arg_conv);
51675 jboolean __attribute__((export_name("TS_NodeFeatures_supports_onion_messages"))) TS_NodeFeatures_supports_onion_messages(uint64_t this_arg) {
51676 LDKNodeFeatures this_arg_conv;
51677 this_arg_conv.inner = untag_ptr(this_arg);
51678 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51679 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51680 this_arg_conv.is_owned = false;
51681 jboolean ret_conv = NodeFeatures_supports_onion_messages(&this_arg_conv);
51685 jboolean __attribute__((export_name("TS_InitFeatures_requires_onion_messages"))) TS_InitFeatures_requires_onion_messages(uint64_t this_arg) {
51686 LDKInitFeatures this_arg_conv;
51687 this_arg_conv.inner = untag_ptr(this_arg);
51688 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51690 this_arg_conv.is_owned = false;
51691 jboolean ret_conv = InitFeatures_requires_onion_messages(&this_arg_conv);
51695 jboolean __attribute__((export_name("TS_NodeFeatures_requires_onion_messages"))) TS_NodeFeatures_requires_onion_messages(uint64_t this_arg) {
51696 LDKNodeFeatures this_arg_conv;
51697 this_arg_conv.inner = untag_ptr(this_arg);
51698 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51700 this_arg_conv.is_owned = false;
51701 jboolean ret_conv = NodeFeatures_requires_onion_messages(&this_arg_conv);
51705 void __attribute__((export_name("TS_InitFeatures_set_channel_type_optional"))) TS_InitFeatures_set_channel_type_optional(uint64_t this_arg) {
51706 LDKInitFeatures this_arg_conv;
51707 this_arg_conv.inner = untag_ptr(this_arg);
51708 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51710 this_arg_conv.is_owned = false;
51711 InitFeatures_set_channel_type_optional(&this_arg_conv);
51714 void __attribute__((export_name("TS_InitFeatures_set_channel_type_required"))) TS_InitFeatures_set_channel_type_required(uint64_t this_arg) {
51715 LDKInitFeatures this_arg_conv;
51716 this_arg_conv.inner = untag_ptr(this_arg);
51717 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51718 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51719 this_arg_conv.is_owned = false;
51720 InitFeatures_set_channel_type_required(&this_arg_conv);
51723 jboolean __attribute__((export_name("TS_InitFeatures_supports_channel_type"))) TS_InitFeatures_supports_channel_type(uint64_t this_arg) {
51724 LDKInitFeatures this_arg_conv;
51725 this_arg_conv.inner = untag_ptr(this_arg);
51726 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51728 this_arg_conv.is_owned = false;
51729 jboolean ret_conv = InitFeatures_supports_channel_type(&this_arg_conv);
51733 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_optional"))) TS_NodeFeatures_set_channel_type_optional(uint64_t this_arg) {
51734 LDKNodeFeatures this_arg_conv;
51735 this_arg_conv.inner = untag_ptr(this_arg);
51736 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51737 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51738 this_arg_conv.is_owned = false;
51739 NodeFeatures_set_channel_type_optional(&this_arg_conv);
51742 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_required"))) TS_NodeFeatures_set_channel_type_required(uint64_t this_arg) {
51743 LDKNodeFeatures this_arg_conv;
51744 this_arg_conv.inner = untag_ptr(this_arg);
51745 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51747 this_arg_conv.is_owned = false;
51748 NodeFeatures_set_channel_type_required(&this_arg_conv);
51751 jboolean __attribute__((export_name("TS_NodeFeatures_supports_channel_type"))) TS_NodeFeatures_supports_channel_type(uint64_t this_arg) {
51752 LDKNodeFeatures this_arg_conv;
51753 this_arg_conv.inner = untag_ptr(this_arg);
51754 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51756 this_arg_conv.is_owned = false;
51757 jboolean ret_conv = NodeFeatures_supports_channel_type(&this_arg_conv);
51761 jboolean __attribute__((export_name("TS_InitFeatures_requires_channel_type"))) TS_InitFeatures_requires_channel_type(uint64_t this_arg) {
51762 LDKInitFeatures this_arg_conv;
51763 this_arg_conv.inner = untag_ptr(this_arg);
51764 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51766 this_arg_conv.is_owned = false;
51767 jboolean ret_conv = InitFeatures_requires_channel_type(&this_arg_conv);
51771 jboolean __attribute__((export_name("TS_NodeFeatures_requires_channel_type"))) TS_NodeFeatures_requires_channel_type(uint64_t this_arg) {
51772 LDKNodeFeatures this_arg_conv;
51773 this_arg_conv.inner = untag_ptr(this_arg);
51774 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51776 this_arg_conv.is_owned = false;
51777 jboolean ret_conv = NodeFeatures_requires_channel_type(&this_arg_conv);
51781 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_optional"))) TS_InitFeatures_set_scid_privacy_optional(uint64_t this_arg) {
51782 LDKInitFeatures this_arg_conv;
51783 this_arg_conv.inner = untag_ptr(this_arg);
51784 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51785 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51786 this_arg_conv.is_owned = false;
51787 InitFeatures_set_scid_privacy_optional(&this_arg_conv);
51790 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_required"))) TS_InitFeatures_set_scid_privacy_required(uint64_t this_arg) {
51791 LDKInitFeatures this_arg_conv;
51792 this_arg_conv.inner = untag_ptr(this_arg);
51793 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51795 this_arg_conv.is_owned = false;
51796 InitFeatures_set_scid_privacy_required(&this_arg_conv);
51799 jboolean __attribute__((export_name("TS_InitFeatures_supports_scid_privacy"))) TS_InitFeatures_supports_scid_privacy(uint64_t this_arg) {
51800 LDKInitFeatures this_arg_conv;
51801 this_arg_conv.inner = untag_ptr(this_arg);
51802 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51803 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51804 this_arg_conv.is_owned = false;
51805 jboolean ret_conv = InitFeatures_supports_scid_privacy(&this_arg_conv);
51809 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_optional"))) TS_NodeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
51810 LDKNodeFeatures this_arg_conv;
51811 this_arg_conv.inner = untag_ptr(this_arg);
51812 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51814 this_arg_conv.is_owned = false;
51815 NodeFeatures_set_scid_privacy_optional(&this_arg_conv);
51818 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_required"))) TS_NodeFeatures_set_scid_privacy_required(uint64_t this_arg) {
51819 LDKNodeFeatures this_arg_conv;
51820 this_arg_conv.inner = untag_ptr(this_arg);
51821 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51823 this_arg_conv.is_owned = false;
51824 NodeFeatures_set_scid_privacy_required(&this_arg_conv);
51827 jboolean __attribute__((export_name("TS_NodeFeatures_supports_scid_privacy"))) TS_NodeFeatures_supports_scid_privacy(uint64_t this_arg) {
51828 LDKNodeFeatures this_arg_conv;
51829 this_arg_conv.inner = untag_ptr(this_arg);
51830 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51832 this_arg_conv.is_owned = false;
51833 jboolean ret_conv = NodeFeatures_supports_scid_privacy(&this_arg_conv);
51837 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_optional"))) TS_ChannelTypeFeatures_set_scid_privacy_optional(uint64_t this_arg) {
51838 LDKChannelTypeFeatures this_arg_conv;
51839 this_arg_conv.inner = untag_ptr(this_arg);
51840 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51841 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51842 this_arg_conv.is_owned = false;
51843 ChannelTypeFeatures_set_scid_privacy_optional(&this_arg_conv);
51846 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_required"))) TS_ChannelTypeFeatures_set_scid_privacy_required(uint64_t this_arg) {
51847 LDKChannelTypeFeatures this_arg_conv;
51848 this_arg_conv.inner = untag_ptr(this_arg);
51849 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51850 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51851 this_arg_conv.is_owned = false;
51852 ChannelTypeFeatures_set_scid_privacy_required(&this_arg_conv);
51855 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_scid_privacy"))) TS_ChannelTypeFeatures_supports_scid_privacy(uint64_t this_arg) {
51856 LDKChannelTypeFeatures this_arg_conv;
51857 this_arg_conv.inner = untag_ptr(this_arg);
51858 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51860 this_arg_conv.is_owned = false;
51861 jboolean ret_conv = ChannelTypeFeatures_supports_scid_privacy(&this_arg_conv);
51865 jboolean __attribute__((export_name("TS_InitFeatures_requires_scid_privacy"))) TS_InitFeatures_requires_scid_privacy(uint64_t this_arg) {
51866 LDKInitFeatures this_arg_conv;
51867 this_arg_conv.inner = untag_ptr(this_arg);
51868 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51869 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51870 this_arg_conv.is_owned = false;
51871 jboolean ret_conv = InitFeatures_requires_scid_privacy(&this_arg_conv);
51875 jboolean __attribute__((export_name("TS_NodeFeatures_requires_scid_privacy"))) TS_NodeFeatures_requires_scid_privacy(uint64_t this_arg) {
51876 LDKNodeFeatures this_arg_conv;
51877 this_arg_conv.inner = untag_ptr(this_arg);
51878 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51879 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51880 this_arg_conv.is_owned = false;
51881 jboolean ret_conv = NodeFeatures_requires_scid_privacy(&this_arg_conv);
51885 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_scid_privacy"))) TS_ChannelTypeFeatures_requires_scid_privacy(uint64_t this_arg) {
51886 LDKChannelTypeFeatures this_arg_conv;
51887 this_arg_conv.inner = untag_ptr(this_arg);
51888 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51889 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51890 this_arg_conv.is_owned = false;
51891 jboolean ret_conv = ChannelTypeFeatures_requires_scid_privacy(&this_arg_conv);
51895 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_payment_metadata_optional"))) TS_Bolt11InvoiceFeatures_set_payment_metadata_optional(uint64_t this_arg) {
51896 LDKBolt11InvoiceFeatures this_arg_conv;
51897 this_arg_conv.inner = untag_ptr(this_arg);
51898 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51900 this_arg_conv.is_owned = false;
51901 Bolt11InvoiceFeatures_set_payment_metadata_optional(&this_arg_conv);
51904 void __attribute__((export_name("TS_Bolt11InvoiceFeatures_set_payment_metadata_required"))) TS_Bolt11InvoiceFeatures_set_payment_metadata_required(uint64_t this_arg) {
51905 LDKBolt11InvoiceFeatures this_arg_conv;
51906 this_arg_conv.inner = untag_ptr(this_arg);
51907 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51909 this_arg_conv.is_owned = false;
51910 Bolt11InvoiceFeatures_set_payment_metadata_required(&this_arg_conv);
51913 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_supports_payment_metadata"))) TS_Bolt11InvoiceFeatures_supports_payment_metadata(uint64_t this_arg) {
51914 LDKBolt11InvoiceFeatures this_arg_conv;
51915 this_arg_conv.inner = untag_ptr(this_arg);
51916 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51917 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51918 this_arg_conv.is_owned = false;
51919 jboolean ret_conv = Bolt11InvoiceFeatures_supports_payment_metadata(&this_arg_conv);
51923 jboolean __attribute__((export_name("TS_Bolt11InvoiceFeatures_requires_payment_metadata"))) TS_Bolt11InvoiceFeatures_requires_payment_metadata(uint64_t this_arg) {
51924 LDKBolt11InvoiceFeatures this_arg_conv;
51925 this_arg_conv.inner = untag_ptr(this_arg);
51926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51928 this_arg_conv.is_owned = false;
51929 jboolean ret_conv = Bolt11InvoiceFeatures_requires_payment_metadata(&this_arg_conv);
51933 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_optional"))) TS_InitFeatures_set_zero_conf_optional(uint64_t this_arg) {
51934 LDKInitFeatures this_arg_conv;
51935 this_arg_conv.inner = untag_ptr(this_arg);
51936 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51938 this_arg_conv.is_owned = false;
51939 InitFeatures_set_zero_conf_optional(&this_arg_conv);
51942 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_required"))) TS_InitFeatures_set_zero_conf_required(uint64_t this_arg) {
51943 LDKInitFeatures this_arg_conv;
51944 this_arg_conv.inner = untag_ptr(this_arg);
51945 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51947 this_arg_conv.is_owned = false;
51948 InitFeatures_set_zero_conf_required(&this_arg_conv);
51951 jboolean __attribute__((export_name("TS_InitFeatures_supports_zero_conf"))) TS_InitFeatures_supports_zero_conf(uint64_t this_arg) {
51952 LDKInitFeatures this_arg_conv;
51953 this_arg_conv.inner = untag_ptr(this_arg);
51954 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51956 this_arg_conv.is_owned = false;
51957 jboolean ret_conv = InitFeatures_supports_zero_conf(&this_arg_conv);
51961 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_optional"))) TS_NodeFeatures_set_zero_conf_optional(uint64_t this_arg) {
51962 LDKNodeFeatures this_arg_conv;
51963 this_arg_conv.inner = untag_ptr(this_arg);
51964 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51966 this_arg_conv.is_owned = false;
51967 NodeFeatures_set_zero_conf_optional(&this_arg_conv);
51970 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_required"))) TS_NodeFeatures_set_zero_conf_required(uint64_t this_arg) {
51971 LDKNodeFeatures this_arg_conv;
51972 this_arg_conv.inner = untag_ptr(this_arg);
51973 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51974 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51975 this_arg_conv.is_owned = false;
51976 NodeFeatures_set_zero_conf_required(&this_arg_conv);
51979 jboolean __attribute__((export_name("TS_NodeFeatures_supports_zero_conf"))) TS_NodeFeatures_supports_zero_conf(uint64_t this_arg) {
51980 LDKNodeFeatures this_arg_conv;
51981 this_arg_conv.inner = untag_ptr(this_arg);
51982 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51984 this_arg_conv.is_owned = false;
51985 jboolean ret_conv = NodeFeatures_supports_zero_conf(&this_arg_conv);
51989 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_optional"))) TS_ChannelTypeFeatures_set_zero_conf_optional(uint64_t this_arg) {
51990 LDKChannelTypeFeatures this_arg_conv;
51991 this_arg_conv.inner = untag_ptr(this_arg);
51992 this_arg_conv.is_owned = ptr_is_owned(this_arg);
51993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
51994 this_arg_conv.is_owned = false;
51995 ChannelTypeFeatures_set_zero_conf_optional(&this_arg_conv);
51998 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_required"))) TS_ChannelTypeFeatures_set_zero_conf_required(uint64_t this_arg) {
51999 LDKChannelTypeFeatures this_arg_conv;
52000 this_arg_conv.inner = untag_ptr(this_arg);
52001 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52002 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52003 this_arg_conv.is_owned = false;
52004 ChannelTypeFeatures_set_zero_conf_required(&this_arg_conv);
52007 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_zero_conf"))) TS_ChannelTypeFeatures_supports_zero_conf(uint64_t this_arg) {
52008 LDKChannelTypeFeatures this_arg_conv;
52009 this_arg_conv.inner = untag_ptr(this_arg);
52010 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52012 this_arg_conv.is_owned = false;
52013 jboolean ret_conv = ChannelTypeFeatures_supports_zero_conf(&this_arg_conv);
52017 jboolean __attribute__((export_name("TS_InitFeatures_requires_zero_conf"))) TS_InitFeatures_requires_zero_conf(uint64_t this_arg) {
52018 LDKInitFeatures this_arg_conv;
52019 this_arg_conv.inner = untag_ptr(this_arg);
52020 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52021 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52022 this_arg_conv.is_owned = false;
52023 jboolean ret_conv = InitFeatures_requires_zero_conf(&this_arg_conv);
52027 jboolean __attribute__((export_name("TS_NodeFeatures_requires_zero_conf"))) TS_NodeFeatures_requires_zero_conf(uint64_t this_arg) {
52028 LDKNodeFeatures this_arg_conv;
52029 this_arg_conv.inner = untag_ptr(this_arg);
52030 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52032 this_arg_conv.is_owned = false;
52033 jboolean ret_conv = NodeFeatures_requires_zero_conf(&this_arg_conv);
52037 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_zero_conf"))) TS_ChannelTypeFeatures_requires_zero_conf(uint64_t this_arg) {
52038 LDKChannelTypeFeatures this_arg_conv;
52039 this_arg_conv.inner = untag_ptr(this_arg);
52040 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52042 this_arg_conv.is_owned = false;
52043 jboolean ret_conv = ChannelTypeFeatures_requires_zero_conf(&this_arg_conv);
52047 void __attribute__((export_name("TS_NodeFeatures_set_keysend_optional"))) TS_NodeFeatures_set_keysend_optional(uint64_t this_arg) {
52048 LDKNodeFeatures this_arg_conv;
52049 this_arg_conv.inner = untag_ptr(this_arg);
52050 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52052 this_arg_conv.is_owned = false;
52053 NodeFeatures_set_keysend_optional(&this_arg_conv);
52056 void __attribute__((export_name("TS_NodeFeatures_set_keysend_required"))) TS_NodeFeatures_set_keysend_required(uint64_t this_arg) {
52057 LDKNodeFeatures this_arg_conv;
52058 this_arg_conv.inner = untag_ptr(this_arg);
52059 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52060 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52061 this_arg_conv.is_owned = false;
52062 NodeFeatures_set_keysend_required(&this_arg_conv);
52065 jboolean __attribute__((export_name("TS_NodeFeatures_supports_keysend"))) TS_NodeFeatures_supports_keysend(uint64_t this_arg) {
52066 LDKNodeFeatures this_arg_conv;
52067 this_arg_conv.inner = untag_ptr(this_arg);
52068 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52070 this_arg_conv.is_owned = false;
52071 jboolean ret_conv = NodeFeatures_supports_keysend(&this_arg_conv);
52075 jboolean __attribute__((export_name("TS_NodeFeatures_requires_keysend"))) TS_NodeFeatures_requires_keysend(uint64_t this_arg) {
52076 LDKNodeFeatures this_arg_conv;
52077 this_arg_conv.inner = untag_ptr(this_arg);
52078 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52080 this_arg_conv.is_owned = false;
52081 jboolean ret_conv = NodeFeatures_requires_keysend(&this_arg_conv);
52085 void __attribute__((export_name("TS_ShutdownScript_free"))) TS_ShutdownScript_free(uint64_t this_obj) {
52086 LDKShutdownScript this_obj_conv;
52087 this_obj_conv.inner = untag_ptr(this_obj);
52088 this_obj_conv.is_owned = ptr_is_owned(this_obj);
52089 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
52090 ShutdownScript_free(this_obj_conv);
52093 static inline uint64_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
52094 LDKShutdownScript ret_var = ShutdownScript_clone(arg);
52095 uint64_t ret_ref = 0;
52096 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52097 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52100 int64_t __attribute__((export_name("TS_ShutdownScript_clone_ptr"))) TS_ShutdownScript_clone_ptr(uint64_t arg) {
52101 LDKShutdownScript arg_conv;
52102 arg_conv.inner = untag_ptr(arg);
52103 arg_conv.is_owned = ptr_is_owned(arg);
52104 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
52105 arg_conv.is_owned = false;
52106 int64_t ret_conv = ShutdownScript_clone_ptr(&arg_conv);
52110 uint64_t __attribute__((export_name("TS_ShutdownScript_clone"))) TS_ShutdownScript_clone(uint64_t orig) {
52111 LDKShutdownScript orig_conv;
52112 orig_conv.inner = untag_ptr(orig);
52113 orig_conv.is_owned = ptr_is_owned(orig);
52114 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
52115 orig_conv.is_owned = false;
52116 LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
52117 uint64_t ret_ref = 0;
52118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52123 jboolean __attribute__((export_name("TS_ShutdownScript_eq"))) TS_ShutdownScript_eq(uint64_t a, uint64_t b) {
52124 LDKShutdownScript a_conv;
52125 a_conv.inner = untag_ptr(a);
52126 a_conv.is_owned = ptr_is_owned(a);
52127 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
52128 a_conv.is_owned = false;
52129 LDKShutdownScript b_conv;
52130 b_conv.inner = untag_ptr(b);
52131 b_conv.is_owned = ptr_is_owned(b);
52132 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
52133 b_conv.is_owned = false;
52134 jboolean ret_conv = ShutdownScript_eq(&a_conv, &b_conv);
52138 void __attribute__((export_name("TS_InvalidShutdownScript_free"))) TS_InvalidShutdownScript_free(uint64_t this_obj) {
52139 LDKInvalidShutdownScript this_obj_conv;
52140 this_obj_conv.inner = untag_ptr(this_obj);
52141 this_obj_conv.is_owned = ptr_is_owned(this_obj);
52142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
52143 InvalidShutdownScript_free(this_obj_conv);
52146 int8_tArray __attribute__((export_name("TS_InvalidShutdownScript_get_script"))) TS_InvalidShutdownScript_get_script(uint64_t this_ptr) {
52147 LDKInvalidShutdownScript this_ptr_conv;
52148 this_ptr_conv.inner = untag_ptr(this_ptr);
52149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52151 this_ptr_conv.is_owned = false;
52152 LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
52153 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
52154 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
52158 void __attribute__((export_name("TS_InvalidShutdownScript_set_script"))) TS_InvalidShutdownScript_set_script(uint64_t this_ptr, int8_tArray val) {
52159 LDKInvalidShutdownScript this_ptr_conv;
52160 this_ptr_conv.inner = untag_ptr(this_ptr);
52161 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52163 this_ptr_conv.is_owned = false;
52164 LDKCVec_u8Z val_ref;
52165 val_ref.datalen = val->arr_len;
52166 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
52167 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
52168 InvalidShutdownScript_set_script(&this_ptr_conv, val_ref);
52171 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_new"))) TS_InvalidShutdownScript_new(int8_tArray script_arg) {
52172 LDKCVec_u8Z script_arg_ref;
52173 script_arg_ref.datalen = script_arg->arr_len;
52174 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
52175 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
52176 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_new(script_arg_ref);
52177 uint64_t ret_ref = 0;
52178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52183 static inline uint64_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
52184 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
52185 uint64_t ret_ref = 0;
52186 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52187 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52190 int64_t __attribute__((export_name("TS_InvalidShutdownScript_clone_ptr"))) TS_InvalidShutdownScript_clone_ptr(uint64_t arg) {
52191 LDKInvalidShutdownScript arg_conv;
52192 arg_conv.inner = untag_ptr(arg);
52193 arg_conv.is_owned = ptr_is_owned(arg);
52194 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
52195 arg_conv.is_owned = false;
52196 int64_t ret_conv = InvalidShutdownScript_clone_ptr(&arg_conv);
52200 uint64_t __attribute__((export_name("TS_InvalidShutdownScript_clone"))) TS_InvalidShutdownScript_clone(uint64_t orig) {
52201 LDKInvalidShutdownScript orig_conv;
52202 orig_conv.inner = untag_ptr(orig);
52203 orig_conv.is_owned = ptr_is_owned(orig);
52204 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
52205 orig_conv.is_owned = false;
52206 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
52207 uint64_t ret_ref = 0;
52208 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52209 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52213 int8_tArray __attribute__((export_name("TS_ShutdownScript_write"))) TS_ShutdownScript_write(uint64_t obj) {
52214 LDKShutdownScript obj_conv;
52215 obj_conv.inner = untag_ptr(obj);
52216 obj_conv.is_owned = ptr_is_owned(obj);
52217 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
52218 obj_conv.is_owned = false;
52219 LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
52220 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
52221 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
52222 CVec_u8Z_free(ret_var);
52226 uint64_t __attribute__((export_name("TS_ShutdownScript_read"))) TS_ShutdownScript_read(int8_tArray ser) {
52227 LDKu8slice ser_ref;
52228 ser_ref.datalen = ser->arr_len;
52229 ser_ref.data = ser->elems;
52230 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
52231 *ret_conv = ShutdownScript_read(ser_ref);
52233 return tag_ptr(ret_conv, true);
52236 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wpkh"))) TS_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) {
52237 uint8_t pubkey_hash_arr[20];
52238 CHECK(pubkey_hash->arr_len == 20);
52239 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
52240 uint8_t (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
52241 LDKShutdownScript ret_var = ShutdownScript_new_p2wpkh(pubkey_hash_ref);
52242 uint64_t ret_ref = 0;
52243 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52244 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52248 uint64_t __attribute__((export_name("TS_ShutdownScript_new_p2wsh"))) TS_ShutdownScript_new_p2wsh(int8_tArray script_hash) {
52249 uint8_t script_hash_arr[32];
52250 CHECK(script_hash->arr_len == 32);
52251 memcpy(script_hash_arr, script_hash->elems, 32); FREE(script_hash);
52252 uint8_t (*script_hash_ref)[32] = &script_hash_arr;
52253 LDKShutdownScript ret_var = ShutdownScript_new_p2wsh(script_hash_ref);
52254 uint64_t ret_ref = 0;
52255 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52256 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52260 uint64_t __attribute__((export_name("TS_ShutdownScript_new_witness_program"))) TS_ShutdownScript_new_witness_program(int8_t version, int8_tArray program) {
52262 LDKu8slice program_ref;
52263 program_ref.datalen = program->arr_len;
52264 program_ref.data = program->elems;
52265 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
52266 *ret_conv = ShutdownScript_new_witness_program((LDKWitnessVersion){ ._0 = version }, program_ref);
52268 return tag_ptr(ret_conv, true);
52271 int8_tArray __attribute__((export_name("TS_ShutdownScript_into_inner"))) TS_ShutdownScript_into_inner(uint64_t this_arg) {
52272 LDKShutdownScript this_arg_conv;
52273 this_arg_conv.inner = untag_ptr(this_arg);
52274 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52275 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52276 this_arg_conv = ShutdownScript_clone(&this_arg_conv);
52277 LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
52278 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
52279 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
52280 CVec_u8Z_free(ret_var);
52284 int8_tArray __attribute__((export_name("TS_ShutdownScript_as_legacy_pubkey"))) TS_ShutdownScript_as_legacy_pubkey(uint64_t this_arg) {
52285 LDKShutdownScript this_arg_conv;
52286 this_arg_conv.inner = untag_ptr(this_arg);
52287 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52289 this_arg_conv.is_owned = false;
52290 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52291 memcpy(ret_arr->elems, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
52295 jboolean __attribute__((export_name("TS_ShutdownScript_is_compatible"))) TS_ShutdownScript_is_compatible(uint64_t this_arg, uint64_t features) {
52296 LDKShutdownScript this_arg_conv;
52297 this_arg_conv.inner = untag_ptr(this_arg);
52298 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52299 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52300 this_arg_conv.is_owned = false;
52301 LDKInitFeatures features_conv;
52302 features_conv.inner = untag_ptr(features);
52303 features_conv.is_owned = ptr_is_owned(features);
52304 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
52305 features_conv.is_owned = false;
52306 jboolean ret_conv = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
52310 void __attribute__((export_name("TS_Retry_free"))) TS_Retry_free(uint64_t this_ptr) {
52311 if (!ptr_is_owned(this_ptr)) return;
52312 void* this_ptr_ptr = untag_ptr(this_ptr);
52313 CHECK_ACCESS(this_ptr_ptr);
52314 LDKRetry this_ptr_conv = *(LDKRetry*)(this_ptr_ptr);
52315 FREE(untag_ptr(this_ptr));
52316 Retry_free(this_ptr_conv);
52319 static inline uint64_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg) {
52320 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
52321 *ret_copy = Retry_clone(arg);
52322 uint64_t ret_ref = tag_ptr(ret_copy, true);
52325 int64_t __attribute__((export_name("TS_Retry_clone_ptr"))) TS_Retry_clone_ptr(uint64_t arg) {
52326 LDKRetry* arg_conv = (LDKRetry*)untag_ptr(arg);
52327 int64_t ret_conv = Retry_clone_ptr(arg_conv);
52331 uint64_t __attribute__((export_name("TS_Retry_clone"))) TS_Retry_clone(uint64_t orig) {
52332 LDKRetry* orig_conv = (LDKRetry*)untag_ptr(orig);
52333 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
52334 *ret_copy = Retry_clone(orig_conv);
52335 uint64_t ret_ref = tag_ptr(ret_copy, true);
52339 uint64_t __attribute__((export_name("TS_Retry_attempts"))) TS_Retry_attempts(int32_t a) {
52340 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
52341 *ret_copy = Retry_attempts(a);
52342 uint64_t ret_ref = tag_ptr(ret_copy, true);
52346 jboolean __attribute__((export_name("TS_Retry_eq"))) TS_Retry_eq(uint64_t a, uint64_t b) {
52347 LDKRetry* a_conv = (LDKRetry*)untag_ptr(a);
52348 LDKRetry* b_conv = (LDKRetry*)untag_ptr(b);
52349 jboolean ret_conv = Retry_eq(a_conv, b_conv);
52353 int64_t __attribute__((export_name("TS_Retry_hash"))) TS_Retry_hash(uint64_t o) {
52354 LDKRetry* o_conv = (LDKRetry*)untag_ptr(o);
52355 int64_t ret_conv = Retry_hash(o_conv);
52359 int8_tArray __attribute__((export_name("TS_Retry_write"))) TS_Retry_write(uint64_t obj) {
52360 LDKRetry* obj_conv = (LDKRetry*)untag_ptr(obj);
52361 LDKCVec_u8Z ret_var = Retry_write(obj_conv);
52362 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
52363 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
52364 CVec_u8Z_free(ret_var);
52368 uint64_t __attribute__((export_name("TS_Retry_read"))) TS_Retry_read(int8_tArray ser) {
52369 LDKu8slice ser_ref;
52370 ser_ref.datalen = ser->arr_len;
52371 ser_ref.data = ser->elems;
52372 LDKCResult_RetryDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RetryDecodeErrorZ), "LDKCResult_RetryDecodeErrorZ");
52373 *ret_conv = Retry_read(ser_ref);
52375 return tag_ptr(ret_conv, true);
52378 uint32_t __attribute__((export_name("TS_RetryableSendFailure_clone"))) TS_RetryableSendFailure_clone(uint64_t orig) {
52379 LDKRetryableSendFailure* orig_conv = (LDKRetryableSendFailure*)untag_ptr(orig);
52380 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_clone(orig_conv));
52384 uint32_t __attribute__((export_name("TS_RetryableSendFailure_payment_expired"))) TS_RetryableSendFailure_payment_expired() {
52385 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_payment_expired());
52389 uint32_t __attribute__((export_name("TS_RetryableSendFailure_route_not_found"))) TS_RetryableSendFailure_route_not_found() {
52390 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_route_not_found());
52394 uint32_t __attribute__((export_name("TS_RetryableSendFailure_duplicate_payment"))) TS_RetryableSendFailure_duplicate_payment() {
52395 uint32_t ret_conv = LDKRetryableSendFailure_to_js(RetryableSendFailure_duplicate_payment());
52399 jboolean __attribute__((export_name("TS_RetryableSendFailure_eq"))) TS_RetryableSendFailure_eq(uint64_t a, uint64_t b) {
52400 LDKRetryableSendFailure* a_conv = (LDKRetryableSendFailure*)untag_ptr(a);
52401 LDKRetryableSendFailure* b_conv = (LDKRetryableSendFailure*)untag_ptr(b);
52402 jboolean ret_conv = RetryableSendFailure_eq(a_conv, b_conv);
52406 void __attribute__((export_name("TS_PaymentSendFailure_free"))) TS_PaymentSendFailure_free(uint64_t this_ptr) {
52407 if (!ptr_is_owned(this_ptr)) return;
52408 void* this_ptr_ptr = untag_ptr(this_ptr);
52409 CHECK_ACCESS(this_ptr_ptr);
52410 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(this_ptr_ptr);
52411 FREE(untag_ptr(this_ptr));
52412 PaymentSendFailure_free(this_ptr_conv);
52415 static inline uint64_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
52416 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52417 *ret_copy = PaymentSendFailure_clone(arg);
52418 uint64_t ret_ref = tag_ptr(ret_copy, true);
52421 int64_t __attribute__((export_name("TS_PaymentSendFailure_clone_ptr"))) TS_PaymentSendFailure_clone_ptr(uint64_t arg) {
52422 LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)untag_ptr(arg);
52423 int64_t ret_conv = PaymentSendFailure_clone_ptr(arg_conv);
52427 uint64_t __attribute__((export_name("TS_PaymentSendFailure_clone"))) TS_PaymentSendFailure_clone(uint64_t orig) {
52428 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)untag_ptr(orig);
52429 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52430 *ret_copy = PaymentSendFailure_clone(orig_conv);
52431 uint64_t ret_ref = tag_ptr(ret_copy, true);
52435 uint64_t __attribute__((export_name("TS_PaymentSendFailure_parameter_error"))) TS_PaymentSendFailure_parameter_error(uint64_t a) {
52436 void* a_ptr = untag_ptr(a);
52437 CHECK_ACCESS(a_ptr);
52438 LDKAPIError a_conv = *(LDKAPIError*)(a_ptr);
52439 a_conv = APIError_clone((LDKAPIError*)untag_ptr(a));
52440 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52441 *ret_copy = PaymentSendFailure_parameter_error(a_conv);
52442 uint64_t ret_ref = tag_ptr(ret_copy, true);
52446 uint64_t __attribute__((export_name("TS_PaymentSendFailure_path_parameter_error"))) TS_PaymentSendFailure_path_parameter_error(uint64_tArray a) {
52447 LDKCVec_CResult_NoneAPIErrorZZ a_constr;
52448 a_constr.datalen = a->arr_len;
52449 if (a_constr.datalen > 0)
52450 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
52452 a_constr.data = NULL;
52453 uint64_t* a_vals = a->elems;
52454 for (size_t w = 0; w < a_constr.datalen; w++) {
52455 uint64_t a_conv_22 = a_vals[w];
52456 void* a_conv_22_ptr = untag_ptr(a_conv_22);
52457 CHECK_ACCESS(a_conv_22_ptr);
52458 LDKCResult_NoneAPIErrorZ a_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(a_conv_22_ptr);
52459 a_conv_22_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)untag_ptr(a_conv_22));
52460 a_constr.data[w] = a_conv_22_conv;
52463 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52464 *ret_copy = PaymentSendFailure_path_parameter_error(a_constr);
52465 uint64_t ret_ref = tag_ptr(ret_copy, true);
52469 uint64_t __attribute__((export_name("TS_PaymentSendFailure_all_failed_resend_safe"))) TS_PaymentSendFailure_all_failed_resend_safe(uint64_tArray a) {
52470 LDKCVec_APIErrorZ a_constr;
52471 a_constr.datalen = a->arr_len;
52472 if (a_constr.datalen > 0)
52473 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
52475 a_constr.data = NULL;
52476 uint64_t* a_vals = a->elems;
52477 for (size_t k = 0; k < a_constr.datalen; k++) {
52478 uint64_t a_conv_10 = a_vals[k];
52479 void* a_conv_10_ptr = untag_ptr(a_conv_10);
52480 CHECK_ACCESS(a_conv_10_ptr);
52481 LDKAPIError a_conv_10_conv = *(LDKAPIError*)(a_conv_10_ptr);
52482 a_conv_10_conv = APIError_clone((LDKAPIError*)untag_ptr(a_conv_10));
52483 a_constr.data[k] = a_conv_10_conv;
52486 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52487 *ret_copy = PaymentSendFailure_all_failed_resend_safe(a_constr);
52488 uint64_t ret_ref = tag_ptr(ret_copy, true);
52492 uint64_t __attribute__((export_name("TS_PaymentSendFailure_duplicate_payment"))) TS_PaymentSendFailure_duplicate_payment() {
52493 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52494 *ret_copy = PaymentSendFailure_duplicate_payment();
52495 uint64_t ret_ref = tag_ptr(ret_copy, true);
52499 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) {
52500 LDKCVec_CResult_NoneAPIErrorZZ results_constr;
52501 results_constr.datalen = results->arr_len;
52502 if (results_constr.datalen > 0)
52503 results_constr.data = MALLOC(results_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
52505 results_constr.data = NULL;
52506 uint64_t* results_vals = results->elems;
52507 for (size_t w = 0; w < results_constr.datalen; w++) {
52508 uint64_t results_conv_22 = results_vals[w];
52509 void* results_conv_22_ptr = untag_ptr(results_conv_22);
52510 CHECK_ACCESS(results_conv_22_ptr);
52511 LDKCResult_NoneAPIErrorZ results_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(results_conv_22_ptr);
52512 results_constr.data[w] = results_conv_22_conv;
52515 LDKRouteParameters failed_paths_retry_conv;
52516 failed_paths_retry_conv.inner = untag_ptr(failed_paths_retry);
52517 failed_paths_retry_conv.is_owned = ptr_is_owned(failed_paths_retry);
52518 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
52519 failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
52520 LDKThirtyTwoBytes payment_id_ref;
52521 CHECK(payment_id->arr_len == 32);
52522 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
52523 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
52524 *ret_copy = PaymentSendFailure_partial_failure(results_constr, failed_paths_retry_conv, payment_id_ref);
52525 uint64_t ret_ref = tag_ptr(ret_copy, true);
52529 jboolean __attribute__((export_name("TS_PaymentSendFailure_eq"))) TS_PaymentSendFailure_eq(uint64_t a, uint64_t b) {
52530 LDKPaymentSendFailure* a_conv = (LDKPaymentSendFailure*)untag_ptr(a);
52531 LDKPaymentSendFailure* b_conv = (LDKPaymentSendFailure*)untag_ptr(b);
52532 jboolean ret_conv = PaymentSendFailure_eq(a_conv, b_conv);
52536 void __attribute__((export_name("TS_ProbeSendFailure_free"))) TS_ProbeSendFailure_free(uint64_t this_ptr) {
52537 if (!ptr_is_owned(this_ptr)) return;
52538 void* this_ptr_ptr = untag_ptr(this_ptr);
52539 CHECK_ACCESS(this_ptr_ptr);
52540 LDKProbeSendFailure this_ptr_conv = *(LDKProbeSendFailure*)(this_ptr_ptr);
52541 FREE(untag_ptr(this_ptr));
52542 ProbeSendFailure_free(this_ptr_conv);
52545 static inline uint64_t ProbeSendFailure_clone_ptr(LDKProbeSendFailure *NONNULL_PTR arg) {
52546 LDKProbeSendFailure *ret_copy = MALLOC(sizeof(LDKProbeSendFailure), "LDKProbeSendFailure");
52547 *ret_copy = ProbeSendFailure_clone(arg);
52548 uint64_t ret_ref = tag_ptr(ret_copy, true);
52551 int64_t __attribute__((export_name("TS_ProbeSendFailure_clone_ptr"))) TS_ProbeSendFailure_clone_ptr(uint64_t arg) {
52552 LDKProbeSendFailure* arg_conv = (LDKProbeSendFailure*)untag_ptr(arg);
52553 int64_t ret_conv = ProbeSendFailure_clone_ptr(arg_conv);
52557 uint64_t __attribute__((export_name("TS_ProbeSendFailure_clone"))) TS_ProbeSendFailure_clone(uint64_t orig) {
52558 LDKProbeSendFailure* orig_conv = (LDKProbeSendFailure*)untag_ptr(orig);
52559 LDKProbeSendFailure *ret_copy = MALLOC(sizeof(LDKProbeSendFailure), "LDKProbeSendFailure");
52560 *ret_copy = ProbeSendFailure_clone(orig_conv);
52561 uint64_t ret_ref = tag_ptr(ret_copy, true);
52565 uint64_t __attribute__((export_name("TS_ProbeSendFailure_route_not_found"))) TS_ProbeSendFailure_route_not_found() {
52566 LDKProbeSendFailure *ret_copy = MALLOC(sizeof(LDKProbeSendFailure), "LDKProbeSendFailure");
52567 *ret_copy = ProbeSendFailure_route_not_found();
52568 uint64_t ret_ref = tag_ptr(ret_copy, true);
52572 uint64_t __attribute__((export_name("TS_ProbeSendFailure_sending_failed"))) TS_ProbeSendFailure_sending_failed(uint64_t a) {
52573 void* a_ptr = untag_ptr(a);
52574 CHECK_ACCESS(a_ptr);
52575 LDKPaymentSendFailure a_conv = *(LDKPaymentSendFailure*)(a_ptr);
52576 a_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)untag_ptr(a));
52577 LDKProbeSendFailure *ret_copy = MALLOC(sizeof(LDKProbeSendFailure), "LDKProbeSendFailure");
52578 *ret_copy = ProbeSendFailure_sending_failed(a_conv);
52579 uint64_t ret_ref = tag_ptr(ret_copy, true);
52583 jboolean __attribute__((export_name("TS_ProbeSendFailure_eq"))) TS_ProbeSendFailure_eq(uint64_t a, uint64_t b) {
52584 LDKProbeSendFailure* a_conv = (LDKProbeSendFailure*)untag_ptr(a);
52585 LDKProbeSendFailure* b_conv = (LDKProbeSendFailure*)untag_ptr(b);
52586 jboolean ret_conv = ProbeSendFailure_eq(a_conv, b_conv);
52590 void __attribute__((export_name("TS_RecipientOnionFields_free"))) TS_RecipientOnionFields_free(uint64_t this_obj) {
52591 LDKRecipientOnionFields this_obj_conv;
52592 this_obj_conv.inner = untag_ptr(this_obj);
52593 this_obj_conv.is_owned = ptr_is_owned(this_obj);
52594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
52595 RecipientOnionFields_free(this_obj_conv);
52598 uint64_t __attribute__((export_name("TS_RecipientOnionFields_get_payment_secret"))) TS_RecipientOnionFields_get_payment_secret(uint64_t this_ptr) {
52599 LDKRecipientOnionFields this_ptr_conv;
52600 this_ptr_conv.inner = untag_ptr(this_ptr);
52601 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52603 this_ptr_conv.is_owned = false;
52604 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
52605 *ret_copy = RecipientOnionFields_get_payment_secret(&this_ptr_conv);
52606 uint64_t ret_ref = tag_ptr(ret_copy, true);
52610 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_secret"))) TS_RecipientOnionFields_set_payment_secret(uint64_t this_ptr, uint64_t val) {
52611 LDKRecipientOnionFields this_ptr_conv;
52612 this_ptr_conv.inner = untag_ptr(this_ptr);
52613 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52615 this_ptr_conv.is_owned = false;
52616 void* val_ptr = untag_ptr(val);
52617 CHECK_ACCESS(val_ptr);
52618 LDKCOption_ThirtyTwoBytesZ val_conv = *(LDKCOption_ThirtyTwoBytesZ*)(val_ptr);
52619 val_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(val));
52620 RecipientOnionFields_set_payment_secret(&this_ptr_conv, val_conv);
52623 uint64_t __attribute__((export_name("TS_RecipientOnionFields_get_payment_metadata"))) TS_RecipientOnionFields_get_payment_metadata(uint64_t this_ptr) {
52624 LDKRecipientOnionFields this_ptr_conv;
52625 this_ptr_conv.inner = untag_ptr(this_ptr);
52626 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52628 this_ptr_conv.is_owned = false;
52629 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52630 *ret_copy = RecipientOnionFields_get_payment_metadata(&this_ptr_conv);
52631 uint64_t ret_ref = tag_ptr(ret_copy, true);
52635 void __attribute__((export_name("TS_RecipientOnionFields_set_payment_metadata"))) TS_RecipientOnionFields_set_payment_metadata(uint64_t this_ptr, uint64_t val) {
52636 LDKRecipientOnionFields this_ptr_conv;
52637 this_ptr_conv.inner = untag_ptr(this_ptr);
52638 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
52639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
52640 this_ptr_conv.is_owned = false;
52641 void* val_ptr = untag_ptr(val);
52642 CHECK_ACCESS(val_ptr);
52643 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
52644 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
52645 RecipientOnionFields_set_payment_metadata(&this_ptr_conv, val_conv);
52648 static inline uint64_t RecipientOnionFields_clone_ptr(LDKRecipientOnionFields *NONNULL_PTR arg) {
52649 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(arg);
52650 uint64_t ret_ref = 0;
52651 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52652 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52655 int64_t __attribute__((export_name("TS_RecipientOnionFields_clone_ptr"))) TS_RecipientOnionFields_clone_ptr(uint64_t arg) {
52656 LDKRecipientOnionFields arg_conv;
52657 arg_conv.inner = untag_ptr(arg);
52658 arg_conv.is_owned = ptr_is_owned(arg);
52659 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
52660 arg_conv.is_owned = false;
52661 int64_t ret_conv = RecipientOnionFields_clone_ptr(&arg_conv);
52665 uint64_t __attribute__((export_name("TS_RecipientOnionFields_clone"))) TS_RecipientOnionFields_clone(uint64_t orig) {
52666 LDKRecipientOnionFields orig_conv;
52667 orig_conv.inner = untag_ptr(orig);
52668 orig_conv.is_owned = ptr_is_owned(orig);
52669 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
52670 orig_conv.is_owned = false;
52671 LDKRecipientOnionFields ret_var = RecipientOnionFields_clone(&orig_conv);
52672 uint64_t ret_ref = 0;
52673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52674 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52678 jboolean __attribute__((export_name("TS_RecipientOnionFields_eq"))) TS_RecipientOnionFields_eq(uint64_t a, uint64_t b) {
52679 LDKRecipientOnionFields a_conv;
52680 a_conv.inner = untag_ptr(a);
52681 a_conv.is_owned = ptr_is_owned(a);
52682 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
52683 a_conv.is_owned = false;
52684 LDKRecipientOnionFields b_conv;
52685 b_conv.inner = untag_ptr(b);
52686 b_conv.is_owned = ptr_is_owned(b);
52687 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
52688 b_conv.is_owned = false;
52689 jboolean ret_conv = RecipientOnionFields_eq(&a_conv, &b_conv);
52693 int8_tArray __attribute__((export_name("TS_RecipientOnionFields_write"))) TS_RecipientOnionFields_write(uint64_t obj) {
52694 LDKRecipientOnionFields obj_conv;
52695 obj_conv.inner = untag_ptr(obj);
52696 obj_conv.is_owned = ptr_is_owned(obj);
52697 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
52698 obj_conv.is_owned = false;
52699 LDKCVec_u8Z ret_var = RecipientOnionFields_write(&obj_conv);
52700 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
52701 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
52702 CVec_u8Z_free(ret_var);
52706 uint64_t __attribute__((export_name("TS_RecipientOnionFields_read"))) TS_RecipientOnionFields_read(int8_tArray ser) {
52707 LDKu8slice ser_ref;
52708 ser_ref.datalen = ser->arr_len;
52709 ser_ref.data = ser->elems;
52710 LDKCResult_RecipientOnionFieldsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsDecodeErrorZ), "LDKCResult_RecipientOnionFieldsDecodeErrorZ");
52711 *ret_conv = RecipientOnionFields_read(ser_ref);
52713 return tag_ptr(ret_conv, true);
52716 uint64_t __attribute__((export_name("TS_RecipientOnionFields_secret_only"))) TS_RecipientOnionFields_secret_only(int8_tArray payment_secret) {
52717 LDKThirtyTwoBytes payment_secret_ref;
52718 CHECK(payment_secret->arr_len == 32);
52719 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
52720 LDKRecipientOnionFields ret_var = RecipientOnionFields_secret_only(payment_secret_ref);
52721 uint64_t ret_ref = 0;
52722 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52723 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52727 uint64_t __attribute__((export_name("TS_RecipientOnionFields_spontaneous_empty"))) TS_RecipientOnionFields_spontaneous_empty() {
52728 LDKRecipientOnionFields ret_var = RecipientOnionFields_spontaneous_empty();
52729 uint64_t ret_ref = 0;
52730 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52731 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52735 uint64_t __attribute__((export_name("TS_RecipientOnionFields_with_custom_tlvs"))) TS_RecipientOnionFields_with_custom_tlvs(uint64_t this_arg, uint64_tArray custom_tlvs) {
52736 LDKRecipientOnionFields this_arg_conv;
52737 this_arg_conv.inner = untag_ptr(this_arg);
52738 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52740 this_arg_conv = RecipientOnionFields_clone(&this_arg_conv);
52741 LDKCVec_C2Tuple_u64CVec_u8ZZZ custom_tlvs_constr;
52742 custom_tlvs_constr.datalen = custom_tlvs->arr_len;
52743 if (custom_tlvs_constr.datalen > 0)
52744 custom_tlvs_constr.data = MALLOC(custom_tlvs_constr.datalen * sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKCVec_C2Tuple_u64CVec_u8ZZZ Elements");
52746 custom_tlvs_constr.data = NULL;
52747 uint64_t* custom_tlvs_vals = custom_tlvs->elems;
52748 for (size_t x = 0; x < custom_tlvs_constr.datalen; x++) {
52749 uint64_t custom_tlvs_conv_23 = custom_tlvs_vals[x];
52750 void* custom_tlvs_conv_23_ptr = untag_ptr(custom_tlvs_conv_23);
52751 CHECK_ACCESS(custom_tlvs_conv_23_ptr);
52752 LDKC2Tuple_u64CVec_u8ZZ custom_tlvs_conv_23_conv = *(LDKC2Tuple_u64CVec_u8ZZ*)(custom_tlvs_conv_23_ptr);
52753 custom_tlvs_conv_23_conv = C2Tuple_u64CVec_u8ZZ_clone((LDKC2Tuple_u64CVec_u8ZZ*)untag_ptr(custom_tlvs_conv_23));
52754 custom_tlvs_constr.data[x] = custom_tlvs_conv_23_conv;
52757 LDKCResult_RecipientOnionFieldsNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecipientOnionFieldsNoneZ), "LDKCResult_RecipientOnionFieldsNoneZ");
52758 *ret_conv = RecipientOnionFields_with_custom_tlvs(this_arg_conv, custom_tlvs_constr);
52759 return tag_ptr(ret_conv, true);
52762 uint64_tArray __attribute__((export_name("TS_RecipientOnionFields_custom_tlvs"))) TS_RecipientOnionFields_custom_tlvs(uint64_t this_arg) {
52763 LDKRecipientOnionFields this_arg_conv;
52764 this_arg_conv.inner = untag_ptr(this_arg);
52765 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52767 this_arg_conv.is_owned = false;
52768 LDKCVec_C2Tuple_u64CVec_u8ZZZ ret_var = RecipientOnionFields_custom_tlvs(&this_arg_conv);
52769 uint64_tArray ret_arr = NULL;
52770 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52771 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52772 for (size_t x = 0; x < ret_var.datalen; x++) {
52773 LDKC2Tuple_u64CVec_u8ZZ* ret_conv_23_conv = MALLOC(sizeof(LDKC2Tuple_u64CVec_u8ZZ), "LDKC2Tuple_u64CVec_u8ZZ");
52774 *ret_conv_23_conv = ret_var.data[x];
52775 ret_arr_ptr[x] = tag_ptr(ret_conv_23_conv, true);
52778 FREE(ret_var.data);
52782 void __attribute__((export_name("TS_CustomMessageReader_free"))) TS_CustomMessageReader_free(uint64_t this_ptr) {
52783 if (!ptr_is_owned(this_ptr)) return;
52784 void* this_ptr_ptr = untag_ptr(this_ptr);
52785 CHECK_ACCESS(this_ptr_ptr);
52786 LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(this_ptr_ptr);
52787 FREE(untag_ptr(this_ptr));
52788 CustomMessageReader_free(this_ptr_conv);
52791 static inline uint64_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
52792 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
52793 *ret_ret = Type_clone(arg);
52794 return tag_ptr(ret_ret, true);
52796 int64_t __attribute__((export_name("TS_Type_clone_ptr"))) TS_Type_clone_ptr(uint64_t arg) {
52797 void* arg_ptr = untag_ptr(arg);
52798 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
52799 LDKType* arg_conv = (LDKType*)arg_ptr;
52800 int64_t ret_conv = Type_clone_ptr(arg_conv);
52804 uint64_t __attribute__((export_name("TS_Type_clone"))) TS_Type_clone(uint64_t orig) {
52805 void* orig_ptr = untag_ptr(orig);
52806 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
52807 LDKType* orig_conv = (LDKType*)orig_ptr;
52808 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
52809 *ret_ret = Type_clone(orig_conv);
52810 return tag_ptr(ret_ret, true);
52813 void __attribute__((export_name("TS_Type_free"))) TS_Type_free(uint64_t this_ptr) {
52814 if (!ptr_is_owned(this_ptr)) return;
52815 void* this_ptr_ptr = untag_ptr(this_ptr);
52816 CHECK_ACCESS(this_ptr_ptr);
52817 LDKType this_ptr_conv = *(LDKType*)(this_ptr_ptr);
52818 FREE(untag_ptr(this_ptr));
52819 Type_free(this_ptr_conv);
52822 void __attribute__((export_name("TS_Offer_free"))) TS_Offer_free(uint64_t this_obj) {
52823 LDKOffer this_obj_conv;
52824 this_obj_conv.inner = untag_ptr(this_obj);
52825 this_obj_conv.is_owned = ptr_is_owned(this_obj);
52826 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
52827 Offer_free(this_obj_conv);
52830 static inline uint64_t Offer_clone_ptr(LDKOffer *NONNULL_PTR arg) {
52831 LDKOffer ret_var = Offer_clone(arg);
52832 uint64_t ret_ref = 0;
52833 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52834 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52837 int64_t __attribute__((export_name("TS_Offer_clone_ptr"))) TS_Offer_clone_ptr(uint64_t arg) {
52839 arg_conv.inner = untag_ptr(arg);
52840 arg_conv.is_owned = ptr_is_owned(arg);
52841 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
52842 arg_conv.is_owned = false;
52843 int64_t ret_conv = Offer_clone_ptr(&arg_conv);
52847 uint64_t __attribute__((export_name("TS_Offer_clone"))) TS_Offer_clone(uint64_t orig) {
52848 LDKOffer orig_conv;
52849 orig_conv.inner = untag_ptr(orig);
52850 orig_conv.is_owned = ptr_is_owned(orig);
52851 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
52852 orig_conv.is_owned = false;
52853 LDKOffer ret_var = Offer_clone(&orig_conv);
52854 uint64_t ret_ref = 0;
52855 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52856 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52860 ptrArray __attribute__((export_name("TS_Offer_chains"))) TS_Offer_chains(uint64_t this_arg) {
52861 LDKOffer this_arg_conv;
52862 this_arg_conv.inner = untag_ptr(this_arg);
52863 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52865 this_arg_conv.is_owned = false;
52866 LDKCVec_ThirtyTwoBytesZ ret_var = Offer_chains(&this_arg_conv);
52867 ptrArray ret_arr = NULL;
52868 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
52869 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
52870 for (size_t m = 0; m < ret_var.datalen; m++) {
52871 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
52872 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
52873 ret_arr_ptr[m] = ret_conv_12_arr;
52876 FREE(ret_var.data);
52880 uint64_t __attribute__((export_name("TS_Offer_metadata"))) TS_Offer_metadata(uint64_t this_arg) {
52881 LDKOffer this_arg_conv;
52882 this_arg_conv.inner = untag_ptr(this_arg);
52883 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52885 this_arg_conv.is_owned = false;
52886 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
52887 *ret_copy = Offer_metadata(&this_arg_conv);
52888 uint64_t ret_ref = tag_ptr(ret_copy, true);
52892 uint64_t __attribute__((export_name("TS_Offer_amount"))) TS_Offer_amount(uint64_t this_arg) {
52893 LDKOffer this_arg_conv;
52894 this_arg_conv.inner = untag_ptr(this_arg);
52895 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52897 this_arg_conv.is_owned = false;
52898 LDKAmount ret_var = Offer_amount(&this_arg_conv);
52899 uint64_t ret_ref = 0;
52900 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52901 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52905 uint64_t __attribute__((export_name("TS_Offer_description"))) TS_Offer_description(uint64_t this_arg) {
52906 LDKOffer this_arg_conv;
52907 this_arg_conv.inner = untag_ptr(this_arg);
52908 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52910 this_arg_conv.is_owned = false;
52911 LDKPrintableString ret_var = Offer_description(&this_arg_conv);
52912 uint64_t ret_ref = 0;
52913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52914 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52918 uint64_t __attribute__((export_name("TS_Offer_offer_features"))) TS_Offer_offer_features(uint64_t this_arg) {
52919 LDKOffer this_arg_conv;
52920 this_arg_conv.inner = untag_ptr(this_arg);
52921 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52923 this_arg_conv.is_owned = false;
52924 LDKOfferFeatures ret_var = Offer_offer_features(&this_arg_conv);
52925 uint64_t ret_ref = 0;
52926 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52927 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52931 uint64_t __attribute__((export_name("TS_Offer_absolute_expiry"))) TS_Offer_absolute_expiry(uint64_t this_arg) {
52932 LDKOffer this_arg_conv;
52933 this_arg_conv.inner = untag_ptr(this_arg);
52934 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52936 this_arg_conv.is_owned = false;
52937 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
52938 *ret_copy = Offer_absolute_expiry(&this_arg_conv);
52939 uint64_t ret_ref = tag_ptr(ret_copy, true);
52943 uint64_t __attribute__((export_name("TS_Offer_issuer"))) TS_Offer_issuer(uint64_t this_arg) {
52944 LDKOffer this_arg_conv;
52945 this_arg_conv.inner = untag_ptr(this_arg);
52946 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52947 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52948 this_arg_conv.is_owned = false;
52949 LDKPrintableString ret_var = Offer_issuer(&this_arg_conv);
52950 uint64_t ret_ref = 0;
52951 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52952 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52956 uint64_tArray __attribute__((export_name("TS_Offer_paths"))) TS_Offer_paths(uint64_t this_arg) {
52957 LDKOffer this_arg_conv;
52958 this_arg_conv.inner = untag_ptr(this_arg);
52959 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52961 this_arg_conv.is_owned = false;
52962 LDKCVec_BlindedPathZ ret_var = Offer_paths(&this_arg_conv);
52963 uint64_tArray ret_arr = NULL;
52964 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
52965 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
52966 for (size_t n = 0; n < ret_var.datalen; n++) {
52967 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
52968 uint64_t ret_conv_13_ref = 0;
52969 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
52970 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
52971 ret_arr_ptr[n] = ret_conv_13_ref;
52974 FREE(ret_var.data);
52978 uint64_t __attribute__((export_name("TS_Offer_supported_quantity"))) TS_Offer_supported_quantity(uint64_t this_arg) {
52979 LDKOffer this_arg_conv;
52980 this_arg_conv.inner = untag_ptr(this_arg);
52981 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52983 this_arg_conv.is_owned = false;
52984 LDKQuantity ret_var = Offer_supported_quantity(&this_arg_conv);
52985 uint64_t ret_ref = 0;
52986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
52987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
52991 int8_tArray __attribute__((export_name("TS_Offer_signing_pubkey"))) TS_Offer_signing_pubkey(uint64_t this_arg) {
52992 LDKOffer this_arg_conv;
52993 this_arg_conv.inner = untag_ptr(this_arg);
52994 this_arg_conv.is_owned = ptr_is_owned(this_arg);
52995 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
52996 this_arg_conv.is_owned = false;
52997 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
52998 memcpy(ret_arr->elems, Offer_signing_pubkey(&this_arg_conv).compressed_form, 33);
53002 jboolean __attribute__((export_name("TS_Offer_supports_chain"))) TS_Offer_supports_chain(uint64_t this_arg, int8_tArray chain) {
53003 LDKOffer this_arg_conv;
53004 this_arg_conv.inner = untag_ptr(this_arg);
53005 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53006 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53007 this_arg_conv.is_owned = false;
53008 LDKThirtyTwoBytes chain_ref;
53009 CHECK(chain->arr_len == 32);
53010 memcpy(chain_ref.data, chain->elems, 32); FREE(chain);
53011 jboolean ret_conv = Offer_supports_chain(&this_arg_conv, chain_ref);
53015 jboolean __attribute__((export_name("TS_Offer_is_valid_quantity"))) TS_Offer_is_valid_quantity(uint64_t this_arg, int64_t quantity) {
53016 LDKOffer this_arg_conv;
53017 this_arg_conv.inner = untag_ptr(this_arg);
53018 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53020 this_arg_conv.is_owned = false;
53021 jboolean ret_conv = Offer_is_valid_quantity(&this_arg_conv, quantity);
53025 jboolean __attribute__((export_name("TS_Offer_expects_quantity"))) TS_Offer_expects_quantity(uint64_t this_arg) {
53026 LDKOffer this_arg_conv;
53027 this_arg_conv.inner = untag_ptr(this_arg);
53028 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53030 this_arg_conv.is_owned = false;
53031 jboolean ret_conv = Offer_expects_quantity(&this_arg_conv);
53035 int8_tArray __attribute__((export_name("TS_Offer_write"))) TS_Offer_write(uint64_t obj) {
53037 obj_conv.inner = untag_ptr(obj);
53038 obj_conv.is_owned = ptr_is_owned(obj);
53039 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
53040 obj_conv.is_owned = false;
53041 LDKCVec_u8Z ret_var = Offer_write(&obj_conv);
53042 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53043 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53044 CVec_u8Z_free(ret_var);
53048 void __attribute__((export_name("TS_Amount_free"))) TS_Amount_free(uint64_t this_obj) {
53049 LDKAmount this_obj_conv;
53050 this_obj_conv.inner = untag_ptr(this_obj);
53051 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
53053 Amount_free(this_obj_conv);
53056 static inline uint64_t Amount_clone_ptr(LDKAmount *NONNULL_PTR arg) {
53057 LDKAmount ret_var = Amount_clone(arg);
53058 uint64_t ret_ref = 0;
53059 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53060 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53063 int64_t __attribute__((export_name("TS_Amount_clone_ptr"))) TS_Amount_clone_ptr(uint64_t arg) {
53064 LDKAmount arg_conv;
53065 arg_conv.inner = untag_ptr(arg);
53066 arg_conv.is_owned = ptr_is_owned(arg);
53067 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
53068 arg_conv.is_owned = false;
53069 int64_t ret_conv = Amount_clone_ptr(&arg_conv);
53073 uint64_t __attribute__((export_name("TS_Amount_clone"))) TS_Amount_clone(uint64_t orig) {
53074 LDKAmount orig_conv;
53075 orig_conv.inner = untag_ptr(orig);
53076 orig_conv.is_owned = ptr_is_owned(orig);
53077 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
53078 orig_conv.is_owned = false;
53079 LDKAmount ret_var = Amount_clone(&orig_conv);
53080 uint64_t ret_ref = 0;
53081 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53082 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53086 void __attribute__((export_name("TS_Quantity_free"))) TS_Quantity_free(uint64_t this_obj) {
53087 LDKQuantity this_obj_conv;
53088 this_obj_conv.inner = untag_ptr(this_obj);
53089 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
53091 Quantity_free(this_obj_conv);
53094 static inline uint64_t Quantity_clone_ptr(LDKQuantity *NONNULL_PTR arg) {
53095 LDKQuantity ret_var = Quantity_clone(arg);
53096 uint64_t ret_ref = 0;
53097 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53098 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53101 int64_t __attribute__((export_name("TS_Quantity_clone_ptr"))) TS_Quantity_clone_ptr(uint64_t arg) {
53102 LDKQuantity arg_conv;
53103 arg_conv.inner = untag_ptr(arg);
53104 arg_conv.is_owned = ptr_is_owned(arg);
53105 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
53106 arg_conv.is_owned = false;
53107 int64_t ret_conv = Quantity_clone_ptr(&arg_conv);
53111 uint64_t __attribute__((export_name("TS_Quantity_clone"))) TS_Quantity_clone(uint64_t orig) {
53112 LDKQuantity orig_conv;
53113 orig_conv.inner = untag_ptr(orig);
53114 orig_conv.is_owned = ptr_is_owned(orig);
53115 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
53116 orig_conv.is_owned = false;
53117 LDKQuantity ret_var = Quantity_clone(&orig_conv);
53118 uint64_t ret_ref = 0;
53119 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53120 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53124 uint64_t __attribute__((export_name("TS_Offer_from_str"))) TS_Offer_from_str(jstring s) {
53125 LDKStr s_conv = str_ref_to_owned_c(s);
53126 LDKCResult_OfferBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OfferBolt12ParseErrorZ), "LDKCResult_OfferBolt12ParseErrorZ");
53127 *ret_conv = Offer_from_str(s_conv);
53128 return tag_ptr(ret_conv, true);
53131 void __attribute__((export_name("TS_UnsignedBolt12Invoice_free"))) TS_UnsignedBolt12Invoice_free(uint64_t this_obj) {
53132 LDKUnsignedBolt12Invoice this_obj_conv;
53133 this_obj_conv.inner = untag_ptr(this_obj);
53134 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53135 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
53136 UnsignedBolt12Invoice_free(this_obj_conv);
53139 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_tagged_hash"))) TS_UnsignedBolt12Invoice_tagged_hash(uint64_t this_arg) {
53140 LDKUnsignedBolt12Invoice this_arg_conv;
53141 this_arg_conv.inner = untag_ptr(this_arg);
53142 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53144 this_arg_conv.is_owned = false;
53145 LDKTaggedHash ret_var = UnsignedBolt12Invoice_tagged_hash(&this_arg_conv);
53146 uint64_t ret_ref = 0;
53147 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53148 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53152 void __attribute__((export_name("TS_Bolt12Invoice_free"))) TS_Bolt12Invoice_free(uint64_t this_obj) {
53153 LDKBolt12Invoice this_obj_conv;
53154 this_obj_conv.inner = untag_ptr(this_obj);
53155 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
53157 Bolt12Invoice_free(this_obj_conv);
53160 static inline uint64_t Bolt12Invoice_clone_ptr(LDKBolt12Invoice *NONNULL_PTR arg) {
53161 LDKBolt12Invoice ret_var = Bolt12Invoice_clone(arg);
53162 uint64_t ret_ref = 0;
53163 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53164 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53167 int64_t __attribute__((export_name("TS_Bolt12Invoice_clone_ptr"))) TS_Bolt12Invoice_clone_ptr(uint64_t arg) {
53168 LDKBolt12Invoice arg_conv;
53169 arg_conv.inner = untag_ptr(arg);
53170 arg_conv.is_owned = ptr_is_owned(arg);
53171 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
53172 arg_conv.is_owned = false;
53173 int64_t ret_conv = Bolt12Invoice_clone_ptr(&arg_conv);
53177 uint64_t __attribute__((export_name("TS_Bolt12Invoice_clone"))) TS_Bolt12Invoice_clone(uint64_t orig) {
53178 LDKBolt12Invoice orig_conv;
53179 orig_conv.inner = untag_ptr(orig);
53180 orig_conv.is_owned = ptr_is_owned(orig);
53181 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
53182 orig_conv.is_owned = false;
53183 LDKBolt12Invoice ret_var = Bolt12Invoice_clone(&orig_conv);
53184 uint64_t ret_ref = 0;
53185 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53186 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53190 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_offer_chains"))) TS_UnsignedBolt12Invoice_offer_chains(uint64_t this_arg) {
53191 LDKUnsignedBolt12Invoice this_arg_conv;
53192 this_arg_conv.inner = untag_ptr(this_arg);
53193 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53195 this_arg_conv.is_owned = false;
53196 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
53197 *ret_copy = UnsignedBolt12Invoice_offer_chains(&this_arg_conv);
53198 uint64_t ret_ref = tag_ptr(ret_copy, true);
53202 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_chain"))) TS_UnsignedBolt12Invoice_chain(uint64_t this_arg) {
53203 LDKUnsignedBolt12Invoice this_arg_conv;
53204 this_arg_conv.inner = untag_ptr(this_arg);
53205 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53207 this_arg_conv.is_owned = false;
53208 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
53209 memcpy(ret_arr->elems, UnsignedBolt12Invoice_chain(&this_arg_conv).data, 32);
53213 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_metadata"))) TS_UnsignedBolt12Invoice_metadata(uint64_t this_arg) {
53214 LDKUnsignedBolt12Invoice this_arg_conv;
53215 this_arg_conv.inner = untag_ptr(this_arg);
53216 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53218 this_arg_conv.is_owned = false;
53219 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
53220 *ret_copy = UnsignedBolt12Invoice_metadata(&this_arg_conv);
53221 uint64_t ret_ref = tag_ptr(ret_copy, true);
53225 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_amount"))) TS_UnsignedBolt12Invoice_amount(uint64_t this_arg) {
53226 LDKUnsignedBolt12Invoice this_arg_conv;
53227 this_arg_conv.inner = untag_ptr(this_arg);
53228 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53230 this_arg_conv.is_owned = false;
53231 LDKAmount ret_var = UnsignedBolt12Invoice_amount(&this_arg_conv);
53232 uint64_t ret_ref = 0;
53233 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53234 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53238 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_offer_features"))) TS_UnsignedBolt12Invoice_offer_features(uint64_t this_arg) {
53239 LDKUnsignedBolt12Invoice this_arg_conv;
53240 this_arg_conv.inner = untag_ptr(this_arg);
53241 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53243 this_arg_conv.is_owned = false;
53244 LDKOfferFeatures ret_var = UnsignedBolt12Invoice_offer_features(&this_arg_conv);
53245 uint64_t ret_ref = 0;
53246 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53247 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53251 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_description"))) TS_UnsignedBolt12Invoice_description(uint64_t this_arg) {
53252 LDKUnsignedBolt12Invoice this_arg_conv;
53253 this_arg_conv.inner = untag_ptr(this_arg);
53254 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53255 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53256 this_arg_conv.is_owned = false;
53257 LDKPrintableString ret_var = UnsignedBolt12Invoice_description(&this_arg_conv);
53258 uint64_t ret_ref = 0;
53259 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53260 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53264 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_absolute_expiry"))) TS_UnsignedBolt12Invoice_absolute_expiry(uint64_t this_arg) {
53265 LDKUnsignedBolt12Invoice this_arg_conv;
53266 this_arg_conv.inner = untag_ptr(this_arg);
53267 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53269 this_arg_conv.is_owned = false;
53270 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
53271 *ret_copy = UnsignedBolt12Invoice_absolute_expiry(&this_arg_conv);
53272 uint64_t ret_ref = tag_ptr(ret_copy, true);
53276 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_issuer"))) TS_UnsignedBolt12Invoice_issuer(uint64_t this_arg) {
53277 LDKUnsignedBolt12Invoice this_arg_conv;
53278 this_arg_conv.inner = untag_ptr(this_arg);
53279 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53280 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53281 this_arg_conv.is_owned = false;
53282 LDKPrintableString ret_var = UnsignedBolt12Invoice_issuer(&this_arg_conv);
53283 uint64_t ret_ref = 0;
53284 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53285 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53289 uint64_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_message_paths"))) TS_UnsignedBolt12Invoice_message_paths(uint64_t this_arg) {
53290 LDKUnsignedBolt12Invoice this_arg_conv;
53291 this_arg_conv.inner = untag_ptr(this_arg);
53292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53294 this_arg_conv.is_owned = false;
53295 LDKCVec_BlindedPathZ ret_var = UnsignedBolt12Invoice_message_paths(&this_arg_conv);
53296 uint64_tArray ret_arr = NULL;
53297 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
53298 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
53299 for (size_t n = 0; n < ret_var.datalen; n++) {
53300 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
53301 uint64_t ret_conv_13_ref = 0;
53302 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
53303 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
53304 ret_arr_ptr[n] = ret_conv_13_ref;
53307 FREE(ret_var.data);
53311 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_supported_quantity"))) TS_UnsignedBolt12Invoice_supported_quantity(uint64_t this_arg) {
53312 LDKUnsignedBolt12Invoice this_arg_conv;
53313 this_arg_conv.inner = untag_ptr(this_arg);
53314 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53316 this_arg_conv.is_owned = false;
53317 LDKQuantity ret_var = UnsignedBolt12Invoice_supported_quantity(&this_arg_conv);
53318 uint64_t ret_ref = 0;
53319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53320 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53324 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_payer_metadata"))) TS_UnsignedBolt12Invoice_payer_metadata(uint64_t this_arg) {
53325 LDKUnsignedBolt12Invoice this_arg_conv;
53326 this_arg_conv.inner = untag_ptr(this_arg);
53327 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53328 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53329 this_arg_conv.is_owned = false;
53330 LDKu8slice ret_var = UnsignedBolt12Invoice_payer_metadata(&this_arg_conv);
53331 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53332 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53336 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_invoice_request_features"))) TS_UnsignedBolt12Invoice_invoice_request_features(uint64_t this_arg) {
53337 LDKUnsignedBolt12Invoice this_arg_conv;
53338 this_arg_conv.inner = untag_ptr(this_arg);
53339 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53341 this_arg_conv.is_owned = false;
53342 LDKInvoiceRequestFeatures ret_var = UnsignedBolt12Invoice_invoice_request_features(&this_arg_conv);
53343 uint64_t ret_ref = 0;
53344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53345 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53349 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_quantity"))) TS_UnsignedBolt12Invoice_quantity(uint64_t this_arg) {
53350 LDKUnsignedBolt12Invoice this_arg_conv;
53351 this_arg_conv.inner = untag_ptr(this_arg);
53352 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53354 this_arg_conv.is_owned = false;
53355 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
53356 *ret_copy = UnsignedBolt12Invoice_quantity(&this_arg_conv);
53357 uint64_t ret_ref = tag_ptr(ret_copy, true);
53361 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_payer_id"))) TS_UnsignedBolt12Invoice_payer_id(uint64_t this_arg) {
53362 LDKUnsignedBolt12Invoice this_arg_conv;
53363 this_arg_conv.inner = untag_ptr(this_arg);
53364 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53366 this_arg_conv.is_owned = false;
53367 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
53368 memcpy(ret_arr->elems, UnsignedBolt12Invoice_payer_id(&this_arg_conv).compressed_form, 33);
53372 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_payer_note"))) TS_UnsignedBolt12Invoice_payer_note(uint64_t this_arg) {
53373 LDKUnsignedBolt12Invoice this_arg_conv;
53374 this_arg_conv.inner = untag_ptr(this_arg);
53375 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53377 this_arg_conv.is_owned = false;
53378 LDKPrintableString ret_var = UnsignedBolt12Invoice_payer_note(&this_arg_conv);
53379 uint64_t ret_ref = 0;
53380 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53381 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53385 int64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_created_at"))) TS_UnsignedBolt12Invoice_created_at(uint64_t this_arg) {
53386 LDKUnsignedBolt12Invoice this_arg_conv;
53387 this_arg_conv.inner = untag_ptr(this_arg);
53388 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53390 this_arg_conv.is_owned = false;
53391 int64_t ret_conv = UnsignedBolt12Invoice_created_at(&this_arg_conv);
53395 int64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_relative_expiry"))) TS_UnsignedBolt12Invoice_relative_expiry(uint64_t this_arg) {
53396 LDKUnsignedBolt12Invoice this_arg_conv;
53397 this_arg_conv.inner = untag_ptr(this_arg);
53398 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53400 this_arg_conv.is_owned = false;
53401 int64_t ret_conv = UnsignedBolt12Invoice_relative_expiry(&this_arg_conv);
53405 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_payment_hash"))) TS_UnsignedBolt12Invoice_payment_hash(uint64_t this_arg) {
53406 LDKUnsignedBolt12Invoice this_arg_conv;
53407 this_arg_conv.inner = untag_ptr(this_arg);
53408 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53410 this_arg_conv.is_owned = false;
53411 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
53412 memcpy(ret_arr->elems, UnsignedBolt12Invoice_payment_hash(&this_arg_conv).data, 32);
53416 int64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_amount_msats"))) TS_UnsignedBolt12Invoice_amount_msats(uint64_t this_arg) {
53417 LDKUnsignedBolt12Invoice this_arg_conv;
53418 this_arg_conv.inner = untag_ptr(this_arg);
53419 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53420 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53421 this_arg_conv.is_owned = false;
53422 int64_t ret_conv = UnsignedBolt12Invoice_amount_msats(&this_arg_conv);
53426 uint64_t __attribute__((export_name("TS_UnsignedBolt12Invoice_invoice_features"))) TS_UnsignedBolt12Invoice_invoice_features(uint64_t this_arg) {
53427 LDKUnsignedBolt12Invoice this_arg_conv;
53428 this_arg_conv.inner = untag_ptr(this_arg);
53429 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53430 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53431 this_arg_conv.is_owned = false;
53432 LDKBolt12InvoiceFeatures ret_var = UnsignedBolt12Invoice_invoice_features(&this_arg_conv);
53433 uint64_t ret_ref = 0;
53434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53435 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53439 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_signing_pubkey"))) TS_UnsignedBolt12Invoice_signing_pubkey(uint64_t this_arg) {
53440 LDKUnsignedBolt12Invoice this_arg_conv;
53441 this_arg_conv.inner = untag_ptr(this_arg);
53442 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53444 this_arg_conv.is_owned = false;
53445 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
53446 memcpy(ret_arr->elems, UnsignedBolt12Invoice_signing_pubkey(&this_arg_conv).compressed_form, 33);
53450 uint64_t __attribute__((export_name("TS_Bolt12Invoice_offer_chains"))) TS_Bolt12Invoice_offer_chains(uint64_t this_arg) {
53451 LDKBolt12Invoice this_arg_conv;
53452 this_arg_conv.inner = untag_ptr(this_arg);
53453 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53454 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53455 this_arg_conv.is_owned = false;
53456 LDKCOption_CVec_ThirtyTwoBytesZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_ThirtyTwoBytesZZ), "LDKCOption_CVec_ThirtyTwoBytesZZ");
53457 *ret_copy = Bolt12Invoice_offer_chains(&this_arg_conv);
53458 uint64_t ret_ref = tag_ptr(ret_copy, true);
53462 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_chain"))) TS_Bolt12Invoice_chain(uint64_t this_arg) {
53463 LDKBolt12Invoice this_arg_conv;
53464 this_arg_conv.inner = untag_ptr(this_arg);
53465 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53467 this_arg_conv.is_owned = false;
53468 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
53469 memcpy(ret_arr->elems, Bolt12Invoice_chain(&this_arg_conv).data, 32);
53473 uint64_t __attribute__((export_name("TS_Bolt12Invoice_metadata"))) TS_Bolt12Invoice_metadata(uint64_t this_arg) {
53474 LDKBolt12Invoice this_arg_conv;
53475 this_arg_conv.inner = untag_ptr(this_arg);
53476 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53477 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53478 this_arg_conv.is_owned = false;
53479 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
53480 *ret_copy = Bolt12Invoice_metadata(&this_arg_conv);
53481 uint64_t ret_ref = tag_ptr(ret_copy, true);
53485 uint64_t __attribute__((export_name("TS_Bolt12Invoice_amount"))) TS_Bolt12Invoice_amount(uint64_t this_arg) {
53486 LDKBolt12Invoice this_arg_conv;
53487 this_arg_conv.inner = untag_ptr(this_arg);
53488 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53490 this_arg_conv.is_owned = false;
53491 LDKAmount ret_var = Bolt12Invoice_amount(&this_arg_conv);
53492 uint64_t ret_ref = 0;
53493 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53494 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53498 uint64_t __attribute__((export_name("TS_Bolt12Invoice_offer_features"))) TS_Bolt12Invoice_offer_features(uint64_t this_arg) {
53499 LDKBolt12Invoice this_arg_conv;
53500 this_arg_conv.inner = untag_ptr(this_arg);
53501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53503 this_arg_conv.is_owned = false;
53504 LDKOfferFeatures ret_var = Bolt12Invoice_offer_features(&this_arg_conv);
53505 uint64_t ret_ref = 0;
53506 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53507 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53511 uint64_t __attribute__((export_name("TS_Bolt12Invoice_description"))) TS_Bolt12Invoice_description(uint64_t this_arg) {
53512 LDKBolt12Invoice this_arg_conv;
53513 this_arg_conv.inner = untag_ptr(this_arg);
53514 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53516 this_arg_conv.is_owned = false;
53517 LDKPrintableString ret_var = Bolt12Invoice_description(&this_arg_conv);
53518 uint64_t ret_ref = 0;
53519 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53520 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53524 uint64_t __attribute__((export_name("TS_Bolt12Invoice_absolute_expiry"))) TS_Bolt12Invoice_absolute_expiry(uint64_t this_arg) {
53525 LDKBolt12Invoice this_arg_conv;
53526 this_arg_conv.inner = untag_ptr(this_arg);
53527 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53528 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53529 this_arg_conv.is_owned = false;
53530 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
53531 *ret_copy = Bolt12Invoice_absolute_expiry(&this_arg_conv);
53532 uint64_t ret_ref = tag_ptr(ret_copy, true);
53536 uint64_t __attribute__((export_name("TS_Bolt12Invoice_issuer"))) TS_Bolt12Invoice_issuer(uint64_t this_arg) {
53537 LDKBolt12Invoice this_arg_conv;
53538 this_arg_conv.inner = untag_ptr(this_arg);
53539 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53541 this_arg_conv.is_owned = false;
53542 LDKPrintableString ret_var = Bolt12Invoice_issuer(&this_arg_conv);
53543 uint64_t ret_ref = 0;
53544 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53545 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53549 uint64_tArray __attribute__((export_name("TS_Bolt12Invoice_message_paths"))) TS_Bolt12Invoice_message_paths(uint64_t this_arg) {
53550 LDKBolt12Invoice this_arg_conv;
53551 this_arg_conv.inner = untag_ptr(this_arg);
53552 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53554 this_arg_conv.is_owned = false;
53555 LDKCVec_BlindedPathZ ret_var = Bolt12Invoice_message_paths(&this_arg_conv);
53556 uint64_tArray ret_arr = NULL;
53557 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
53558 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
53559 for (size_t n = 0; n < ret_var.datalen; n++) {
53560 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
53561 uint64_t ret_conv_13_ref = 0;
53562 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
53563 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
53564 ret_arr_ptr[n] = ret_conv_13_ref;
53567 FREE(ret_var.data);
53571 uint64_t __attribute__((export_name("TS_Bolt12Invoice_supported_quantity"))) TS_Bolt12Invoice_supported_quantity(uint64_t this_arg) {
53572 LDKBolt12Invoice this_arg_conv;
53573 this_arg_conv.inner = untag_ptr(this_arg);
53574 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53576 this_arg_conv.is_owned = false;
53577 LDKQuantity ret_var = Bolt12Invoice_supported_quantity(&this_arg_conv);
53578 uint64_t ret_ref = 0;
53579 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53580 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53584 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_payer_metadata"))) TS_Bolt12Invoice_payer_metadata(uint64_t this_arg) {
53585 LDKBolt12Invoice this_arg_conv;
53586 this_arg_conv.inner = untag_ptr(this_arg);
53587 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53588 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53589 this_arg_conv.is_owned = false;
53590 LDKu8slice ret_var = Bolt12Invoice_payer_metadata(&this_arg_conv);
53591 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53592 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53596 uint64_t __attribute__((export_name("TS_Bolt12Invoice_invoice_request_features"))) TS_Bolt12Invoice_invoice_request_features(uint64_t this_arg) {
53597 LDKBolt12Invoice this_arg_conv;
53598 this_arg_conv.inner = untag_ptr(this_arg);
53599 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53600 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53601 this_arg_conv.is_owned = false;
53602 LDKInvoiceRequestFeatures ret_var = Bolt12Invoice_invoice_request_features(&this_arg_conv);
53603 uint64_t ret_ref = 0;
53604 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53605 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53609 uint64_t __attribute__((export_name("TS_Bolt12Invoice_quantity"))) TS_Bolt12Invoice_quantity(uint64_t this_arg) {
53610 LDKBolt12Invoice this_arg_conv;
53611 this_arg_conv.inner = untag_ptr(this_arg);
53612 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53614 this_arg_conv.is_owned = false;
53615 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
53616 *ret_copy = Bolt12Invoice_quantity(&this_arg_conv);
53617 uint64_t ret_ref = tag_ptr(ret_copy, true);
53621 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_payer_id"))) TS_Bolt12Invoice_payer_id(uint64_t this_arg) {
53622 LDKBolt12Invoice this_arg_conv;
53623 this_arg_conv.inner = untag_ptr(this_arg);
53624 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53625 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53626 this_arg_conv.is_owned = false;
53627 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
53628 memcpy(ret_arr->elems, Bolt12Invoice_payer_id(&this_arg_conv).compressed_form, 33);
53632 uint64_t __attribute__((export_name("TS_Bolt12Invoice_payer_note"))) TS_Bolt12Invoice_payer_note(uint64_t this_arg) {
53633 LDKBolt12Invoice this_arg_conv;
53634 this_arg_conv.inner = untag_ptr(this_arg);
53635 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53636 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53637 this_arg_conv.is_owned = false;
53638 LDKPrintableString ret_var = Bolt12Invoice_payer_note(&this_arg_conv);
53639 uint64_t ret_ref = 0;
53640 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53641 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53645 int64_t __attribute__((export_name("TS_Bolt12Invoice_created_at"))) TS_Bolt12Invoice_created_at(uint64_t this_arg) {
53646 LDKBolt12Invoice this_arg_conv;
53647 this_arg_conv.inner = untag_ptr(this_arg);
53648 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53649 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53650 this_arg_conv.is_owned = false;
53651 int64_t ret_conv = Bolt12Invoice_created_at(&this_arg_conv);
53655 int64_t __attribute__((export_name("TS_Bolt12Invoice_relative_expiry"))) TS_Bolt12Invoice_relative_expiry(uint64_t this_arg) {
53656 LDKBolt12Invoice this_arg_conv;
53657 this_arg_conv.inner = untag_ptr(this_arg);
53658 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53659 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53660 this_arg_conv.is_owned = false;
53661 int64_t ret_conv = Bolt12Invoice_relative_expiry(&this_arg_conv);
53665 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_payment_hash"))) TS_Bolt12Invoice_payment_hash(uint64_t this_arg) {
53666 LDKBolt12Invoice this_arg_conv;
53667 this_arg_conv.inner = untag_ptr(this_arg);
53668 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53670 this_arg_conv.is_owned = false;
53671 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
53672 memcpy(ret_arr->elems, Bolt12Invoice_payment_hash(&this_arg_conv).data, 32);
53676 int64_t __attribute__((export_name("TS_Bolt12Invoice_amount_msats"))) TS_Bolt12Invoice_amount_msats(uint64_t this_arg) {
53677 LDKBolt12Invoice this_arg_conv;
53678 this_arg_conv.inner = untag_ptr(this_arg);
53679 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53681 this_arg_conv.is_owned = false;
53682 int64_t ret_conv = Bolt12Invoice_amount_msats(&this_arg_conv);
53686 uint64_t __attribute__((export_name("TS_Bolt12Invoice_invoice_features"))) TS_Bolt12Invoice_invoice_features(uint64_t this_arg) {
53687 LDKBolt12Invoice this_arg_conv;
53688 this_arg_conv.inner = untag_ptr(this_arg);
53689 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53691 this_arg_conv.is_owned = false;
53692 LDKBolt12InvoiceFeatures ret_var = Bolt12Invoice_invoice_features(&this_arg_conv);
53693 uint64_t ret_ref = 0;
53694 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53695 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53699 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_signing_pubkey"))) TS_Bolt12Invoice_signing_pubkey(uint64_t this_arg) {
53700 LDKBolt12Invoice this_arg_conv;
53701 this_arg_conv.inner = untag_ptr(this_arg);
53702 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53704 this_arg_conv.is_owned = false;
53705 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
53706 memcpy(ret_arr->elems, Bolt12Invoice_signing_pubkey(&this_arg_conv).compressed_form, 33);
53710 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_signature"))) TS_Bolt12Invoice_signature(uint64_t this_arg) {
53711 LDKBolt12Invoice this_arg_conv;
53712 this_arg_conv.inner = untag_ptr(this_arg);
53713 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53715 this_arg_conv.is_owned = false;
53716 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
53717 memcpy(ret_arr->elems, Bolt12Invoice_signature(&this_arg_conv).compact_form, 64);
53721 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_signable_hash"))) TS_Bolt12Invoice_signable_hash(uint64_t this_arg) {
53722 LDKBolt12Invoice this_arg_conv;
53723 this_arg_conv.inner = untag_ptr(this_arg);
53724 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53725 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53726 this_arg_conv.is_owned = false;
53727 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
53728 memcpy(ret_arr->elems, Bolt12Invoice_signable_hash(&this_arg_conv).data, 32);
53732 uint64_t __attribute__((export_name("TS_Bolt12Invoice_verify"))) TS_Bolt12Invoice_verify(uint64_t this_arg, uint64_t key) {
53733 LDKBolt12Invoice this_arg_conv;
53734 this_arg_conv.inner = untag_ptr(this_arg);
53735 this_arg_conv.is_owned = ptr_is_owned(this_arg);
53736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
53737 this_arg_conv.is_owned = false;
53738 LDKExpandedKey key_conv;
53739 key_conv.inner = untag_ptr(key);
53740 key_conv.is_owned = ptr_is_owned(key);
53741 CHECK_INNER_FIELD_ACCESS_OR_NULL(key_conv);
53742 key_conv.is_owned = false;
53743 LDKCResult_ThirtyTwoBytesNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesNoneZ), "LDKCResult_ThirtyTwoBytesNoneZ");
53744 *ret_conv = Bolt12Invoice_verify(&this_arg_conv, &key_conv);
53745 return tag_ptr(ret_conv, true);
53748 int8_tArray __attribute__((export_name("TS_UnsignedBolt12Invoice_write"))) TS_UnsignedBolt12Invoice_write(uint64_t obj) {
53749 LDKUnsignedBolt12Invoice obj_conv;
53750 obj_conv.inner = untag_ptr(obj);
53751 obj_conv.is_owned = ptr_is_owned(obj);
53752 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
53753 obj_conv.is_owned = false;
53754 LDKCVec_u8Z ret_var = UnsignedBolt12Invoice_write(&obj_conv);
53755 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53756 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53757 CVec_u8Z_free(ret_var);
53761 int8_tArray __attribute__((export_name("TS_Bolt12Invoice_write"))) TS_Bolt12Invoice_write(uint64_t obj) {
53762 LDKBolt12Invoice obj_conv;
53763 obj_conv.inner = untag_ptr(obj);
53764 obj_conv.is_owned = ptr_is_owned(obj);
53765 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
53766 obj_conv.is_owned = false;
53767 LDKCVec_u8Z ret_var = Bolt12Invoice_write(&obj_conv);
53768 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53769 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53770 CVec_u8Z_free(ret_var);
53774 void __attribute__((export_name("TS_BlindedPayInfo_free"))) TS_BlindedPayInfo_free(uint64_t this_obj) {
53775 LDKBlindedPayInfo this_obj_conv;
53776 this_obj_conv.inner = untag_ptr(this_obj);
53777 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
53779 BlindedPayInfo_free(this_obj_conv);
53782 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_base_msat"))) TS_BlindedPayInfo_get_fee_base_msat(uint64_t this_ptr) {
53783 LDKBlindedPayInfo this_ptr_conv;
53784 this_ptr_conv.inner = untag_ptr(this_ptr);
53785 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53787 this_ptr_conv.is_owned = false;
53788 int32_t ret_conv = BlindedPayInfo_get_fee_base_msat(&this_ptr_conv);
53792 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_base_msat"))) TS_BlindedPayInfo_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
53793 LDKBlindedPayInfo this_ptr_conv;
53794 this_ptr_conv.inner = untag_ptr(this_ptr);
53795 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53797 this_ptr_conv.is_owned = false;
53798 BlindedPayInfo_set_fee_base_msat(&this_ptr_conv, val);
53801 int32_t __attribute__((export_name("TS_BlindedPayInfo_get_fee_proportional_millionths"))) TS_BlindedPayInfo_get_fee_proportional_millionths(uint64_t this_ptr) {
53802 LDKBlindedPayInfo this_ptr_conv;
53803 this_ptr_conv.inner = untag_ptr(this_ptr);
53804 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53806 this_ptr_conv.is_owned = false;
53807 int32_t ret_conv = BlindedPayInfo_get_fee_proportional_millionths(&this_ptr_conv);
53811 void __attribute__((export_name("TS_BlindedPayInfo_set_fee_proportional_millionths"))) TS_BlindedPayInfo_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
53812 LDKBlindedPayInfo this_ptr_conv;
53813 this_ptr_conv.inner = untag_ptr(this_ptr);
53814 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53816 this_ptr_conv.is_owned = false;
53817 BlindedPayInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
53820 int16_t __attribute__((export_name("TS_BlindedPayInfo_get_cltv_expiry_delta"))) TS_BlindedPayInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
53821 LDKBlindedPayInfo this_ptr_conv;
53822 this_ptr_conv.inner = untag_ptr(this_ptr);
53823 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53824 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53825 this_ptr_conv.is_owned = false;
53826 int16_t ret_conv = BlindedPayInfo_get_cltv_expiry_delta(&this_ptr_conv);
53830 void __attribute__((export_name("TS_BlindedPayInfo_set_cltv_expiry_delta"))) TS_BlindedPayInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
53831 LDKBlindedPayInfo this_ptr_conv;
53832 this_ptr_conv.inner = untag_ptr(this_ptr);
53833 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53835 this_ptr_conv.is_owned = false;
53836 BlindedPayInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
53839 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_minimum_msat"))) TS_BlindedPayInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
53840 LDKBlindedPayInfo this_ptr_conv;
53841 this_ptr_conv.inner = untag_ptr(this_ptr);
53842 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53844 this_ptr_conv.is_owned = false;
53845 int64_t ret_conv = BlindedPayInfo_get_htlc_minimum_msat(&this_ptr_conv);
53849 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_minimum_msat"))) TS_BlindedPayInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
53850 LDKBlindedPayInfo this_ptr_conv;
53851 this_ptr_conv.inner = untag_ptr(this_ptr);
53852 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53854 this_ptr_conv.is_owned = false;
53855 BlindedPayInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
53858 int64_t __attribute__((export_name("TS_BlindedPayInfo_get_htlc_maximum_msat"))) TS_BlindedPayInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
53859 LDKBlindedPayInfo this_ptr_conv;
53860 this_ptr_conv.inner = untag_ptr(this_ptr);
53861 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53862 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53863 this_ptr_conv.is_owned = false;
53864 int64_t ret_conv = BlindedPayInfo_get_htlc_maximum_msat(&this_ptr_conv);
53868 void __attribute__((export_name("TS_BlindedPayInfo_set_htlc_maximum_msat"))) TS_BlindedPayInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
53869 LDKBlindedPayInfo this_ptr_conv;
53870 this_ptr_conv.inner = untag_ptr(this_ptr);
53871 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53873 this_ptr_conv.is_owned = false;
53874 BlindedPayInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
53877 uint64_t __attribute__((export_name("TS_BlindedPayInfo_get_features"))) TS_BlindedPayInfo_get_features(uint64_t this_ptr) {
53878 LDKBlindedPayInfo this_ptr_conv;
53879 this_ptr_conv.inner = untag_ptr(this_ptr);
53880 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53881 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53882 this_ptr_conv.is_owned = false;
53883 LDKBlindedHopFeatures ret_var = BlindedPayInfo_get_features(&this_ptr_conv);
53884 uint64_t ret_ref = 0;
53885 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53886 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53890 void __attribute__((export_name("TS_BlindedPayInfo_set_features"))) TS_BlindedPayInfo_set_features(uint64_t this_ptr, uint64_t val) {
53891 LDKBlindedPayInfo this_ptr_conv;
53892 this_ptr_conv.inner = untag_ptr(this_ptr);
53893 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
53894 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
53895 this_ptr_conv.is_owned = false;
53896 LDKBlindedHopFeatures val_conv;
53897 val_conv.inner = untag_ptr(val);
53898 val_conv.is_owned = ptr_is_owned(val);
53899 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
53900 val_conv = BlindedHopFeatures_clone(&val_conv);
53901 BlindedPayInfo_set_features(&this_ptr_conv, val_conv);
53904 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) {
53905 LDKBlindedHopFeatures features_arg_conv;
53906 features_arg_conv.inner = untag_ptr(features_arg);
53907 features_arg_conv.is_owned = ptr_is_owned(features_arg);
53908 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
53909 features_arg_conv = BlindedHopFeatures_clone(&features_arg_conv);
53910 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);
53911 uint64_t ret_ref = 0;
53912 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53913 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53917 static inline uint64_t BlindedPayInfo_clone_ptr(LDKBlindedPayInfo *NONNULL_PTR arg) {
53918 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(arg);
53919 uint64_t ret_ref = 0;
53920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53921 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53924 int64_t __attribute__((export_name("TS_BlindedPayInfo_clone_ptr"))) TS_BlindedPayInfo_clone_ptr(uint64_t arg) {
53925 LDKBlindedPayInfo arg_conv;
53926 arg_conv.inner = untag_ptr(arg);
53927 arg_conv.is_owned = ptr_is_owned(arg);
53928 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
53929 arg_conv.is_owned = false;
53930 int64_t ret_conv = BlindedPayInfo_clone_ptr(&arg_conv);
53934 uint64_t __attribute__((export_name("TS_BlindedPayInfo_clone"))) TS_BlindedPayInfo_clone(uint64_t orig) {
53935 LDKBlindedPayInfo orig_conv;
53936 orig_conv.inner = untag_ptr(orig);
53937 orig_conv.is_owned = ptr_is_owned(orig);
53938 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
53939 orig_conv.is_owned = false;
53940 LDKBlindedPayInfo ret_var = BlindedPayInfo_clone(&orig_conv);
53941 uint64_t ret_ref = 0;
53942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
53943 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
53947 int64_t __attribute__((export_name("TS_BlindedPayInfo_hash"))) TS_BlindedPayInfo_hash(uint64_t o) {
53948 LDKBlindedPayInfo o_conv;
53949 o_conv.inner = untag_ptr(o);
53950 o_conv.is_owned = ptr_is_owned(o);
53951 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
53952 o_conv.is_owned = false;
53953 int64_t ret_conv = BlindedPayInfo_hash(&o_conv);
53957 jboolean __attribute__((export_name("TS_BlindedPayInfo_eq"))) TS_BlindedPayInfo_eq(uint64_t a, uint64_t b) {
53958 LDKBlindedPayInfo a_conv;
53959 a_conv.inner = untag_ptr(a);
53960 a_conv.is_owned = ptr_is_owned(a);
53961 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
53962 a_conv.is_owned = false;
53963 LDKBlindedPayInfo b_conv;
53964 b_conv.inner = untag_ptr(b);
53965 b_conv.is_owned = ptr_is_owned(b);
53966 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
53967 b_conv.is_owned = false;
53968 jboolean ret_conv = BlindedPayInfo_eq(&a_conv, &b_conv);
53972 int8_tArray __attribute__((export_name("TS_BlindedPayInfo_write"))) TS_BlindedPayInfo_write(uint64_t obj) {
53973 LDKBlindedPayInfo obj_conv;
53974 obj_conv.inner = untag_ptr(obj);
53975 obj_conv.is_owned = ptr_is_owned(obj);
53976 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
53977 obj_conv.is_owned = false;
53978 LDKCVec_u8Z ret_var = BlindedPayInfo_write(&obj_conv);
53979 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
53980 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
53981 CVec_u8Z_free(ret_var);
53985 uint64_t __attribute__((export_name("TS_BlindedPayInfo_read"))) TS_BlindedPayInfo_read(int8_tArray ser) {
53986 LDKu8slice ser_ref;
53987 ser_ref.datalen = ser->arr_len;
53988 ser_ref.data = ser->elems;
53989 LDKCResult_BlindedPayInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPayInfoDecodeErrorZ), "LDKCResult_BlindedPayInfoDecodeErrorZ");
53990 *ret_conv = BlindedPayInfo_read(ser_ref);
53992 return tag_ptr(ret_conv, true);
53995 void __attribute__((export_name("TS_InvoiceError_free"))) TS_InvoiceError_free(uint64_t this_obj) {
53996 LDKInvoiceError this_obj_conv;
53997 this_obj_conv.inner = untag_ptr(this_obj);
53998 this_obj_conv.is_owned = ptr_is_owned(this_obj);
53999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
54000 InvoiceError_free(this_obj_conv);
54003 uint64_t __attribute__((export_name("TS_InvoiceError_get_erroneous_field"))) TS_InvoiceError_get_erroneous_field(uint64_t this_ptr) {
54004 LDKInvoiceError this_ptr_conv;
54005 this_ptr_conv.inner = untag_ptr(this_ptr);
54006 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54008 this_ptr_conv.is_owned = false;
54009 LDKErroneousField ret_var = InvoiceError_get_erroneous_field(&this_ptr_conv);
54010 uint64_t ret_ref = 0;
54011 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54012 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54016 void __attribute__((export_name("TS_InvoiceError_set_erroneous_field"))) TS_InvoiceError_set_erroneous_field(uint64_t this_ptr, uint64_t val) {
54017 LDKInvoiceError this_ptr_conv;
54018 this_ptr_conv.inner = untag_ptr(this_ptr);
54019 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54021 this_ptr_conv.is_owned = false;
54022 LDKErroneousField val_conv;
54023 val_conv.inner = untag_ptr(val);
54024 val_conv.is_owned = ptr_is_owned(val);
54025 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
54026 val_conv = ErroneousField_clone(&val_conv);
54027 InvoiceError_set_erroneous_field(&this_ptr_conv, val_conv);
54030 uint64_t __attribute__((export_name("TS_InvoiceError_get_message"))) TS_InvoiceError_get_message(uint64_t this_ptr) {
54031 LDKInvoiceError this_ptr_conv;
54032 this_ptr_conv.inner = untag_ptr(this_ptr);
54033 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54035 this_ptr_conv.is_owned = false;
54036 LDKUntrustedString ret_var = InvoiceError_get_message(&this_ptr_conv);
54037 uint64_t ret_ref = 0;
54038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54039 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54043 void __attribute__((export_name("TS_InvoiceError_set_message"))) TS_InvoiceError_set_message(uint64_t this_ptr, uint64_t val) {
54044 LDKInvoiceError this_ptr_conv;
54045 this_ptr_conv.inner = untag_ptr(this_ptr);
54046 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54047 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54048 this_ptr_conv.is_owned = false;
54049 LDKUntrustedString val_conv;
54050 val_conv.inner = untag_ptr(val);
54051 val_conv.is_owned = ptr_is_owned(val);
54052 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
54053 val_conv = UntrustedString_clone(&val_conv);
54054 InvoiceError_set_message(&this_ptr_conv, val_conv);
54057 uint64_t __attribute__((export_name("TS_InvoiceError_new"))) TS_InvoiceError_new(uint64_t erroneous_field_arg, uint64_t message_arg) {
54058 LDKErroneousField erroneous_field_arg_conv;
54059 erroneous_field_arg_conv.inner = untag_ptr(erroneous_field_arg);
54060 erroneous_field_arg_conv.is_owned = ptr_is_owned(erroneous_field_arg);
54061 CHECK_INNER_FIELD_ACCESS_OR_NULL(erroneous_field_arg_conv);
54062 erroneous_field_arg_conv = ErroneousField_clone(&erroneous_field_arg_conv);
54063 LDKUntrustedString message_arg_conv;
54064 message_arg_conv.inner = untag_ptr(message_arg);
54065 message_arg_conv.is_owned = ptr_is_owned(message_arg);
54066 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_arg_conv);
54067 message_arg_conv = UntrustedString_clone(&message_arg_conv);
54068 LDKInvoiceError ret_var = InvoiceError_new(erroneous_field_arg_conv, message_arg_conv);
54069 uint64_t ret_ref = 0;
54070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54071 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54075 static inline uint64_t InvoiceError_clone_ptr(LDKInvoiceError *NONNULL_PTR arg) {
54076 LDKInvoiceError ret_var = InvoiceError_clone(arg);
54077 uint64_t ret_ref = 0;
54078 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54079 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54082 int64_t __attribute__((export_name("TS_InvoiceError_clone_ptr"))) TS_InvoiceError_clone_ptr(uint64_t arg) {
54083 LDKInvoiceError arg_conv;
54084 arg_conv.inner = untag_ptr(arg);
54085 arg_conv.is_owned = ptr_is_owned(arg);
54086 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
54087 arg_conv.is_owned = false;
54088 int64_t ret_conv = InvoiceError_clone_ptr(&arg_conv);
54092 uint64_t __attribute__((export_name("TS_InvoiceError_clone"))) TS_InvoiceError_clone(uint64_t orig) {
54093 LDKInvoiceError orig_conv;
54094 orig_conv.inner = untag_ptr(orig);
54095 orig_conv.is_owned = ptr_is_owned(orig);
54096 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
54097 orig_conv.is_owned = false;
54098 LDKInvoiceError ret_var = InvoiceError_clone(&orig_conv);
54099 uint64_t ret_ref = 0;
54100 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54101 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54105 void __attribute__((export_name("TS_ErroneousField_free"))) TS_ErroneousField_free(uint64_t this_obj) {
54106 LDKErroneousField this_obj_conv;
54107 this_obj_conv.inner = untag_ptr(this_obj);
54108 this_obj_conv.is_owned = ptr_is_owned(this_obj);
54109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
54110 ErroneousField_free(this_obj_conv);
54113 int64_t __attribute__((export_name("TS_ErroneousField_get_tlv_fieldnum"))) TS_ErroneousField_get_tlv_fieldnum(uint64_t this_ptr) {
54114 LDKErroneousField this_ptr_conv;
54115 this_ptr_conv.inner = untag_ptr(this_ptr);
54116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54118 this_ptr_conv.is_owned = false;
54119 int64_t ret_conv = ErroneousField_get_tlv_fieldnum(&this_ptr_conv);
54123 void __attribute__((export_name("TS_ErroneousField_set_tlv_fieldnum"))) TS_ErroneousField_set_tlv_fieldnum(uint64_t this_ptr, int64_t val) {
54124 LDKErroneousField this_ptr_conv;
54125 this_ptr_conv.inner = untag_ptr(this_ptr);
54126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54128 this_ptr_conv.is_owned = false;
54129 ErroneousField_set_tlv_fieldnum(&this_ptr_conv, val);
54132 uint64_t __attribute__((export_name("TS_ErroneousField_get_suggested_value"))) TS_ErroneousField_get_suggested_value(uint64_t this_ptr) {
54133 LDKErroneousField this_ptr_conv;
54134 this_ptr_conv.inner = untag_ptr(this_ptr);
54135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54137 this_ptr_conv.is_owned = false;
54138 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
54139 *ret_copy = ErroneousField_get_suggested_value(&this_ptr_conv);
54140 uint64_t ret_ref = tag_ptr(ret_copy, true);
54144 void __attribute__((export_name("TS_ErroneousField_set_suggested_value"))) TS_ErroneousField_set_suggested_value(uint64_t this_ptr, uint64_t val) {
54145 LDKErroneousField this_ptr_conv;
54146 this_ptr_conv.inner = untag_ptr(this_ptr);
54147 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54149 this_ptr_conv.is_owned = false;
54150 void* val_ptr = untag_ptr(val);
54151 CHECK_ACCESS(val_ptr);
54152 LDKCOption_CVec_u8ZZ val_conv = *(LDKCOption_CVec_u8ZZ*)(val_ptr);
54153 val_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(val));
54154 ErroneousField_set_suggested_value(&this_ptr_conv, val_conv);
54157 uint64_t __attribute__((export_name("TS_ErroneousField_new"))) TS_ErroneousField_new(int64_t tlv_fieldnum_arg, uint64_t suggested_value_arg) {
54158 void* suggested_value_arg_ptr = untag_ptr(suggested_value_arg);
54159 CHECK_ACCESS(suggested_value_arg_ptr);
54160 LDKCOption_CVec_u8ZZ suggested_value_arg_conv = *(LDKCOption_CVec_u8ZZ*)(suggested_value_arg_ptr);
54161 suggested_value_arg_conv = COption_CVec_u8ZZ_clone((LDKCOption_CVec_u8ZZ*)untag_ptr(suggested_value_arg));
54162 LDKErroneousField ret_var = ErroneousField_new(tlv_fieldnum_arg, suggested_value_arg_conv);
54163 uint64_t ret_ref = 0;
54164 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54165 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54169 static inline uint64_t ErroneousField_clone_ptr(LDKErroneousField *NONNULL_PTR arg) {
54170 LDKErroneousField ret_var = ErroneousField_clone(arg);
54171 uint64_t ret_ref = 0;
54172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54173 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54176 int64_t __attribute__((export_name("TS_ErroneousField_clone_ptr"))) TS_ErroneousField_clone_ptr(uint64_t arg) {
54177 LDKErroneousField arg_conv;
54178 arg_conv.inner = untag_ptr(arg);
54179 arg_conv.is_owned = ptr_is_owned(arg);
54180 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
54181 arg_conv.is_owned = false;
54182 int64_t ret_conv = ErroneousField_clone_ptr(&arg_conv);
54186 uint64_t __attribute__((export_name("TS_ErroneousField_clone"))) TS_ErroneousField_clone(uint64_t orig) {
54187 LDKErroneousField orig_conv;
54188 orig_conv.inner = untag_ptr(orig);
54189 orig_conv.is_owned = ptr_is_owned(orig);
54190 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
54191 orig_conv.is_owned = false;
54192 LDKErroneousField ret_var = ErroneousField_clone(&orig_conv);
54193 uint64_t ret_ref = 0;
54194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54195 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54199 int8_tArray __attribute__((export_name("TS_InvoiceError_write"))) TS_InvoiceError_write(uint64_t obj) {
54200 LDKInvoiceError obj_conv;
54201 obj_conv.inner = untag_ptr(obj);
54202 obj_conv.is_owned = ptr_is_owned(obj);
54203 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
54204 obj_conv.is_owned = false;
54205 LDKCVec_u8Z ret_var = InvoiceError_write(&obj_conv);
54206 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
54207 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
54208 CVec_u8Z_free(ret_var);
54212 uint64_t __attribute__((export_name("TS_InvoiceError_read"))) TS_InvoiceError_read(int8_tArray ser) {
54213 LDKu8slice ser_ref;
54214 ser_ref.datalen = ser->arr_len;
54215 ser_ref.data = ser->elems;
54216 LDKCResult_InvoiceErrorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceErrorDecodeErrorZ), "LDKCResult_InvoiceErrorDecodeErrorZ");
54217 *ret_conv = InvoiceError_read(ser_ref);
54219 return tag_ptr(ret_conv, true);
54222 void __attribute__((export_name("TS_UnsignedInvoiceRequest_free"))) TS_UnsignedInvoiceRequest_free(uint64_t this_obj) {
54223 LDKUnsignedInvoiceRequest this_obj_conv;
54224 this_obj_conv.inner = untag_ptr(this_obj);
54225 this_obj_conv.is_owned = ptr_is_owned(this_obj);
54226 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
54227 UnsignedInvoiceRequest_free(this_obj_conv);
54230 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_tagged_hash"))) TS_UnsignedInvoiceRequest_tagged_hash(uint64_t this_arg) {
54231 LDKUnsignedInvoiceRequest this_arg_conv;
54232 this_arg_conv.inner = untag_ptr(this_arg);
54233 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54234 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54235 this_arg_conv.is_owned = false;
54236 LDKTaggedHash ret_var = UnsignedInvoiceRequest_tagged_hash(&this_arg_conv);
54237 uint64_t ret_ref = 0;
54238 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54239 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54243 void __attribute__((export_name("TS_InvoiceRequest_free"))) TS_InvoiceRequest_free(uint64_t this_obj) {
54244 LDKInvoiceRequest this_obj_conv;
54245 this_obj_conv.inner = untag_ptr(this_obj);
54246 this_obj_conv.is_owned = ptr_is_owned(this_obj);
54247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
54248 InvoiceRequest_free(this_obj_conv);
54251 static inline uint64_t InvoiceRequest_clone_ptr(LDKInvoiceRequest *NONNULL_PTR arg) {
54252 LDKInvoiceRequest ret_var = InvoiceRequest_clone(arg);
54253 uint64_t ret_ref = 0;
54254 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54255 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54258 int64_t __attribute__((export_name("TS_InvoiceRequest_clone_ptr"))) TS_InvoiceRequest_clone_ptr(uint64_t arg) {
54259 LDKInvoiceRequest arg_conv;
54260 arg_conv.inner = untag_ptr(arg);
54261 arg_conv.is_owned = ptr_is_owned(arg);
54262 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
54263 arg_conv.is_owned = false;
54264 int64_t ret_conv = InvoiceRequest_clone_ptr(&arg_conv);
54268 uint64_t __attribute__((export_name("TS_InvoiceRequest_clone"))) TS_InvoiceRequest_clone(uint64_t orig) {
54269 LDKInvoiceRequest orig_conv;
54270 orig_conv.inner = untag_ptr(orig);
54271 orig_conv.is_owned = ptr_is_owned(orig);
54272 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
54273 orig_conv.is_owned = false;
54274 LDKInvoiceRequest ret_var = InvoiceRequest_clone(&orig_conv);
54275 uint64_t ret_ref = 0;
54276 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54277 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54281 void __attribute__((export_name("TS_VerifiedInvoiceRequest_free"))) TS_VerifiedInvoiceRequest_free(uint64_t this_obj) {
54282 LDKVerifiedInvoiceRequest this_obj_conv;
54283 this_obj_conv.inner = untag_ptr(this_obj);
54284 this_obj_conv.is_owned = ptr_is_owned(this_obj);
54285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
54286 VerifiedInvoiceRequest_free(this_obj_conv);
54289 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_get_keys"))) TS_VerifiedInvoiceRequest_get_keys(uint64_t this_ptr) {
54290 LDKVerifiedInvoiceRequest this_ptr_conv;
54291 this_ptr_conv.inner = untag_ptr(this_ptr);
54292 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54294 this_ptr_conv.is_owned = false;
54295 LDKCOption_SecretKeyZ *ret_copy = MALLOC(sizeof(LDKCOption_SecretKeyZ), "LDKCOption_SecretKeyZ");
54296 *ret_copy = VerifiedInvoiceRequest_get_keys(&this_ptr_conv);
54297 uint64_t ret_ref = tag_ptr(ret_copy, true);
54301 void __attribute__((export_name("TS_VerifiedInvoiceRequest_set_keys"))) TS_VerifiedInvoiceRequest_set_keys(uint64_t this_ptr, uint64_t val) {
54302 LDKVerifiedInvoiceRequest this_ptr_conv;
54303 this_ptr_conv.inner = untag_ptr(this_ptr);
54304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
54305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
54306 this_ptr_conv.is_owned = false;
54307 void* val_ptr = untag_ptr(val);
54308 CHECK_ACCESS(val_ptr);
54309 LDKCOption_SecretKeyZ val_conv = *(LDKCOption_SecretKeyZ*)(val_ptr);
54310 val_conv = COption_SecretKeyZ_clone((LDKCOption_SecretKeyZ*)untag_ptr(val));
54311 VerifiedInvoiceRequest_set_keys(&this_ptr_conv, val_conv);
54314 static inline uint64_t VerifiedInvoiceRequest_clone_ptr(LDKVerifiedInvoiceRequest *NONNULL_PTR arg) {
54315 LDKVerifiedInvoiceRequest ret_var = VerifiedInvoiceRequest_clone(arg);
54316 uint64_t ret_ref = 0;
54317 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54318 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54321 int64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_clone_ptr"))) TS_VerifiedInvoiceRequest_clone_ptr(uint64_t arg) {
54322 LDKVerifiedInvoiceRequest arg_conv;
54323 arg_conv.inner = untag_ptr(arg);
54324 arg_conv.is_owned = ptr_is_owned(arg);
54325 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
54326 arg_conv.is_owned = false;
54327 int64_t ret_conv = VerifiedInvoiceRequest_clone_ptr(&arg_conv);
54331 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_clone"))) TS_VerifiedInvoiceRequest_clone(uint64_t orig) {
54332 LDKVerifiedInvoiceRequest orig_conv;
54333 orig_conv.inner = untag_ptr(orig);
54334 orig_conv.is_owned = ptr_is_owned(orig);
54335 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
54336 orig_conv.is_owned = false;
54337 LDKVerifiedInvoiceRequest ret_var = VerifiedInvoiceRequest_clone(&orig_conv);
54338 uint64_t ret_ref = 0;
54339 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54340 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54344 ptrArray __attribute__((export_name("TS_UnsignedInvoiceRequest_chains"))) TS_UnsignedInvoiceRequest_chains(uint64_t this_arg) {
54345 LDKUnsignedInvoiceRequest this_arg_conv;
54346 this_arg_conv.inner = untag_ptr(this_arg);
54347 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54348 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54349 this_arg_conv.is_owned = false;
54350 LDKCVec_ThirtyTwoBytesZ ret_var = UnsignedInvoiceRequest_chains(&this_arg_conv);
54351 ptrArray ret_arr = NULL;
54352 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
54353 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
54354 for (size_t m = 0; m < ret_var.datalen; m++) {
54355 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
54356 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
54357 ret_arr_ptr[m] = ret_conv_12_arr;
54360 FREE(ret_var.data);
54364 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_metadata"))) TS_UnsignedInvoiceRequest_metadata(uint64_t this_arg) {
54365 LDKUnsignedInvoiceRequest this_arg_conv;
54366 this_arg_conv.inner = untag_ptr(this_arg);
54367 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54368 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54369 this_arg_conv.is_owned = false;
54370 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
54371 *ret_copy = UnsignedInvoiceRequest_metadata(&this_arg_conv);
54372 uint64_t ret_ref = tag_ptr(ret_copy, true);
54376 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_amount"))) TS_UnsignedInvoiceRequest_amount(uint64_t this_arg) {
54377 LDKUnsignedInvoiceRequest this_arg_conv;
54378 this_arg_conv.inner = untag_ptr(this_arg);
54379 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54381 this_arg_conv.is_owned = false;
54382 LDKAmount ret_var = UnsignedInvoiceRequest_amount(&this_arg_conv);
54383 uint64_t ret_ref = 0;
54384 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54385 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54389 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_description"))) TS_UnsignedInvoiceRequest_description(uint64_t this_arg) {
54390 LDKUnsignedInvoiceRequest this_arg_conv;
54391 this_arg_conv.inner = untag_ptr(this_arg);
54392 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54393 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54394 this_arg_conv.is_owned = false;
54395 LDKPrintableString ret_var = UnsignedInvoiceRequest_description(&this_arg_conv);
54396 uint64_t ret_ref = 0;
54397 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54398 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54402 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_offer_features"))) TS_UnsignedInvoiceRequest_offer_features(uint64_t this_arg) {
54403 LDKUnsignedInvoiceRequest this_arg_conv;
54404 this_arg_conv.inner = untag_ptr(this_arg);
54405 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54406 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54407 this_arg_conv.is_owned = false;
54408 LDKOfferFeatures ret_var = UnsignedInvoiceRequest_offer_features(&this_arg_conv);
54409 uint64_t ret_ref = 0;
54410 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54411 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54415 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_absolute_expiry"))) TS_UnsignedInvoiceRequest_absolute_expiry(uint64_t this_arg) {
54416 LDKUnsignedInvoiceRequest this_arg_conv;
54417 this_arg_conv.inner = untag_ptr(this_arg);
54418 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54419 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54420 this_arg_conv.is_owned = false;
54421 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54422 *ret_copy = UnsignedInvoiceRequest_absolute_expiry(&this_arg_conv);
54423 uint64_t ret_ref = tag_ptr(ret_copy, true);
54427 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_issuer"))) TS_UnsignedInvoiceRequest_issuer(uint64_t this_arg) {
54428 LDKUnsignedInvoiceRequest this_arg_conv;
54429 this_arg_conv.inner = untag_ptr(this_arg);
54430 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54432 this_arg_conv.is_owned = false;
54433 LDKPrintableString ret_var = UnsignedInvoiceRequest_issuer(&this_arg_conv);
54434 uint64_t ret_ref = 0;
54435 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54436 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54440 uint64_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_paths"))) TS_UnsignedInvoiceRequest_paths(uint64_t this_arg) {
54441 LDKUnsignedInvoiceRequest this_arg_conv;
54442 this_arg_conv.inner = untag_ptr(this_arg);
54443 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54444 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54445 this_arg_conv.is_owned = false;
54446 LDKCVec_BlindedPathZ ret_var = UnsignedInvoiceRequest_paths(&this_arg_conv);
54447 uint64_tArray ret_arr = NULL;
54448 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
54449 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
54450 for (size_t n = 0; n < ret_var.datalen; n++) {
54451 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
54452 uint64_t ret_conv_13_ref = 0;
54453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
54454 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
54455 ret_arr_ptr[n] = ret_conv_13_ref;
54458 FREE(ret_var.data);
54462 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_supported_quantity"))) TS_UnsignedInvoiceRequest_supported_quantity(uint64_t this_arg) {
54463 LDKUnsignedInvoiceRequest this_arg_conv;
54464 this_arg_conv.inner = untag_ptr(this_arg);
54465 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54466 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54467 this_arg_conv.is_owned = false;
54468 LDKQuantity ret_var = UnsignedInvoiceRequest_supported_quantity(&this_arg_conv);
54469 uint64_t ret_ref = 0;
54470 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54471 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54475 int8_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_signing_pubkey"))) TS_UnsignedInvoiceRequest_signing_pubkey(uint64_t this_arg) {
54476 LDKUnsignedInvoiceRequest this_arg_conv;
54477 this_arg_conv.inner = untag_ptr(this_arg);
54478 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54480 this_arg_conv.is_owned = false;
54481 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
54482 memcpy(ret_arr->elems, UnsignedInvoiceRequest_signing_pubkey(&this_arg_conv).compressed_form, 33);
54486 int8_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_payer_metadata"))) TS_UnsignedInvoiceRequest_payer_metadata(uint64_t this_arg) {
54487 LDKUnsignedInvoiceRequest this_arg_conv;
54488 this_arg_conv.inner = untag_ptr(this_arg);
54489 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54491 this_arg_conv.is_owned = false;
54492 LDKu8slice ret_var = UnsignedInvoiceRequest_payer_metadata(&this_arg_conv);
54493 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
54494 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
54498 int8_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_chain"))) TS_UnsignedInvoiceRequest_chain(uint64_t this_arg) {
54499 LDKUnsignedInvoiceRequest this_arg_conv;
54500 this_arg_conv.inner = untag_ptr(this_arg);
54501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54503 this_arg_conv.is_owned = false;
54504 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
54505 memcpy(ret_arr->elems, UnsignedInvoiceRequest_chain(&this_arg_conv).data, 32);
54509 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_amount_msats"))) TS_UnsignedInvoiceRequest_amount_msats(uint64_t this_arg) {
54510 LDKUnsignedInvoiceRequest this_arg_conv;
54511 this_arg_conv.inner = untag_ptr(this_arg);
54512 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54514 this_arg_conv.is_owned = false;
54515 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54516 *ret_copy = UnsignedInvoiceRequest_amount_msats(&this_arg_conv);
54517 uint64_t ret_ref = tag_ptr(ret_copy, true);
54521 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_invoice_request_features"))) TS_UnsignedInvoiceRequest_invoice_request_features(uint64_t this_arg) {
54522 LDKUnsignedInvoiceRequest this_arg_conv;
54523 this_arg_conv.inner = untag_ptr(this_arg);
54524 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54526 this_arg_conv.is_owned = false;
54527 LDKInvoiceRequestFeatures ret_var = UnsignedInvoiceRequest_invoice_request_features(&this_arg_conv);
54528 uint64_t ret_ref = 0;
54529 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54530 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54534 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_quantity"))) TS_UnsignedInvoiceRequest_quantity(uint64_t this_arg) {
54535 LDKUnsignedInvoiceRequest this_arg_conv;
54536 this_arg_conv.inner = untag_ptr(this_arg);
54537 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54539 this_arg_conv.is_owned = false;
54540 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54541 *ret_copy = UnsignedInvoiceRequest_quantity(&this_arg_conv);
54542 uint64_t ret_ref = tag_ptr(ret_copy, true);
54546 int8_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_payer_id"))) TS_UnsignedInvoiceRequest_payer_id(uint64_t this_arg) {
54547 LDKUnsignedInvoiceRequest this_arg_conv;
54548 this_arg_conv.inner = untag_ptr(this_arg);
54549 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54550 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54551 this_arg_conv.is_owned = false;
54552 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
54553 memcpy(ret_arr->elems, UnsignedInvoiceRequest_payer_id(&this_arg_conv).compressed_form, 33);
54557 uint64_t __attribute__((export_name("TS_UnsignedInvoiceRequest_payer_note"))) TS_UnsignedInvoiceRequest_payer_note(uint64_t this_arg) {
54558 LDKUnsignedInvoiceRequest this_arg_conv;
54559 this_arg_conv.inner = untag_ptr(this_arg);
54560 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54562 this_arg_conv.is_owned = false;
54563 LDKPrintableString ret_var = UnsignedInvoiceRequest_payer_note(&this_arg_conv);
54564 uint64_t ret_ref = 0;
54565 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54566 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54570 ptrArray __attribute__((export_name("TS_InvoiceRequest_chains"))) TS_InvoiceRequest_chains(uint64_t this_arg) {
54571 LDKInvoiceRequest this_arg_conv;
54572 this_arg_conv.inner = untag_ptr(this_arg);
54573 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54575 this_arg_conv.is_owned = false;
54576 LDKCVec_ThirtyTwoBytesZ ret_var = InvoiceRequest_chains(&this_arg_conv);
54577 ptrArray ret_arr = NULL;
54578 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
54579 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
54580 for (size_t m = 0; m < ret_var.datalen; m++) {
54581 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
54582 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
54583 ret_arr_ptr[m] = ret_conv_12_arr;
54586 FREE(ret_var.data);
54590 uint64_t __attribute__((export_name("TS_InvoiceRequest_metadata"))) TS_InvoiceRequest_metadata(uint64_t this_arg) {
54591 LDKInvoiceRequest this_arg_conv;
54592 this_arg_conv.inner = untag_ptr(this_arg);
54593 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54595 this_arg_conv.is_owned = false;
54596 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
54597 *ret_copy = InvoiceRequest_metadata(&this_arg_conv);
54598 uint64_t ret_ref = tag_ptr(ret_copy, true);
54602 uint64_t __attribute__((export_name("TS_InvoiceRequest_amount"))) TS_InvoiceRequest_amount(uint64_t this_arg) {
54603 LDKInvoiceRequest this_arg_conv;
54604 this_arg_conv.inner = untag_ptr(this_arg);
54605 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54607 this_arg_conv.is_owned = false;
54608 LDKAmount ret_var = InvoiceRequest_amount(&this_arg_conv);
54609 uint64_t ret_ref = 0;
54610 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54611 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54615 uint64_t __attribute__((export_name("TS_InvoiceRequest_description"))) TS_InvoiceRequest_description(uint64_t this_arg) {
54616 LDKInvoiceRequest this_arg_conv;
54617 this_arg_conv.inner = untag_ptr(this_arg);
54618 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54620 this_arg_conv.is_owned = false;
54621 LDKPrintableString ret_var = InvoiceRequest_description(&this_arg_conv);
54622 uint64_t ret_ref = 0;
54623 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54624 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54628 uint64_t __attribute__((export_name("TS_InvoiceRequest_offer_features"))) TS_InvoiceRequest_offer_features(uint64_t this_arg) {
54629 LDKInvoiceRequest this_arg_conv;
54630 this_arg_conv.inner = untag_ptr(this_arg);
54631 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54632 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54633 this_arg_conv.is_owned = false;
54634 LDKOfferFeatures ret_var = InvoiceRequest_offer_features(&this_arg_conv);
54635 uint64_t ret_ref = 0;
54636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54637 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54641 uint64_t __attribute__((export_name("TS_InvoiceRequest_absolute_expiry"))) TS_InvoiceRequest_absolute_expiry(uint64_t this_arg) {
54642 LDKInvoiceRequest this_arg_conv;
54643 this_arg_conv.inner = untag_ptr(this_arg);
54644 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54646 this_arg_conv.is_owned = false;
54647 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54648 *ret_copy = InvoiceRequest_absolute_expiry(&this_arg_conv);
54649 uint64_t ret_ref = tag_ptr(ret_copy, true);
54653 uint64_t __attribute__((export_name("TS_InvoiceRequest_issuer"))) TS_InvoiceRequest_issuer(uint64_t this_arg) {
54654 LDKInvoiceRequest this_arg_conv;
54655 this_arg_conv.inner = untag_ptr(this_arg);
54656 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54658 this_arg_conv.is_owned = false;
54659 LDKPrintableString ret_var = InvoiceRequest_issuer(&this_arg_conv);
54660 uint64_t ret_ref = 0;
54661 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54662 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54666 uint64_tArray __attribute__((export_name("TS_InvoiceRequest_paths"))) TS_InvoiceRequest_paths(uint64_t this_arg) {
54667 LDKInvoiceRequest this_arg_conv;
54668 this_arg_conv.inner = untag_ptr(this_arg);
54669 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54670 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54671 this_arg_conv.is_owned = false;
54672 LDKCVec_BlindedPathZ ret_var = InvoiceRequest_paths(&this_arg_conv);
54673 uint64_tArray ret_arr = NULL;
54674 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
54675 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
54676 for (size_t n = 0; n < ret_var.datalen; n++) {
54677 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
54678 uint64_t ret_conv_13_ref = 0;
54679 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
54680 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
54681 ret_arr_ptr[n] = ret_conv_13_ref;
54684 FREE(ret_var.data);
54688 uint64_t __attribute__((export_name("TS_InvoiceRequest_supported_quantity"))) TS_InvoiceRequest_supported_quantity(uint64_t this_arg) {
54689 LDKInvoiceRequest this_arg_conv;
54690 this_arg_conv.inner = untag_ptr(this_arg);
54691 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54693 this_arg_conv.is_owned = false;
54694 LDKQuantity ret_var = InvoiceRequest_supported_quantity(&this_arg_conv);
54695 uint64_t ret_ref = 0;
54696 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54697 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54701 int8_tArray __attribute__((export_name("TS_InvoiceRequest_signing_pubkey"))) TS_InvoiceRequest_signing_pubkey(uint64_t this_arg) {
54702 LDKInvoiceRequest this_arg_conv;
54703 this_arg_conv.inner = untag_ptr(this_arg);
54704 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54706 this_arg_conv.is_owned = false;
54707 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
54708 memcpy(ret_arr->elems, InvoiceRequest_signing_pubkey(&this_arg_conv).compressed_form, 33);
54712 int8_tArray __attribute__((export_name("TS_InvoiceRequest_payer_metadata"))) TS_InvoiceRequest_payer_metadata(uint64_t this_arg) {
54713 LDKInvoiceRequest this_arg_conv;
54714 this_arg_conv.inner = untag_ptr(this_arg);
54715 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54717 this_arg_conv.is_owned = false;
54718 LDKu8slice ret_var = InvoiceRequest_payer_metadata(&this_arg_conv);
54719 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
54720 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
54724 int8_tArray __attribute__((export_name("TS_InvoiceRequest_chain"))) TS_InvoiceRequest_chain(uint64_t this_arg) {
54725 LDKInvoiceRequest this_arg_conv;
54726 this_arg_conv.inner = untag_ptr(this_arg);
54727 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54729 this_arg_conv.is_owned = false;
54730 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
54731 memcpy(ret_arr->elems, InvoiceRequest_chain(&this_arg_conv).data, 32);
54735 uint64_t __attribute__((export_name("TS_InvoiceRequest_amount_msats"))) TS_InvoiceRequest_amount_msats(uint64_t this_arg) {
54736 LDKInvoiceRequest this_arg_conv;
54737 this_arg_conv.inner = untag_ptr(this_arg);
54738 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54740 this_arg_conv.is_owned = false;
54741 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54742 *ret_copy = InvoiceRequest_amount_msats(&this_arg_conv);
54743 uint64_t ret_ref = tag_ptr(ret_copy, true);
54747 uint64_t __attribute__((export_name("TS_InvoiceRequest_invoice_request_features"))) TS_InvoiceRequest_invoice_request_features(uint64_t this_arg) {
54748 LDKInvoiceRequest this_arg_conv;
54749 this_arg_conv.inner = untag_ptr(this_arg);
54750 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54752 this_arg_conv.is_owned = false;
54753 LDKInvoiceRequestFeatures ret_var = InvoiceRequest_invoice_request_features(&this_arg_conv);
54754 uint64_t ret_ref = 0;
54755 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54756 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54760 uint64_t __attribute__((export_name("TS_InvoiceRequest_quantity"))) TS_InvoiceRequest_quantity(uint64_t this_arg) {
54761 LDKInvoiceRequest this_arg_conv;
54762 this_arg_conv.inner = untag_ptr(this_arg);
54763 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54764 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54765 this_arg_conv.is_owned = false;
54766 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54767 *ret_copy = InvoiceRequest_quantity(&this_arg_conv);
54768 uint64_t ret_ref = tag_ptr(ret_copy, true);
54772 int8_tArray __attribute__((export_name("TS_InvoiceRequest_payer_id"))) TS_InvoiceRequest_payer_id(uint64_t this_arg) {
54773 LDKInvoiceRequest this_arg_conv;
54774 this_arg_conv.inner = untag_ptr(this_arg);
54775 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54776 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54777 this_arg_conv.is_owned = false;
54778 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
54779 memcpy(ret_arr->elems, InvoiceRequest_payer_id(&this_arg_conv).compressed_form, 33);
54783 uint64_t __attribute__((export_name("TS_InvoiceRequest_payer_note"))) TS_InvoiceRequest_payer_note(uint64_t this_arg) {
54784 LDKInvoiceRequest this_arg_conv;
54785 this_arg_conv.inner = untag_ptr(this_arg);
54786 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54788 this_arg_conv.is_owned = false;
54789 LDKPrintableString ret_var = InvoiceRequest_payer_note(&this_arg_conv);
54790 uint64_t ret_ref = 0;
54791 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54792 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54796 int8_tArray __attribute__((export_name("TS_InvoiceRequest_signature"))) TS_InvoiceRequest_signature(uint64_t this_arg) {
54797 LDKInvoiceRequest this_arg_conv;
54798 this_arg_conv.inner = untag_ptr(this_arg);
54799 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54801 this_arg_conv.is_owned = false;
54802 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
54803 memcpy(ret_arr->elems, InvoiceRequest_signature(&this_arg_conv).compact_form, 64);
54807 uint64_t __attribute__((export_name("TS_InvoiceRequest_verify"))) TS_InvoiceRequest_verify(uint64_t this_arg, uint64_t key) {
54808 LDKInvoiceRequest this_arg_conv;
54809 this_arg_conv.inner = untag_ptr(this_arg);
54810 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54812 this_arg_conv = InvoiceRequest_clone(&this_arg_conv);
54813 LDKExpandedKey key_conv;
54814 key_conv.inner = untag_ptr(key);
54815 key_conv.is_owned = ptr_is_owned(key);
54816 CHECK_INNER_FIELD_ACCESS_OR_NULL(key_conv);
54817 key_conv.is_owned = false;
54818 LDKCResult_VerifiedInvoiceRequestNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_VerifiedInvoiceRequestNoneZ), "LDKCResult_VerifiedInvoiceRequestNoneZ");
54819 *ret_conv = InvoiceRequest_verify(this_arg_conv, &key_conv);
54820 return tag_ptr(ret_conv, true);
54823 ptrArray __attribute__((export_name("TS_VerifiedInvoiceRequest_chains"))) TS_VerifiedInvoiceRequest_chains(uint64_t this_arg) {
54824 LDKVerifiedInvoiceRequest this_arg_conv;
54825 this_arg_conv.inner = untag_ptr(this_arg);
54826 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54828 this_arg_conv.is_owned = false;
54829 LDKCVec_ThirtyTwoBytesZ ret_var = VerifiedInvoiceRequest_chains(&this_arg_conv);
54830 ptrArray ret_arr = NULL;
54831 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
54832 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
54833 for (size_t m = 0; m < ret_var.datalen; m++) {
54834 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
54835 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
54836 ret_arr_ptr[m] = ret_conv_12_arr;
54839 FREE(ret_var.data);
54843 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_metadata"))) TS_VerifiedInvoiceRequest_metadata(uint64_t this_arg) {
54844 LDKVerifiedInvoiceRequest this_arg_conv;
54845 this_arg_conv.inner = untag_ptr(this_arg);
54846 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54847 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54848 this_arg_conv.is_owned = false;
54849 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
54850 *ret_copy = VerifiedInvoiceRequest_metadata(&this_arg_conv);
54851 uint64_t ret_ref = tag_ptr(ret_copy, true);
54855 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_amount"))) TS_VerifiedInvoiceRequest_amount(uint64_t this_arg) {
54856 LDKVerifiedInvoiceRequest this_arg_conv;
54857 this_arg_conv.inner = untag_ptr(this_arg);
54858 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54860 this_arg_conv.is_owned = false;
54861 LDKAmount ret_var = VerifiedInvoiceRequest_amount(&this_arg_conv);
54862 uint64_t ret_ref = 0;
54863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54864 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54868 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_description"))) TS_VerifiedInvoiceRequest_description(uint64_t this_arg) {
54869 LDKVerifiedInvoiceRequest this_arg_conv;
54870 this_arg_conv.inner = untag_ptr(this_arg);
54871 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54873 this_arg_conv.is_owned = false;
54874 LDKPrintableString ret_var = VerifiedInvoiceRequest_description(&this_arg_conv);
54875 uint64_t ret_ref = 0;
54876 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54877 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54881 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_offer_features"))) TS_VerifiedInvoiceRequest_offer_features(uint64_t this_arg) {
54882 LDKVerifiedInvoiceRequest this_arg_conv;
54883 this_arg_conv.inner = untag_ptr(this_arg);
54884 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54886 this_arg_conv.is_owned = false;
54887 LDKOfferFeatures ret_var = VerifiedInvoiceRequest_offer_features(&this_arg_conv);
54888 uint64_t ret_ref = 0;
54889 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54890 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54894 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_absolute_expiry"))) TS_VerifiedInvoiceRequest_absolute_expiry(uint64_t this_arg) {
54895 LDKVerifiedInvoiceRequest this_arg_conv;
54896 this_arg_conv.inner = untag_ptr(this_arg);
54897 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54899 this_arg_conv.is_owned = false;
54900 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54901 *ret_copy = VerifiedInvoiceRequest_absolute_expiry(&this_arg_conv);
54902 uint64_t ret_ref = tag_ptr(ret_copy, true);
54906 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_issuer"))) TS_VerifiedInvoiceRequest_issuer(uint64_t this_arg) {
54907 LDKVerifiedInvoiceRequest this_arg_conv;
54908 this_arg_conv.inner = untag_ptr(this_arg);
54909 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54911 this_arg_conv.is_owned = false;
54912 LDKPrintableString ret_var = VerifiedInvoiceRequest_issuer(&this_arg_conv);
54913 uint64_t ret_ref = 0;
54914 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54915 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54919 uint64_tArray __attribute__((export_name("TS_VerifiedInvoiceRequest_paths"))) TS_VerifiedInvoiceRequest_paths(uint64_t this_arg) {
54920 LDKVerifiedInvoiceRequest this_arg_conv;
54921 this_arg_conv.inner = untag_ptr(this_arg);
54922 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54923 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54924 this_arg_conv.is_owned = false;
54925 LDKCVec_BlindedPathZ ret_var = VerifiedInvoiceRequest_paths(&this_arg_conv);
54926 uint64_tArray ret_arr = NULL;
54927 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
54928 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
54929 for (size_t n = 0; n < ret_var.datalen; n++) {
54930 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
54931 uint64_t ret_conv_13_ref = 0;
54932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
54933 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
54934 ret_arr_ptr[n] = ret_conv_13_ref;
54937 FREE(ret_var.data);
54941 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_supported_quantity"))) TS_VerifiedInvoiceRequest_supported_quantity(uint64_t this_arg) {
54942 LDKVerifiedInvoiceRequest this_arg_conv;
54943 this_arg_conv.inner = untag_ptr(this_arg);
54944 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54946 this_arg_conv.is_owned = false;
54947 LDKQuantity ret_var = VerifiedInvoiceRequest_supported_quantity(&this_arg_conv);
54948 uint64_t ret_ref = 0;
54949 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
54950 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
54954 int8_tArray __attribute__((export_name("TS_VerifiedInvoiceRequest_signing_pubkey"))) TS_VerifiedInvoiceRequest_signing_pubkey(uint64_t this_arg) {
54955 LDKVerifiedInvoiceRequest this_arg_conv;
54956 this_arg_conv.inner = untag_ptr(this_arg);
54957 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54959 this_arg_conv.is_owned = false;
54960 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
54961 memcpy(ret_arr->elems, VerifiedInvoiceRequest_signing_pubkey(&this_arg_conv).compressed_form, 33);
54965 int8_tArray __attribute__((export_name("TS_VerifiedInvoiceRequest_payer_metadata"))) TS_VerifiedInvoiceRequest_payer_metadata(uint64_t this_arg) {
54966 LDKVerifiedInvoiceRequest this_arg_conv;
54967 this_arg_conv.inner = untag_ptr(this_arg);
54968 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54970 this_arg_conv.is_owned = false;
54971 LDKu8slice ret_var = VerifiedInvoiceRequest_payer_metadata(&this_arg_conv);
54972 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
54973 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
54977 int8_tArray __attribute__((export_name("TS_VerifiedInvoiceRequest_chain"))) TS_VerifiedInvoiceRequest_chain(uint64_t this_arg) {
54978 LDKVerifiedInvoiceRequest this_arg_conv;
54979 this_arg_conv.inner = untag_ptr(this_arg);
54980 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54982 this_arg_conv.is_owned = false;
54983 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
54984 memcpy(ret_arr->elems, VerifiedInvoiceRequest_chain(&this_arg_conv).data, 32);
54988 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_amount_msats"))) TS_VerifiedInvoiceRequest_amount_msats(uint64_t this_arg) {
54989 LDKVerifiedInvoiceRequest this_arg_conv;
54990 this_arg_conv.inner = untag_ptr(this_arg);
54991 this_arg_conv.is_owned = ptr_is_owned(this_arg);
54992 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
54993 this_arg_conv.is_owned = false;
54994 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
54995 *ret_copy = VerifiedInvoiceRequest_amount_msats(&this_arg_conv);
54996 uint64_t ret_ref = tag_ptr(ret_copy, true);
55000 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_invoice_request_features"))) TS_VerifiedInvoiceRequest_invoice_request_features(uint64_t this_arg) {
55001 LDKVerifiedInvoiceRequest this_arg_conv;
55002 this_arg_conv.inner = untag_ptr(this_arg);
55003 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55005 this_arg_conv.is_owned = false;
55006 LDKInvoiceRequestFeatures ret_var = VerifiedInvoiceRequest_invoice_request_features(&this_arg_conv);
55007 uint64_t ret_ref = 0;
55008 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55009 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55013 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_quantity"))) TS_VerifiedInvoiceRequest_quantity(uint64_t this_arg) {
55014 LDKVerifiedInvoiceRequest this_arg_conv;
55015 this_arg_conv.inner = untag_ptr(this_arg);
55016 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55018 this_arg_conv.is_owned = false;
55019 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
55020 *ret_copy = VerifiedInvoiceRequest_quantity(&this_arg_conv);
55021 uint64_t ret_ref = tag_ptr(ret_copy, true);
55025 int8_tArray __attribute__((export_name("TS_VerifiedInvoiceRequest_payer_id"))) TS_VerifiedInvoiceRequest_payer_id(uint64_t this_arg) {
55026 LDKVerifiedInvoiceRequest this_arg_conv;
55027 this_arg_conv.inner = untag_ptr(this_arg);
55028 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55030 this_arg_conv.is_owned = false;
55031 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
55032 memcpy(ret_arr->elems, VerifiedInvoiceRequest_payer_id(&this_arg_conv).compressed_form, 33);
55036 uint64_t __attribute__((export_name("TS_VerifiedInvoiceRequest_payer_note"))) TS_VerifiedInvoiceRequest_payer_note(uint64_t this_arg) {
55037 LDKVerifiedInvoiceRequest this_arg_conv;
55038 this_arg_conv.inner = untag_ptr(this_arg);
55039 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55040 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55041 this_arg_conv.is_owned = false;
55042 LDKPrintableString ret_var = VerifiedInvoiceRequest_payer_note(&this_arg_conv);
55043 uint64_t ret_ref = 0;
55044 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55045 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55049 int8_tArray __attribute__((export_name("TS_UnsignedInvoiceRequest_write"))) TS_UnsignedInvoiceRequest_write(uint64_t obj) {
55050 LDKUnsignedInvoiceRequest obj_conv;
55051 obj_conv.inner = untag_ptr(obj);
55052 obj_conv.is_owned = ptr_is_owned(obj);
55053 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
55054 obj_conv.is_owned = false;
55055 LDKCVec_u8Z ret_var = UnsignedInvoiceRequest_write(&obj_conv);
55056 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55057 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55058 CVec_u8Z_free(ret_var);
55062 int8_tArray __attribute__((export_name("TS_InvoiceRequest_write"))) TS_InvoiceRequest_write(uint64_t obj) {
55063 LDKInvoiceRequest obj_conv;
55064 obj_conv.inner = untag_ptr(obj);
55065 obj_conv.is_owned = ptr_is_owned(obj);
55066 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
55067 obj_conv.is_owned = false;
55068 LDKCVec_u8Z ret_var = InvoiceRequest_write(&obj_conv);
55069 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55070 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55071 CVec_u8Z_free(ret_var);
55075 void __attribute__((export_name("TS_TaggedHash_free"))) TS_TaggedHash_free(uint64_t this_obj) {
55076 LDKTaggedHash this_obj_conv;
55077 this_obj_conv.inner = untag_ptr(this_obj);
55078 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55079 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55080 TaggedHash_free(this_obj_conv);
55083 void __attribute__((export_name("TS_Bolt12ParseError_free"))) TS_Bolt12ParseError_free(uint64_t this_obj) {
55084 LDKBolt12ParseError this_obj_conv;
55085 this_obj_conv.inner = untag_ptr(this_obj);
55086 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55088 Bolt12ParseError_free(this_obj_conv);
55091 static inline uint64_t Bolt12ParseError_clone_ptr(LDKBolt12ParseError *NONNULL_PTR arg) {
55092 LDKBolt12ParseError ret_var = Bolt12ParseError_clone(arg);
55093 uint64_t ret_ref = 0;
55094 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55095 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55098 int64_t __attribute__((export_name("TS_Bolt12ParseError_clone_ptr"))) TS_Bolt12ParseError_clone_ptr(uint64_t arg) {
55099 LDKBolt12ParseError arg_conv;
55100 arg_conv.inner = untag_ptr(arg);
55101 arg_conv.is_owned = ptr_is_owned(arg);
55102 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
55103 arg_conv.is_owned = false;
55104 int64_t ret_conv = Bolt12ParseError_clone_ptr(&arg_conv);
55108 uint64_t __attribute__((export_name("TS_Bolt12ParseError_clone"))) TS_Bolt12ParseError_clone(uint64_t orig) {
55109 LDKBolt12ParseError orig_conv;
55110 orig_conv.inner = untag_ptr(orig);
55111 orig_conv.is_owned = ptr_is_owned(orig);
55112 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
55113 orig_conv.is_owned = false;
55114 LDKBolt12ParseError ret_var = Bolt12ParseError_clone(&orig_conv);
55115 uint64_t ret_ref = 0;
55116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55117 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55121 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_clone"))) TS_Bolt12SemanticError_clone(uint64_t orig) {
55122 LDKBolt12SemanticError* orig_conv = (LDKBolt12SemanticError*)untag_ptr(orig);
55123 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_clone(orig_conv));
55127 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_already_expired"))) TS_Bolt12SemanticError_already_expired() {
55128 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_already_expired());
55132 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unsupported_chain"))) TS_Bolt12SemanticError_unsupported_chain() {
55133 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unsupported_chain());
55137 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_chain"))) TS_Bolt12SemanticError_unexpected_chain() {
55138 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_chain());
55142 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_amount"))) TS_Bolt12SemanticError_missing_amount() {
55143 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_amount());
55147 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_invalid_amount"))) TS_Bolt12SemanticError_invalid_amount() {
55148 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_invalid_amount());
55152 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_insufficient_amount"))) TS_Bolt12SemanticError_insufficient_amount() {
55153 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_insufficient_amount());
55157 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_amount"))) TS_Bolt12SemanticError_unexpected_amount() {
55158 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_amount());
55162 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unsupported_currency"))) TS_Bolt12SemanticError_unsupported_currency() {
55163 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unsupported_currency());
55167 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unknown_required_features"))) TS_Bolt12SemanticError_unknown_required_features() {
55168 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unknown_required_features());
55172 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_features"))) TS_Bolt12SemanticError_unexpected_features() {
55173 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_features());
55177 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_description"))) TS_Bolt12SemanticError_missing_description() {
55178 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_description());
55182 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_signing_pubkey"))) TS_Bolt12SemanticError_missing_signing_pubkey() {
55183 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_signing_pubkey());
55187 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_invalid_signing_pubkey"))) TS_Bolt12SemanticError_invalid_signing_pubkey() {
55188 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_invalid_signing_pubkey());
55192 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_signing_pubkey"))) TS_Bolt12SemanticError_unexpected_signing_pubkey() {
55193 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_signing_pubkey());
55197 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_quantity"))) TS_Bolt12SemanticError_missing_quantity() {
55198 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_quantity());
55202 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_invalid_quantity"))) TS_Bolt12SemanticError_invalid_quantity() {
55203 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_invalid_quantity());
55207 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_quantity"))) TS_Bolt12SemanticError_unexpected_quantity() {
55208 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_quantity());
55212 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_invalid_metadata"))) TS_Bolt12SemanticError_invalid_metadata() {
55213 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_invalid_metadata());
55217 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_unexpected_metadata"))) TS_Bolt12SemanticError_unexpected_metadata() {
55218 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_unexpected_metadata());
55222 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_payer_metadata"))) TS_Bolt12SemanticError_missing_payer_metadata() {
55223 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_payer_metadata());
55227 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_payer_id"))) TS_Bolt12SemanticError_missing_payer_id() {
55228 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_payer_id());
55232 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_paths"))) TS_Bolt12SemanticError_missing_paths() {
55233 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_paths());
55237 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_invalid_pay_info"))) TS_Bolt12SemanticError_invalid_pay_info() {
55238 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_invalid_pay_info());
55242 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_creation_time"))) TS_Bolt12SemanticError_missing_creation_time() {
55243 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_creation_time());
55247 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_payment_hash"))) TS_Bolt12SemanticError_missing_payment_hash() {
55248 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_payment_hash());
55252 uint32_t __attribute__((export_name("TS_Bolt12SemanticError_missing_signature"))) TS_Bolt12SemanticError_missing_signature() {
55253 uint32_t ret_conv = LDKBolt12SemanticError_to_js(Bolt12SemanticError_missing_signature());
55257 void __attribute__((export_name("TS_Refund_free"))) TS_Refund_free(uint64_t this_obj) {
55258 LDKRefund this_obj_conv;
55259 this_obj_conv.inner = untag_ptr(this_obj);
55260 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55262 Refund_free(this_obj_conv);
55265 static inline uint64_t Refund_clone_ptr(LDKRefund *NONNULL_PTR arg) {
55266 LDKRefund ret_var = Refund_clone(arg);
55267 uint64_t ret_ref = 0;
55268 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55269 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55272 int64_t __attribute__((export_name("TS_Refund_clone_ptr"))) TS_Refund_clone_ptr(uint64_t arg) {
55273 LDKRefund arg_conv;
55274 arg_conv.inner = untag_ptr(arg);
55275 arg_conv.is_owned = ptr_is_owned(arg);
55276 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
55277 arg_conv.is_owned = false;
55278 int64_t ret_conv = Refund_clone_ptr(&arg_conv);
55282 uint64_t __attribute__((export_name("TS_Refund_clone"))) TS_Refund_clone(uint64_t orig) {
55283 LDKRefund orig_conv;
55284 orig_conv.inner = untag_ptr(orig);
55285 orig_conv.is_owned = ptr_is_owned(orig);
55286 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
55287 orig_conv.is_owned = false;
55288 LDKRefund ret_var = Refund_clone(&orig_conv);
55289 uint64_t ret_ref = 0;
55290 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55291 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55295 uint64_t __attribute__((export_name("TS_Refund_description"))) TS_Refund_description(uint64_t this_arg) {
55296 LDKRefund this_arg_conv;
55297 this_arg_conv.inner = untag_ptr(this_arg);
55298 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55299 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55300 this_arg_conv.is_owned = false;
55301 LDKPrintableString ret_var = Refund_description(&this_arg_conv);
55302 uint64_t ret_ref = 0;
55303 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55304 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55308 uint64_t __attribute__((export_name("TS_Refund_absolute_expiry"))) TS_Refund_absolute_expiry(uint64_t this_arg) {
55309 LDKRefund this_arg_conv;
55310 this_arg_conv.inner = untag_ptr(this_arg);
55311 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55312 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55313 this_arg_conv.is_owned = false;
55314 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
55315 *ret_copy = Refund_absolute_expiry(&this_arg_conv);
55316 uint64_t ret_ref = tag_ptr(ret_copy, true);
55320 uint64_t __attribute__((export_name("TS_Refund_issuer"))) TS_Refund_issuer(uint64_t this_arg) {
55321 LDKRefund this_arg_conv;
55322 this_arg_conv.inner = untag_ptr(this_arg);
55323 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55325 this_arg_conv.is_owned = false;
55326 LDKPrintableString ret_var = Refund_issuer(&this_arg_conv);
55327 uint64_t ret_ref = 0;
55328 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55329 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55333 uint64_tArray __attribute__((export_name("TS_Refund_paths"))) TS_Refund_paths(uint64_t this_arg) {
55334 LDKRefund this_arg_conv;
55335 this_arg_conv.inner = untag_ptr(this_arg);
55336 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55337 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55338 this_arg_conv.is_owned = false;
55339 LDKCVec_BlindedPathZ ret_var = Refund_paths(&this_arg_conv);
55340 uint64_tArray ret_arr = NULL;
55341 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
55342 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
55343 for (size_t n = 0; n < ret_var.datalen; n++) {
55344 LDKBlindedPath ret_conv_13_var = ret_var.data[n];
55345 uint64_t ret_conv_13_ref = 0;
55346 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_13_var);
55347 ret_conv_13_ref = tag_ptr(ret_conv_13_var.inner, ret_conv_13_var.is_owned);
55348 ret_arr_ptr[n] = ret_conv_13_ref;
55351 FREE(ret_var.data);
55355 int8_tArray __attribute__((export_name("TS_Refund_payer_metadata"))) TS_Refund_payer_metadata(uint64_t this_arg) {
55356 LDKRefund this_arg_conv;
55357 this_arg_conv.inner = untag_ptr(this_arg);
55358 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55359 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55360 this_arg_conv.is_owned = false;
55361 LDKu8slice ret_var = Refund_payer_metadata(&this_arg_conv);
55362 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55363 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55367 int8_tArray __attribute__((export_name("TS_Refund_chain"))) TS_Refund_chain(uint64_t this_arg) {
55368 LDKRefund this_arg_conv;
55369 this_arg_conv.inner = untag_ptr(this_arg);
55370 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55372 this_arg_conv.is_owned = false;
55373 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
55374 memcpy(ret_arr->elems, Refund_chain(&this_arg_conv).data, 32);
55378 int64_t __attribute__((export_name("TS_Refund_amount_msats"))) TS_Refund_amount_msats(uint64_t this_arg) {
55379 LDKRefund this_arg_conv;
55380 this_arg_conv.inner = untag_ptr(this_arg);
55381 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55383 this_arg_conv.is_owned = false;
55384 int64_t ret_conv = Refund_amount_msats(&this_arg_conv);
55388 uint64_t __attribute__((export_name("TS_Refund_features"))) TS_Refund_features(uint64_t this_arg) {
55389 LDKRefund this_arg_conv;
55390 this_arg_conv.inner = untag_ptr(this_arg);
55391 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55393 this_arg_conv.is_owned = false;
55394 LDKInvoiceRequestFeatures ret_var = Refund_features(&this_arg_conv);
55395 uint64_t ret_ref = 0;
55396 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55397 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55401 uint64_t __attribute__((export_name("TS_Refund_quantity"))) TS_Refund_quantity(uint64_t this_arg) {
55402 LDKRefund this_arg_conv;
55403 this_arg_conv.inner = untag_ptr(this_arg);
55404 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55405 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55406 this_arg_conv.is_owned = false;
55407 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
55408 *ret_copy = Refund_quantity(&this_arg_conv);
55409 uint64_t ret_ref = tag_ptr(ret_copy, true);
55413 int8_tArray __attribute__((export_name("TS_Refund_payer_id"))) TS_Refund_payer_id(uint64_t this_arg) {
55414 LDKRefund this_arg_conv;
55415 this_arg_conv.inner = untag_ptr(this_arg);
55416 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55418 this_arg_conv.is_owned = false;
55419 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
55420 memcpy(ret_arr->elems, Refund_payer_id(&this_arg_conv).compressed_form, 33);
55424 uint64_t __attribute__((export_name("TS_Refund_payer_note"))) TS_Refund_payer_note(uint64_t this_arg) {
55425 LDKRefund this_arg_conv;
55426 this_arg_conv.inner = untag_ptr(this_arg);
55427 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55429 this_arg_conv.is_owned = false;
55430 LDKPrintableString ret_var = Refund_payer_note(&this_arg_conv);
55431 uint64_t ret_ref = 0;
55432 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55433 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55437 int8_tArray __attribute__((export_name("TS_Refund_write"))) TS_Refund_write(uint64_t obj) {
55438 LDKRefund obj_conv;
55439 obj_conv.inner = untag_ptr(obj);
55440 obj_conv.is_owned = ptr_is_owned(obj);
55441 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
55442 obj_conv.is_owned = false;
55443 LDKCVec_u8Z ret_var = Refund_write(&obj_conv);
55444 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55445 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55446 CVec_u8Z_free(ret_var);
55450 uint64_t __attribute__((export_name("TS_Refund_from_str"))) TS_Refund_from_str(jstring s) {
55451 LDKStr s_conv = str_ref_to_owned_c(s);
55452 LDKCResult_RefundBolt12ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RefundBolt12ParseErrorZ), "LDKCResult_RefundBolt12ParseErrorZ");
55453 *ret_conv = Refund_from_str(s_conv);
55454 return tag_ptr(ret_conv, true);
55457 uint32_t __attribute__((export_name("TS_UtxoLookupError_clone"))) TS_UtxoLookupError_clone(uint64_t orig) {
55458 LDKUtxoLookupError* orig_conv = (LDKUtxoLookupError*)untag_ptr(orig);
55459 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_clone(orig_conv));
55463 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_chain"))) TS_UtxoLookupError_unknown_chain() {
55464 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_chain());
55468 uint32_t __attribute__((export_name("TS_UtxoLookupError_unknown_tx"))) TS_UtxoLookupError_unknown_tx() {
55469 uint32_t ret_conv = LDKUtxoLookupError_to_js(UtxoLookupError_unknown_tx());
55473 void __attribute__((export_name("TS_UtxoResult_free"))) TS_UtxoResult_free(uint64_t this_ptr) {
55474 if (!ptr_is_owned(this_ptr)) return;
55475 void* this_ptr_ptr = untag_ptr(this_ptr);
55476 CHECK_ACCESS(this_ptr_ptr);
55477 LDKUtxoResult this_ptr_conv = *(LDKUtxoResult*)(this_ptr_ptr);
55478 FREE(untag_ptr(this_ptr));
55479 UtxoResult_free(this_ptr_conv);
55482 static inline uint64_t UtxoResult_clone_ptr(LDKUtxoResult *NONNULL_PTR arg) {
55483 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
55484 *ret_copy = UtxoResult_clone(arg);
55485 uint64_t ret_ref = tag_ptr(ret_copy, true);
55488 int64_t __attribute__((export_name("TS_UtxoResult_clone_ptr"))) TS_UtxoResult_clone_ptr(uint64_t arg) {
55489 LDKUtxoResult* arg_conv = (LDKUtxoResult*)untag_ptr(arg);
55490 int64_t ret_conv = UtxoResult_clone_ptr(arg_conv);
55494 uint64_t __attribute__((export_name("TS_UtxoResult_clone"))) TS_UtxoResult_clone(uint64_t orig) {
55495 LDKUtxoResult* orig_conv = (LDKUtxoResult*)untag_ptr(orig);
55496 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
55497 *ret_copy = UtxoResult_clone(orig_conv);
55498 uint64_t ret_ref = tag_ptr(ret_copy, true);
55502 uint64_t __attribute__((export_name("TS_UtxoResult_sync"))) TS_UtxoResult_sync(uint64_t a) {
55503 void* a_ptr = untag_ptr(a);
55504 CHECK_ACCESS(a_ptr);
55505 LDKCResult_TxOutUtxoLookupErrorZ a_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(a_ptr);
55506 a_conv = CResult_TxOutUtxoLookupErrorZ_clone((LDKCResult_TxOutUtxoLookupErrorZ*)untag_ptr(a));
55507 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
55508 *ret_copy = UtxoResult_sync(a_conv);
55509 uint64_t ret_ref = tag_ptr(ret_copy, true);
55513 uint64_t __attribute__((export_name("TS_UtxoResult_async"))) TS_UtxoResult_async(uint64_t a) {
55514 LDKUtxoFuture a_conv;
55515 a_conv.inner = untag_ptr(a);
55516 a_conv.is_owned = ptr_is_owned(a);
55517 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
55518 a_conv = UtxoFuture_clone(&a_conv);
55519 LDKUtxoResult *ret_copy = MALLOC(sizeof(LDKUtxoResult), "LDKUtxoResult");
55520 *ret_copy = UtxoResult_async(a_conv);
55521 uint64_t ret_ref = tag_ptr(ret_copy, true);
55525 void __attribute__((export_name("TS_UtxoLookup_free"))) TS_UtxoLookup_free(uint64_t this_ptr) {
55526 if (!ptr_is_owned(this_ptr)) return;
55527 void* this_ptr_ptr = untag_ptr(this_ptr);
55528 CHECK_ACCESS(this_ptr_ptr);
55529 LDKUtxoLookup this_ptr_conv = *(LDKUtxoLookup*)(this_ptr_ptr);
55530 FREE(untag_ptr(this_ptr));
55531 UtxoLookup_free(this_ptr_conv);
55534 void __attribute__((export_name("TS_UtxoFuture_free"))) TS_UtxoFuture_free(uint64_t this_obj) {
55535 LDKUtxoFuture this_obj_conv;
55536 this_obj_conv.inner = untag_ptr(this_obj);
55537 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55538 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55539 UtxoFuture_free(this_obj_conv);
55542 static inline uint64_t UtxoFuture_clone_ptr(LDKUtxoFuture *NONNULL_PTR arg) {
55543 LDKUtxoFuture ret_var = UtxoFuture_clone(arg);
55544 uint64_t ret_ref = 0;
55545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55546 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55549 int64_t __attribute__((export_name("TS_UtxoFuture_clone_ptr"))) TS_UtxoFuture_clone_ptr(uint64_t arg) {
55550 LDKUtxoFuture arg_conv;
55551 arg_conv.inner = untag_ptr(arg);
55552 arg_conv.is_owned = ptr_is_owned(arg);
55553 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
55554 arg_conv.is_owned = false;
55555 int64_t ret_conv = UtxoFuture_clone_ptr(&arg_conv);
55559 uint64_t __attribute__((export_name("TS_UtxoFuture_clone"))) TS_UtxoFuture_clone(uint64_t orig) {
55560 LDKUtxoFuture orig_conv;
55561 orig_conv.inner = untag_ptr(orig);
55562 orig_conv.is_owned = ptr_is_owned(orig);
55563 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
55564 orig_conv.is_owned = false;
55565 LDKUtxoFuture ret_var = UtxoFuture_clone(&orig_conv);
55566 uint64_t ret_ref = 0;
55567 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55568 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55572 uint64_t __attribute__((export_name("TS_UtxoFuture_new"))) TS_UtxoFuture_new() {
55573 LDKUtxoFuture ret_var = UtxoFuture_new();
55574 uint64_t ret_ref = 0;
55575 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55576 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55580 void __attribute__((export_name("TS_UtxoFuture_resolve_without_forwarding"))) TS_UtxoFuture_resolve_without_forwarding(uint64_t this_arg, uint64_t graph, uint64_t result) {
55581 LDKUtxoFuture this_arg_conv;
55582 this_arg_conv.inner = untag_ptr(this_arg);
55583 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55585 this_arg_conv.is_owned = false;
55586 LDKNetworkGraph graph_conv;
55587 graph_conv.inner = untag_ptr(graph);
55588 graph_conv.is_owned = ptr_is_owned(graph);
55589 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
55590 graph_conv.is_owned = false;
55591 void* result_ptr = untag_ptr(result);
55592 CHECK_ACCESS(result_ptr);
55593 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
55594 UtxoFuture_resolve_without_forwarding(&this_arg_conv, &graph_conv, result_conv);
55597 void __attribute__((export_name("TS_UtxoFuture_resolve"))) TS_UtxoFuture_resolve(uint64_t this_arg, uint64_t graph, uint64_t gossip, uint64_t result) {
55598 LDKUtxoFuture this_arg_conv;
55599 this_arg_conv.inner = untag_ptr(this_arg);
55600 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55602 this_arg_conv.is_owned = false;
55603 LDKNetworkGraph graph_conv;
55604 graph_conv.inner = untag_ptr(graph);
55605 graph_conv.is_owned = ptr_is_owned(graph);
55606 CHECK_INNER_FIELD_ACCESS_OR_NULL(graph_conv);
55607 graph_conv.is_owned = false;
55608 LDKP2PGossipSync gossip_conv;
55609 gossip_conv.inner = untag_ptr(gossip);
55610 gossip_conv.is_owned = ptr_is_owned(gossip);
55611 CHECK_INNER_FIELD_ACCESS_OR_NULL(gossip_conv);
55612 gossip_conv.is_owned = false;
55613 void* result_ptr = untag_ptr(result);
55614 CHECK_ACCESS(result_ptr);
55615 LDKCResult_TxOutUtxoLookupErrorZ result_conv = *(LDKCResult_TxOutUtxoLookupErrorZ*)(result_ptr);
55616 UtxoFuture_resolve(&this_arg_conv, &graph_conv, &gossip_conv, result_conv);
55619 void __attribute__((export_name("TS_NodeId_free"))) TS_NodeId_free(uint64_t this_obj) {
55620 LDKNodeId this_obj_conv;
55621 this_obj_conv.inner = untag_ptr(this_obj);
55622 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55624 NodeId_free(this_obj_conv);
55627 static inline uint64_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
55628 LDKNodeId ret_var = NodeId_clone(arg);
55629 uint64_t ret_ref = 0;
55630 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55631 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55634 int64_t __attribute__((export_name("TS_NodeId_clone_ptr"))) TS_NodeId_clone_ptr(uint64_t arg) {
55635 LDKNodeId arg_conv;
55636 arg_conv.inner = untag_ptr(arg);
55637 arg_conv.is_owned = ptr_is_owned(arg);
55638 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
55639 arg_conv.is_owned = false;
55640 int64_t ret_conv = NodeId_clone_ptr(&arg_conv);
55644 uint64_t __attribute__((export_name("TS_NodeId_clone"))) TS_NodeId_clone(uint64_t orig) {
55645 LDKNodeId orig_conv;
55646 orig_conv.inner = untag_ptr(orig);
55647 orig_conv.is_owned = ptr_is_owned(orig);
55648 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
55649 orig_conv.is_owned = false;
55650 LDKNodeId ret_var = NodeId_clone(&orig_conv);
55651 uint64_t ret_ref = 0;
55652 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55653 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55657 uint64_t __attribute__((export_name("TS_NodeId_from_pubkey"))) TS_NodeId_from_pubkey(int8_tArray pubkey) {
55658 LDKPublicKey pubkey_ref;
55659 CHECK(pubkey->arr_len == 33);
55660 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
55661 LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref);
55662 uint64_t ret_ref = 0;
55663 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55664 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55668 int8_tArray __attribute__((export_name("TS_NodeId_as_slice"))) TS_NodeId_as_slice(uint64_t this_arg) {
55669 LDKNodeId this_arg_conv;
55670 this_arg_conv.inner = untag_ptr(this_arg);
55671 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55673 this_arg_conv.is_owned = false;
55674 LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
55675 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55676 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55680 uint64_t __attribute__((export_name("TS_NodeId_as_pubkey"))) TS_NodeId_as_pubkey(uint64_t this_arg) {
55681 LDKNodeId this_arg_conv;
55682 this_arg_conv.inner = untag_ptr(this_arg);
55683 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55684 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55685 this_arg_conv.is_owned = false;
55686 LDKCResult_PublicKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeySecp256k1ErrorZ), "LDKCResult_PublicKeySecp256k1ErrorZ");
55687 *ret_conv = NodeId_as_pubkey(&this_arg_conv);
55688 return tag_ptr(ret_conv, true);
55691 int64_t __attribute__((export_name("TS_NodeId_hash"))) TS_NodeId_hash(uint64_t o) {
55693 o_conv.inner = untag_ptr(o);
55694 o_conv.is_owned = ptr_is_owned(o);
55695 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
55696 o_conv.is_owned = false;
55697 int64_t ret_conv = NodeId_hash(&o_conv);
55701 int8_tArray __attribute__((export_name("TS_NodeId_write"))) TS_NodeId_write(uint64_t obj) {
55702 LDKNodeId obj_conv;
55703 obj_conv.inner = untag_ptr(obj);
55704 obj_conv.is_owned = ptr_is_owned(obj);
55705 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
55706 obj_conv.is_owned = false;
55707 LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
55708 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55709 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55710 CVec_u8Z_free(ret_var);
55714 uint64_t __attribute__((export_name("TS_NodeId_read"))) TS_NodeId_read(int8_tArray ser) {
55715 LDKu8slice ser_ref;
55716 ser_ref.datalen = ser->arr_len;
55717 ser_ref.data = ser->elems;
55718 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
55719 *ret_conv = NodeId_read(ser_ref);
55721 return tag_ptr(ret_conv, true);
55724 void __attribute__((export_name("TS_NetworkGraph_free"))) TS_NetworkGraph_free(uint64_t this_obj) {
55725 LDKNetworkGraph this_obj_conv;
55726 this_obj_conv.inner = untag_ptr(this_obj);
55727 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55729 NetworkGraph_free(this_obj_conv);
55732 void __attribute__((export_name("TS_ReadOnlyNetworkGraph_free"))) TS_ReadOnlyNetworkGraph_free(uint64_t this_obj) {
55733 LDKReadOnlyNetworkGraph this_obj_conv;
55734 this_obj_conv.inner = untag_ptr(this_obj);
55735 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55737 ReadOnlyNetworkGraph_free(this_obj_conv);
55740 void __attribute__((export_name("TS_NetworkUpdate_free"))) TS_NetworkUpdate_free(uint64_t this_ptr) {
55741 if (!ptr_is_owned(this_ptr)) return;
55742 void* this_ptr_ptr = untag_ptr(this_ptr);
55743 CHECK_ACCESS(this_ptr_ptr);
55744 LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(this_ptr_ptr);
55745 FREE(untag_ptr(this_ptr));
55746 NetworkUpdate_free(this_ptr_conv);
55749 static inline uint64_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
55750 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
55751 *ret_copy = NetworkUpdate_clone(arg);
55752 uint64_t ret_ref = tag_ptr(ret_copy, true);
55755 int64_t __attribute__((export_name("TS_NetworkUpdate_clone_ptr"))) TS_NetworkUpdate_clone_ptr(uint64_t arg) {
55756 LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)untag_ptr(arg);
55757 int64_t ret_conv = NetworkUpdate_clone_ptr(arg_conv);
55761 uint64_t __attribute__((export_name("TS_NetworkUpdate_clone"))) TS_NetworkUpdate_clone(uint64_t orig) {
55762 LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)untag_ptr(orig);
55763 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
55764 *ret_copy = NetworkUpdate_clone(orig_conv);
55765 uint64_t ret_ref = tag_ptr(ret_copy, true);
55769 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_update_message"))) TS_NetworkUpdate_channel_update_message(uint64_t msg) {
55770 LDKChannelUpdate msg_conv;
55771 msg_conv.inner = untag_ptr(msg);
55772 msg_conv.is_owned = ptr_is_owned(msg);
55773 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
55774 msg_conv = ChannelUpdate_clone(&msg_conv);
55775 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
55776 *ret_copy = NetworkUpdate_channel_update_message(msg_conv);
55777 uint64_t ret_ref = tag_ptr(ret_copy, true);
55781 uint64_t __attribute__((export_name("TS_NetworkUpdate_channel_failure"))) TS_NetworkUpdate_channel_failure(int64_t short_channel_id, jboolean is_permanent) {
55782 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
55783 *ret_copy = NetworkUpdate_channel_failure(short_channel_id, is_permanent);
55784 uint64_t ret_ref = tag_ptr(ret_copy, true);
55788 uint64_t __attribute__((export_name("TS_NetworkUpdate_node_failure"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) {
55789 LDKPublicKey node_id_ref;
55790 CHECK(node_id->arr_len == 33);
55791 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
55792 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
55793 *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent);
55794 uint64_t ret_ref = tag_ptr(ret_copy, true);
55798 jboolean __attribute__((export_name("TS_NetworkUpdate_eq"))) TS_NetworkUpdate_eq(uint64_t a, uint64_t b) {
55799 LDKNetworkUpdate* a_conv = (LDKNetworkUpdate*)untag_ptr(a);
55800 LDKNetworkUpdate* b_conv = (LDKNetworkUpdate*)untag_ptr(b);
55801 jboolean ret_conv = NetworkUpdate_eq(a_conv, b_conv);
55805 int8_tArray __attribute__((export_name("TS_NetworkUpdate_write"))) TS_NetworkUpdate_write(uint64_t obj) {
55806 LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)untag_ptr(obj);
55807 LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_conv);
55808 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
55809 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
55810 CVec_u8Z_free(ret_var);
55814 uint64_t __attribute__((export_name("TS_NetworkUpdate_read"))) TS_NetworkUpdate_read(int8_tArray ser) {
55815 LDKu8slice ser_ref;
55816 ser_ref.datalen = ser->arr_len;
55817 ser_ref.data = ser->elems;
55818 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
55819 *ret_conv = NetworkUpdate_read(ser_ref);
55821 return tag_ptr(ret_conv, true);
55824 void __attribute__((export_name("TS_P2PGossipSync_free"))) TS_P2PGossipSync_free(uint64_t this_obj) {
55825 LDKP2PGossipSync this_obj_conv;
55826 this_obj_conv.inner = untag_ptr(this_obj);
55827 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55828 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55829 P2PGossipSync_free(this_obj_conv);
55832 uint64_t __attribute__((export_name("TS_P2PGossipSync_new"))) TS_P2PGossipSync_new(uint64_t network_graph, uint64_t utxo_lookup, uint64_t logger) {
55833 LDKNetworkGraph network_graph_conv;
55834 network_graph_conv.inner = untag_ptr(network_graph);
55835 network_graph_conv.is_owned = ptr_is_owned(network_graph);
55836 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
55837 network_graph_conv.is_owned = false;
55838 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
55839 CHECK_ACCESS(utxo_lookup_ptr);
55840 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
55841 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
55842 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
55843 // Manually implement clone for Java trait instances
55844 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
55845 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
55846 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
55849 void* logger_ptr = untag_ptr(logger);
55850 CHECK_ACCESS(logger_ptr);
55851 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
55852 if (logger_conv.free == LDKLogger_JCalls_free) {
55853 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
55854 LDKLogger_JCalls_cloned(&logger_conv);
55856 LDKP2PGossipSync ret_var = P2PGossipSync_new(&network_graph_conv, utxo_lookup_conv, logger_conv);
55857 uint64_t ret_ref = 0;
55858 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
55859 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
55863 void __attribute__((export_name("TS_P2PGossipSync_add_utxo_lookup"))) TS_P2PGossipSync_add_utxo_lookup(uint64_t this_arg, uint64_t utxo_lookup) {
55864 LDKP2PGossipSync this_arg_conv;
55865 this_arg_conv.inner = untag_ptr(this_arg);
55866 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55868 this_arg_conv.is_owned = false;
55869 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
55870 CHECK_ACCESS(utxo_lookup_ptr);
55871 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
55872 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
55873 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
55874 // Manually implement clone for Java trait instances
55875 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
55876 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
55877 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
55880 P2PGossipSync_add_utxo_lookup(&this_arg_conv, utxo_lookup_conv);
55883 void __attribute__((export_name("TS_NetworkGraph_handle_network_update"))) TS_NetworkGraph_handle_network_update(uint64_t this_arg, uint64_t network_update) {
55884 LDKNetworkGraph this_arg_conv;
55885 this_arg_conv.inner = untag_ptr(this_arg);
55886 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55888 this_arg_conv.is_owned = false;
55889 LDKNetworkUpdate* network_update_conv = (LDKNetworkUpdate*)untag_ptr(network_update);
55890 NetworkGraph_handle_network_update(&this_arg_conv, network_update_conv);
55893 int8_tArray __attribute__((export_name("TS_NetworkGraph_get_genesis_hash"))) TS_NetworkGraph_get_genesis_hash(uint64_t this_arg) {
55894 LDKNetworkGraph this_arg_conv;
55895 this_arg_conv.inner = untag_ptr(this_arg);
55896 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55897 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55898 this_arg_conv.is_owned = false;
55899 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
55900 memcpy(ret_arr->elems, NetworkGraph_get_genesis_hash(&this_arg_conv).data, 32);
55904 uint64_t __attribute__((export_name("TS_verify_node_announcement"))) TS_verify_node_announcement(uint64_t msg) {
55905 LDKNodeAnnouncement msg_conv;
55906 msg_conv.inner = untag_ptr(msg);
55907 msg_conv.is_owned = ptr_is_owned(msg);
55908 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
55909 msg_conv.is_owned = false;
55910 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
55911 *ret_conv = verify_node_announcement(&msg_conv);
55912 return tag_ptr(ret_conv, true);
55915 uint64_t __attribute__((export_name("TS_verify_channel_announcement"))) TS_verify_channel_announcement(uint64_t msg) {
55916 LDKChannelAnnouncement msg_conv;
55917 msg_conv.inner = untag_ptr(msg);
55918 msg_conv.is_owned = ptr_is_owned(msg);
55919 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
55920 msg_conv.is_owned = false;
55921 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
55922 *ret_conv = verify_channel_announcement(&msg_conv);
55923 return tag_ptr(ret_conv, true);
55926 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_RoutingMessageHandler"))) TS_P2PGossipSync_as_RoutingMessageHandler(uint64_t this_arg) {
55927 LDKP2PGossipSync this_arg_conv;
55928 this_arg_conv.inner = untag_ptr(this_arg);
55929 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55930 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55931 this_arg_conv.is_owned = false;
55932 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
55933 *ret_ret = P2PGossipSync_as_RoutingMessageHandler(&this_arg_conv);
55934 return tag_ptr(ret_ret, true);
55937 uint64_t __attribute__((export_name("TS_P2PGossipSync_as_MessageSendEventsProvider"))) TS_P2PGossipSync_as_MessageSendEventsProvider(uint64_t this_arg) {
55938 LDKP2PGossipSync this_arg_conv;
55939 this_arg_conv.inner = untag_ptr(this_arg);
55940 this_arg_conv.is_owned = ptr_is_owned(this_arg);
55941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
55942 this_arg_conv.is_owned = false;
55943 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
55944 *ret_ret = P2PGossipSync_as_MessageSendEventsProvider(&this_arg_conv);
55945 return tag_ptr(ret_ret, true);
55948 void __attribute__((export_name("TS_ChannelUpdateInfo_free"))) TS_ChannelUpdateInfo_free(uint64_t this_obj) {
55949 LDKChannelUpdateInfo this_obj_conv;
55950 this_obj_conv.inner = untag_ptr(this_obj);
55951 this_obj_conv.is_owned = ptr_is_owned(this_obj);
55952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
55953 ChannelUpdateInfo_free(this_obj_conv);
55956 int32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update"))) TS_ChannelUpdateInfo_get_last_update(uint64_t this_ptr) {
55957 LDKChannelUpdateInfo this_ptr_conv;
55958 this_ptr_conv.inner = untag_ptr(this_ptr);
55959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
55960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
55961 this_ptr_conv.is_owned = false;
55962 int32_t ret_conv = ChannelUpdateInfo_get_last_update(&this_ptr_conv);
55966 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update"))) TS_ChannelUpdateInfo_set_last_update(uint64_t this_ptr, int32_t val) {
55967 LDKChannelUpdateInfo this_ptr_conv;
55968 this_ptr_conv.inner = untag_ptr(this_ptr);
55969 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
55970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
55971 this_ptr_conv.is_owned = false;
55972 ChannelUpdateInfo_set_last_update(&this_ptr_conv, val);
55975 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_get_enabled"))) TS_ChannelUpdateInfo_get_enabled(uint64_t this_ptr) {
55976 LDKChannelUpdateInfo this_ptr_conv;
55977 this_ptr_conv.inner = untag_ptr(this_ptr);
55978 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
55979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
55980 this_ptr_conv.is_owned = false;
55981 jboolean ret_conv = ChannelUpdateInfo_get_enabled(&this_ptr_conv);
55985 void __attribute__((export_name("TS_ChannelUpdateInfo_set_enabled"))) TS_ChannelUpdateInfo_set_enabled(uint64_t this_ptr, jboolean val) {
55986 LDKChannelUpdateInfo this_ptr_conv;
55987 this_ptr_conv.inner = untag_ptr(this_ptr);
55988 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
55989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
55990 this_ptr_conv.is_owned = false;
55991 ChannelUpdateInfo_set_enabled(&this_ptr_conv, val);
55994 int16_t __attribute__((export_name("TS_ChannelUpdateInfo_get_cltv_expiry_delta"))) TS_ChannelUpdateInfo_get_cltv_expiry_delta(uint64_t this_ptr) {
55995 LDKChannelUpdateInfo this_ptr_conv;
55996 this_ptr_conv.inner = untag_ptr(this_ptr);
55997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
55998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
55999 this_ptr_conv.is_owned = false;
56000 int16_t ret_conv = ChannelUpdateInfo_get_cltv_expiry_delta(&this_ptr_conv);
56004 void __attribute__((export_name("TS_ChannelUpdateInfo_set_cltv_expiry_delta"))) TS_ChannelUpdateInfo_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
56005 LDKChannelUpdateInfo this_ptr_conv;
56006 this_ptr_conv.inner = untag_ptr(this_ptr);
56007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56009 this_ptr_conv.is_owned = false;
56010 ChannelUpdateInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
56013 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_minimum_msat"))) TS_ChannelUpdateInfo_get_htlc_minimum_msat(uint64_t this_ptr) {
56014 LDKChannelUpdateInfo this_ptr_conv;
56015 this_ptr_conv.inner = untag_ptr(this_ptr);
56016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56018 this_ptr_conv.is_owned = false;
56019 int64_t ret_conv = ChannelUpdateInfo_get_htlc_minimum_msat(&this_ptr_conv);
56023 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_minimum_msat"))) TS_ChannelUpdateInfo_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
56024 LDKChannelUpdateInfo this_ptr_conv;
56025 this_ptr_conv.inner = untag_ptr(this_ptr);
56026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56028 this_ptr_conv.is_owned = false;
56029 ChannelUpdateInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
56032 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_maximum_msat"))) TS_ChannelUpdateInfo_get_htlc_maximum_msat(uint64_t this_ptr) {
56033 LDKChannelUpdateInfo this_ptr_conv;
56034 this_ptr_conv.inner = untag_ptr(this_ptr);
56035 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56037 this_ptr_conv.is_owned = false;
56038 int64_t ret_conv = ChannelUpdateInfo_get_htlc_maximum_msat(&this_ptr_conv);
56042 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_maximum_msat"))) TS_ChannelUpdateInfo_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
56043 LDKChannelUpdateInfo this_ptr_conv;
56044 this_ptr_conv.inner = untag_ptr(this_ptr);
56045 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56047 this_ptr_conv.is_owned = false;
56048 ChannelUpdateInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
56051 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_fees"))) TS_ChannelUpdateInfo_get_fees(uint64_t this_ptr) {
56052 LDKChannelUpdateInfo this_ptr_conv;
56053 this_ptr_conv.inner = untag_ptr(this_ptr);
56054 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56056 this_ptr_conv.is_owned = false;
56057 LDKRoutingFees ret_var = ChannelUpdateInfo_get_fees(&this_ptr_conv);
56058 uint64_t ret_ref = 0;
56059 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56060 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56064 void __attribute__((export_name("TS_ChannelUpdateInfo_set_fees"))) TS_ChannelUpdateInfo_set_fees(uint64_t this_ptr, uint64_t val) {
56065 LDKChannelUpdateInfo this_ptr_conv;
56066 this_ptr_conv.inner = untag_ptr(this_ptr);
56067 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56068 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56069 this_ptr_conv.is_owned = false;
56070 LDKRoutingFees val_conv;
56071 val_conv.inner = untag_ptr(val);
56072 val_conv.is_owned = ptr_is_owned(val);
56073 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56074 val_conv = RoutingFees_clone(&val_conv);
56075 ChannelUpdateInfo_set_fees(&this_ptr_conv, val_conv);
56078 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update_message"))) TS_ChannelUpdateInfo_get_last_update_message(uint64_t this_ptr) {
56079 LDKChannelUpdateInfo this_ptr_conv;
56080 this_ptr_conv.inner = untag_ptr(this_ptr);
56081 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56083 this_ptr_conv.is_owned = false;
56084 LDKChannelUpdate ret_var = ChannelUpdateInfo_get_last_update_message(&this_ptr_conv);
56085 uint64_t ret_ref = 0;
56086 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56087 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56091 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update_message"))) TS_ChannelUpdateInfo_set_last_update_message(uint64_t this_ptr, uint64_t val) {
56092 LDKChannelUpdateInfo this_ptr_conv;
56093 this_ptr_conv.inner = untag_ptr(this_ptr);
56094 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56096 this_ptr_conv.is_owned = false;
56097 LDKChannelUpdate val_conv;
56098 val_conv.inner = untag_ptr(val);
56099 val_conv.is_owned = ptr_is_owned(val);
56100 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56101 val_conv = ChannelUpdate_clone(&val_conv);
56102 ChannelUpdateInfo_set_last_update_message(&this_ptr_conv, val_conv);
56105 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) {
56106 LDKRoutingFees fees_arg_conv;
56107 fees_arg_conv.inner = untag_ptr(fees_arg);
56108 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
56109 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
56110 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
56111 LDKChannelUpdate last_update_message_arg_conv;
56112 last_update_message_arg_conv.inner = untag_ptr(last_update_message_arg);
56113 last_update_message_arg_conv.is_owned = ptr_is_owned(last_update_message_arg);
56114 CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
56115 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
56116 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);
56117 uint64_t ret_ref = 0;
56118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56119 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56123 static inline uint64_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg) {
56124 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(arg);
56125 uint64_t ret_ref = 0;
56126 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56127 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56130 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone_ptr"))) TS_ChannelUpdateInfo_clone_ptr(uint64_t arg) {
56131 LDKChannelUpdateInfo arg_conv;
56132 arg_conv.inner = untag_ptr(arg);
56133 arg_conv.is_owned = ptr_is_owned(arg);
56134 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
56135 arg_conv.is_owned = false;
56136 int64_t ret_conv = ChannelUpdateInfo_clone_ptr(&arg_conv);
56140 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_clone"))) TS_ChannelUpdateInfo_clone(uint64_t orig) {
56141 LDKChannelUpdateInfo orig_conv;
56142 orig_conv.inner = untag_ptr(orig);
56143 orig_conv.is_owned = ptr_is_owned(orig);
56144 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
56145 orig_conv.is_owned = false;
56146 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(&orig_conv);
56147 uint64_t ret_ref = 0;
56148 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56149 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56153 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_eq"))) TS_ChannelUpdateInfo_eq(uint64_t a, uint64_t b) {
56154 LDKChannelUpdateInfo a_conv;
56155 a_conv.inner = untag_ptr(a);
56156 a_conv.is_owned = ptr_is_owned(a);
56157 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
56158 a_conv.is_owned = false;
56159 LDKChannelUpdateInfo b_conv;
56160 b_conv.inner = untag_ptr(b);
56161 b_conv.is_owned = ptr_is_owned(b);
56162 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
56163 b_conv.is_owned = false;
56164 jboolean ret_conv = ChannelUpdateInfo_eq(&a_conv, &b_conv);
56168 int8_tArray __attribute__((export_name("TS_ChannelUpdateInfo_write"))) TS_ChannelUpdateInfo_write(uint64_t obj) {
56169 LDKChannelUpdateInfo obj_conv;
56170 obj_conv.inner = untag_ptr(obj);
56171 obj_conv.is_owned = ptr_is_owned(obj);
56172 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
56173 obj_conv.is_owned = false;
56174 LDKCVec_u8Z ret_var = ChannelUpdateInfo_write(&obj_conv);
56175 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
56176 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
56177 CVec_u8Z_free(ret_var);
56181 uint64_t __attribute__((export_name("TS_ChannelUpdateInfo_read"))) TS_ChannelUpdateInfo_read(int8_tArray ser) {
56182 LDKu8slice ser_ref;
56183 ser_ref.datalen = ser->arr_len;
56184 ser_ref.data = ser->elems;
56185 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
56186 *ret_conv = ChannelUpdateInfo_read(ser_ref);
56188 return tag_ptr(ret_conv, true);
56191 void __attribute__((export_name("TS_ChannelInfo_free"))) TS_ChannelInfo_free(uint64_t this_obj) {
56192 LDKChannelInfo this_obj_conv;
56193 this_obj_conv.inner = untag_ptr(this_obj);
56194 this_obj_conv.is_owned = ptr_is_owned(this_obj);
56195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
56196 ChannelInfo_free(this_obj_conv);
56199 uint64_t __attribute__((export_name("TS_ChannelInfo_get_features"))) TS_ChannelInfo_get_features(uint64_t this_ptr) {
56200 LDKChannelInfo this_ptr_conv;
56201 this_ptr_conv.inner = untag_ptr(this_ptr);
56202 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56204 this_ptr_conv.is_owned = false;
56205 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
56206 uint64_t ret_ref = 0;
56207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56208 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56212 void __attribute__((export_name("TS_ChannelInfo_set_features"))) TS_ChannelInfo_set_features(uint64_t this_ptr, uint64_t val) {
56213 LDKChannelInfo this_ptr_conv;
56214 this_ptr_conv.inner = untag_ptr(this_ptr);
56215 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56217 this_ptr_conv.is_owned = false;
56218 LDKChannelFeatures val_conv;
56219 val_conv.inner = untag_ptr(val);
56220 val_conv.is_owned = ptr_is_owned(val);
56221 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56222 val_conv = ChannelFeatures_clone(&val_conv);
56223 ChannelInfo_set_features(&this_ptr_conv, val_conv);
56226 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_one"))) TS_ChannelInfo_get_node_one(uint64_t this_ptr) {
56227 LDKChannelInfo this_ptr_conv;
56228 this_ptr_conv.inner = untag_ptr(this_ptr);
56229 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56231 this_ptr_conv.is_owned = false;
56232 LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
56233 uint64_t ret_ref = 0;
56234 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56235 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56239 void __attribute__((export_name("TS_ChannelInfo_set_node_one"))) TS_ChannelInfo_set_node_one(uint64_t this_ptr, uint64_t val) {
56240 LDKChannelInfo this_ptr_conv;
56241 this_ptr_conv.inner = untag_ptr(this_ptr);
56242 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56244 this_ptr_conv.is_owned = false;
56245 LDKNodeId val_conv;
56246 val_conv.inner = untag_ptr(val);
56247 val_conv.is_owned = ptr_is_owned(val);
56248 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56249 val_conv = NodeId_clone(&val_conv);
56250 ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
56253 uint64_t __attribute__((export_name("TS_ChannelInfo_get_one_to_two"))) TS_ChannelInfo_get_one_to_two(uint64_t this_ptr) {
56254 LDKChannelInfo this_ptr_conv;
56255 this_ptr_conv.inner = untag_ptr(this_ptr);
56256 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56257 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56258 this_ptr_conv.is_owned = false;
56259 LDKChannelUpdateInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
56260 uint64_t ret_ref = 0;
56261 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56262 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56266 void __attribute__((export_name("TS_ChannelInfo_set_one_to_two"))) TS_ChannelInfo_set_one_to_two(uint64_t this_ptr, uint64_t val) {
56267 LDKChannelInfo this_ptr_conv;
56268 this_ptr_conv.inner = untag_ptr(this_ptr);
56269 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56270 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56271 this_ptr_conv.is_owned = false;
56272 LDKChannelUpdateInfo val_conv;
56273 val_conv.inner = untag_ptr(val);
56274 val_conv.is_owned = ptr_is_owned(val);
56275 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56276 val_conv = ChannelUpdateInfo_clone(&val_conv);
56277 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
56280 uint64_t __attribute__((export_name("TS_ChannelInfo_get_node_two"))) TS_ChannelInfo_get_node_two(uint64_t this_ptr) {
56281 LDKChannelInfo this_ptr_conv;
56282 this_ptr_conv.inner = untag_ptr(this_ptr);
56283 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56285 this_ptr_conv.is_owned = false;
56286 LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
56287 uint64_t ret_ref = 0;
56288 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56289 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56293 void __attribute__((export_name("TS_ChannelInfo_set_node_two"))) TS_ChannelInfo_set_node_two(uint64_t this_ptr, uint64_t val) {
56294 LDKChannelInfo this_ptr_conv;
56295 this_ptr_conv.inner = untag_ptr(this_ptr);
56296 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56298 this_ptr_conv.is_owned = false;
56299 LDKNodeId val_conv;
56300 val_conv.inner = untag_ptr(val);
56301 val_conv.is_owned = ptr_is_owned(val);
56302 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56303 val_conv = NodeId_clone(&val_conv);
56304 ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
56307 uint64_t __attribute__((export_name("TS_ChannelInfo_get_two_to_one"))) TS_ChannelInfo_get_two_to_one(uint64_t this_ptr) {
56308 LDKChannelInfo this_ptr_conv;
56309 this_ptr_conv.inner = untag_ptr(this_ptr);
56310 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56311 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56312 this_ptr_conv.is_owned = false;
56313 LDKChannelUpdateInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
56314 uint64_t ret_ref = 0;
56315 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56316 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56320 void __attribute__((export_name("TS_ChannelInfo_set_two_to_one"))) TS_ChannelInfo_set_two_to_one(uint64_t this_ptr, uint64_t val) {
56321 LDKChannelInfo this_ptr_conv;
56322 this_ptr_conv.inner = untag_ptr(this_ptr);
56323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56325 this_ptr_conv.is_owned = false;
56326 LDKChannelUpdateInfo val_conv;
56327 val_conv.inner = untag_ptr(val);
56328 val_conv.is_owned = ptr_is_owned(val);
56329 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56330 val_conv = ChannelUpdateInfo_clone(&val_conv);
56331 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
56334 uint64_t __attribute__((export_name("TS_ChannelInfo_get_capacity_sats"))) TS_ChannelInfo_get_capacity_sats(uint64_t this_ptr) {
56335 LDKChannelInfo this_ptr_conv;
56336 this_ptr_conv.inner = untag_ptr(this_ptr);
56337 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56339 this_ptr_conv.is_owned = false;
56340 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
56341 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
56342 uint64_t ret_ref = tag_ptr(ret_copy, true);
56346 void __attribute__((export_name("TS_ChannelInfo_set_capacity_sats"))) TS_ChannelInfo_set_capacity_sats(uint64_t this_ptr, uint64_t val) {
56347 LDKChannelInfo this_ptr_conv;
56348 this_ptr_conv.inner = untag_ptr(this_ptr);
56349 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56350 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56351 this_ptr_conv.is_owned = false;
56352 void* val_ptr = untag_ptr(val);
56353 CHECK_ACCESS(val_ptr);
56354 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
56355 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
56356 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
56359 uint64_t __attribute__((export_name("TS_ChannelInfo_get_announcement_message"))) TS_ChannelInfo_get_announcement_message(uint64_t this_ptr) {
56360 LDKChannelInfo this_ptr_conv;
56361 this_ptr_conv.inner = untag_ptr(this_ptr);
56362 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56364 this_ptr_conv.is_owned = false;
56365 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
56366 uint64_t ret_ref = 0;
56367 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56368 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56372 void __attribute__((export_name("TS_ChannelInfo_set_announcement_message"))) TS_ChannelInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
56373 LDKChannelInfo this_ptr_conv;
56374 this_ptr_conv.inner = untag_ptr(this_ptr);
56375 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56377 this_ptr_conv.is_owned = false;
56378 LDKChannelAnnouncement val_conv;
56379 val_conv.inner = untag_ptr(val);
56380 val_conv.is_owned = ptr_is_owned(val);
56381 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56382 val_conv = ChannelAnnouncement_clone(&val_conv);
56383 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
56386 static inline uint64_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
56387 LDKChannelInfo ret_var = ChannelInfo_clone(arg);
56388 uint64_t ret_ref = 0;
56389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56393 int64_t __attribute__((export_name("TS_ChannelInfo_clone_ptr"))) TS_ChannelInfo_clone_ptr(uint64_t arg) {
56394 LDKChannelInfo arg_conv;
56395 arg_conv.inner = untag_ptr(arg);
56396 arg_conv.is_owned = ptr_is_owned(arg);
56397 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
56398 arg_conv.is_owned = false;
56399 int64_t ret_conv = ChannelInfo_clone_ptr(&arg_conv);
56403 uint64_t __attribute__((export_name("TS_ChannelInfo_clone"))) TS_ChannelInfo_clone(uint64_t orig) {
56404 LDKChannelInfo orig_conv;
56405 orig_conv.inner = untag_ptr(orig);
56406 orig_conv.is_owned = ptr_is_owned(orig);
56407 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
56408 orig_conv.is_owned = false;
56409 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
56410 uint64_t ret_ref = 0;
56411 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56412 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56416 jboolean __attribute__((export_name("TS_ChannelInfo_eq"))) TS_ChannelInfo_eq(uint64_t a, uint64_t b) {
56417 LDKChannelInfo a_conv;
56418 a_conv.inner = untag_ptr(a);
56419 a_conv.is_owned = ptr_is_owned(a);
56420 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
56421 a_conv.is_owned = false;
56422 LDKChannelInfo b_conv;
56423 b_conv.inner = untag_ptr(b);
56424 b_conv.is_owned = ptr_is_owned(b);
56425 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
56426 b_conv.is_owned = false;
56427 jboolean ret_conv = ChannelInfo_eq(&a_conv, &b_conv);
56431 uint64_t __attribute__((export_name("TS_ChannelInfo_get_directional_info"))) TS_ChannelInfo_get_directional_info(uint64_t this_arg, int8_t channel_flags) {
56432 LDKChannelInfo this_arg_conv;
56433 this_arg_conv.inner = untag_ptr(this_arg);
56434 this_arg_conv.is_owned = ptr_is_owned(this_arg);
56435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
56436 this_arg_conv.is_owned = false;
56437 LDKChannelUpdateInfo ret_var = ChannelInfo_get_directional_info(&this_arg_conv, channel_flags);
56438 uint64_t ret_ref = 0;
56439 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56440 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56444 int8_tArray __attribute__((export_name("TS_ChannelInfo_write"))) TS_ChannelInfo_write(uint64_t obj) {
56445 LDKChannelInfo obj_conv;
56446 obj_conv.inner = untag_ptr(obj);
56447 obj_conv.is_owned = ptr_is_owned(obj);
56448 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
56449 obj_conv.is_owned = false;
56450 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
56451 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
56452 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
56453 CVec_u8Z_free(ret_var);
56457 uint64_t __attribute__((export_name("TS_ChannelInfo_read"))) TS_ChannelInfo_read(int8_tArray ser) {
56458 LDKu8slice ser_ref;
56459 ser_ref.datalen = ser->arr_len;
56460 ser_ref.data = ser->elems;
56461 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
56462 *ret_conv = ChannelInfo_read(ser_ref);
56464 return tag_ptr(ret_conv, true);
56467 void __attribute__((export_name("TS_DirectedChannelInfo_free"))) TS_DirectedChannelInfo_free(uint64_t this_obj) {
56468 LDKDirectedChannelInfo this_obj_conv;
56469 this_obj_conv.inner = untag_ptr(this_obj);
56470 this_obj_conv.is_owned = ptr_is_owned(this_obj);
56471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
56472 DirectedChannelInfo_free(this_obj_conv);
56475 static inline uint64_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg) {
56476 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(arg);
56477 uint64_t ret_ref = 0;
56478 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56479 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56482 int64_t __attribute__((export_name("TS_DirectedChannelInfo_clone_ptr"))) TS_DirectedChannelInfo_clone_ptr(uint64_t arg) {
56483 LDKDirectedChannelInfo arg_conv;
56484 arg_conv.inner = untag_ptr(arg);
56485 arg_conv.is_owned = ptr_is_owned(arg);
56486 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
56487 arg_conv.is_owned = false;
56488 int64_t ret_conv = DirectedChannelInfo_clone_ptr(&arg_conv);
56492 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_clone"))) TS_DirectedChannelInfo_clone(uint64_t orig) {
56493 LDKDirectedChannelInfo orig_conv;
56494 orig_conv.inner = untag_ptr(orig);
56495 orig_conv.is_owned = ptr_is_owned(orig);
56496 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
56497 orig_conv.is_owned = false;
56498 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(&orig_conv);
56499 uint64_t ret_ref = 0;
56500 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56501 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56505 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_channel"))) TS_DirectedChannelInfo_channel(uint64_t this_arg) {
56506 LDKDirectedChannelInfo this_arg_conv;
56507 this_arg_conv.inner = untag_ptr(this_arg);
56508 this_arg_conv.is_owned = ptr_is_owned(this_arg);
56509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
56510 this_arg_conv.is_owned = false;
56511 LDKChannelInfo ret_var = DirectedChannelInfo_channel(&this_arg_conv);
56512 uint64_t ret_ref = 0;
56513 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56514 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56518 int64_t __attribute__((export_name("TS_DirectedChannelInfo_htlc_maximum_msat"))) TS_DirectedChannelInfo_htlc_maximum_msat(uint64_t this_arg) {
56519 LDKDirectedChannelInfo this_arg_conv;
56520 this_arg_conv.inner = untag_ptr(this_arg);
56521 this_arg_conv.is_owned = ptr_is_owned(this_arg);
56522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
56523 this_arg_conv.is_owned = false;
56524 int64_t ret_conv = DirectedChannelInfo_htlc_maximum_msat(&this_arg_conv);
56528 uint64_t __attribute__((export_name("TS_DirectedChannelInfo_effective_capacity"))) TS_DirectedChannelInfo_effective_capacity(uint64_t this_arg) {
56529 LDKDirectedChannelInfo this_arg_conv;
56530 this_arg_conv.inner = untag_ptr(this_arg);
56531 this_arg_conv.is_owned = ptr_is_owned(this_arg);
56532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
56533 this_arg_conv.is_owned = false;
56534 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56535 *ret_copy = DirectedChannelInfo_effective_capacity(&this_arg_conv);
56536 uint64_t ret_ref = tag_ptr(ret_copy, true);
56540 void __attribute__((export_name("TS_EffectiveCapacity_free"))) TS_EffectiveCapacity_free(uint64_t this_ptr) {
56541 if (!ptr_is_owned(this_ptr)) return;
56542 void* this_ptr_ptr = untag_ptr(this_ptr);
56543 CHECK_ACCESS(this_ptr_ptr);
56544 LDKEffectiveCapacity this_ptr_conv = *(LDKEffectiveCapacity*)(this_ptr_ptr);
56545 FREE(untag_ptr(this_ptr));
56546 EffectiveCapacity_free(this_ptr_conv);
56549 static inline uint64_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg) {
56550 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56551 *ret_copy = EffectiveCapacity_clone(arg);
56552 uint64_t ret_ref = tag_ptr(ret_copy, true);
56555 int64_t __attribute__((export_name("TS_EffectiveCapacity_clone_ptr"))) TS_EffectiveCapacity_clone_ptr(uint64_t arg) {
56556 LDKEffectiveCapacity* arg_conv = (LDKEffectiveCapacity*)untag_ptr(arg);
56557 int64_t ret_conv = EffectiveCapacity_clone_ptr(arg_conv);
56561 uint64_t __attribute__((export_name("TS_EffectiveCapacity_clone"))) TS_EffectiveCapacity_clone(uint64_t orig) {
56562 LDKEffectiveCapacity* orig_conv = (LDKEffectiveCapacity*)untag_ptr(orig);
56563 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56564 *ret_copy = EffectiveCapacity_clone(orig_conv);
56565 uint64_t ret_ref = tag_ptr(ret_copy, true);
56569 uint64_t __attribute__((export_name("TS_EffectiveCapacity_exact_liquidity"))) TS_EffectiveCapacity_exact_liquidity(int64_t liquidity_msat) {
56570 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56571 *ret_copy = EffectiveCapacity_exact_liquidity(liquidity_msat);
56572 uint64_t ret_ref = tag_ptr(ret_copy, true);
56576 uint64_t __attribute__((export_name("TS_EffectiveCapacity_advertised_max_htlc"))) TS_EffectiveCapacity_advertised_max_htlc(int64_t amount_msat) {
56577 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56578 *ret_copy = EffectiveCapacity_advertised_max_htlc(amount_msat);
56579 uint64_t ret_ref = tag_ptr(ret_copy, true);
56583 uint64_t __attribute__((export_name("TS_EffectiveCapacity_total"))) TS_EffectiveCapacity_total(int64_t capacity_msat, int64_t htlc_maximum_msat) {
56584 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56585 *ret_copy = EffectiveCapacity_total(capacity_msat, htlc_maximum_msat);
56586 uint64_t ret_ref = tag_ptr(ret_copy, true);
56590 uint64_t __attribute__((export_name("TS_EffectiveCapacity_infinite"))) TS_EffectiveCapacity_infinite() {
56591 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56592 *ret_copy = EffectiveCapacity_infinite();
56593 uint64_t ret_ref = tag_ptr(ret_copy, true);
56597 uint64_t __attribute__((export_name("TS_EffectiveCapacity_hint_max_htlc"))) TS_EffectiveCapacity_hint_max_htlc(int64_t amount_msat) {
56598 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56599 *ret_copy = EffectiveCapacity_hint_max_htlc(amount_msat);
56600 uint64_t ret_ref = tag_ptr(ret_copy, true);
56604 uint64_t __attribute__((export_name("TS_EffectiveCapacity_unknown"))) TS_EffectiveCapacity_unknown() {
56605 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
56606 *ret_copy = EffectiveCapacity_unknown();
56607 uint64_t ret_ref = tag_ptr(ret_copy, true);
56611 int64_t __attribute__((export_name("TS_EffectiveCapacity_as_msat"))) TS_EffectiveCapacity_as_msat(uint64_t this_arg) {
56612 LDKEffectiveCapacity* this_arg_conv = (LDKEffectiveCapacity*)untag_ptr(this_arg);
56613 int64_t ret_conv = EffectiveCapacity_as_msat(this_arg_conv);
56617 void __attribute__((export_name("TS_RoutingFees_free"))) TS_RoutingFees_free(uint64_t this_obj) {
56618 LDKRoutingFees this_obj_conv;
56619 this_obj_conv.inner = untag_ptr(this_obj);
56620 this_obj_conv.is_owned = ptr_is_owned(this_obj);
56621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
56622 RoutingFees_free(this_obj_conv);
56625 int32_t __attribute__((export_name("TS_RoutingFees_get_base_msat"))) TS_RoutingFees_get_base_msat(uint64_t this_ptr) {
56626 LDKRoutingFees this_ptr_conv;
56627 this_ptr_conv.inner = untag_ptr(this_ptr);
56628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56630 this_ptr_conv.is_owned = false;
56631 int32_t ret_conv = RoutingFees_get_base_msat(&this_ptr_conv);
56635 void __attribute__((export_name("TS_RoutingFees_set_base_msat"))) TS_RoutingFees_set_base_msat(uint64_t this_ptr, int32_t val) {
56636 LDKRoutingFees this_ptr_conv;
56637 this_ptr_conv.inner = untag_ptr(this_ptr);
56638 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56640 this_ptr_conv.is_owned = false;
56641 RoutingFees_set_base_msat(&this_ptr_conv, val);
56644 int32_t __attribute__((export_name("TS_RoutingFees_get_proportional_millionths"))) TS_RoutingFees_get_proportional_millionths(uint64_t this_ptr) {
56645 LDKRoutingFees this_ptr_conv;
56646 this_ptr_conv.inner = untag_ptr(this_ptr);
56647 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56649 this_ptr_conv.is_owned = false;
56650 int32_t ret_conv = RoutingFees_get_proportional_millionths(&this_ptr_conv);
56654 void __attribute__((export_name("TS_RoutingFees_set_proportional_millionths"))) TS_RoutingFees_set_proportional_millionths(uint64_t this_ptr, int32_t val) {
56655 LDKRoutingFees this_ptr_conv;
56656 this_ptr_conv.inner = untag_ptr(this_ptr);
56657 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56658 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56659 this_ptr_conv.is_owned = false;
56660 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
56663 uint64_t __attribute__((export_name("TS_RoutingFees_new"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
56664 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
56665 uint64_t ret_ref = 0;
56666 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56667 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56671 jboolean __attribute__((export_name("TS_RoutingFees_eq"))) TS_RoutingFees_eq(uint64_t a, uint64_t b) {
56672 LDKRoutingFees a_conv;
56673 a_conv.inner = untag_ptr(a);
56674 a_conv.is_owned = ptr_is_owned(a);
56675 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
56676 a_conv.is_owned = false;
56677 LDKRoutingFees b_conv;
56678 b_conv.inner = untag_ptr(b);
56679 b_conv.is_owned = ptr_is_owned(b);
56680 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
56681 b_conv.is_owned = false;
56682 jboolean ret_conv = RoutingFees_eq(&a_conv, &b_conv);
56686 static inline uint64_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
56687 LDKRoutingFees ret_var = RoutingFees_clone(arg);
56688 uint64_t ret_ref = 0;
56689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56690 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56693 int64_t __attribute__((export_name("TS_RoutingFees_clone_ptr"))) TS_RoutingFees_clone_ptr(uint64_t arg) {
56694 LDKRoutingFees arg_conv;
56695 arg_conv.inner = untag_ptr(arg);
56696 arg_conv.is_owned = ptr_is_owned(arg);
56697 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
56698 arg_conv.is_owned = false;
56699 int64_t ret_conv = RoutingFees_clone_ptr(&arg_conv);
56703 uint64_t __attribute__((export_name("TS_RoutingFees_clone"))) TS_RoutingFees_clone(uint64_t orig) {
56704 LDKRoutingFees orig_conv;
56705 orig_conv.inner = untag_ptr(orig);
56706 orig_conv.is_owned = ptr_is_owned(orig);
56707 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
56708 orig_conv.is_owned = false;
56709 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
56710 uint64_t ret_ref = 0;
56711 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56712 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56716 int64_t __attribute__((export_name("TS_RoutingFees_hash"))) TS_RoutingFees_hash(uint64_t o) {
56717 LDKRoutingFees o_conv;
56718 o_conv.inner = untag_ptr(o);
56719 o_conv.is_owned = ptr_is_owned(o);
56720 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
56721 o_conv.is_owned = false;
56722 int64_t ret_conv = RoutingFees_hash(&o_conv);
56726 int8_tArray __attribute__((export_name("TS_RoutingFees_write"))) TS_RoutingFees_write(uint64_t obj) {
56727 LDKRoutingFees obj_conv;
56728 obj_conv.inner = untag_ptr(obj);
56729 obj_conv.is_owned = ptr_is_owned(obj);
56730 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
56731 obj_conv.is_owned = false;
56732 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
56733 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
56734 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
56735 CVec_u8Z_free(ret_var);
56739 uint64_t __attribute__((export_name("TS_RoutingFees_read"))) TS_RoutingFees_read(int8_tArray ser) {
56740 LDKu8slice ser_ref;
56741 ser_ref.datalen = ser->arr_len;
56742 ser_ref.data = ser->elems;
56743 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
56744 *ret_conv = RoutingFees_read(ser_ref);
56746 return tag_ptr(ret_conv, true);
56749 void __attribute__((export_name("TS_NodeAnnouncementInfo_free"))) TS_NodeAnnouncementInfo_free(uint64_t this_obj) {
56750 LDKNodeAnnouncementInfo this_obj_conv;
56751 this_obj_conv.inner = untag_ptr(this_obj);
56752 this_obj_conv.is_owned = ptr_is_owned(this_obj);
56753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
56754 NodeAnnouncementInfo_free(this_obj_conv);
56757 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_features"))) TS_NodeAnnouncementInfo_get_features(uint64_t this_ptr) {
56758 LDKNodeAnnouncementInfo this_ptr_conv;
56759 this_ptr_conv.inner = untag_ptr(this_ptr);
56760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56762 this_ptr_conv.is_owned = false;
56763 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
56764 uint64_t ret_ref = 0;
56765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56766 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56770 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_features"))) TS_NodeAnnouncementInfo_set_features(uint64_t this_ptr, uint64_t val) {
56771 LDKNodeAnnouncementInfo this_ptr_conv;
56772 this_ptr_conv.inner = untag_ptr(this_ptr);
56773 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56775 this_ptr_conv.is_owned = false;
56776 LDKNodeFeatures val_conv;
56777 val_conv.inner = untag_ptr(val);
56778 val_conv.is_owned = ptr_is_owned(val);
56779 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56780 val_conv = NodeFeatures_clone(&val_conv);
56781 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
56784 int32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_last_update"))) TS_NodeAnnouncementInfo_get_last_update(uint64_t this_ptr) {
56785 LDKNodeAnnouncementInfo this_ptr_conv;
56786 this_ptr_conv.inner = untag_ptr(this_ptr);
56787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56789 this_ptr_conv.is_owned = false;
56790 int32_t ret_conv = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
56794 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_last_update"))) TS_NodeAnnouncementInfo_set_last_update(uint64_t this_ptr, int32_t val) {
56795 LDKNodeAnnouncementInfo this_ptr_conv;
56796 this_ptr_conv.inner = untag_ptr(this_ptr);
56797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56799 this_ptr_conv.is_owned = false;
56800 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
56803 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_rgb"))) TS_NodeAnnouncementInfo_get_rgb(uint64_t this_ptr) {
56804 LDKNodeAnnouncementInfo this_ptr_conv;
56805 this_ptr_conv.inner = untag_ptr(this_ptr);
56806 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56808 this_ptr_conv.is_owned = false;
56809 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
56810 memcpy(ret_arr->elems, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
56814 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_rgb"))) TS_NodeAnnouncementInfo_set_rgb(uint64_t this_ptr, int8_tArray val) {
56815 LDKNodeAnnouncementInfo this_ptr_conv;
56816 this_ptr_conv.inner = untag_ptr(this_ptr);
56817 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56818 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56819 this_ptr_conv.is_owned = false;
56820 LDKThreeBytes val_ref;
56821 CHECK(val->arr_len == 3);
56822 memcpy(val_ref.data, val->elems, 3); FREE(val);
56823 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
56826 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_alias"))) TS_NodeAnnouncementInfo_get_alias(uint64_t this_ptr) {
56827 LDKNodeAnnouncementInfo this_ptr_conv;
56828 this_ptr_conv.inner = untag_ptr(this_ptr);
56829 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56831 this_ptr_conv.is_owned = false;
56832 LDKNodeAlias ret_var = NodeAnnouncementInfo_get_alias(&this_ptr_conv);
56833 uint64_t ret_ref = 0;
56834 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56835 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56839 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_alias"))) TS_NodeAnnouncementInfo_set_alias(uint64_t this_ptr, uint64_t val) {
56840 LDKNodeAnnouncementInfo this_ptr_conv;
56841 this_ptr_conv.inner = untag_ptr(this_ptr);
56842 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56844 this_ptr_conv.is_owned = false;
56845 LDKNodeAlias val_conv;
56846 val_conv.inner = untag_ptr(val);
56847 val_conv.is_owned = ptr_is_owned(val);
56848 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56849 val_conv = NodeAlias_clone(&val_conv);
56850 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_conv);
56853 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_announcement_message"))) TS_NodeAnnouncementInfo_get_announcement_message(uint64_t this_ptr) {
56854 LDKNodeAnnouncementInfo this_ptr_conv;
56855 this_ptr_conv.inner = untag_ptr(this_ptr);
56856 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56858 this_ptr_conv.is_owned = false;
56859 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
56860 uint64_t ret_ref = 0;
56861 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56862 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56866 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_announcement_message"))) TS_NodeAnnouncementInfo_set_announcement_message(uint64_t this_ptr, uint64_t val) {
56867 LDKNodeAnnouncementInfo this_ptr_conv;
56868 this_ptr_conv.inner = untag_ptr(this_ptr);
56869 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
56870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
56871 this_ptr_conv.is_owned = false;
56872 LDKNodeAnnouncement val_conv;
56873 val_conv.inner = untag_ptr(val);
56874 val_conv.is_owned = ptr_is_owned(val);
56875 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
56876 val_conv = NodeAnnouncement_clone(&val_conv);
56877 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
56880 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) {
56881 LDKNodeFeatures features_arg_conv;
56882 features_arg_conv.inner = untag_ptr(features_arg);
56883 features_arg_conv.is_owned = ptr_is_owned(features_arg);
56884 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
56885 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
56886 LDKThreeBytes rgb_arg_ref;
56887 CHECK(rgb_arg->arr_len == 3);
56888 memcpy(rgb_arg_ref.data, rgb_arg->elems, 3); FREE(rgb_arg);
56889 LDKNodeAlias alias_arg_conv;
56890 alias_arg_conv.inner = untag_ptr(alias_arg);
56891 alias_arg_conv.is_owned = ptr_is_owned(alias_arg);
56892 CHECK_INNER_FIELD_ACCESS_OR_NULL(alias_arg_conv);
56893 alias_arg_conv = NodeAlias_clone(&alias_arg_conv);
56894 LDKNodeAnnouncement announcement_message_arg_conv;
56895 announcement_message_arg_conv.inner = untag_ptr(announcement_message_arg);
56896 announcement_message_arg_conv.is_owned = ptr_is_owned(announcement_message_arg);
56897 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
56898 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
56899 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_conv, announcement_message_arg_conv);
56900 uint64_t ret_ref = 0;
56901 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56902 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56906 static inline uint64_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
56907 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
56908 uint64_t ret_ref = 0;
56909 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56910 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56913 int64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone_ptr"))) TS_NodeAnnouncementInfo_clone_ptr(uint64_t arg) {
56914 LDKNodeAnnouncementInfo arg_conv;
56915 arg_conv.inner = untag_ptr(arg);
56916 arg_conv.is_owned = ptr_is_owned(arg);
56917 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
56918 arg_conv.is_owned = false;
56919 int64_t ret_conv = NodeAnnouncementInfo_clone_ptr(&arg_conv);
56923 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone"))) TS_NodeAnnouncementInfo_clone(uint64_t orig) {
56924 LDKNodeAnnouncementInfo orig_conv;
56925 orig_conv.inner = untag_ptr(orig);
56926 orig_conv.is_owned = ptr_is_owned(orig);
56927 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
56928 orig_conv.is_owned = false;
56929 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
56930 uint64_t ret_ref = 0;
56931 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
56932 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
56936 jboolean __attribute__((export_name("TS_NodeAnnouncementInfo_eq"))) TS_NodeAnnouncementInfo_eq(uint64_t a, uint64_t b) {
56937 LDKNodeAnnouncementInfo a_conv;
56938 a_conv.inner = untag_ptr(a);
56939 a_conv.is_owned = ptr_is_owned(a);
56940 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
56941 a_conv.is_owned = false;
56942 LDKNodeAnnouncementInfo b_conv;
56943 b_conv.inner = untag_ptr(b);
56944 b_conv.is_owned = ptr_is_owned(b);
56945 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
56946 b_conv.is_owned = false;
56947 jboolean ret_conv = NodeAnnouncementInfo_eq(&a_conv, &b_conv);
56951 uint64_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_addresses"))) TS_NodeAnnouncementInfo_addresses(uint64_t this_arg) {
56952 LDKNodeAnnouncementInfo this_arg_conv;
56953 this_arg_conv.inner = untag_ptr(this_arg);
56954 this_arg_conv.is_owned = ptr_is_owned(this_arg);
56955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
56956 this_arg_conv.is_owned = false;
56957 LDKCVec_SocketAddressZ ret_var = NodeAnnouncementInfo_addresses(&this_arg_conv);
56958 uint64_tArray ret_arr = NULL;
56959 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
56960 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
56961 for (size_t p = 0; p < ret_var.datalen; p++) {
56962 LDKSocketAddress *ret_conv_15_copy = MALLOC(sizeof(LDKSocketAddress), "LDKSocketAddress");
56963 *ret_conv_15_copy = ret_var.data[p];
56964 uint64_t ret_conv_15_ref = tag_ptr(ret_conv_15_copy, true);
56965 ret_arr_ptr[p] = ret_conv_15_ref;
56968 FREE(ret_var.data);
56972 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_write"))) TS_NodeAnnouncementInfo_write(uint64_t obj) {
56973 LDKNodeAnnouncementInfo obj_conv;
56974 obj_conv.inner = untag_ptr(obj);
56975 obj_conv.is_owned = ptr_is_owned(obj);
56976 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
56977 obj_conv.is_owned = false;
56978 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
56979 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
56980 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
56981 CVec_u8Z_free(ret_var);
56985 uint64_t __attribute__((export_name("TS_NodeAnnouncementInfo_read"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
56986 LDKu8slice ser_ref;
56987 ser_ref.datalen = ser->arr_len;
56988 ser_ref.data = ser->elems;
56989 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
56990 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
56992 return tag_ptr(ret_conv, true);
56995 void __attribute__((export_name("TS_NodeAlias_free"))) TS_NodeAlias_free(uint64_t this_obj) {
56996 LDKNodeAlias this_obj_conv;
56997 this_obj_conv.inner = untag_ptr(this_obj);
56998 this_obj_conv.is_owned = ptr_is_owned(this_obj);
56999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57000 NodeAlias_free(this_obj_conv);
57003 int8_tArray __attribute__((export_name("TS_NodeAlias_get_a"))) TS_NodeAlias_get_a(uint64_t this_ptr) {
57004 LDKNodeAlias this_ptr_conv;
57005 this_ptr_conv.inner = untag_ptr(this_ptr);
57006 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57008 this_ptr_conv.is_owned = false;
57009 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
57010 memcpy(ret_arr->elems, *NodeAlias_get_a(&this_ptr_conv), 32);
57014 void __attribute__((export_name("TS_NodeAlias_set_a"))) TS_NodeAlias_set_a(uint64_t this_ptr, int8_tArray val) {
57015 LDKNodeAlias this_ptr_conv;
57016 this_ptr_conv.inner = untag_ptr(this_ptr);
57017 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57018 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57019 this_ptr_conv.is_owned = false;
57020 LDKThirtyTwoBytes val_ref;
57021 CHECK(val->arr_len == 32);
57022 memcpy(val_ref.data, val->elems, 32); FREE(val);
57023 NodeAlias_set_a(&this_ptr_conv, val_ref);
57026 uint64_t __attribute__((export_name("TS_NodeAlias_new"))) TS_NodeAlias_new(int8_tArray a_arg) {
57027 LDKThirtyTwoBytes a_arg_ref;
57028 CHECK(a_arg->arr_len == 32);
57029 memcpy(a_arg_ref.data, a_arg->elems, 32); FREE(a_arg);
57030 LDKNodeAlias ret_var = NodeAlias_new(a_arg_ref);
57031 uint64_t ret_ref = 0;
57032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57033 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57037 static inline uint64_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg) {
57038 LDKNodeAlias ret_var = NodeAlias_clone(arg);
57039 uint64_t ret_ref = 0;
57040 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57041 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57044 int64_t __attribute__((export_name("TS_NodeAlias_clone_ptr"))) TS_NodeAlias_clone_ptr(uint64_t arg) {
57045 LDKNodeAlias arg_conv;
57046 arg_conv.inner = untag_ptr(arg);
57047 arg_conv.is_owned = ptr_is_owned(arg);
57048 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
57049 arg_conv.is_owned = false;
57050 int64_t ret_conv = NodeAlias_clone_ptr(&arg_conv);
57054 uint64_t __attribute__((export_name("TS_NodeAlias_clone"))) TS_NodeAlias_clone(uint64_t orig) {
57055 LDKNodeAlias orig_conv;
57056 orig_conv.inner = untag_ptr(orig);
57057 orig_conv.is_owned = ptr_is_owned(orig);
57058 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
57059 orig_conv.is_owned = false;
57060 LDKNodeAlias ret_var = NodeAlias_clone(&orig_conv);
57061 uint64_t ret_ref = 0;
57062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57063 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57067 jboolean __attribute__((export_name("TS_NodeAlias_eq"))) TS_NodeAlias_eq(uint64_t a, uint64_t b) {
57068 LDKNodeAlias a_conv;
57069 a_conv.inner = untag_ptr(a);
57070 a_conv.is_owned = ptr_is_owned(a);
57071 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
57072 a_conv.is_owned = false;
57073 LDKNodeAlias b_conv;
57074 b_conv.inner = untag_ptr(b);
57075 b_conv.is_owned = ptr_is_owned(b);
57076 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
57077 b_conv.is_owned = false;
57078 jboolean ret_conv = NodeAlias_eq(&a_conv, &b_conv);
57082 int8_tArray __attribute__((export_name("TS_NodeAlias_write"))) TS_NodeAlias_write(uint64_t obj) {
57083 LDKNodeAlias obj_conv;
57084 obj_conv.inner = untag_ptr(obj);
57085 obj_conv.is_owned = ptr_is_owned(obj);
57086 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
57087 obj_conv.is_owned = false;
57088 LDKCVec_u8Z ret_var = NodeAlias_write(&obj_conv);
57089 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
57090 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
57091 CVec_u8Z_free(ret_var);
57095 uint64_t __attribute__((export_name("TS_NodeAlias_read"))) TS_NodeAlias_read(int8_tArray ser) {
57096 LDKu8slice ser_ref;
57097 ser_ref.datalen = ser->arr_len;
57098 ser_ref.data = ser->elems;
57099 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
57100 *ret_conv = NodeAlias_read(ser_ref);
57102 return tag_ptr(ret_conv, true);
57105 void __attribute__((export_name("TS_NodeInfo_free"))) TS_NodeInfo_free(uint64_t this_obj) {
57106 LDKNodeInfo this_obj_conv;
57107 this_obj_conv.inner = untag_ptr(this_obj);
57108 this_obj_conv.is_owned = ptr_is_owned(this_obj);
57109 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57110 NodeInfo_free(this_obj_conv);
57113 int64_tArray __attribute__((export_name("TS_NodeInfo_get_channels"))) TS_NodeInfo_get_channels(uint64_t this_ptr) {
57114 LDKNodeInfo this_ptr_conv;
57115 this_ptr_conv.inner = untag_ptr(this_ptr);
57116 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57118 this_ptr_conv.is_owned = false;
57119 LDKCVec_u64Z ret_var = NodeInfo_get_channels(&this_ptr_conv);
57120 int64_tArray ret_arr = NULL;
57121 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
57122 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
57123 for (size_t i = 0; i < ret_var.datalen; i++) {
57124 int64_t ret_conv_8_conv = ret_var.data[i];
57125 ret_arr_ptr[i] = ret_conv_8_conv;
57128 FREE(ret_var.data);
57132 void __attribute__((export_name("TS_NodeInfo_set_channels"))) TS_NodeInfo_set_channels(uint64_t this_ptr, int64_tArray val) {
57133 LDKNodeInfo this_ptr_conv;
57134 this_ptr_conv.inner = untag_ptr(this_ptr);
57135 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57137 this_ptr_conv.is_owned = false;
57138 LDKCVec_u64Z val_constr;
57139 val_constr.datalen = val->arr_len;
57140 if (val_constr.datalen > 0)
57141 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
57143 val_constr.data = NULL;
57144 int64_t* val_vals = val->elems;
57145 for (size_t i = 0; i < val_constr.datalen; i++) {
57146 int64_t val_conv_8 = val_vals[i];
57147 val_constr.data[i] = val_conv_8;
57150 NodeInfo_set_channels(&this_ptr_conv, val_constr);
57153 uint64_t __attribute__((export_name("TS_NodeInfo_get_announcement_info"))) TS_NodeInfo_get_announcement_info(uint64_t this_ptr) {
57154 LDKNodeInfo this_ptr_conv;
57155 this_ptr_conv.inner = untag_ptr(this_ptr);
57156 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57158 this_ptr_conv.is_owned = false;
57159 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
57160 uint64_t ret_ref = 0;
57161 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57162 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57166 void __attribute__((export_name("TS_NodeInfo_set_announcement_info"))) TS_NodeInfo_set_announcement_info(uint64_t this_ptr, uint64_t val) {
57167 LDKNodeInfo this_ptr_conv;
57168 this_ptr_conv.inner = untag_ptr(this_ptr);
57169 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57170 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57171 this_ptr_conv.is_owned = false;
57172 LDKNodeAnnouncementInfo val_conv;
57173 val_conv.inner = untag_ptr(val);
57174 val_conv.is_owned = ptr_is_owned(val);
57175 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
57176 val_conv = NodeAnnouncementInfo_clone(&val_conv);
57177 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
57180 uint64_t __attribute__((export_name("TS_NodeInfo_new"))) TS_NodeInfo_new(int64_tArray channels_arg, uint64_t announcement_info_arg) {
57181 LDKCVec_u64Z channels_arg_constr;
57182 channels_arg_constr.datalen = channels_arg->arr_len;
57183 if (channels_arg_constr.datalen > 0)
57184 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
57186 channels_arg_constr.data = NULL;
57187 int64_t* channels_arg_vals = channels_arg->elems;
57188 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
57189 int64_t channels_arg_conv_8 = channels_arg_vals[i];
57190 channels_arg_constr.data[i] = channels_arg_conv_8;
57192 FREE(channels_arg);
57193 LDKNodeAnnouncementInfo announcement_info_arg_conv;
57194 announcement_info_arg_conv.inner = untag_ptr(announcement_info_arg);
57195 announcement_info_arg_conv.is_owned = ptr_is_owned(announcement_info_arg);
57196 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
57197 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
57198 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, announcement_info_arg_conv);
57199 uint64_t ret_ref = 0;
57200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57201 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57205 static inline uint64_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
57206 LDKNodeInfo ret_var = NodeInfo_clone(arg);
57207 uint64_t ret_ref = 0;
57208 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57209 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57212 int64_t __attribute__((export_name("TS_NodeInfo_clone_ptr"))) TS_NodeInfo_clone_ptr(uint64_t arg) {
57213 LDKNodeInfo arg_conv;
57214 arg_conv.inner = untag_ptr(arg);
57215 arg_conv.is_owned = ptr_is_owned(arg);
57216 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
57217 arg_conv.is_owned = false;
57218 int64_t ret_conv = NodeInfo_clone_ptr(&arg_conv);
57222 uint64_t __attribute__((export_name("TS_NodeInfo_clone"))) TS_NodeInfo_clone(uint64_t orig) {
57223 LDKNodeInfo orig_conv;
57224 orig_conv.inner = untag_ptr(orig);
57225 orig_conv.is_owned = ptr_is_owned(orig);
57226 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
57227 orig_conv.is_owned = false;
57228 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
57229 uint64_t ret_ref = 0;
57230 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57231 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57235 jboolean __attribute__((export_name("TS_NodeInfo_eq"))) TS_NodeInfo_eq(uint64_t a, uint64_t b) {
57236 LDKNodeInfo a_conv;
57237 a_conv.inner = untag_ptr(a);
57238 a_conv.is_owned = ptr_is_owned(a);
57239 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
57240 a_conv.is_owned = false;
57241 LDKNodeInfo b_conv;
57242 b_conv.inner = untag_ptr(b);
57243 b_conv.is_owned = ptr_is_owned(b);
57244 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
57245 b_conv.is_owned = false;
57246 jboolean ret_conv = NodeInfo_eq(&a_conv, &b_conv);
57250 int8_tArray __attribute__((export_name("TS_NodeInfo_write"))) TS_NodeInfo_write(uint64_t obj) {
57251 LDKNodeInfo obj_conv;
57252 obj_conv.inner = untag_ptr(obj);
57253 obj_conv.is_owned = ptr_is_owned(obj);
57254 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
57255 obj_conv.is_owned = false;
57256 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
57257 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
57258 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
57259 CVec_u8Z_free(ret_var);
57263 uint64_t __attribute__((export_name("TS_NodeInfo_read"))) TS_NodeInfo_read(int8_tArray ser) {
57264 LDKu8slice ser_ref;
57265 ser_ref.datalen = ser->arr_len;
57266 ser_ref.data = ser->elems;
57267 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
57268 *ret_conv = NodeInfo_read(ser_ref);
57270 return tag_ptr(ret_conv, true);
57273 int8_tArray __attribute__((export_name("TS_NetworkGraph_write"))) TS_NetworkGraph_write(uint64_t obj) {
57274 LDKNetworkGraph obj_conv;
57275 obj_conv.inner = untag_ptr(obj);
57276 obj_conv.is_owned = ptr_is_owned(obj);
57277 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
57278 obj_conv.is_owned = false;
57279 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
57280 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
57281 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
57282 CVec_u8Z_free(ret_var);
57286 uint64_t __attribute__((export_name("TS_NetworkGraph_read"))) TS_NetworkGraph_read(int8_tArray ser, uint64_t arg) {
57287 LDKu8slice ser_ref;
57288 ser_ref.datalen = ser->arr_len;
57289 ser_ref.data = ser->elems;
57290 void* arg_ptr = untag_ptr(arg);
57291 CHECK_ACCESS(arg_ptr);
57292 LDKLogger arg_conv = *(LDKLogger*)(arg_ptr);
57293 if (arg_conv.free == LDKLogger_JCalls_free) {
57294 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57295 LDKLogger_JCalls_cloned(&arg_conv);
57297 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
57298 *ret_conv = NetworkGraph_read(ser_ref, arg_conv);
57300 return tag_ptr(ret_conv, true);
57303 uint64_t __attribute__((export_name("TS_NetworkGraph_new"))) TS_NetworkGraph_new(uint32_t network, uint64_t logger) {
57304 LDKNetwork network_conv = LDKNetwork_from_js(network);
57305 void* logger_ptr = untag_ptr(logger);
57306 CHECK_ACCESS(logger_ptr);
57307 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
57308 if (logger_conv.free == LDKLogger_JCalls_free) {
57309 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57310 LDKLogger_JCalls_cloned(&logger_conv);
57312 LDKNetworkGraph ret_var = NetworkGraph_new(network_conv, logger_conv);
57313 uint64_t ret_ref = 0;
57314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57315 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57319 uint64_t __attribute__((export_name("TS_NetworkGraph_read_only"))) TS_NetworkGraph_read_only(uint64_t this_arg) {
57320 LDKNetworkGraph this_arg_conv;
57321 this_arg_conv.inner = untag_ptr(this_arg);
57322 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57324 this_arg_conv.is_owned = false;
57325 LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
57326 uint64_t ret_ref = 0;
57327 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57328 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57332 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) {
57333 LDKNetworkGraph this_arg_conv;
57334 this_arg_conv.inner = untag_ptr(this_arg);
57335 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57337 this_arg_conv.is_owned = false;
57338 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
57339 *ret_copy = NetworkGraph_get_last_rapid_gossip_sync_timestamp(&this_arg_conv);
57340 uint64_t ret_ref = tag_ptr(ret_copy, true);
57344 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) {
57345 LDKNetworkGraph this_arg_conv;
57346 this_arg_conv.inner = untag_ptr(this_arg);
57347 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57348 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57349 this_arg_conv.is_owned = false;
57350 NetworkGraph_set_last_rapid_gossip_sync_timestamp(&this_arg_conv, last_rapid_gossip_sync_timestamp);
57353 uint64_t __attribute__((export_name("TS_NetworkGraph_update_node_from_announcement"))) TS_NetworkGraph_update_node_from_announcement(uint64_t this_arg, uint64_t msg) {
57354 LDKNetworkGraph this_arg_conv;
57355 this_arg_conv.inner = untag_ptr(this_arg);
57356 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57357 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57358 this_arg_conv.is_owned = false;
57359 LDKNodeAnnouncement msg_conv;
57360 msg_conv.inner = untag_ptr(msg);
57361 msg_conv.is_owned = ptr_is_owned(msg);
57362 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57363 msg_conv.is_owned = false;
57364 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57365 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
57366 return tag_ptr(ret_conv, true);
57369 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) {
57370 LDKNetworkGraph this_arg_conv;
57371 this_arg_conv.inner = untag_ptr(this_arg);
57372 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57374 this_arg_conv.is_owned = false;
57375 LDKUnsignedNodeAnnouncement msg_conv;
57376 msg_conv.inner = untag_ptr(msg);
57377 msg_conv.is_owned = ptr_is_owned(msg);
57378 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57379 msg_conv.is_owned = false;
57380 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57381 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
57382 return tag_ptr(ret_conv, true);
57385 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) {
57386 LDKNetworkGraph this_arg_conv;
57387 this_arg_conv.inner = untag_ptr(this_arg);
57388 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57390 this_arg_conv.is_owned = false;
57391 LDKChannelAnnouncement msg_conv;
57392 msg_conv.inner = untag_ptr(msg);
57393 msg_conv.is_owned = ptr_is_owned(msg);
57394 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57395 msg_conv.is_owned = false;
57396 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
57397 CHECK_ACCESS(utxo_lookup_ptr);
57398 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
57399 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
57400 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
57401 // Manually implement clone for Java trait instances
57402 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
57403 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57404 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
57407 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57408 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
57409 return tag_ptr(ret_conv, true);
57412 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_from_announcement_no_lookup"))) TS_NetworkGraph_update_channel_from_announcement_no_lookup(uint64_t this_arg, uint64_t msg) {
57413 LDKNetworkGraph this_arg_conv;
57414 this_arg_conv.inner = untag_ptr(this_arg);
57415 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57417 this_arg_conv.is_owned = false;
57418 LDKChannelAnnouncement msg_conv;
57419 msg_conv.inner = untag_ptr(msg);
57420 msg_conv.is_owned = ptr_is_owned(msg);
57421 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57422 msg_conv.is_owned = false;
57423 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57424 *ret_conv = NetworkGraph_update_channel_from_announcement_no_lookup(&this_arg_conv, &msg_conv);
57425 return tag_ptr(ret_conv, true);
57428 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) {
57429 LDKNetworkGraph this_arg_conv;
57430 this_arg_conv.inner = untag_ptr(this_arg);
57431 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57433 this_arg_conv.is_owned = false;
57434 LDKUnsignedChannelAnnouncement msg_conv;
57435 msg_conv.inner = untag_ptr(msg);
57436 msg_conv.is_owned = ptr_is_owned(msg);
57437 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57438 msg_conv.is_owned = false;
57439 void* utxo_lookup_ptr = untag_ptr(utxo_lookup);
57440 CHECK_ACCESS(utxo_lookup_ptr);
57441 LDKCOption_UtxoLookupZ utxo_lookup_conv = *(LDKCOption_UtxoLookupZ*)(utxo_lookup_ptr);
57442 // WARNING: we may need a move here but no clone is available for LDKCOption_UtxoLookupZ
57443 if (utxo_lookup_conv.tag == LDKCOption_UtxoLookupZ_Some) {
57444 // Manually implement clone for Java trait instances
57445 if (utxo_lookup_conv.some.free == LDKUtxoLookup_JCalls_free) {
57446 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57447 LDKUtxoLookup_JCalls_cloned(&utxo_lookup_conv.some);
57450 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57451 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, utxo_lookup_conv);
57452 return tag_ptr(ret_conv, true);
57455 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) {
57456 LDKNetworkGraph this_arg_conv;
57457 this_arg_conv.inner = untag_ptr(this_arg);
57458 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57460 this_arg_conv.is_owned = false;
57461 LDKChannelFeatures features_conv;
57462 features_conv.inner = untag_ptr(features);
57463 features_conv.is_owned = ptr_is_owned(features);
57464 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
57465 features_conv = ChannelFeatures_clone(&features_conv);
57466 LDKPublicKey node_id_1_ref;
57467 CHECK(node_id_1->arr_len == 33);
57468 memcpy(node_id_1_ref.compressed_form, node_id_1->elems, 33); FREE(node_id_1);
57469 LDKPublicKey node_id_2_ref;
57470 CHECK(node_id_2->arr_len == 33);
57471 memcpy(node_id_2_ref.compressed_form, node_id_2->elems, 33); FREE(node_id_2);
57472 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57473 *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);
57474 return tag_ptr(ret_conv, true);
57477 void __attribute__((export_name("TS_NetworkGraph_channel_failed_permanent"))) TS_NetworkGraph_channel_failed_permanent(uint64_t this_arg, int64_t short_channel_id) {
57478 LDKNetworkGraph this_arg_conv;
57479 this_arg_conv.inner = untag_ptr(this_arg);
57480 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57481 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57482 this_arg_conv.is_owned = false;
57483 NetworkGraph_channel_failed_permanent(&this_arg_conv, short_channel_id);
57486 void __attribute__((export_name("TS_NetworkGraph_node_failed_permanent"))) TS_NetworkGraph_node_failed_permanent(uint64_t this_arg, int8_tArray node_id) {
57487 LDKNetworkGraph this_arg_conv;
57488 this_arg_conv.inner = untag_ptr(this_arg);
57489 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57490 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57491 this_arg_conv.is_owned = false;
57492 LDKPublicKey node_id_ref;
57493 CHECK(node_id->arr_len == 33);
57494 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
57495 NetworkGraph_node_failed_permanent(&this_arg_conv, node_id_ref);
57498 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) {
57499 LDKNetworkGraph this_arg_conv;
57500 this_arg_conv.inner = untag_ptr(this_arg);
57501 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57503 this_arg_conv.is_owned = false;
57504 NetworkGraph_remove_stale_channels_and_tracking_with_time(&this_arg_conv, current_time_unix);
57507 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel"))) TS_NetworkGraph_update_channel(uint64_t this_arg, uint64_t msg) {
57508 LDKNetworkGraph this_arg_conv;
57509 this_arg_conv.inner = untag_ptr(this_arg);
57510 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57512 this_arg_conv.is_owned = false;
57513 LDKChannelUpdate msg_conv;
57514 msg_conv.inner = untag_ptr(msg);
57515 msg_conv.is_owned = ptr_is_owned(msg);
57516 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57517 msg_conv.is_owned = false;
57518 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57519 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
57520 return tag_ptr(ret_conv, true);
57523 uint64_t __attribute__((export_name("TS_NetworkGraph_update_channel_unsigned"))) TS_NetworkGraph_update_channel_unsigned(uint64_t this_arg, uint64_t msg) {
57524 LDKNetworkGraph this_arg_conv;
57525 this_arg_conv.inner = untag_ptr(this_arg);
57526 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57528 this_arg_conv.is_owned = false;
57529 LDKUnsignedChannelUpdate msg_conv;
57530 msg_conv.inner = untag_ptr(msg);
57531 msg_conv.is_owned = ptr_is_owned(msg);
57532 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
57533 msg_conv.is_owned = false;
57534 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
57535 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
57536 return tag_ptr(ret_conv, true);
57539 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_channel"))) TS_ReadOnlyNetworkGraph_channel(uint64_t this_arg, int64_t short_channel_id) {
57540 LDKReadOnlyNetworkGraph this_arg_conv;
57541 this_arg_conv.inner = untag_ptr(this_arg);
57542 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57543 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57544 this_arg_conv.is_owned = false;
57545 LDKChannelInfo ret_var = ReadOnlyNetworkGraph_channel(&this_arg_conv, short_channel_id);
57546 uint64_t ret_ref = 0;
57547 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57548 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57552 int64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_channels"))) TS_ReadOnlyNetworkGraph_list_channels(uint64_t this_arg) {
57553 LDKReadOnlyNetworkGraph this_arg_conv;
57554 this_arg_conv.inner = untag_ptr(this_arg);
57555 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57557 this_arg_conv.is_owned = false;
57558 LDKCVec_u64Z ret_var = ReadOnlyNetworkGraph_list_channels(&this_arg_conv);
57559 int64_tArray ret_arr = NULL;
57560 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
57561 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
57562 for (size_t i = 0; i < ret_var.datalen; i++) {
57563 int64_t ret_conv_8_conv = ret_var.data[i];
57564 ret_arr_ptr[i] = ret_conv_8_conv;
57567 FREE(ret_var.data);
57571 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_node"))) TS_ReadOnlyNetworkGraph_node(uint64_t this_arg, uint64_t node_id) {
57572 LDKReadOnlyNetworkGraph this_arg_conv;
57573 this_arg_conv.inner = untag_ptr(this_arg);
57574 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57576 this_arg_conv.is_owned = false;
57577 LDKNodeId node_id_conv;
57578 node_id_conv.inner = untag_ptr(node_id);
57579 node_id_conv.is_owned = ptr_is_owned(node_id);
57580 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
57581 node_id_conv.is_owned = false;
57582 LDKNodeInfo ret_var = ReadOnlyNetworkGraph_node(&this_arg_conv, &node_id_conv);
57583 uint64_t ret_ref = 0;
57584 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57585 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57589 uint64_tArray __attribute__((export_name("TS_ReadOnlyNetworkGraph_list_nodes"))) TS_ReadOnlyNetworkGraph_list_nodes(uint64_t this_arg) {
57590 LDKReadOnlyNetworkGraph this_arg_conv;
57591 this_arg_conv.inner = untag_ptr(this_arg);
57592 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57594 this_arg_conv.is_owned = false;
57595 LDKCVec_NodeIdZ ret_var = ReadOnlyNetworkGraph_list_nodes(&this_arg_conv);
57596 uint64_tArray ret_arr = NULL;
57597 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
57598 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
57599 for (size_t i = 0; i < ret_var.datalen; i++) {
57600 LDKNodeId ret_conv_8_var = ret_var.data[i];
57601 uint64_t ret_conv_8_ref = 0;
57602 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_8_var);
57603 ret_conv_8_ref = tag_ptr(ret_conv_8_var.inner, ret_conv_8_var.is_owned);
57604 ret_arr_ptr[i] = ret_conv_8_ref;
57607 FREE(ret_var.data);
57611 uint64_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_get_addresses"))) TS_ReadOnlyNetworkGraph_get_addresses(uint64_t this_arg, int8_tArray pubkey) {
57612 LDKReadOnlyNetworkGraph this_arg_conv;
57613 this_arg_conv.inner = untag_ptr(this_arg);
57614 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57615 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57616 this_arg_conv.is_owned = false;
57617 LDKPublicKey pubkey_ref;
57618 CHECK(pubkey->arr_len == 33);
57619 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
57620 LDKCOption_CVec_SocketAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_SocketAddressZZ), "LDKCOption_CVec_SocketAddressZZ");
57621 *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref);
57622 uint64_t ret_ref = tag_ptr(ret_copy, true);
57626 void __attribute__((export_name("TS_DefaultRouter_free"))) TS_DefaultRouter_free(uint64_t this_obj) {
57627 LDKDefaultRouter this_obj_conv;
57628 this_obj_conv.inner = untag_ptr(this_obj);
57629 this_obj_conv.is_owned = ptr_is_owned(this_obj);
57630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57631 DefaultRouter_free(this_obj_conv);
57634 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, uint64_t score_params) {
57635 LDKNetworkGraph network_graph_conv;
57636 network_graph_conv.inner = untag_ptr(network_graph);
57637 network_graph_conv.is_owned = ptr_is_owned(network_graph);
57638 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
57639 network_graph_conv.is_owned = false;
57640 void* logger_ptr = untag_ptr(logger);
57641 CHECK_ACCESS(logger_ptr);
57642 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
57643 if (logger_conv.free == LDKLogger_JCalls_free) {
57644 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57645 LDKLogger_JCalls_cloned(&logger_conv);
57647 LDKThirtyTwoBytes random_seed_bytes_ref;
57648 CHECK(random_seed_bytes->arr_len == 32);
57649 memcpy(random_seed_bytes_ref.data, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
57650 void* scorer_ptr = untag_ptr(scorer);
57651 CHECK_ACCESS(scorer_ptr);
57652 LDKLockableScore scorer_conv = *(LDKLockableScore*)(scorer_ptr);
57653 if (scorer_conv.free == LDKLockableScore_JCalls_free) {
57654 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57655 LDKLockableScore_JCalls_cloned(&scorer_conv);
57657 LDKProbabilisticScoringFeeParameters score_params_conv;
57658 score_params_conv.inner = untag_ptr(score_params);
57659 score_params_conv.is_owned = ptr_is_owned(score_params);
57660 CHECK_INNER_FIELD_ACCESS_OR_NULL(score_params_conv);
57661 score_params_conv = ProbabilisticScoringFeeParameters_clone(&score_params_conv);
57662 LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref, scorer_conv, score_params_conv);
57663 uint64_t ret_ref = 0;
57664 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57665 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57669 uint64_t __attribute__((export_name("TS_DefaultRouter_as_Router"))) TS_DefaultRouter_as_Router(uint64_t this_arg) {
57670 LDKDefaultRouter this_arg_conv;
57671 this_arg_conv.inner = untag_ptr(this_arg);
57672 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57674 this_arg_conv.is_owned = false;
57675 LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
57676 *ret_ret = DefaultRouter_as_Router(&this_arg_conv);
57677 return tag_ptr(ret_ret, true);
57680 void __attribute__((export_name("TS_Router_free"))) TS_Router_free(uint64_t this_ptr) {
57681 if (!ptr_is_owned(this_ptr)) return;
57682 void* this_ptr_ptr = untag_ptr(this_ptr);
57683 CHECK_ACCESS(this_ptr_ptr);
57684 LDKRouter this_ptr_conv = *(LDKRouter*)(this_ptr_ptr);
57685 FREE(untag_ptr(this_ptr));
57686 Router_free(this_ptr_conv);
57689 void __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_free"))) TS_ScorerAccountingForInFlightHtlcs_free(uint64_t this_obj) {
57690 LDKScorerAccountingForInFlightHtlcs this_obj_conv;
57691 this_obj_conv.inner = untag_ptr(this_obj);
57692 this_obj_conv.is_owned = ptr_is_owned(this_obj);
57693 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57694 ScorerAccountingForInFlightHtlcs_free(this_obj_conv);
57697 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_new"))) TS_ScorerAccountingForInFlightHtlcs_new(uint64_t scorer, uint64_t inflight_htlcs) {
57698 void* scorer_ptr = untag_ptr(scorer);
57699 CHECK_ACCESS(scorer_ptr);
57700 LDKScoreLookUp scorer_conv = *(LDKScoreLookUp*)(scorer_ptr);
57701 if (scorer_conv.free == LDKScoreLookUp_JCalls_free) {
57702 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
57703 LDKScoreLookUp_JCalls_cloned(&scorer_conv);
57705 LDKInFlightHtlcs inflight_htlcs_conv;
57706 inflight_htlcs_conv.inner = untag_ptr(inflight_htlcs);
57707 inflight_htlcs_conv.is_owned = ptr_is_owned(inflight_htlcs);
57708 CHECK_INNER_FIELD_ACCESS_OR_NULL(inflight_htlcs_conv);
57709 inflight_htlcs_conv.is_owned = false;
57710 LDKScorerAccountingForInFlightHtlcs ret_var = ScorerAccountingForInFlightHtlcs_new(scorer_conv, &inflight_htlcs_conv);
57711 uint64_t ret_ref = 0;
57712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57713 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57717 uint64_t __attribute__((export_name("TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp"))) TS_ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(uint64_t this_arg) {
57718 LDKScorerAccountingForInFlightHtlcs this_arg_conv;
57719 this_arg_conv.inner = untag_ptr(this_arg);
57720 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57722 this_arg_conv.is_owned = false;
57723 LDKScoreLookUp* ret_ret = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
57724 *ret_ret = ScorerAccountingForInFlightHtlcs_as_ScoreLookUp(&this_arg_conv);
57725 return tag_ptr(ret_ret, true);
57728 void __attribute__((export_name("TS_InFlightHtlcs_free"))) TS_InFlightHtlcs_free(uint64_t this_obj) {
57729 LDKInFlightHtlcs this_obj_conv;
57730 this_obj_conv.inner = untag_ptr(this_obj);
57731 this_obj_conv.is_owned = ptr_is_owned(this_obj);
57732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57733 InFlightHtlcs_free(this_obj_conv);
57736 static inline uint64_t InFlightHtlcs_clone_ptr(LDKInFlightHtlcs *NONNULL_PTR arg) {
57737 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(arg);
57738 uint64_t ret_ref = 0;
57739 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57740 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57743 int64_t __attribute__((export_name("TS_InFlightHtlcs_clone_ptr"))) TS_InFlightHtlcs_clone_ptr(uint64_t arg) {
57744 LDKInFlightHtlcs arg_conv;
57745 arg_conv.inner = untag_ptr(arg);
57746 arg_conv.is_owned = ptr_is_owned(arg);
57747 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
57748 arg_conv.is_owned = false;
57749 int64_t ret_conv = InFlightHtlcs_clone_ptr(&arg_conv);
57753 uint64_t __attribute__((export_name("TS_InFlightHtlcs_clone"))) TS_InFlightHtlcs_clone(uint64_t orig) {
57754 LDKInFlightHtlcs orig_conv;
57755 orig_conv.inner = untag_ptr(orig);
57756 orig_conv.is_owned = ptr_is_owned(orig);
57757 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
57758 orig_conv.is_owned = false;
57759 LDKInFlightHtlcs ret_var = InFlightHtlcs_clone(&orig_conv);
57760 uint64_t ret_ref = 0;
57761 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57762 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57766 uint64_t __attribute__((export_name("TS_InFlightHtlcs_new"))) TS_InFlightHtlcs_new() {
57767 LDKInFlightHtlcs ret_var = InFlightHtlcs_new();
57768 uint64_t ret_ref = 0;
57769 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57770 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57774 void __attribute__((export_name("TS_InFlightHtlcs_process_path"))) TS_InFlightHtlcs_process_path(uint64_t this_arg, uint64_t path, int8_tArray payer_node_id) {
57775 LDKInFlightHtlcs this_arg_conv;
57776 this_arg_conv.inner = untag_ptr(this_arg);
57777 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57778 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57779 this_arg_conv.is_owned = false;
57781 path_conv.inner = untag_ptr(path);
57782 path_conv.is_owned = ptr_is_owned(path);
57783 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
57784 path_conv.is_owned = false;
57785 LDKPublicKey payer_node_id_ref;
57786 CHECK(payer_node_id->arr_len == 33);
57787 memcpy(payer_node_id_ref.compressed_form, payer_node_id->elems, 33); FREE(payer_node_id);
57788 InFlightHtlcs_process_path(&this_arg_conv, &path_conv, payer_node_id_ref);
57791 void __attribute__((export_name("TS_InFlightHtlcs_add_inflight_htlc"))) TS_InFlightHtlcs_add_inflight_htlc(uint64_t this_arg, uint64_t source, uint64_t target, int64_t channel_scid, int64_t used_msat) {
57792 LDKInFlightHtlcs this_arg_conv;
57793 this_arg_conv.inner = untag_ptr(this_arg);
57794 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57795 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57796 this_arg_conv.is_owned = false;
57797 LDKNodeId source_conv;
57798 source_conv.inner = untag_ptr(source);
57799 source_conv.is_owned = ptr_is_owned(source);
57800 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
57801 source_conv.is_owned = false;
57802 LDKNodeId target_conv;
57803 target_conv.inner = untag_ptr(target);
57804 target_conv.is_owned = ptr_is_owned(target);
57805 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
57806 target_conv.is_owned = false;
57807 InFlightHtlcs_add_inflight_htlc(&this_arg_conv, &source_conv, &target_conv, channel_scid, used_msat);
57810 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) {
57811 LDKInFlightHtlcs this_arg_conv;
57812 this_arg_conv.inner = untag_ptr(this_arg);
57813 this_arg_conv.is_owned = ptr_is_owned(this_arg);
57814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
57815 this_arg_conv.is_owned = false;
57816 LDKNodeId source_conv;
57817 source_conv.inner = untag_ptr(source);
57818 source_conv.is_owned = ptr_is_owned(source);
57819 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
57820 source_conv.is_owned = false;
57821 LDKNodeId target_conv;
57822 target_conv.inner = untag_ptr(target);
57823 target_conv.is_owned = ptr_is_owned(target);
57824 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
57825 target_conv.is_owned = false;
57826 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
57827 *ret_copy = InFlightHtlcs_used_liquidity_msat(&this_arg_conv, &source_conv, &target_conv, channel_scid);
57828 uint64_t ret_ref = tag_ptr(ret_copy, true);
57832 int8_tArray __attribute__((export_name("TS_InFlightHtlcs_write"))) TS_InFlightHtlcs_write(uint64_t obj) {
57833 LDKInFlightHtlcs obj_conv;
57834 obj_conv.inner = untag_ptr(obj);
57835 obj_conv.is_owned = ptr_is_owned(obj);
57836 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
57837 obj_conv.is_owned = false;
57838 LDKCVec_u8Z ret_var = InFlightHtlcs_write(&obj_conv);
57839 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
57840 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
57841 CVec_u8Z_free(ret_var);
57845 uint64_t __attribute__((export_name("TS_InFlightHtlcs_read"))) TS_InFlightHtlcs_read(int8_tArray ser) {
57846 LDKu8slice ser_ref;
57847 ser_ref.datalen = ser->arr_len;
57848 ser_ref.data = ser->elems;
57849 LDKCResult_InFlightHtlcsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InFlightHtlcsDecodeErrorZ), "LDKCResult_InFlightHtlcsDecodeErrorZ");
57850 *ret_conv = InFlightHtlcs_read(ser_ref);
57852 return tag_ptr(ret_conv, true);
57855 void __attribute__((export_name("TS_RouteHop_free"))) TS_RouteHop_free(uint64_t this_obj) {
57856 LDKRouteHop this_obj_conv;
57857 this_obj_conv.inner = untag_ptr(this_obj);
57858 this_obj_conv.is_owned = ptr_is_owned(this_obj);
57859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
57860 RouteHop_free(this_obj_conv);
57863 int8_tArray __attribute__((export_name("TS_RouteHop_get_pubkey"))) TS_RouteHop_get_pubkey(uint64_t this_ptr) {
57864 LDKRouteHop this_ptr_conv;
57865 this_ptr_conv.inner = untag_ptr(this_ptr);
57866 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57868 this_ptr_conv.is_owned = false;
57869 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
57870 memcpy(ret_arr->elems, RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
57874 void __attribute__((export_name("TS_RouteHop_set_pubkey"))) TS_RouteHop_set_pubkey(uint64_t this_ptr, int8_tArray val) {
57875 LDKRouteHop this_ptr_conv;
57876 this_ptr_conv.inner = untag_ptr(this_ptr);
57877 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57879 this_ptr_conv.is_owned = false;
57880 LDKPublicKey val_ref;
57881 CHECK(val->arr_len == 33);
57882 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
57883 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
57886 uint64_t __attribute__((export_name("TS_RouteHop_get_node_features"))) TS_RouteHop_get_node_features(uint64_t this_ptr) {
57887 LDKRouteHop this_ptr_conv;
57888 this_ptr_conv.inner = untag_ptr(this_ptr);
57889 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57891 this_ptr_conv.is_owned = false;
57892 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
57893 uint64_t ret_ref = 0;
57894 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57895 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57899 void __attribute__((export_name("TS_RouteHop_set_node_features"))) TS_RouteHop_set_node_features(uint64_t this_ptr, uint64_t val) {
57900 LDKRouteHop this_ptr_conv;
57901 this_ptr_conv.inner = untag_ptr(this_ptr);
57902 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57904 this_ptr_conv.is_owned = false;
57905 LDKNodeFeatures val_conv;
57906 val_conv.inner = untag_ptr(val);
57907 val_conv.is_owned = ptr_is_owned(val);
57908 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
57909 val_conv = NodeFeatures_clone(&val_conv);
57910 RouteHop_set_node_features(&this_ptr_conv, val_conv);
57913 int64_t __attribute__((export_name("TS_RouteHop_get_short_channel_id"))) TS_RouteHop_get_short_channel_id(uint64_t this_ptr) {
57914 LDKRouteHop this_ptr_conv;
57915 this_ptr_conv.inner = untag_ptr(this_ptr);
57916 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57917 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57918 this_ptr_conv.is_owned = false;
57919 int64_t ret_conv = RouteHop_get_short_channel_id(&this_ptr_conv);
57923 void __attribute__((export_name("TS_RouteHop_set_short_channel_id"))) TS_RouteHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
57924 LDKRouteHop this_ptr_conv;
57925 this_ptr_conv.inner = untag_ptr(this_ptr);
57926 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57928 this_ptr_conv.is_owned = false;
57929 RouteHop_set_short_channel_id(&this_ptr_conv, val);
57932 uint64_t __attribute__((export_name("TS_RouteHop_get_channel_features"))) TS_RouteHop_get_channel_features(uint64_t this_ptr) {
57933 LDKRouteHop this_ptr_conv;
57934 this_ptr_conv.inner = untag_ptr(this_ptr);
57935 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57936 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57937 this_ptr_conv.is_owned = false;
57938 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
57939 uint64_t ret_ref = 0;
57940 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
57941 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
57945 void __attribute__((export_name("TS_RouteHop_set_channel_features"))) TS_RouteHop_set_channel_features(uint64_t this_ptr, uint64_t val) {
57946 LDKRouteHop this_ptr_conv;
57947 this_ptr_conv.inner = untag_ptr(this_ptr);
57948 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57950 this_ptr_conv.is_owned = false;
57951 LDKChannelFeatures val_conv;
57952 val_conv.inner = untag_ptr(val);
57953 val_conv.is_owned = ptr_is_owned(val);
57954 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
57955 val_conv = ChannelFeatures_clone(&val_conv);
57956 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
57959 int64_t __attribute__((export_name("TS_RouteHop_get_fee_msat"))) TS_RouteHop_get_fee_msat(uint64_t this_ptr) {
57960 LDKRouteHop this_ptr_conv;
57961 this_ptr_conv.inner = untag_ptr(this_ptr);
57962 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57963 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57964 this_ptr_conv.is_owned = false;
57965 int64_t ret_conv = RouteHop_get_fee_msat(&this_ptr_conv);
57969 void __attribute__((export_name("TS_RouteHop_set_fee_msat"))) TS_RouteHop_set_fee_msat(uint64_t this_ptr, int64_t val) {
57970 LDKRouteHop this_ptr_conv;
57971 this_ptr_conv.inner = untag_ptr(this_ptr);
57972 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57974 this_ptr_conv.is_owned = false;
57975 RouteHop_set_fee_msat(&this_ptr_conv, val);
57978 int32_t __attribute__((export_name("TS_RouteHop_get_cltv_expiry_delta"))) TS_RouteHop_get_cltv_expiry_delta(uint64_t this_ptr) {
57979 LDKRouteHop this_ptr_conv;
57980 this_ptr_conv.inner = untag_ptr(this_ptr);
57981 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57982 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57983 this_ptr_conv.is_owned = false;
57984 int32_t ret_conv = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
57988 void __attribute__((export_name("TS_RouteHop_set_cltv_expiry_delta"))) TS_RouteHop_set_cltv_expiry_delta(uint64_t this_ptr, int32_t val) {
57989 LDKRouteHop this_ptr_conv;
57990 this_ptr_conv.inner = untag_ptr(this_ptr);
57991 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
57992 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
57993 this_ptr_conv.is_owned = false;
57994 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
57997 jboolean __attribute__((export_name("TS_RouteHop_get_maybe_announced_channel"))) TS_RouteHop_get_maybe_announced_channel(uint64_t this_ptr) {
57998 LDKRouteHop this_ptr_conv;
57999 this_ptr_conv.inner = untag_ptr(this_ptr);
58000 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58002 this_ptr_conv.is_owned = false;
58003 jboolean ret_conv = RouteHop_get_maybe_announced_channel(&this_ptr_conv);
58007 void __attribute__((export_name("TS_RouteHop_set_maybe_announced_channel"))) TS_RouteHop_set_maybe_announced_channel(uint64_t this_ptr, jboolean val) {
58008 LDKRouteHop this_ptr_conv;
58009 this_ptr_conv.inner = untag_ptr(this_ptr);
58010 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58011 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58012 this_ptr_conv.is_owned = false;
58013 RouteHop_set_maybe_announced_channel(&this_ptr_conv, val);
58016 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, jboolean maybe_announced_channel_arg) {
58017 LDKPublicKey pubkey_arg_ref;
58018 CHECK(pubkey_arg->arr_len == 33);
58019 memcpy(pubkey_arg_ref.compressed_form, pubkey_arg->elems, 33); FREE(pubkey_arg);
58020 LDKNodeFeatures node_features_arg_conv;
58021 node_features_arg_conv.inner = untag_ptr(node_features_arg);
58022 node_features_arg_conv.is_owned = ptr_is_owned(node_features_arg);
58023 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
58024 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
58025 LDKChannelFeatures channel_features_arg_conv;
58026 channel_features_arg_conv.inner = untag_ptr(channel_features_arg);
58027 channel_features_arg_conv.is_owned = ptr_is_owned(channel_features_arg);
58028 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
58029 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
58030 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, maybe_announced_channel_arg);
58031 uint64_t ret_ref = 0;
58032 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58033 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58037 static inline uint64_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
58038 LDKRouteHop ret_var = RouteHop_clone(arg);
58039 uint64_t ret_ref = 0;
58040 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58041 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58044 int64_t __attribute__((export_name("TS_RouteHop_clone_ptr"))) TS_RouteHop_clone_ptr(uint64_t arg) {
58045 LDKRouteHop arg_conv;
58046 arg_conv.inner = untag_ptr(arg);
58047 arg_conv.is_owned = ptr_is_owned(arg);
58048 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
58049 arg_conv.is_owned = false;
58050 int64_t ret_conv = RouteHop_clone_ptr(&arg_conv);
58054 uint64_t __attribute__((export_name("TS_RouteHop_clone"))) TS_RouteHop_clone(uint64_t orig) {
58055 LDKRouteHop orig_conv;
58056 orig_conv.inner = untag_ptr(orig);
58057 orig_conv.is_owned = ptr_is_owned(orig);
58058 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
58059 orig_conv.is_owned = false;
58060 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
58061 uint64_t ret_ref = 0;
58062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58063 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58067 int64_t __attribute__((export_name("TS_RouteHop_hash"))) TS_RouteHop_hash(uint64_t o) {
58068 LDKRouteHop o_conv;
58069 o_conv.inner = untag_ptr(o);
58070 o_conv.is_owned = ptr_is_owned(o);
58071 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
58072 o_conv.is_owned = false;
58073 int64_t ret_conv = RouteHop_hash(&o_conv);
58077 jboolean __attribute__((export_name("TS_RouteHop_eq"))) TS_RouteHop_eq(uint64_t a, uint64_t b) {
58078 LDKRouteHop a_conv;
58079 a_conv.inner = untag_ptr(a);
58080 a_conv.is_owned = ptr_is_owned(a);
58081 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
58082 a_conv.is_owned = false;
58083 LDKRouteHop b_conv;
58084 b_conv.inner = untag_ptr(b);
58085 b_conv.is_owned = ptr_is_owned(b);
58086 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
58087 b_conv.is_owned = false;
58088 jboolean ret_conv = RouteHop_eq(&a_conv, &b_conv);
58092 int8_tArray __attribute__((export_name("TS_RouteHop_write"))) TS_RouteHop_write(uint64_t obj) {
58093 LDKRouteHop obj_conv;
58094 obj_conv.inner = untag_ptr(obj);
58095 obj_conv.is_owned = ptr_is_owned(obj);
58096 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
58097 obj_conv.is_owned = false;
58098 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
58099 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
58100 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
58101 CVec_u8Z_free(ret_var);
58105 uint64_t __attribute__((export_name("TS_RouteHop_read"))) TS_RouteHop_read(int8_tArray ser) {
58106 LDKu8slice ser_ref;
58107 ser_ref.datalen = ser->arr_len;
58108 ser_ref.data = ser->elems;
58109 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
58110 *ret_conv = RouteHop_read(ser_ref);
58112 return tag_ptr(ret_conv, true);
58115 void __attribute__((export_name("TS_BlindedTail_free"))) TS_BlindedTail_free(uint64_t this_obj) {
58116 LDKBlindedTail this_obj_conv;
58117 this_obj_conv.inner = untag_ptr(this_obj);
58118 this_obj_conv.is_owned = ptr_is_owned(this_obj);
58119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
58120 BlindedTail_free(this_obj_conv);
58123 uint64_tArray __attribute__((export_name("TS_BlindedTail_get_hops"))) TS_BlindedTail_get_hops(uint64_t this_ptr) {
58124 LDKBlindedTail this_ptr_conv;
58125 this_ptr_conv.inner = untag_ptr(this_ptr);
58126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58128 this_ptr_conv.is_owned = false;
58129 LDKCVec_BlindedHopZ ret_var = BlindedTail_get_hops(&this_ptr_conv);
58130 uint64_tArray ret_arr = NULL;
58131 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
58132 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
58133 for (size_t m = 0; m < ret_var.datalen; m++) {
58134 LDKBlindedHop ret_conv_12_var = ret_var.data[m];
58135 uint64_t ret_conv_12_ref = 0;
58136 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_var);
58137 ret_conv_12_ref = tag_ptr(ret_conv_12_var.inner, ret_conv_12_var.is_owned);
58138 ret_arr_ptr[m] = ret_conv_12_ref;
58141 FREE(ret_var.data);
58145 void __attribute__((export_name("TS_BlindedTail_set_hops"))) TS_BlindedTail_set_hops(uint64_t this_ptr, uint64_tArray val) {
58146 LDKBlindedTail this_ptr_conv;
58147 this_ptr_conv.inner = untag_ptr(this_ptr);
58148 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58149 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58150 this_ptr_conv.is_owned = false;
58151 LDKCVec_BlindedHopZ val_constr;
58152 val_constr.datalen = val->arr_len;
58153 if (val_constr.datalen > 0)
58154 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
58156 val_constr.data = NULL;
58157 uint64_t* val_vals = val->elems;
58158 for (size_t m = 0; m < val_constr.datalen; m++) {
58159 uint64_t val_conv_12 = val_vals[m];
58160 LDKBlindedHop val_conv_12_conv;
58161 val_conv_12_conv.inner = untag_ptr(val_conv_12);
58162 val_conv_12_conv.is_owned = ptr_is_owned(val_conv_12);
58163 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv);
58164 val_conv_12_conv = BlindedHop_clone(&val_conv_12_conv);
58165 val_constr.data[m] = val_conv_12_conv;
58168 BlindedTail_set_hops(&this_ptr_conv, val_constr);
58171 int8_tArray __attribute__((export_name("TS_BlindedTail_get_blinding_point"))) TS_BlindedTail_get_blinding_point(uint64_t this_ptr) {
58172 LDKBlindedTail this_ptr_conv;
58173 this_ptr_conv.inner = untag_ptr(this_ptr);
58174 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58176 this_ptr_conv.is_owned = false;
58177 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
58178 memcpy(ret_arr->elems, BlindedTail_get_blinding_point(&this_ptr_conv).compressed_form, 33);
58182 void __attribute__((export_name("TS_BlindedTail_set_blinding_point"))) TS_BlindedTail_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
58183 LDKBlindedTail this_ptr_conv;
58184 this_ptr_conv.inner = untag_ptr(this_ptr);
58185 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58186 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58187 this_ptr_conv.is_owned = false;
58188 LDKPublicKey val_ref;
58189 CHECK(val->arr_len == 33);
58190 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
58191 BlindedTail_set_blinding_point(&this_ptr_conv, val_ref);
58194 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) {
58195 LDKBlindedTail this_ptr_conv;
58196 this_ptr_conv.inner = untag_ptr(this_ptr);
58197 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58199 this_ptr_conv.is_owned = false;
58200 int32_t ret_conv = BlindedTail_get_excess_final_cltv_expiry_delta(&this_ptr_conv);
58204 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) {
58205 LDKBlindedTail this_ptr_conv;
58206 this_ptr_conv.inner = untag_ptr(this_ptr);
58207 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58209 this_ptr_conv.is_owned = false;
58210 BlindedTail_set_excess_final_cltv_expiry_delta(&this_ptr_conv, val);
58213 int64_t __attribute__((export_name("TS_BlindedTail_get_final_value_msat"))) TS_BlindedTail_get_final_value_msat(uint64_t this_ptr) {
58214 LDKBlindedTail this_ptr_conv;
58215 this_ptr_conv.inner = untag_ptr(this_ptr);
58216 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58218 this_ptr_conv.is_owned = false;
58219 int64_t ret_conv = BlindedTail_get_final_value_msat(&this_ptr_conv);
58223 void __attribute__((export_name("TS_BlindedTail_set_final_value_msat"))) TS_BlindedTail_set_final_value_msat(uint64_t this_ptr, int64_t val) {
58224 LDKBlindedTail this_ptr_conv;
58225 this_ptr_conv.inner = untag_ptr(this_ptr);
58226 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58228 this_ptr_conv.is_owned = false;
58229 BlindedTail_set_final_value_msat(&this_ptr_conv, val);
58232 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) {
58233 LDKCVec_BlindedHopZ hops_arg_constr;
58234 hops_arg_constr.datalen = hops_arg->arr_len;
58235 if (hops_arg_constr.datalen > 0)
58236 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
58238 hops_arg_constr.data = NULL;
58239 uint64_t* hops_arg_vals = hops_arg->elems;
58240 for (size_t m = 0; m < hops_arg_constr.datalen; m++) {
58241 uint64_t hops_arg_conv_12 = hops_arg_vals[m];
58242 LDKBlindedHop hops_arg_conv_12_conv;
58243 hops_arg_conv_12_conv.inner = untag_ptr(hops_arg_conv_12);
58244 hops_arg_conv_12_conv.is_owned = ptr_is_owned(hops_arg_conv_12);
58245 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_12_conv);
58246 hops_arg_conv_12_conv = BlindedHop_clone(&hops_arg_conv_12_conv);
58247 hops_arg_constr.data[m] = hops_arg_conv_12_conv;
58250 LDKPublicKey blinding_point_arg_ref;
58251 CHECK(blinding_point_arg->arr_len == 33);
58252 memcpy(blinding_point_arg_ref.compressed_form, blinding_point_arg->elems, 33); FREE(blinding_point_arg);
58253 LDKBlindedTail ret_var = BlindedTail_new(hops_arg_constr, blinding_point_arg_ref, excess_final_cltv_expiry_delta_arg, final_value_msat_arg);
58254 uint64_t ret_ref = 0;
58255 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58256 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58260 static inline uint64_t BlindedTail_clone_ptr(LDKBlindedTail *NONNULL_PTR arg) {
58261 LDKBlindedTail ret_var = BlindedTail_clone(arg);
58262 uint64_t ret_ref = 0;
58263 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58264 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58267 int64_t __attribute__((export_name("TS_BlindedTail_clone_ptr"))) TS_BlindedTail_clone_ptr(uint64_t arg) {
58268 LDKBlindedTail arg_conv;
58269 arg_conv.inner = untag_ptr(arg);
58270 arg_conv.is_owned = ptr_is_owned(arg);
58271 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
58272 arg_conv.is_owned = false;
58273 int64_t ret_conv = BlindedTail_clone_ptr(&arg_conv);
58277 uint64_t __attribute__((export_name("TS_BlindedTail_clone"))) TS_BlindedTail_clone(uint64_t orig) {
58278 LDKBlindedTail orig_conv;
58279 orig_conv.inner = untag_ptr(orig);
58280 orig_conv.is_owned = ptr_is_owned(orig);
58281 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
58282 orig_conv.is_owned = false;
58283 LDKBlindedTail ret_var = BlindedTail_clone(&orig_conv);
58284 uint64_t ret_ref = 0;
58285 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58286 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58290 int64_t __attribute__((export_name("TS_BlindedTail_hash"))) TS_BlindedTail_hash(uint64_t o) {
58291 LDKBlindedTail o_conv;
58292 o_conv.inner = untag_ptr(o);
58293 o_conv.is_owned = ptr_is_owned(o);
58294 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
58295 o_conv.is_owned = false;
58296 int64_t ret_conv = BlindedTail_hash(&o_conv);
58300 jboolean __attribute__((export_name("TS_BlindedTail_eq"))) TS_BlindedTail_eq(uint64_t a, uint64_t b) {
58301 LDKBlindedTail a_conv;
58302 a_conv.inner = untag_ptr(a);
58303 a_conv.is_owned = ptr_is_owned(a);
58304 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
58305 a_conv.is_owned = false;
58306 LDKBlindedTail b_conv;
58307 b_conv.inner = untag_ptr(b);
58308 b_conv.is_owned = ptr_is_owned(b);
58309 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
58310 b_conv.is_owned = false;
58311 jboolean ret_conv = BlindedTail_eq(&a_conv, &b_conv);
58315 int8_tArray __attribute__((export_name("TS_BlindedTail_write"))) TS_BlindedTail_write(uint64_t obj) {
58316 LDKBlindedTail obj_conv;
58317 obj_conv.inner = untag_ptr(obj);
58318 obj_conv.is_owned = ptr_is_owned(obj);
58319 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
58320 obj_conv.is_owned = false;
58321 LDKCVec_u8Z ret_var = BlindedTail_write(&obj_conv);
58322 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
58323 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
58324 CVec_u8Z_free(ret_var);
58328 uint64_t __attribute__((export_name("TS_BlindedTail_read"))) TS_BlindedTail_read(int8_tArray ser) {
58329 LDKu8slice ser_ref;
58330 ser_ref.datalen = ser->arr_len;
58331 ser_ref.data = ser->elems;
58332 LDKCResult_BlindedTailDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedTailDecodeErrorZ), "LDKCResult_BlindedTailDecodeErrorZ");
58333 *ret_conv = BlindedTail_read(ser_ref);
58335 return tag_ptr(ret_conv, true);
58338 void __attribute__((export_name("TS_Path_free"))) TS_Path_free(uint64_t this_obj) {
58339 LDKPath this_obj_conv;
58340 this_obj_conv.inner = untag_ptr(this_obj);
58341 this_obj_conv.is_owned = ptr_is_owned(this_obj);
58342 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
58343 Path_free(this_obj_conv);
58346 uint64_tArray __attribute__((export_name("TS_Path_get_hops"))) TS_Path_get_hops(uint64_t this_ptr) {
58347 LDKPath this_ptr_conv;
58348 this_ptr_conv.inner = untag_ptr(this_ptr);
58349 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58350 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58351 this_ptr_conv.is_owned = false;
58352 LDKCVec_RouteHopZ ret_var = Path_get_hops(&this_ptr_conv);
58353 uint64_tArray ret_arr = NULL;
58354 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
58355 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
58356 for (size_t k = 0; k < ret_var.datalen; k++) {
58357 LDKRouteHop ret_conv_10_var = ret_var.data[k];
58358 uint64_t ret_conv_10_ref = 0;
58359 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
58360 ret_conv_10_ref = tag_ptr(ret_conv_10_var.inner, ret_conv_10_var.is_owned);
58361 ret_arr_ptr[k] = ret_conv_10_ref;
58364 FREE(ret_var.data);
58368 void __attribute__((export_name("TS_Path_set_hops"))) TS_Path_set_hops(uint64_t this_ptr, uint64_tArray val) {
58369 LDKPath this_ptr_conv;
58370 this_ptr_conv.inner = untag_ptr(this_ptr);
58371 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58373 this_ptr_conv.is_owned = false;
58374 LDKCVec_RouteHopZ val_constr;
58375 val_constr.datalen = val->arr_len;
58376 if (val_constr.datalen > 0)
58377 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
58379 val_constr.data = NULL;
58380 uint64_t* val_vals = val->elems;
58381 for (size_t k = 0; k < val_constr.datalen; k++) {
58382 uint64_t val_conv_10 = val_vals[k];
58383 LDKRouteHop val_conv_10_conv;
58384 val_conv_10_conv.inner = untag_ptr(val_conv_10);
58385 val_conv_10_conv.is_owned = ptr_is_owned(val_conv_10);
58386 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_10_conv);
58387 val_conv_10_conv = RouteHop_clone(&val_conv_10_conv);
58388 val_constr.data[k] = val_conv_10_conv;
58391 Path_set_hops(&this_ptr_conv, val_constr);
58394 uint64_t __attribute__((export_name("TS_Path_get_blinded_tail"))) TS_Path_get_blinded_tail(uint64_t this_ptr) {
58395 LDKPath this_ptr_conv;
58396 this_ptr_conv.inner = untag_ptr(this_ptr);
58397 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58399 this_ptr_conv.is_owned = false;
58400 LDKBlindedTail ret_var = Path_get_blinded_tail(&this_ptr_conv);
58401 uint64_t ret_ref = 0;
58402 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58403 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58407 void __attribute__((export_name("TS_Path_set_blinded_tail"))) TS_Path_set_blinded_tail(uint64_t this_ptr, uint64_t val) {
58408 LDKPath this_ptr_conv;
58409 this_ptr_conv.inner = untag_ptr(this_ptr);
58410 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58412 this_ptr_conv.is_owned = false;
58413 LDKBlindedTail val_conv;
58414 val_conv.inner = untag_ptr(val);
58415 val_conv.is_owned = ptr_is_owned(val);
58416 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
58417 val_conv = BlindedTail_clone(&val_conv);
58418 Path_set_blinded_tail(&this_ptr_conv, val_conv);
58421 uint64_t __attribute__((export_name("TS_Path_new"))) TS_Path_new(uint64_tArray hops_arg, uint64_t blinded_tail_arg) {
58422 LDKCVec_RouteHopZ hops_arg_constr;
58423 hops_arg_constr.datalen = hops_arg->arr_len;
58424 if (hops_arg_constr.datalen > 0)
58425 hops_arg_constr.data = MALLOC(hops_arg_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
58427 hops_arg_constr.data = NULL;
58428 uint64_t* hops_arg_vals = hops_arg->elems;
58429 for (size_t k = 0; k < hops_arg_constr.datalen; k++) {
58430 uint64_t hops_arg_conv_10 = hops_arg_vals[k];
58431 LDKRouteHop hops_arg_conv_10_conv;
58432 hops_arg_conv_10_conv.inner = untag_ptr(hops_arg_conv_10);
58433 hops_arg_conv_10_conv.is_owned = ptr_is_owned(hops_arg_conv_10);
58434 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_arg_conv_10_conv);
58435 hops_arg_conv_10_conv = RouteHop_clone(&hops_arg_conv_10_conv);
58436 hops_arg_constr.data[k] = hops_arg_conv_10_conv;
58439 LDKBlindedTail blinded_tail_arg_conv;
58440 blinded_tail_arg_conv.inner = untag_ptr(blinded_tail_arg);
58441 blinded_tail_arg_conv.is_owned = ptr_is_owned(blinded_tail_arg);
58442 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_tail_arg_conv);
58443 blinded_tail_arg_conv = BlindedTail_clone(&blinded_tail_arg_conv);
58444 LDKPath ret_var = Path_new(hops_arg_constr, blinded_tail_arg_conv);
58445 uint64_t ret_ref = 0;
58446 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58447 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58451 static inline uint64_t Path_clone_ptr(LDKPath *NONNULL_PTR arg) {
58452 LDKPath ret_var = Path_clone(arg);
58453 uint64_t ret_ref = 0;
58454 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58455 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58458 int64_t __attribute__((export_name("TS_Path_clone_ptr"))) TS_Path_clone_ptr(uint64_t arg) {
58460 arg_conv.inner = untag_ptr(arg);
58461 arg_conv.is_owned = ptr_is_owned(arg);
58462 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
58463 arg_conv.is_owned = false;
58464 int64_t ret_conv = Path_clone_ptr(&arg_conv);
58468 uint64_t __attribute__((export_name("TS_Path_clone"))) TS_Path_clone(uint64_t orig) {
58470 orig_conv.inner = untag_ptr(orig);
58471 orig_conv.is_owned = ptr_is_owned(orig);
58472 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
58473 orig_conv.is_owned = false;
58474 LDKPath ret_var = Path_clone(&orig_conv);
58475 uint64_t ret_ref = 0;
58476 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58477 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58481 int64_t __attribute__((export_name("TS_Path_hash"))) TS_Path_hash(uint64_t o) {
58483 o_conv.inner = untag_ptr(o);
58484 o_conv.is_owned = ptr_is_owned(o);
58485 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
58486 o_conv.is_owned = false;
58487 int64_t ret_conv = Path_hash(&o_conv);
58491 jboolean __attribute__((export_name("TS_Path_eq"))) TS_Path_eq(uint64_t a, uint64_t b) {
58493 a_conv.inner = untag_ptr(a);
58494 a_conv.is_owned = ptr_is_owned(a);
58495 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
58496 a_conv.is_owned = false;
58498 b_conv.inner = untag_ptr(b);
58499 b_conv.is_owned = ptr_is_owned(b);
58500 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
58501 b_conv.is_owned = false;
58502 jboolean ret_conv = Path_eq(&a_conv, &b_conv);
58506 int64_t __attribute__((export_name("TS_Path_fee_msat"))) TS_Path_fee_msat(uint64_t this_arg) {
58507 LDKPath this_arg_conv;
58508 this_arg_conv.inner = untag_ptr(this_arg);
58509 this_arg_conv.is_owned = ptr_is_owned(this_arg);
58510 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
58511 this_arg_conv.is_owned = false;
58512 int64_t ret_conv = Path_fee_msat(&this_arg_conv);
58516 int64_t __attribute__((export_name("TS_Path_final_value_msat"))) TS_Path_final_value_msat(uint64_t this_arg) {
58517 LDKPath this_arg_conv;
58518 this_arg_conv.inner = untag_ptr(this_arg);
58519 this_arg_conv.is_owned = ptr_is_owned(this_arg);
58520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
58521 this_arg_conv.is_owned = false;
58522 int64_t ret_conv = Path_final_value_msat(&this_arg_conv);
58526 uint64_t __attribute__((export_name("TS_Path_final_cltv_expiry_delta"))) TS_Path_final_cltv_expiry_delta(uint64_t this_arg) {
58527 LDKPath this_arg_conv;
58528 this_arg_conv.inner = untag_ptr(this_arg);
58529 this_arg_conv.is_owned = ptr_is_owned(this_arg);
58530 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
58531 this_arg_conv.is_owned = false;
58532 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
58533 *ret_copy = Path_final_cltv_expiry_delta(&this_arg_conv);
58534 uint64_t ret_ref = tag_ptr(ret_copy, true);
58538 void __attribute__((export_name("TS_Route_free"))) TS_Route_free(uint64_t this_obj) {
58539 LDKRoute this_obj_conv;
58540 this_obj_conv.inner = untag_ptr(this_obj);
58541 this_obj_conv.is_owned = ptr_is_owned(this_obj);
58542 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
58543 Route_free(this_obj_conv);
58546 uint64_tArray __attribute__((export_name("TS_Route_get_paths"))) TS_Route_get_paths(uint64_t this_ptr) {
58547 LDKRoute this_ptr_conv;
58548 this_ptr_conv.inner = untag_ptr(this_ptr);
58549 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58550 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58551 this_ptr_conv.is_owned = false;
58552 LDKCVec_PathZ ret_var = Route_get_paths(&this_ptr_conv);
58553 uint64_tArray ret_arr = NULL;
58554 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
58555 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
58556 for (size_t g = 0; g < ret_var.datalen; g++) {
58557 LDKPath ret_conv_6_var = ret_var.data[g];
58558 uint64_t ret_conv_6_ref = 0;
58559 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_6_var);
58560 ret_conv_6_ref = tag_ptr(ret_conv_6_var.inner, ret_conv_6_var.is_owned);
58561 ret_arr_ptr[g] = ret_conv_6_ref;
58564 FREE(ret_var.data);
58568 void __attribute__((export_name("TS_Route_set_paths"))) TS_Route_set_paths(uint64_t this_ptr, uint64_tArray val) {
58569 LDKRoute this_ptr_conv;
58570 this_ptr_conv.inner = untag_ptr(this_ptr);
58571 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58573 this_ptr_conv.is_owned = false;
58574 LDKCVec_PathZ val_constr;
58575 val_constr.datalen = val->arr_len;
58576 if (val_constr.datalen > 0)
58577 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
58579 val_constr.data = NULL;
58580 uint64_t* val_vals = val->elems;
58581 for (size_t g = 0; g < val_constr.datalen; g++) {
58582 uint64_t val_conv_6 = val_vals[g];
58583 LDKPath val_conv_6_conv;
58584 val_conv_6_conv.inner = untag_ptr(val_conv_6);
58585 val_conv_6_conv.is_owned = ptr_is_owned(val_conv_6);
58586 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_6_conv);
58587 val_conv_6_conv = Path_clone(&val_conv_6_conv);
58588 val_constr.data[g] = val_conv_6_conv;
58591 Route_set_paths(&this_ptr_conv, val_constr);
58594 uint64_t __attribute__((export_name("TS_Route_get_route_params"))) TS_Route_get_route_params(uint64_t this_ptr) {
58595 LDKRoute this_ptr_conv;
58596 this_ptr_conv.inner = untag_ptr(this_ptr);
58597 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58599 this_ptr_conv.is_owned = false;
58600 LDKRouteParameters ret_var = Route_get_route_params(&this_ptr_conv);
58601 uint64_t ret_ref = 0;
58602 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58603 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58607 void __attribute__((export_name("TS_Route_set_route_params"))) TS_Route_set_route_params(uint64_t this_ptr, uint64_t val) {
58608 LDKRoute this_ptr_conv;
58609 this_ptr_conv.inner = untag_ptr(this_ptr);
58610 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58611 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58612 this_ptr_conv.is_owned = false;
58613 LDKRouteParameters val_conv;
58614 val_conv.inner = untag_ptr(val);
58615 val_conv.is_owned = ptr_is_owned(val);
58616 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
58617 val_conv = RouteParameters_clone(&val_conv);
58618 Route_set_route_params(&this_ptr_conv, val_conv);
58621 uint64_t __attribute__((export_name("TS_Route_new"))) TS_Route_new(uint64_tArray paths_arg, uint64_t route_params_arg) {
58622 LDKCVec_PathZ paths_arg_constr;
58623 paths_arg_constr.datalen = paths_arg->arr_len;
58624 if (paths_arg_constr.datalen > 0)
58625 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKPath), "LDKCVec_PathZ Elements");
58627 paths_arg_constr.data = NULL;
58628 uint64_t* paths_arg_vals = paths_arg->elems;
58629 for (size_t g = 0; g < paths_arg_constr.datalen; g++) {
58630 uint64_t paths_arg_conv_6 = paths_arg_vals[g];
58631 LDKPath paths_arg_conv_6_conv;
58632 paths_arg_conv_6_conv.inner = untag_ptr(paths_arg_conv_6);
58633 paths_arg_conv_6_conv.is_owned = ptr_is_owned(paths_arg_conv_6);
58634 CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_6_conv);
58635 paths_arg_conv_6_conv = Path_clone(&paths_arg_conv_6_conv);
58636 paths_arg_constr.data[g] = paths_arg_conv_6_conv;
58639 LDKRouteParameters route_params_arg_conv;
58640 route_params_arg_conv.inner = untag_ptr(route_params_arg);
58641 route_params_arg_conv.is_owned = ptr_is_owned(route_params_arg);
58642 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_arg_conv);
58643 route_params_arg_conv = RouteParameters_clone(&route_params_arg_conv);
58644 LDKRoute ret_var = Route_new(paths_arg_constr, route_params_arg_conv);
58645 uint64_t ret_ref = 0;
58646 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58647 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58651 static inline uint64_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
58652 LDKRoute ret_var = Route_clone(arg);
58653 uint64_t ret_ref = 0;
58654 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58655 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58658 int64_t __attribute__((export_name("TS_Route_clone_ptr"))) TS_Route_clone_ptr(uint64_t arg) {
58660 arg_conv.inner = untag_ptr(arg);
58661 arg_conv.is_owned = ptr_is_owned(arg);
58662 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
58663 arg_conv.is_owned = false;
58664 int64_t ret_conv = Route_clone_ptr(&arg_conv);
58668 uint64_t __attribute__((export_name("TS_Route_clone"))) TS_Route_clone(uint64_t orig) {
58669 LDKRoute orig_conv;
58670 orig_conv.inner = untag_ptr(orig);
58671 orig_conv.is_owned = ptr_is_owned(orig);
58672 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
58673 orig_conv.is_owned = false;
58674 LDKRoute ret_var = Route_clone(&orig_conv);
58675 uint64_t ret_ref = 0;
58676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58681 int64_t __attribute__((export_name("TS_Route_hash"))) TS_Route_hash(uint64_t o) {
58683 o_conv.inner = untag_ptr(o);
58684 o_conv.is_owned = ptr_is_owned(o);
58685 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
58686 o_conv.is_owned = false;
58687 int64_t ret_conv = Route_hash(&o_conv);
58691 jboolean __attribute__((export_name("TS_Route_eq"))) TS_Route_eq(uint64_t a, uint64_t b) {
58693 a_conv.inner = untag_ptr(a);
58694 a_conv.is_owned = ptr_is_owned(a);
58695 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
58696 a_conv.is_owned = false;
58698 b_conv.inner = untag_ptr(b);
58699 b_conv.is_owned = ptr_is_owned(b);
58700 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
58701 b_conv.is_owned = false;
58702 jboolean ret_conv = Route_eq(&a_conv, &b_conv);
58706 int64_t __attribute__((export_name("TS_Route_get_total_fees"))) TS_Route_get_total_fees(uint64_t this_arg) {
58707 LDKRoute this_arg_conv;
58708 this_arg_conv.inner = untag_ptr(this_arg);
58709 this_arg_conv.is_owned = ptr_is_owned(this_arg);
58710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
58711 this_arg_conv.is_owned = false;
58712 int64_t ret_conv = Route_get_total_fees(&this_arg_conv);
58716 int64_t __attribute__((export_name("TS_Route_get_total_amount"))) TS_Route_get_total_amount(uint64_t this_arg) {
58717 LDKRoute this_arg_conv;
58718 this_arg_conv.inner = untag_ptr(this_arg);
58719 this_arg_conv.is_owned = ptr_is_owned(this_arg);
58720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
58721 this_arg_conv.is_owned = false;
58722 int64_t ret_conv = Route_get_total_amount(&this_arg_conv);
58726 int8_tArray __attribute__((export_name("TS_Route_write"))) TS_Route_write(uint64_t obj) {
58728 obj_conv.inner = untag_ptr(obj);
58729 obj_conv.is_owned = ptr_is_owned(obj);
58730 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
58731 obj_conv.is_owned = false;
58732 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
58733 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
58734 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
58735 CVec_u8Z_free(ret_var);
58739 uint64_t __attribute__((export_name("TS_Route_read"))) TS_Route_read(int8_tArray ser) {
58740 LDKu8slice ser_ref;
58741 ser_ref.datalen = ser->arr_len;
58742 ser_ref.data = ser->elems;
58743 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
58744 *ret_conv = Route_read(ser_ref);
58746 return tag_ptr(ret_conv, true);
58749 void __attribute__((export_name("TS_RouteParameters_free"))) TS_RouteParameters_free(uint64_t this_obj) {
58750 LDKRouteParameters this_obj_conv;
58751 this_obj_conv.inner = untag_ptr(this_obj);
58752 this_obj_conv.is_owned = ptr_is_owned(this_obj);
58753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
58754 RouteParameters_free(this_obj_conv);
58757 uint64_t __attribute__((export_name("TS_RouteParameters_get_payment_params"))) TS_RouteParameters_get_payment_params(uint64_t this_ptr) {
58758 LDKRouteParameters this_ptr_conv;
58759 this_ptr_conv.inner = untag_ptr(this_ptr);
58760 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58761 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58762 this_ptr_conv.is_owned = false;
58763 LDKPaymentParameters ret_var = RouteParameters_get_payment_params(&this_ptr_conv);
58764 uint64_t ret_ref = 0;
58765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58766 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58770 void __attribute__((export_name("TS_RouteParameters_set_payment_params"))) TS_RouteParameters_set_payment_params(uint64_t this_ptr, uint64_t val) {
58771 LDKRouteParameters this_ptr_conv;
58772 this_ptr_conv.inner = untag_ptr(this_ptr);
58773 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58775 this_ptr_conv.is_owned = false;
58776 LDKPaymentParameters val_conv;
58777 val_conv.inner = untag_ptr(val);
58778 val_conv.is_owned = ptr_is_owned(val);
58779 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
58780 val_conv = PaymentParameters_clone(&val_conv);
58781 RouteParameters_set_payment_params(&this_ptr_conv, val_conv);
58784 int64_t __attribute__((export_name("TS_RouteParameters_get_final_value_msat"))) TS_RouteParameters_get_final_value_msat(uint64_t this_ptr) {
58785 LDKRouteParameters this_ptr_conv;
58786 this_ptr_conv.inner = untag_ptr(this_ptr);
58787 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58788 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58789 this_ptr_conv.is_owned = false;
58790 int64_t ret_conv = RouteParameters_get_final_value_msat(&this_ptr_conv);
58794 void __attribute__((export_name("TS_RouteParameters_set_final_value_msat"))) TS_RouteParameters_set_final_value_msat(uint64_t this_ptr, int64_t val) {
58795 LDKRouteParameters this_ptr_conv;
58796 this_ptr_conv.inner = untag_ptr(this_ptr);
58797 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58799 this_ptr_conv.is_owned = false;
58800 RouteParameters_set_final_value_msat(&this_ptr_conv, val);
58803 uint64_t __attribute__((export_name("TS_RouteParameters_get_max_total_routing_fee_msat"))) TS_RouteParameters_get_max_total_routing_fee_msat(uint64_t this_ptr) {
58804 LDKRouteParameters this_ptr_conv;
58805 this_ptr_conv.inner = untag_ptr(this_ptr);
58806 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58807 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58808 this_ptr_conv.is_owned = false;
58809 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
58810 *ret_copy = RouteParameters_get_max_total_routing_fee_msat(&this_ptr_conv);
58811 uint64_t ret_ref = tag_ptr(ret_copy, true);
58815 void __attribute__((export_name("TS_RouteParameters_set_max_total_routing_fee_msat"))) TS_RouteParameters_set_max_total_routing_fee_msat(uint64_t this_ptr, uint64_t val) {
58816 LDKRouteParameters this_ptr_conv;
58817 this_ptr_conv.inner = untag_ptr(this_ptr);
58818 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58820 this_ptr_conv.is_owned = false;
58821 void* val_ptr = untag_ptr(val);
58822 CHECK_ACCESS(val_ptr);
58823 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
58824 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
58825 RouteParameters_set_max_total_routing_fee_msat(&this_ptr_conv, val_conv);
58828 uint64_t __attribute__((export_name("TS_RouteParameters_new"))) TS_RouteParameters_new(uint64_t payment_params_arg, int64_t final_value_msat_arg, uint64_t max_total_routing_fee_msat_arg) {
58829 LDKPaymentParameters payment_params_arg_conv;
58830 payment_params_arg_conv.inner = untag_ptr(payment_params_arg);
58831 payment_params_arg_conv.is_owned = ptr_is_owned(payment_params_arg);
58832 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
58833 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
58834 void* max_total_routing_fee_msat_arg_ptr = untag_ptr(max_total_routing_fee_msat_arg);
58835 CHECK_ACCESS(max_total_routing_fee_msat_arg_ptr);
58836 LDKCOption_u64Z max_total_routing_fee_msat_arg_conv = *(LDKCOption_u64Z*)(max_total_routing_fee_msat_arg_ptr);
58837 max_total_routing_fee_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(max_total_routing_fee_msat_arg));
58838 LDKRouteParameters ret_var = RouteParameters_new(payment_params_arg_conv, final_value_msat_arg, max_total_routing_fee_msat_arg_conv);
58839 uint64_t ret_ref = 0;
58840 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58841 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58845 static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
58846 LDKRouteParameters ret_var = RouteParameters_clone(arg);
58847 uint64_t ret_ref = 0;
58848 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58849 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58852 int64_t __attribute__((export_name("TS_RouteParameters_clone_ptr"))) TS_RouteParameters_clone_ptr(uint64_t arg) {
58853 LDKRouteParameters arg_conv;
58854 arg_conv.inner = untag_ptr(arg);
58855 arg_conv.is_owned = ptr_is_owned(arg);
58856 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
58857 arg_conv.is_owned = false;
58858 int64_t ret_conv = RouteParameters_clone_ptr(&arg_conv);
58862 uint64_t __attribute__((export_name("TS_RouteParameters_clone"))) TS_RouteParameters_clone(uint64_t orig) {
58863 LDKRouteParameters orig_conv;
58864 orig_conv.inner = untag_ptr(orig);
58865 orig_conv.is_owned = ptr_is_owned(orig);
58866 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
58867 orig_conv.is_owned = false;
58868 LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
58869 uint64_t ret_ref = 0;
58870 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58871 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58875 int64_t __attribute__((export_name("TS_RouteParameters_hash"))) TS_RouteParameters_hash(uint64_t o) {
58876 LDKRouteParameters o_conv;
58877 o_conv.inner = untag_ptr(o);
58878 o_conv.is_owned = ptr_is_owned(o);
58879 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
58880 o_conv.is_owned = false;
58881 int64_t ret_conv = RouteParameters_hash(&o_conv);
58885 jboolean __attribute__((export_name("TS_RouteParameters_eq"))) TS_RouteParameters_eq(uint64_t a, uint64_t b) {
58886 LDKRouteParameters a_conv;
58887 a_conv.inner = untag_ptr(a);
58888 a_conv.is_owned = ptr_is_owned(a);
58889 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
58890 a_conv.is_owned = false;
58891 LDKRouteParameters b_conv;
58892 b_conv.inner = untag_ptr(b);
58893 b_conv.is_owned = ptr_is_owned(b);
58894 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
58895 b_conv.is_owned = false;
58896 jboolean ret_conv = RouteParameters_eq(&a_conv, &b_conv);
58900 uint64_t __attribute__((export_name("TS_RouteParameters_from_payment_params_and_value"))) TS_RouteParameters_from_payment_params_and_value(uint64_t payment_params, int64_t final_value_msat) {
58901 LDKPaymentParameters payment_params_conv;
58902 payment_params_conv.inner = untag_ptr(payment_params);
58903 payment_params_conv.is_owned = ptr_is_owned(payment_params);
58904 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_conv);
58905 payment_params_conv = PaymentParameters_clone(&payment_params_conv);
58906 LDKRouteParameters ret_var = RouteParameters_from_payment_params_and_value(payment_params_conv, final_value_msat);
58907 uint64_t ret_ref = 0;
58908 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
58909 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
58913 int8_tArray __attribute__((export_name("TS_RouteParameters_write"))) TS_RouteParameters_write(uint64_t obj) {
58914 LDKRouteParameters obj_conv;
58915 obj_conv.inner = untag_ptr(obj);
58916 obj_conv.is_owned = ptr_is_owned(obj);
58917 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
58918 obj_conv.is_owned = false;
58919 LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
58920 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
58921 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
58922 CVec_u8Z_free(ret_var);
58926 uint64_t __attribute__((export_name("TS_RouteParameters_read"))) TS_RouteParameters_read(int8_tArray ser) {
58927 LDKu8slice ser_ref;
58928 ser_ref.datalen = ser->arr_len;
58929 ser_ref.data = ser->elems;
58930 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
58931 *ret_conv = RouteParameters_read(ser_ref);
58933 return tag_ptr(ret_conv, true);
58936 void __attribute__((export_name("TS_PaymentParameters_free"))) TS_PaymentParameters_free(uint64_t this_obj) {
58937 LDKPaymentParameters this_obj_conv;
58938 this_obj_conv.inner = untag_ptr(this_obj);
58939 this_obj_conv.is_owned = ptr_is_owned(this_obj);
58940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
58941 PaymentParameters_free(this_obj_conv);
58944 uint64_t __attribute__((export_name("TS_PaymentParameters_get_payee"))) TS_PaymentParameters_get_payee(uint64_t this_ptr) {
58945 LDKPaymentParameters this_ptr_conv;
58946 this_ptr_conv.inner = untag_ptr(this_ptr);
58947 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58948 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58949 this_ptr_conv.is_owned = false;
58950 LDKPayee *ret_copy = MALLOC(sizeof(LDKPayee), "LDKPayee");
58951 *ret_copy = PaymentParameters_get_payee(&this_ptr_conv);
58952 uint64_t ret_ref = tag_ptr(ret_copy, true);
58956 void __attribute__((export_name("TS_PaymentParameters_set_payee"))) TS_PaymentParameters_set_payee(uint64_t this_ptr, uint64_t val) {
58957 LDKPaymentParameters this_ptr_conv;
58958 this_ptr_conv.inner = untag_ptr(this_ptr);
58959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58961 this_ptr_conv.is_owned = false;
58962 void* val_ptr = untag_ptr(val);
58963 CHECK_ACCESS(val_ptr);
58964 LDKPayee val_conv = *(LDKPayee*)(val_ptr);
58965 val_conv = Payee_clone((LDKPayee*)untag_ptr(val));
58966 PaymentParameters_set_payee(&this_ptr_conv, val_conv);
58969 uint64_t __attribute__((export_name("TS_PaymentParameters_get_expiry_time"))) TS_PaymentParameters_get_expiry_time(uint64_t this_ptr) {
58970 LDKPaymentParameters this_ptr_conv;
58971 this_ptr_conv.inner = untag_ptr(this_ptr);
58972 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58974 this_ptr_conv.is_owned = false;
58975 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
58976 *ret_copy = PaymentParameters_get_expiry_time(&this_ptr_conv);
58977 uint64_t ret_ref = tag_ptr(ret_copy, true);
58981 void __attribute__((export_name("TS_PaymentParameters_set_expiry_time"))) TS_PaymentParameters_set_expiry_time(uint64_t this_ptr, uint64_t val) {
58982 LDKPaymentParameters this_ptr_conv;
58983 this_ptr_conv.inner = untag_ptr(this_ptr);
58984 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58986 this_ptr_conv.is_owned = false;
58987 void* val_ptr = untag_ptr(val);
58988 CHECK_ACCESS(val_ptr);
58989 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
58990 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
58991 PaymentParameters_set_expiry_time(&this_ptr_conv, val_conv);
58994 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) {
58995 LDKPaymentParameters this_ptr_conv;
58996 this_ptr_conv.inner = untag_ptr(this_ptr);
58997 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
58998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
58999 this_ptr_conv.is_owned = false;
59000 int32_t ret_conv = PaymentParameters_get_max_total_cltv_expiry_delta(&this_ptr_conv);
59004 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) {
59005 LDKPaymentParameters this_ptr_conv;
59006 this_ptr_conv.inner = untag_ptr(this_ptr);
59007 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59009 this_ptr_conv.is_owned = false;
59010 PaymentParameters_set_max_total_cltv_expiry_delta(&this_ptr_conv, val);
59013 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_path_count"))) TS_PaymentParameters_get_max_path_count(uint64_t this_ptr) {
59014 LDKPaymentParameters this_ptr_conv;
59015 this_ptr_conv.inner = untag_ptr(this_ptr);
59016 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59018 this_ptr_conv.is_owned = false;
59019 int8_t ret_conv = PaymentParameters_get_max_path_count(&this_ptr_conv);
59023 void __attribute__((export_name("TS_PaymentParameters_set_max_path_count"))) TS_PaymentParameters_set_max_path_count(uint64_t this_ptr, int8_t val) {
59024 LDKPaymentParameters this_ptr_conv;
59025 this_ptr_conv.inner = untag_ptr(this_ptr);
59026 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59027 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59028 this_ptr_conv.is_owned = false;
59029 PaymentParameters_set_max_path_count(&this_ptr_conv, val);
59032 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) {
59033 LDKPaymentParameters this_ptr_conv;
59034 this_ptr_conv.inner = untag_ptr(this_ptr);
59035 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59037 this_ptr_conv.is_owned = false;
59038 int8_t ret_conv = PaymentParameters_get_max_channel_saturation_power_of_half(&this_ptr_conv);
59042 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) {
59043 LDKPaymentParameters this_ptr_conv;
59044 this_ptr_conv.inner = untag_ptr(this_ptr);
59045 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59047 this_ptr_conv.is_owned = false;
59048 PaymentParameters_set_max_channel_saturation_power_of_half(&this_ptr_conv, val);
59051 int64_tArray __attribute__((export_name("TS_PaymentParameters_get_previously_failed_channels"))) TS_PaymentParameters_get_previously_failed_channels(uint64_t this_ptr) {
59052 LDKPaymentParameters this_ptr_conv;
59053 this_ptr_conv.inner = untag_ptr(this_ptr);
59054 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59056 this_ptr_conv.is_owned = false;
59057 LDKCVec_u64Z ret_var = PaymentParameters_get_previously_failed_channels(&this_ptr_conv);
59058 int64_tArray ret_arr = NULL;
59059 ret_arr = init_int64_tArray(ret_var.datalen, __LINE__);
59060 int64_t *ret_arr_ptr = (int64_t*)(((uint8_t*)ret_arr) + 8);
59061 for (size_t i = 0; i < ret_var.datalen; i++) {
59062 int64_t ret_conv_8_conv = ret_var.data[i];
59063 ret_arr_ptr[i] = ret_conv_8_conv;
59066 FREE(ret_var.data);
59070 void __attribute__((export_name("TS_PaymentParameters_set_previously_failed_channels"))) TS_PaymentParameters_set_previously_failed_channels(uint64_t this_ptr, int64_tArray val) {
59071 LDKPaymentParameters this_ptr_conv;
59072 this_ptr_conv.inner = untag_ptr(this_ptr);
59073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59075 this_ptr_conv.is_owned = false;
59076 LDKCVec_u64Z val_constr;
59077 val_constr.datalen = val->arr_len;
59078 if (val_constr.datalen > 0)
59079 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
59081 val_constr.data = NULL;
59082 int64_t* val_vals = val->elems;
59083 for (size_t i = 0; i < val_constr.datalen; i++) {
59084 int64_t val_conv_8 = val_vals[i];
59085 val_constr.data[i] = val_conv_8;
59088 PaymentParameters_set_previously_failed_channels(&this_ptr_conv, val_constr);
59091 uint64_t __attribute__((export_name("TS_PaymentParameters_new"))) TS_PaymentParameters_new(uint64_t payee_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) {
59092 void* payee_arg_ptr = untag_ptr(payee_arg);
59093 CHECK_ACCESS(payee_arg_ptr);
59094 LDKPayee payee_arg_conv = *(LDKPayee*)(payee_arg_ptr);
59095 payee_arg_conv = Payee_clone((LDKPayee*)untag_ptr(payee_arg));
59096 void* expiry_time_arg_ptr = untag_ptr(expiry_time_arg);
59097 CHECK_ACCESS(expiry_time_arg_ptr);
59098 LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
59099 expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(expiry_time_arg));
59100 LDKCVec_u64Z previously_failed_channels_arg_constr;
59101 previously_failed_channels_arg_constr.datalen = previously_failed_channels_arg->arr_len;
59102 if (previously_failed_channels_arg_constr.datalen > 0)
59103 previously_failed_channels_arg_constr.data = MALLOC(previously_failed_channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
59105 previously_failed_channels_arg_constr.data = NULL;
59106 int64_t* previously_failed_channels_arg_vals = previously_failed_channels_arg->elems;
59107 for (size_t i = 0; i < previously_failed_channels_arg_constr.datalen; i++) {
59108 int64_t previously_failed_channels_arg_conv_8 = previously_failed_channels_arg_vals[i];
59109 previously_failed_channels_arg_constr.data[i] = previously_failed_channels_arg_conv_8;
59111 FREE(previously_failed_channels_arg);
59112 LDKPaymentParameters ret_var = PaymentParameters_new(payee_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);
59113 uint64_t ret_ref = 0;
59114 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59115 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59119 static inline uint64_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg) {
59120 LDKPaymentParameters ret_var = PaymentParameters_clone(arg);
59121 uint64_t ret_ref = 0;
59122 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59123 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59126 int64_t __attribute__((export_name("TS_PaymentParameters_clone_ptr"))) TS_PaymentParameters_clone_ptr(uint64_t arg) {
59127 LDKPaymentParameters arg_conv;
59128 arg_conv.inner = untag_ptr(arg);
59129 arg_conv.is_owned = ptr_is_owned(arg);
59130 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
59131 arg_conv.is_owned = false;
59132 int64_t ret_conv = PaymentParameters_clone_ptr(&arg_conv);
59136 uint64_t __attribute__((export_name("TS_PaymentParameters_clone"))) TS_PaymentParameters_clone(uint64_t orig) {
59137 LDKPaymentParameters orig_conv;
59138 orig_conv.inner = untag_ptr(orig);
59139 orig_conv.is_owned = ptr_is_owned(orig);
59140 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
59141 orig_conv.is_owned = false;
59142 LDKPaymentParameters ret_var = PaymentParameters_clone(&orig_conv);
59143 uint64_t ret_ref = 0;
59144 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59145 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59149 int64_t __attribute__((export_name("TS_PaymentParameters_hash"))) TS_PaymentParameters_hash(uint64_t o) {
59150 LDKPaymentParameters o_conv;
59151 o_conv.inner = untag_ptr(o);
59152 o_conv.is_owned = ptr_is_owned(o);
59153 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
59154 o_conv.is_owned = false;
59155 int64_t ret_conv = PaymentParameters_hash(&o_conv);
59159 jboolean __attribute__((export_name("TS_PaymentParameters_eq"))) TS_PaymentParameters_eq(uint64_t a, uint64_t b) {
59160 LDKPaymentParameters a_conv;
59161 a_conv.inner = untag_ptr(a);
59162 a_conv.is_owned = ptr_is_owned(a);
59163 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
59164 a_conv.is_owned = false;
59165 LDKPaymentParameters b_conv;
59166 b_conv.inner = untag_ptr(b);
59167 b_conv.is_owned = ptr_is_owned(b);
59168 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
59169 b_conv.is_owned = false;
59170 jboolean ret_conv = PaymentParameters_eq(&a_conv, &b_conv);
59174 int8_tArray __attribute__((export_name("TS_PaymentParameters_write"))) TS_PaymentParameters_write(uint64_t obj) {
59175 LDKPaymentParameters obj_conv;
59176 obj_conv.inner = untag_ptr(obj);
59177 obj_conv.is_owned = ptr_is_owned(obj);
59178 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
59179 obj_conv.is_owned = false;
59180 LDKCVec_u8Z ret_var = PaymentParameters_write(&obj_conv);
59181 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
59182 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
59183 CVec_u8Z_free(ret_var);
59187 uint64_t __attribute__((export_name("TS_PaymentParameters_read"))) TS_PaymentParameters_read(int8_tArray ser, int32_t arg) {
59188 LDKu8slice ser_ref;
59189 ser_ref.datalen = ser->arr_len;
59190 ser_ref.data = ser->elems;
59191 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
59192 *ret_conv = PaymentParameters_read(ser_ref, arg);
59194 return tag_ptr(ret_conv, true);
59197 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) {
59198 LDKPublicKey payee_pubkey_ref;
59199 CHECK(payee_pubkey->arr_len == 33);
59200 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
59201 LDKPaymentParameters ret_var = PaymentParameters_from_node_id(payee_pubkey_ref, final_cltv_expiry_delta);
59202 uint64_t ret_ref = 0;
59203 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59204 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59208 uint64_t __attribute__((export_name("TS_PaymentParameters_for_keysend"))) TS_PaymentParameters_for_keysend(int8_tArray payee_pubkey, int32_t final_cltv_expiry_delta, jboolean allow_mpp) {
59209 LDKPublicKey payee_pubkey_ref;
59210 CHECK(payee_pubkey->arr_len == 33);
59211 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
59212 LDKPaymentParameters ret_var = PaymentParameters_for_keysend(payee_pubkey_ref, final_cltv_expiry_delta, allow_mpp);
59213 uint64_t ret_ref = 0;
59214 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59215 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59219 uint64_t __attribute__((export_name("TS_PaymentParameters_from_bolt12_invoice"))) TS_PaymentParameters_from_bolt12_invoice(uint64_t invoice) {
59220 LDKBolt12Invoice invoice_conv;
59221 invoice_conv.inner = untag_ptr(invoice);
59222 invoice_conv.is_owned = ptr_is_owned(invoice);
59223 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
59224 invoice_conv.is_owned = false;
59225 LDKPaymentParameters ret_var = PaymentParameters_from_bolt12_invoice(&invoice_conv);
59226 uint64_t ret_ref = 0;
59227 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59228 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59232 uint64_t __attribute__((export_name("TS_PaymentParameters_blinded"))) TS_PaymentParameters_blinded(uint64_tArray blinded_route_hints) {
59233 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ blinded_route_hints_constr;
59234 blinded_route_hints_constr.datalen = blinded_route_hints->arr_len;
59235 if (blinded_route_hints_constr.datalen > 0)
59236 blinded_route_hints_constr.data = MALLOC(blinded_route_hints_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
59238 blinded_route_hints_constr.data = NULL;
59239 uint64_t* blinded_route_hints_vals = blinded_route_hints->elems;
59240 for (size_t l = 0; l < blinded_route_hints_constr.datalen; l++) {
59241 uint64_t blinded_route_hints_conv_37 = blinded_route_hints_vals[l];
59242 void* blinded_route_hints_conv_37_ptr = untag_ptr(blinded_route_hints_conv_37);
59243 CHECK_ACCESS(blinded_route_hints_conv_37_ptr);
59244 LDKC2Tuple_BlindedPayInfoBlindedPathZ blinded_route_hints_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(blinded_route_hints_conv_37_ptr);
59245 blinded_route_hints_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone((LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(blinded_route_hints_conv_37));
59246 blinded_route_hints_constr.data[l] = blinded_route_hints_conv_37_conv;
59248 FREE(blinded_route_hints);
59249 LDKPaymentParameters ret_var = PaymentParameters_blinded(blinded_route_hints_constr);
59250 uint64_t ret_ref = 0;
59251 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59252 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59256 void __attribute__((export_name("TS_Payee_free"))) TS_Payee_free(uint64_t this_ptr) {
59257 if (!ptr_is_owned(this_ptr)) return;
59258 void* this_ptr_ptr = untag_ptr(this_ptr);
59259 CHECK_ACCESS(this_ptr_ptr);
59260 LDKPayee this_ptr_conv = *(LDKPayee*)(this_ptr_ptr);
59261 FREE(untag_ptr(this_ptr));
59262 Payee_free(this_ptr_conv);
59265 static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
59266 LDKPayee *ret_copy = MALLOC(sizeof(LDKPayee), "LDKPayee");
59267 *ret_copy = Payee_clone(arg);
59268 uint64_t ret_ref = tag_ptr(ret_copy, true);
59271 int64_t __attribute__((export_name("TS_Payee_clone_ptr"))) TS_Payee_clone_ptr(uint64_t arg) {
59272 LDKPayee* arg_conv = (LDKPayee*)untag_ptr(arg);
59273 int64_t ret_conv = Payee_clone_ptr(arg_conv);
59277 uint64_t __attribute__((export_name("TS_Payee_clone"))) TS_Payee_clone(uint64_t orig) {
59278 LDKPayee* orig_conv = (LDKPayee*)untag_ptr(orig);
59279 LDKPayee *ret_copy = MALLOC(sizeof(LDKPayee), "LDKPayee");
59280 *ret_copy = Payee_clone(orig_conv);
59281 uint64_t ret_ref = tag_ptr(ret_copy, true);
59285 uint64_t __attribute__((export_name("TS_Payee_blinded"))) TS_Payee_blinded(uint64_tArray route_hints, uint64_t features) {
59286 LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ route_hints_constr;
59287 route_hints_constr.datalen = route_hints->arr_len;
59288 if (route_hints_constr.datalen > 0)
59289 route_hints_constr.data = MALLOC(route_hints_constr.datalen * sizeof(LDKC2Tuple_BlindedPayInfoBlindedPathZ), "LDKCVec_C2Tuple_BlindedPayInfoBlindedPathZZ Elements");
59291 route_hints_constr.data = NULL;
59292 uint64_t* route_hints_vals = route_hints->elems;
59293 for (size_t l = 0; l < route_hints_constr.datalen; l++) {
59294 uint64_t route_hints_conv_37 = route_hints_vals[l];
59295 void* route_hints_conv_37_ptr = untag_ptr(route_hints_conv_37);
59296 CHECK_ACCESS(route_hints_conv_37_ptr);
59297 LDKC2Tuple_BlindedPayInfoBlindedPathZ route_hints_conv_37_conv = *(LDKC2Tuple_BlindedPayInfoBlindedPathZ*)(route_hints_conv_37_ptr);
59298 route_hints_conv_37_conv = C2Tuple_BlindedPayInfoBlindedPathZ_clone((LDKC2Tuple_BlindedPayInfoBlindedPathZ*)untag_ptr(route_hints_conv_37));
59299 route_hints_constr.data[l] = route_hints_conv_37_conv;
59302 LDKBolt12InvoiceFeatures features_conv;
59303 features_conv.inner = untag_ptr(features);
59304 features_conv.is_owned = ptr_is_owned(features);
59305 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
59306 features_conv = Bolt12InvoiceFeatures_clone(&features_conv);
59307 LDKPayee *ret_copy = MALLOC(sizeof(LDKPayee), "LDKPayee");
59308 *ret_copy = Payee_blinded(route_hints_constr, features_conv);
59309 uint64_t ret_ref = tag_ptr(ret_copy, true);
59313 uint64_t __attribute__((export_name("TS_Payee_clear"))) TS_Payee_clear(int8_tArray node_id, uint64_tArray route_hints, uint64_t features, int32_t final_cltv_expiry_delta) {
59314 LDKPublicKey node_id_ref;
59315 CHECK(node_id->arr_len == 33);
59316 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
59317 LDKCVec_RouteHintZ route_hints_constr;
59318 route_hints_constr.datalen = route_hints->arr_len;
59319 if (route_hints_constr.datalen > 0)
59320 route_hints_constr.data = MALLOC(route_hints_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
59322 route_hints_constr.data = NULL;
59323 uint64_t* route_hints_vals = route_hints->elems;
59324 for (size_t l = 0; l < route_hints_constr.datalen; l++) {
59325 uint64_t route_hints_conv_11 = route_hints_vals[l];
59326 LDKRouteHint route_hints_conv_11_conv;
59327 route_hints_conv_11_conv.inner = untag_ptr(route_hints_conv_11);
59328 route_hints_conv_11_conv.is_owned = ptr_is_owned(route_hints_conv_11);
59329 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_conv_11_conv);
59330 route_hints_conv_11_conv = RouteHint_clone(&route_hints_conv_11_conv);
59331 route_hints_constr.data[l] = route_hints_conv_11_conv;
59334 LDKBolt11InvoiceFeatures features_conv;
59335 features_conv.inner = untag_ptr(features);
59336 features_conv.is_owned = ptr_is_owned(features);
59337 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
59338 features_conv = Bolt11InvoiceFeatures_clone(&features_conv);
59339 LDKPayee *ret_copy = MALLOC(sizeof(LDKPayee), "LDKPayee");
59340 *ret_copy = Payee_clear(node_id_ref, route_hints_constr, features_conv, final_cltv_expiry_delta);
59341 uint64_t ret_ref = tag_ptr(ret_copy, true);
59345 int64_t __attribute__((export_name("TS_Payee_hash"))) TS_Payee_hash(uint64_t o) {
59346 LDKPayee* o_conv = (LDKPayee*)untag_ptr(o);
59347 int64_t ret_conv = Payee_hash(o_conv);
59351 jboolean __attribute__((export_name("TS_Payee_eq"))) TS_Payee_eq(uint64_t a, uint64_t b) {
59352 LDKPayee* a_conv = (LDKPayee*)untag_ptr(a);
59353 LDKPayee* b_conv = (LDKPayee*)untag_ptr(b);
59354 jboolean ret_conv = Payee_eq(a_conv, b_conv);
59358 void __attribute__((export_name("TS_RouteHint_free"))) TS_RouteHint_free(uint64_t this_obj) {
59359 LDKRouteHint this_obj_conv;
59360 this_obj_conv.inner = untag_ptr(this_obj);
59361 this_obj_conv.is_owned = ptr_is_owned(this_obj);
59362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
59363 RouteHint_free(this_obj_conv);
59366 uint64_tArray __attribute__((export_name("TS_RouteHint_get_a"))) TS_RouteHint_get_a(uint64_t this_ptr) {
59367 LDKRouteHint this_ptr_conv;
59368 this_ptr_conv.inner = untag_ptr(this_ptr);
59369 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59370 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59371 this_ptr_conv.is_owned = false;
59372 LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
59373 uint64_tArray ret_arr = NULL;
59374 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
59375 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
59376 for (size_t o = 0; o < ret_var.datalen; o++) {
59377 LDKRouteHintHop ret_conv_14_var = ret_var.data[o];
59378 uint64_t ret_conv_14_ref = 0;
59379 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
59380 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
59381 ret_arr_ptr[o] = ret_conv_14_ref;
59384 FREE(ret_var.data);
59388 void __attribute__((export_name("TS_RouteHint_set_a"))) TS_RouteHint_set_a(uint64_t this_ptr, uint64_tArray val) {
59389 LDKRouteHint this_ptr_conv;
59390 this_ptr_conv.inner = untag_ptr(this_ptr);
59391 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59393 this_ptr_conv.is_owned = false;
59394 LDKCVec_RouteHintHopZ val_constr;
59395 val_constr.datalen = val->arr_len;
59396 if (val_constr.datalen > 0)
59397 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
59399 val_constr.data = NULL;
59400 uint64_t* val_vals = val->elems;
59401 for (size_t o = 0; o < val_constr.datalen; o++) {
59402 uint64_t val_conv_14 = val_vals[o];
59403 LDKRouteHintHop val_conv_14_conv;
59404 val_conv_14_conv.inner = untag_ptr(val_conv_14);
59405 val_conv_14_conv.is_owned = ptr_is_owned(val_conv_14);
59406 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
59407 val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
59408 val_constr.data[o] = val_conv_14_conv;
59411 RouteHint_set_a(&this_ptr_conv, val_constr);
59414 uint64_t __attribute__((export_name("TS_RouteHint_new"))) TS_RouteHint_new(uint64_tArray a_arg) {
59415 LDKCVec_RouteHintHopZ a_arg_constr;
59416 a_arg_constr.datalen = a_arg->arr_len;
59417 if (a_arg_constr.datalen > 0)
59418 a_arg_constr.data = MALLOC(a_arg_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
59420 a_arg_constr.data = NULL;
59421 uint64_t* a_arg_vals = a_arg->elems;
59422 for (size_t o = 0; o < a_arg_constr.datalen; o++) {
59423 uint64_t a_arg_conv_14 = a_arg_vals[o];
59424 LDKRouteHintHop a_arg_conv_14_conv;
59425 a_arg_conv_14_conv.inner = untag_ptr(a_arg_conv_14);
59426 a_arg_conv_14_conv.is_owned = ptr_is_owned(a_arg_conv_14);
59427 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
59428 a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
59429 a_arg_constr.data[o] = a_arg_conv_14_conv;
59432 LDKRouteHint ret_var = RouteHint_new(a_arg_constr);
59433 uint64_t ret_ref = 0;
59434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59435 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59439 static inline uint64_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
59440 LDKRouteHint ret_var = RouteHint_clone(arg);
59441 uint64_t ret_ref = 0;
59442 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59443 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59446 int64_t __attribute__((export_name("TS_RouteHint_clone_ptr"))) TS_RouteHint_clone_ptr(uint64_t arg) {
59447 LDKRouteHint arg_conv;
59448 arg_conv.inner = untag_ptr(arg);
59449 arg_conv.is_owned = ptr_is_owned(arg);
59450 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
59451 arg_conv.is_owned = false;
59452 int64_t ret_conv = RouteHint_clone_ptr(&arg_conv);
59456 uint64_t __attribute__((export_name("TS_RouteHint_clone"))) TS_RouteHint_clone(uint64_t orig) {
59457 LDKRouteHint orig_conv;
59458 orig_conv.inner = untag_ptr(orig);
59459 orig_conv.is_owned = ptr_is_owned(orig);
59460 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
59461 orig_conv.is_owned = false;
59462 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
59463 uint64_t ret_ref = 0;
59464 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59465 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59469 int64_t __attribute__((export_name("TS_RouteHint_hash"))) TS_RouteHint_hash(uint64_t o) {
59470 LDKRouteHint o_conv;
59471 o_conv.inner = untag_ptr(o);
59472 o_conv.is_owned = ptr_is_owned(o);
59473 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
59474 o_conv.is_owned = false;
59475 int64_t ret_conv = RouteHint_hash(&o_conv);
59479 jboolean __attribute__((export_name("TS_RouteHint_eq"))) TS_RouteHint_eq(uint64_t a, uint64_t b) {
59480 LDKRouteHint a_conv;
59481 a_conv.inner = untag_ptr(a);
59482 a_conv.is_owned = ptr_is_owned(a);
59483 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
59484 a_conv.is_owned = false;
59485 LDKRouteHint b_conv;
59486 b_conv.inner = untag_ptr(b);
59487 b_conv.is_owned = ptr_is_owned(b);
59488 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
59489 b_conv.is_owned = false;
59490 jboolean ret_conv = RouteHint_eq(&a_conv, &b_conv);
59494 int8_tArray __attribute__((export_name("TS_RouteHint_write"))) TS_RouteHint_write(uint64_t obj) {
59495 LDKRouteHint obj_conv;
59496 obj_conv.inner = untag_ptr(obj);
59497 obj_conv.is_owned = ptr_is_owned(obj);
59498 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
59499 obj_conv.is_owned = false;
59500 LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
59501 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
59502 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
59503 CVec_u8Z_free(ret_var);
59507 uint64_t __attribute__((export_name("TS_RouteHint_read"))) TS_RouteHint_read(int8_tArray ser) {
59508 LDKu8slice ser_ref;
59509 ser_ref.datalen = ser->arr_len;
59510 ser_ref.data = ser->elems;
59511 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
59512 *ret_conv = RouteHint_read(ser_ref);
59514 return tag_ptr(ret_conv, true);
59517 void __attribute__((export_name("TS_RouteHintHop_free"))) TS_RouteHintHop_free(uint64_t this_obj) {
59518 LDKRouteHintHop this_obj_conv;
59519 this_obj_conv.inner = untag_ptr(this_obj);
59520 this_obj_conv.is_owned = ptr_is_owned(this_obj);
59521 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
59522 RouteHintHop_free(this_obj_conv);
59525 int8_tArray __attribute__((export_name("TS_RouteHintHop_get_src_node_id"))) TS_RouteHintHop_get_src_node_id(uint64_t this_ptr) {
59526 LDKRouteHintHop this_ptr_conv;
59527 this_ptr_conv.inner = untag_ptr(this_ptr);
59528 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59530 this_ptr_conv.is_owned = false;
59531 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
59532 memcpy(ret_arr->elems, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
59536 void __attribute__((export_name("TS_RouteHintHop_set_src_node_id"))) TS_RouteHintHop_set_src_node_id(uint64_t this_ptr, int8_tArray val) {
59537 LDKRouteHintHop this_ptr_conv;
59538 this_ptr_conv.inner = untag_ptr(this_ptr);
59539 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59541 this_ptr_conv.is_owned = false;
59542 LDKPublicKey val_ref;
59543 CHECK(val->arr_len == 33);
59544 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
59545 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
59548 int64_t __attribute__((export_name("TS_RouteHintHop_get_short_channel_id"))) TS_RouteHintHop_get_short_channel_id(uint64_t this_ptr) {
59549 LDKRouteHintHop this_ptr_conv;
59550 this_ptr_conv.inner = untag_ptr(this_ptr);
59551 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59552 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59553 this_ptr_conv.is_owned = false;
59554 int64_t ret_conv = RouteHintHop_get_short_channel_id(&this_ptr_conv);
59558 void __attribute__((export_name("TS_RouteHintHop_set_short_channel_id"))) TS_RouteHintHop_set_short_channel_id(uint64_t this_ptr, int64_t val) {
59559 LDKRouteHintHop this_ptr_conv;
59560 this_ptr_conv.inner = untag_ptr(this_ptr);
59561 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59562 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59563 this_ptr_conv.is_owned = false;
59564 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
59567 uint64_t __attribute__((export_name("TS_RouteHintHop_get_fees"))) TS_RouteHintHop_get_fees(uint64_t this_ptr) {
59568 LDKRouteHintHop this_ptr_conv;
59569 this_ptr_conv.inner = untag_ptr(this_ptr);
59570 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59571 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59572 this_ptr_conv.is_owned = false;
59573 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
59574 uint64_t ret_ref = 0;
59575 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59576 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59580 void __attribute__((export_name("TS_RouteHintHop_set_fees"))) TS_RouteHintHop_set_fees(uint64_t this_ptr, uint64_t val) {
59581 LDKRouteHintHop this_ptr_conv;
59582 this_ptr_conv.inner = untag_ptr(this_ptr);
59583 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59585 this_ptr_conv.is_owned = false;
59586 LDKRoutingFees val_conv;
59587 val_conv.inner = untag_ptr(val);
59588 val_conv.is_owned = ptr_is_owned(val);
59589 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
59590 val_conv = RoutingFees_clone(&val_conv);
59591 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
59594 int16_t __attribute__((export_name("TS_RouteHintHop_get_cltv_expiry_delta"))) TS_RouteHintHop_get_cltv_expiry_delta(uint64_t this_ptr) {
59595 LDKRouteHintHop this_ptr_conv;
59596 this_ptr_conv.inner = untag_ptr(this_ptr);
59597 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59599 this_ptr_conv.is_owned = false;
59600 int16_t ret_conv = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
59604 void __attribute__((export_name("TS_RouteHintHop_set_cltv_expiry_delta"))) TS_RouteHintHop_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
59605 LDKRouteHintHop this_ptr_conv;
59606 this_ptr_conv.inner = untag_ptr(this_ptr);
59607 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59608 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59609 this_ptr_conv.is_owned = false;
59610 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
59613 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_minimum_msat"))) TS_RouteHintHop_get_htlc_minimum_msat(uint64_t this_ptr) {
59614 LDKRouteHintHop this_ptr_conv;
59615 this_ptr_conv.inner = untag_ptr(this_ptr);
59616 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59617 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59618 this_ptr_conv.is_owned = false;
59619 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
59620 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
59621 uint64_t ret_ref = tag_ptr(ret_copy, true);
59625 void __attribute__((export_name("TS_RouteHintHop_set_htlc_minimum_msat"))) TS_RouteHintHop_set_htlc_minimum_msat(uint64_t this_ptr, uint64_t val) {
59626 LDKRouteHintHop this_ptr_conv;
59627 this_ptr_conv.inner = untag_ptr(this_ptr);
59628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59630 this_ptr_conv.is_owned = false;
59631 void* val_ptr = untag_ptr(val);
59632 CHECK_ACCESS(val_ptr);
59633 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
59634 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
59635 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
59638 uint64_t __attribute__((export_name("TS_RouteHintHop_get_htlc_maximum_msat"))) TS_RouteHintHop_get_htlc_maximum_msat(uint64_t this_ptr) {
59639 LDKRouteHintHop this_ptr_conv;
59640 this_ptr_conv.inner = untag_ptr(this_ptr);
59641 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59643 this_ptr_conv.is_owned = false;
59644 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
59645 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
59646 uint64_t ret_ref = tag_ptr(ret_copy, true);
59650 void __attribute__((export_name("TS_RouteHintHop_set_htlc_maximum_msat"))) TS_RouteHintHop_set_htlc_maximum_msat(uint64_t this_ptr, uint64_t val) {
59651 LDKRouteHintHop this_ptr_conv;
59652 this_ptr_conv.inner = untag_ptr(this_ptr);
59653 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
59654 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
59655 this_ptr_conv.is_owned = false;
59656 void* val_ptr = untag_ptr(val);
59657 CHECK_ACCESS(val_ptr);
59658 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
59659 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(val));
59660 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
59663 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) {
59664 LDKPublicKey src_node_id_arg_ref;
59665 CHECK(src_node_id_arg->arr_len == 33);
59666 memcpy(src_node_id_arg_ref.compressed_form, src_node_id_arg->elems, 33); FREE(src_node_id_arg);
59667 LDKRoutingFees fees_arg_conv;
59668 fees_arg_conv.inner = untag_ptr(fees_arg);
59669 fees_arg_conv.is_owned = ptr_is_owned(fees_arg);
59670 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
59671 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
59672 void* htlc_minimum_msat_arg_ptr = untag_ptr(htlc_minimum_msat_arg);
59673 CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
59674 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_minimum_msat_arg_ptr);
59675 htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_minimum_msat_arg));
59676 void* htlc_maximum_msat_arg_ptr = untag_ptr(htlc_maximum_msat_arg);
59677 CHECK_ACCESS(htlc_maximum_msat_arg_ptr);
59678 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_arg_ptr);
59679 htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(htlc_maximum_msat_arg));
59680 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);
59681 uint64_t ret_ref = 0;
59682 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59683 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59687 static inline uint64_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
59688 LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
59689 uint64_t ret_ref = 0;
59690 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59691 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59694 int64_t __attribute__((export_name("TS_RouteHintHop_clone_ptr"))) TS_RouteHintHop_clone_ptr(uint64_t arg) {
59695 LDKRouteHintHop arg_conv;
59696 arg_conv.inner = untag_ptr(arg);
59697 arg_conv.is_owned = ptr_is_owned(arg);
59698 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
59699 arg_conv.is_owned = false;
59700 int64_t ret_conv = RouteHintHop_clone_ptr(&arg_conv);
59704 uint64_t __attribute__((export_name("TS_RouteHintHop_clone"))) TS_RouteHintHop_clone(uint64_t orig) {
59705 LDKRouteHintHop orig_conv;
59706 orig_conv.inner = untag_ptr(orig);
59707 orig_conv.is_owned = ptr_is_owned(orig);
59708 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
59709 orig_conv.is_owned = false;
59710 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
59711 uint64_t ret_ref = 0;
59712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59713 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59717 int64_t __attribute__((export_name("TS_RouteHintHop_hash"))) TS_RouteHintHop_hash(uint64_t o) {
59718 LDKRouteHintHop o_conv;
59719 o_conv.inner = untag_ptr(o);
59720 o_conv.is_owned = ptr_is_owned(o);
59721 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
59722 o_conv.is_owned = false;
59723 int64_t ret_conv = RouteHintHop_hash(&o_conv);
59727 jboolean __attribute__((export_name("TS_RouteHintHop_eq"))) TS_RouteHintHop_eq(uint64_t a, uint64_t b) {
59728 LDKRouteHintHop a_conv;
59729 a_conv.inner = untag_ptr(a);
59730 a_conv.is_owned = ptr_is_owned(a);
59731 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
59732 a_conv.is_owned = false;
59733 LDKRouteHintHop b_conv;
59734 b_conv.inner = untag_ptr(b);
59735 b_conv.is_owned = ptr_is_owned(b);
59736 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
59737 b_conv.is_owned = false;
59738 jboolean ret_conv = RouteHintHop_eq(&a_conv, &b_conv);
59742 int8_tArray __attribute__((export_name("TS_RouteHintHop_write"))) TS_RouteHintHop_write(uint64_t obj) {
59743 LDKRouteHintHop obj_conv;
59744 obj_conv.inner = untag_ptr(obj);
59745 obj_conv.is_owned = ptr_is_owned(obj);
59746 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
59747 obj_conv.is_owned = false;
59748 LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
59749 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
59750 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
59751 CVec_u8Z_free(ret_var);
59755 uint64_t __attribute__((export_name("TS_RouteHintHop_read"))) TS_RouteHintHop_read(int8_tArray ser) {
59756 LDKu8slice ser_ref;
59757 ser_ref.datalen = ser->arr_len;
59758 ser_ref.data = ser->elems;
59759 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
59760 *ret_conv = RouteHintHop_read(ser_ref);
59762 return tag_ptr(ret_conv, true);
59765 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, uint64_t score_params, int8_tArray random_seed_bytes) {
59766 LDKPublicKey our_node_pubkey_ref;
59767 CHECK(our_node_pubkey->arr_len == 33);
59768 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
59769 LDKRouteParameters route_params_conv;
59770 route_params_conv.inner = untag_ptr(route_params);
59771 route_params_conv.is_owned = ptr_is_owned(route_params);
59772 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
59773 route_params_conv.is_owned = false;
59774 LDKNetworkGraph network_graph_conv;
59775 network_graph_conv.inner = untag_ptr(network_graph);
59776 network_graph_conv.is_owned = ptr_is_owned(network_graph);
59777 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
59778 network_graph_conv.is_owned = false;
59779 LDKCVec_ChannelDetailsZ first_hops_constr;
59780 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
59781 if (first_hops != 0) {
59782 first_hops_constr.datalen = first_hops->arr_len;
59783 if (first_hops_constr.datalen > 0)
59784 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
59786 first_hops_constr.data = NULL;
59787 uint64_t* first_hops_vals = first_hops->elems;
59788 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
59789 uint64_t first_hops_conv_16 = first_hops_vals[q];
59790 LDKChannelDetails first_hops_conv_16_conv;
59791 first_hops_conv_16_conv.inner = untag_ptr(first_hops_conv_16);
59792 first_hops_conv_16_conv.is_owned = ptr_is_owned(first_hops_conv_16);
59793 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
59794 first_hops_conv_16_conv.is_owned = false;
59795 first_hops_constr.data[q] = first_hops_conv_16_conv;
59798 first_hops_ptr = &first_hops_constr;
59800 void* logger_ptr = untag_ptr(logger);
59801 CHECK_ACCESS(logger_ptr);
59802 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
59803 if (logger_conv.free == LDKLogger_JCalls_free) {
59804 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
59805 LDKLogger_JCalls_cloned(&logger_conv);
59807 void* scorer_ptr = untag_ptr(scorer);
59808 if (ptr_is_owned(scorer)) { CHECK_ACCESS(scorer_ptr); }
59809 LDKScoreLookUp* scorer_conv = (LDKScoreLookUp*)scorer_ptr;
59810 LDKProbabilisticScoringFeeParameters score_params_conv;
59811 score_params_conv.inner = untag_ptr(score_params);
59812 score_params_conv.is_owned = ptr_is_owned(score_params);
59813 CHECK_INNER_FIELD_ACCESS_OR_NULL(score_params_conv);
59814 score_params_conv.is_owned = false;
59815 uint8_t random_seed_bytes_arr[32];
59816 CHECK(random_seed_bytes->arr_len == 32);
59817 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
59818 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
59819 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
59820 *ret_conv = find_route(our_node_pubkey_ref, &route_params_conv, &network_graph_conv, first_hops_ptr, logger_conv, scorer_conv, &score_params_conv, random_seed_bytes_ref);
59821 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
59822 return tag_ptr(ret_conv, true);
59825 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) {
59826 LDKPublicKey our_node_pubkey_ref;
59827 CHECK(our_node_pubkey->arr_len == 33);
59828 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
59829 LDKCVec_PublicKeyZ hops_constr;
59830 hops_constr.datalen = hops->arr_len;
59831 if (hops_constr.datalen > 0)
59832 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
59834 hops_constr.data = NULL;
59835 int8_tArray* hops_vals = (void*) hops->elems;
59836 for (size_t m = 0; m < hops_constr.datalen; m++) {
59837 int8_tArray hops_conv_12 = hops_vals[m];
59838 LDKPublicKey hops_conv_12_ref;
59839 CHECK(hops_conv_12->arr_len == 33);
59840 memcpy(hops_conv_12_ref.compressed_form, hops_conv_12->elems, 33); FREE(hops_conv_12);
59841 hops_constr.data[m] = hops_conv_12_ref;
59844 LDKRouteParameters route_params_conv;
59845 route_params_conv.inner = untag_ptr(route_params);
59846 route_params_conv.is_owned = ptr_is_owned(route_params);
59847 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
59848 route_params_conv.is_owned = false;
59849 LDKNetworkGraph network_graph_conv;
59850 network_graph_conv.inner = untag_ptr(network_graph);
59851 network_graph_conv.is_owned = ptr_is_owned(network_graph);
59852 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
59853 network_graph_conv.is_owned = false;
59854 void* logger_ptr = untag_ptr(logger);
59855 CHECK_ACCESS(logger_ptr);
59856 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
59857 if (logger_conv.free == LDKLogger_JCalls_free) {
59858 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
59859 LDKLogger_JCalls_cloned(&logger_conv);
59861 uint8_t random_seed_bytes_arr[32];
59862 CHECK(random_seed_bytes->arr_len == 32);
59863 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
59864 uint8_t (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
59865 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
59866 *ret_conv = build_route_from_hops(our_node_pubkey_ref, hops_constr, &route_params_conv, &network_graph_conv, logger_conv, random_seed_bytes_ref);
59867 return tag_ptr(ret_conv, true);
59870 void __attribute__((export_name("TS_ScoreLookUp_free"))) TS_ScoreLookUp_free(uint64_t this_ptr) {
59871 if (!ptr_is_owned(this_ptr)) return;
59872 void* this_ptr_ptr = untag_ptr(this_ptr);
59873 CHECK_ACCESS(this_ptr_ptr);
59874 LDKScoreLookUp this_ptr_conv = *(LDKScoreLookUp*)(this_ptr_ptr);
59875 FREE(untag_ptr(this_ptr));
59876 ScoreLookUp_free(this_ptr_conv);
59879 void __attribute__((export_name("TS_ScoreUpdate_free"))) TS_ScoreUpdate_free(uint64_t this_ptr) {
59880 if (!ptr_is_owned(this_ptr)) return;
59881 void* this_ptr_ptr = untag_ptr(this_ptr);
59882 CHECK_ACCESS(this_ptr_ptr);
59883 LDKScoreUpdate this_ptr_conv = *(LDKScoreUpdate*)(this_ptr_ptr);
59884 FREE(untag_ptr(this_ptr));
59885 ScoreUpdate_free(this_ptr_conv);
59888 void __attribute__((export_name("TS_Score_free"))) TS_Score_free(uint64_t this_ptr) {
59889 if (!ptr_is_owned(this_ptr)) return;
59890 void* this_ptr_ptr = untag_ptr(this_ptr);
59891 CHECK_ACCESS(this_ptr_ptr);
59892 LDKScore this_ptr_conv = *(LDKScore*)(this_ptr_ptr);
59893 FREE(untag_ptr(this_ptr));
59894 Score_free(this_ptr_conv);
59897 void __attribute__((export_name("TS_LockableScore_free"))) TS_LockableScore_free(uint64_t this_ptr) {
59898 if (!ptr_is_owned(this_ptr)) return;
59899 void* this_ptr_ptr = untag_ptr(this_ptr);
59900 CHECK_ACCESS(this_ptr_ptr);
59901 LDKLockableScore this_ptr_conv = *(LDKLockableScore*)(this_ptr_ptr);
59902 FREE(untag_ptr(this_ptr));
59903 LockableScore_free(this_ptr_conv);
59906 void __attribute__((export_name("TS_WriteableScore_free"))) TS_WriteableScore_free(uint64_t this_ptr) {
59907 if (!ptr_is_owned(this_ptr)) return;
59908 void* this_ptr_ptr = untag_ptr(this_ptr);
59909 CHECK_ACCESS(this_ptr_ptr);
59910 LDKWriteableScore this_ptr_conv = *(LDKWriteableScore*)(this_ptr_ptr);
59911 FREE(untag_ptr(this_ptr));
59912 WriteableScore_free(this_ptr_conv);
59915 void __attribute__((export_name("TS_MultiThreadedLockableScore_free"))) TS_MultiThreadedLockableScore_free(uint64_t this_obj) {
59916 LDKMultiThreadedLockableScore this_obj_conv;
59917 this_obj_conv.inner = untag_ptr(this_obj);
59918 this_obj_conv.is_owned = ptr_is_owned(this_obj);
59919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
59920 MultiThreadedLockableScore_free(this_obj_conv);
59923 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_LockableScore"))) TS_MultiThreadedLockableScore_as_LockableScore(uint64_t this_arg) {
59924 LDKMultiThreadedLockableScore this_arg_conv;
59925 this_arg_conv.inner = untag_ptr(this_arg);
59926 this_arg_conv.is_owned = ptr_is_owned(this_arg);
59927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
59928 this_arg_conv.is_owned = false;
59929 LDKLockableScore* ret_ret = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
59930 *ret_ret = MultiThreadedLockableScore_as_LockableScore(&this_arg_conv);
59931 return tag_ptr(ret_ret, true);
59934 int8_tArray __attribute__((export_name("TS_MultiThreadedLockableScore_write"))) TS_MultiThreadedLockableScore_write(uint64_t obj) {
59935 LDKMultiThreadedLockableScore obj_conv;
59936 obj_conv.inner = untag_ptr(obj);
59937 obj_conv.is_owned = ptr_is_owned(obj);
59938 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
59939 obj_conv.is_owned = false;
59940 LDKCVec_u8Z ret_var = MultiThreadedLockableScore_write(&obj_conv);
59941 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
59942 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
59943 CVec_u8Z_free(ret_var);
59947 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_as_WriteableScore"))) TS_MultiThreadedLockableScore_as_WriteableScore(uint64_t this_arg) {
59948 LDKMultiThreadedLockableScore this_arg_conv;
59949 this_arg_conv.inner = untag_ptr(this_arg);
59950 this_arg_conv.is_owned = ptr_is_owned(this_arg);
59951 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
59952 this_arg_conv.is_owned = false;
59953 LDKWriteableScore* ret_ret = MALLOC(sizeof(LDKWriteableScore), "LDKWriteableScore");
59954 *ret_ret = MultiThreadedLockableScore_as_WriteableScore(&this_arg_conv);
59955 return tag_ptr(ret_ret, true);
59958 uint64_t __attribute__((export_name("TS_MultiThreadedLockableScore_new"))) TS_MultiThreadedLockableScore_new(uint64_t score) {
59959 void* score_ptr = untag_ptr(score);
59960 CHECK_ACCESS(score_ptr);
59961 LDKScore score_conv = *(LDKScore*)(score_ptr);
59962 if (score_conv.free == LDKScore_JCalls_free) {
59963 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
59964 LDKScore_JCalls_cloned(&score_conv);
59966 LDKMultiThreadedLockableScore ret_var = MultiThreadedLockableScore_new(score_conv);
59967 uint64_t ret_ref = 0;
59968 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
59969 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
59973 void __attribute__((export_name("TS_MultiThreadedScoreLockRead_free"))) TS_MultiThreadedScoreLockRead_free(uint64_t this_obj) {
59974 LDKMultiThreadedScoreLockRead this_obj_conv;
59975 this_obj_conv.inner = untag_ptr(this_obj);
59976 this_obj_conv.is_owned = ptr_is_owned(this_obj);
59977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
59978 MultiThreadedScoreLockRead_free(this_obj_conv);
59981 void __attribute__((export_name("TS_MultiThreadedScoreLockWrite_free"))) TS_MultiThreadedScoreLockWrite_free(uint64_t this_obj) {
59982 LDKMultiThreadedScoreLockWrite this_obj_conv;
59983 this_obj_conv.inner = untag_ptr(this_obj);
59984 this_obj_conv.is_owned = ptr_is_owned(this_obj);
59985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
59986 MultiThreadedScoreLockWrite_free(this_obj_conv);
59989 uint64_t __attribute__((export_name("TS_MultiThreadedScoreLockRead_as_ScoreLookUp"))) TS_MultiThreadedScoreLockRead_as_ScoreLookUp(uint64_t this_arg) {
59990 LDKMultiThreadedScoreLockRead this_arg_conv;
59991 this_arg_conv.inner = untag_ptr(this_arg);
59992 this_arg_conv.is_owned = ptr_is_owned(this_arg);
59993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
59994 this_arg_conv.is_owned = false;
59995 LDKScoreLookUp* ret_ret = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
59996 *ret_ret = MultiThreadedScoreLockRead_as_ScoreLookUp(&this_arg_conv);
59997 return tag_ptr(ret_ret, true);
60000 int8_tArray __attribute__((export_name("TS_MultiThreadedScoreLockWrite_write"))) TS_MultiThreadedScoreLockWrite_write(uint64_t obj) {
60001 LDKMultiThreadedScoreLockWrite obj_conv;
60002 obj_conv.inner = untag_ptr(obj);
60003 obj_conv.is_owned = ptr_is_owned(obj);
60004 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
60005 obj_conv.is_owned = false;
60006 LDKCVec_u8Z ret_var = MultiThreadedScoreLockWrite_write(&obj_conv);
60007 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
60008 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
60009 CVec_u8Z_free(ret_var);
60013 uint64_t __attribute__((export_name("TS_MultiThreadedScoreLockWrite_as_ScoreUpdate"))) TS_MultiThreadedScoreLockWrite_as_ScoreUpdate(uint64_t this_arg) {
60014 LDKMultiThreadedScoreLockWrite this_arg_conv;
60015 this_arg_conv.inner = untag_ptr(this_arg);
60016 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60017 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60018 this_arg_conv.is_owned = false;
60019 LDKScoreUpdate* ret_ret = MALLOC(sizeof(LDKScoreUpdate), "LDKScoreUpdate");
60020 *ret_ret = MultiThreadedScoreLockWrite_as_ScoreUpdate(&this_arg_conv);
60021 return tag_ptr(ret_ret, true);
60024 void __attribute__((export_name("TS_ChannelUsage_free"))) TS_ChannelUsage_free(uint64_t this_obj) {
60025 LDKChannelUsage this_obj_conv;
60026 this_obj_conv.inner = untag_ptr(this_obj);
60027 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60028 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60029 ChannelUsage_free(this_obj_conv);
60032 int64_t __attribute__((export_name("TS_ChannelUsage_get_amount_msat"))) TS_ChannelUsage_get_amount_msat(uint64_t this_ptr) {
60033 LDKChannelUsage this_ptr_conv;
60034 this_ptr_conv.inner = untag_ptr(this_ptr);
60035 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60037 this_ptr_conv.is_owned = false;
60038 int64_t ret_conv = ChannelUsage_get_amount_msat(&this_ptr_conv);
60042 void __attribute__((export_name("TS_ChannelUsage_set_amount_msat"))) TS_ChannelUsage_set_amount_msat(uint64_t this_ptr, int64_t val) {
60043 LDKChannelUsage this_ptr_conv;
60044 this_ptr_conv.inner = untag_ptr(this_ptr);
60045 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60047 this_ptr_conv.is_owned = false;
60048 ChannelUsage_set_amount_msat(&this_ptr_conv, val);
60051 int64_t __attribute__((export_name("TS_ChannelUsage_get_inflight_htlc_msat"))) TS_ChannelUsage_get_inflight_htlc_msat(uint64_t this_ptr) {
60052 LDKChannelUsage this_ptr_conv;
60053 this_ptr_conv.inner = untag_ptr(this_ptr);
60054 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60056 this_ptr_conv.is_owned = false;
60057 int64_t ret_conv = ChannelUsage_get_inflight_htlc_msat(&this_ptr_conv);
60061 void __attribute__((export_name("TS_ChannelUsage_set_inflight_htlc_msat"))) TS_ChannelUsage_set_inflight_htlc_msat(uint64_t this_ptr, int64_t val) {
60062 LDKChannelUsage this_ptr_conv;
60063 this_ptr_conv.inner = untag_ptr(this_ptr);
60064 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60065 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60066 this_ptr_conv.is_owned = false;
60067 ChannelUsage_set_inflight_htlc_msat(&this_ptr_conv, val);
60070 uint64_t __attribute__((export_name("TS_ChannelUsage_get_effective_capacity"))) TS_ChannelUsage_get_effective_capacity(uint64_t this_ptr) {
60071 LDKChannelUsage this_ptr_conv;
60072 this_ptr_conv.inner = untag_ptr(this_ptr);
60073 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60075 this_ptr_conv.is_owned = false;
60076 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
60077 *ret_copy = ChannelUsage_get_effective_capacity(&this_ptr_conv);
60078 uint64_t ret_ref = tag_ptr(ret_copy, true);
60082 void __attribute__((export_name("TS_ChannelUsage_set_effective_capacity"))) TS_ChannelUsage_set_effective_capacity(uint64_t this_ptr, uint64_t val) {
60083 LDKChannelUsage this_ptr_conv;
60084 this_ptr_conv.inner = untag_ptr(this_ptr);
60085 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60087 this_ptr_conv.is_owned = false;
60088 void* val_ptr = untag_ptr(val);
60089 CHECK_ACCESS(val_ptr);
60090 LDKEffectiveCapacity val_conv = *(LDKEffectiveCapacity*)(val_ptr);
60091 val_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(val));
60092 ChannelUsage_set_effective_capacity(&this_ptr_conv, val_conv);
60095 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) {
60096 void* effective_capacity_arg_ptr = untag_ptr(effective_capacity_arg);
60097 CHECK_ACCESS(effective_capacity_arg_ptr);
60098 LDKEffectiveCapacity effective_capacity_arg_conv = *(LDKEffectiveCapacity*)(effective_capacity_arg_ptr);
60099 effective_capacity_arg_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)untag_ptr(effective_capacity_arg));
60100 LDKChannelUsage ret_var = ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg_conv);
60101 uint64_t ret_ref = 0;
60102 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60103 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60107 static inline uint64_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg) {
60108 LDKChannelUsage ret_var = ChannelUsage_clone(arg);
60109 uint64_t ret_ref = 0;
60110 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60111 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60114 int64_t __attribute__((export_name("TS_ChannelUsage_clone_ptr"))) TS_ChannelUsage_clone_ptr(uint64_t arg) {
60115 LDKChannelUsage arg_conv;
60116 arg_conv.inner = untag_ptr(arg);
60117 arg_conv.is_owned = ptr_is_owned(arg);
60118 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
60119 arg_conv.is_owned = false;
60120 int64_t ret_conv = ChannelUsage_clone_ptr(&arg_conv);
60124 uint64_t __attribute__((export_name("TS_ChannelUsage_clone"))) TS_ChannelUsage_clone(uint64_t orig) {
60125 LDKChannelUsage orig_conv;
60126 orig_conv.inner = untag_ptr(orig);
60127 orig_conv.is_owned = ptr_is_owned(orig);
60128 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
60129 orig_conv.is_owned = false;
60130 LDKChannelUsage ret_var = ChannelUsage_clone(&orig_conv);
60131 uint64_t ret_ref = 0;
60132 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60133 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60137 void __attribute__((export_name("TS_FixedPenaltyScorer_free"))) TS_FixedPenaltyScorer_free(uint64_t this_obj) {
60138 LDKFixedPenaltyScorer this_obj_conv;
60139 this_obj_conv.inner = untag_ptr(this_obj);
60140 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60141 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60142 FixedPenaltyScorer_free(this_obj_conv);
60145 static inline uint64_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg) {
60146 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(arg);
60147 uint64_t ret_ref = 0;
60148 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60149 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60152 int64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone_ptr"))) TS_FixedPenaltyScorer_clone_ptr(uint64_t arg) {
60153 LDKFixedPenaltyScorer arg_conv;
60154 arg_conv.inner = untag_ptr(arg);
60155 arg_conv.is_owned = ptr_is_owned(arg);
60156 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
60157 arg_conv.is_owned = false;
60158 int64_t ret_conv = FixedPenaltyScorer_clone_ptr(&arg_conv);
60162 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_clone"))) TS_FixedPenaltyScorer_clone(uint64_t orig) {
60163 LDKFixedPenaltyScorer orig_conv;
60164 orig_conv.inner = untag_ptr(orig);
60165 orig_conv.is_owned = ptr_is_owned(orig);
60166 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
60167 orig_conv.is_owned = false;
60168 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(&orig_conv);
60169 uint64_t ret_ref = 0;
60170 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60171 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60175 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_with_penalty"))) TS_FixedPenaltyScorer_with_penalty(int64_t penalty_msat) {
60176 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_with_penalty(penalty_msat);
60177 uint64_t ret_ref = 0;
60178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60183 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_as_ScoreLookUp"))) TS_FixedPenaltyScorer_as_ScoreLookUp(uint64_t this_arg) {
60184 LDKFixedPenaltyScorer this_arg_conv;
60185 this_arg_conv.inner = untag_ptr(this_arg);
60186 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60188 this_arg_conv.is_owned = false;
60189 LDKScoreLookUp* ret_ret = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
60190 *ret_ret = FixedPenaltyScorer_as_ScoreLookUp(&this_arg_conv);
60191 return tag_ptr(ret_ret, true);
60194 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_as_ScoreUpdate"))) TS_FixedPenaltyScorer_as_ScoreUpdate(uint64_t this_arg) {
60195 LDKFixedPenaltyScorer this_arg_conv;
60196 this_arg_conv.inner = untag_ptr(this_arg);
60197 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60199 this_arg_conv.is_owned = false;
60200 LDKScoreUpdate* ret_ret = MALLOC(sizeof(LDKScoreUpdate), "LDKScoreUpdate");
60201 *ret_ret = FixedPenaltyScorer_as_ScoreUpdate(&this_arg_conv);
60202 return tag_ptr(ret_ret, true);
60205 int8_tArray __attribute__((export_name("TS_FixedPenaltyScorer_write"))) TS_FixedPenaltyScorer_write(uint64_t obj) {
60206 LDKFixedPenaltyScorer obj_conv;
60207 obj_conv.inner = untag_ptr(obj);
60208 obj_conv.is_owned = ptr_is_owned(obj);
60209 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
60210 obj_conv.is_owned = false;
60211 LDKCVec_u8Z ret_var = FixedPenaltyScorer_write(&obj_conv);
60212 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
60213 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
60214 CVec_u8Z_free(ret_var);
60218 uint64_t __attribute__((export_name("TS_FixedPenaltyScorer_read"))) TS_FixedPenaltyScorer_read(int8_tArray ser, int64_t arg) {
60219 LDKu8slice ser_ref;
60220 ser_ref.datalen = ser->arr_len;
60221 ser_ref.data = ser->elems;
60222 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
60223 *ret_conv = FixedPenaltyScorer_read(ser_ref, arg);
60225 return tag_ptr(ret_conv, true);
60228 void __attribute__((export_name("TS_ProbabilisticScorer_free"))) TS_ProbabilisticScorer_free(uint64_t this_obj) {
60229 LDKProbabilisticScorer this_obj_conv;
60230 this_obj_conv.inner = untag_ptr(this_obj);
60231 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60232 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60233 ProbabilisticScorer_free(this_obj_conv);
60236 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_free"))) TS_ProbabilisticScoringFeeParameters_free(uint64_t this_obj) {
60237 LDKProbabilisticScoringFeeParameters this_obj_conv;
60238 this_obj_conv.inner = untag_ptr(this_obj);
60239 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60241 ProbabilisticScoringFeeParameters_free(this_obj_conv);
60244 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_get_base_penalty_msat(uint64_t this_ptr) {
60245 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60246 this_ptr_conv.inner = untag_ptr(this_ptr);
60247 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60249 this_ptr_conv.is_owned = false;
60250 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_base_penalty_msat(&this_ptr_conv);
60254 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_set_base_penalty_msat(uint64_t this_ptr, int64_t val) {
60255 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60256 this_ptr_conv.inner = untag_ptr(this_ptr);
60257 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60259 this_ptr_conv.is_owned = false;
60260 ProbabilisticScoringFeeParameters_set_base_penalty_msat(&this_ptr_conv, val);
60263 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(uint64_t this_ptr) {
60264 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60265 this_ptr_conv.inner = untag_ptr(this_ptr);
60266 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60268 this_ptr_conv.is_owned = false;
60269 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_base_penalty_amount_multiplier_msat(&this_ptr_conv);
60273 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
60274 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60275 this_ptr_conv.inner = untag_ptr(this_ptr);
60276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60278 this_ptr_conv.is_owned = false;
60279 ProbabilisticScoringFeeParameters_set_base_penalty_amount_multiplier_msat(&this_ptr_conv, val);
60282 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
60283 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60284 this_ptr_conv.inner = untag_ptr(this_ptr);
60285 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60287 this_ptr_conv.is_owned = false;
60288 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_liquidity_penalty_multiplier_msat(&this_ptr_conv);
60292 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(uint64_t this_ptr, int64_t val) {
60293 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60294 this_ptr_conv.inner = untag_ptr(this_ptr);
60295 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60297 this_ptr_conv.is_owned = false;
60298 ProbabilisticScoringFeeParameters_set_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
60301 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr) {
60302 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60303 this_ptr_conv.inner = untag_ptr(this_ptr);
60304 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60306 this_ptr_conv.is_owned = false;
60307 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
60311 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
60312 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60313 this_ptr_conv.inner = untag_ptr(this_ptr);
60314 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60316 this_ptr_conv.is_owned = false;
60317 ProbabilisticScoringFeeParameters_set_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
60320 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(uint64_t this_ptr) {
60321 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60322 this_ptr_conv.inner = untag_ptr(this_ptr);
60323 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60325 this_ptr_conv.is_owned = false;
60326 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv);
60330 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(uint64_t this_ptr, int64_t val) {
60331 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60332 this_ptr_conv.inner = untag_ptr(this_ptr);
60333 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60335 this_ptr_conv.is_owned = false;
60336 ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
60339 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr) {
60340 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60341 this_ptr_conv.inner = untag_ptr(this_ptr);
60342 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60344 this_ptr_conv.is_owned = false;
60345 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
60349 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(uint64_t this_ptr, int64_t val) {
60350 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60351 this_ptr_conv.inner = untag_ptr(this_ptr);
60352 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60353 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60354 this_ptr_conv.is_owned = false;
60355 ProbabilisticScoringFeeParameters_set_historical_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
60358 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(uint64_t this_ptr) {
60359 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60360 this_ptr_conv.inner = untag_ptr(this_ptr);
60361 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60363 this_ptr_conv.is_owned = false;
60364 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_anti_probing_penalty_msat(&this_ptr_conv);
60368 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(uint64_t this_ptr, int64_t val) {
60369 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60370 this_ptr_conv.inner = untag_ptr(this_ptr);
60371 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60373 this_ptr_conv.is_owned = false;
60374 ProbabilisticScoringFeeParameters_set_anti_probing_penalty_msat(&this_ptr_conv, val);
60377 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(uint64_t this_ptr) {
60378 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60379 this_ptr_conv.inner = untag_ptr(this_ptr);
60380 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60381 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60382 this_ptr_conv.is_owned = false;
60383 int64_t ret_conv = ProbabilisticScoringFeeParameters_get_considered_impossible_penalty_msat(&this_ptr_conv);
60387 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(uint64_t this_ptr, int64_t val) {
60388 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60389 this_ptr_conv.inner = untag_ptr(this_ptr);
60390 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60391 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60392 this_ptr_conv.is_owned = false;
60393 ProbabilisticScoringFeeParameters_set_considered_impossible_penalty_msat(&this_ptr_conv, val);
60396 jboolean __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_get_linear_success_probability"))) TS_ProbabilisticScoringFeeParameters_get_linear_success_probability(uint64_t this_ptr) {
60397 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60398 this_ptr_conv.inner = untag_ptr(this_ptr);
60399 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60401 this_ptr_conv.is_owned = false;
60402 jboolean ret_conv = ProbabilisticScoringFeeParameters_get_linear_success_probability(&this_ptr_conv);
60406 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_linear_success_probability"))) TS_ProbabilisticScoringFeeParameters_set_linear_success_probability(uint64_t this_ptr, jboolean val) {
60407 LDKProbabilisticScoringFeeParameters this_ptr_conv;
60408 this_ptr_conv.inner = untag_ptr(this_ptr);
60409 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60410 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60411 this_ptr_conv.is_owned = false;
60412 ProbabilisticScoringFeeParameters_set_linear_success_probability(&this_ptr_conv, val);
60415 static inline uint64_t ProbabilisticScoringFeeParameters_clone_ptr(LDKProbabilisticScoringFeeParameters *NONNULL_PTR arg) {
60416 LDKProbabilisticScoringFeeParameters ret_var = ProbabilisticScoringFeeParameters_clone(arg);
60417 uint64_t ret_ref = 0;
60418 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60419 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60422 int64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_clone_ptr"))) TS_ProbabilisticScoringFeeParameters_clone_ptr(uint64_t arg) {
60423 LDKProbabilisticScoringFeeParameters arg_conv;
60424 arg_conv.inner = untag_ptr(arg);
60425 arg_conv.is_owned = ptr_is_owned(arg);
60426 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
60427 arg_conv.is_owned = false;
60428 int64_t ret_conv = ProbabilisticScoringFeeParameters_clone_ptr(&arg_conv);
60432 uint64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_clone"))) TS_ProbabilisticScoringFeeParameters_clone(uint64_t orig) {
60433 LDKProbabilisticScoringFeeParameters orig_conv;
60434 orig_conv.inner = untag_ptr(orig);
60435 orig_conv.is_owned = ptr_is_owned(orig);
60436 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
60437 orig_conv.is_owned = false;
60438 LDKProbabilisticScoringFeeParameters ret_var = ProbabilisticScoringFeeParameters_clone(&orig_conv);
60439 uint64_t ret_ref = 0;
60440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60441 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60445 uint64_t __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_default"))) TS_ProbabilisticScoringFeeParameters_default() {
60446 LDKProbabilisticScoringFeeParameters ret_var = ProbabilisticScoringFeeParameters_default();
60447 uint64_t ret_ref = 0;
60448 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60449 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60453 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_add_banned"))) TS_ProbabilisticScoringFeeParameters_add_banned(uint64_t this_arg, uint64_t node_id) {
60454 LDKProbabilisticScoringFeeParameters this_arg_conv;
60455 this_arg_conv.inner = untag_ptr(this_arg);
60456 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60458 this_arg_conv.is_owned = false;
60459 LDKNodeId node_id_conv;
60460 node_id_conv.inner = untag_ptr(node_id);
60461 node_id_conv.is_owned = ptr_is_owned(node_id);
60462 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
60463 node_id_conv.is_owned = false;
60464 ProbabilisticScoringFeeParameters_add_banned(&this_arg_conv, &node_id_conv);
60467 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_add_banned_from_list"))) TS_ProbabilisticScoringFeeParameters_add_banned_from_list(uint64_t this_arg, uint64_tArray node_ids) {
60468 LDKProbabilisticScoringFeeParameters this_arg_conv;
60469 this_arg_conv.inner = untag_ptr(this_arg);
60470 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60471 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60472 this_arg_conv.is_owned = false;
60473 LDKCVec_NodeIdZ node_ids_constr;
60474 node_ids_constr.datalen = node_ids->arr_len;
60475 if (node_ids_constr.datalen > 0)
60476 node_ids_constr.data = MALLOC(node_ids_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
60478 node_ids_constr.data = NULL;
60479 uint64_t* node_ids_vals = node_ids->elems;
60480 for (size_t i = 0; i < node_ids_constr.datalen; i++) {
60481 uint64_t node_ids_conv_8 = node_ids_vals[i];
60482 LDKNodeId node_ids_conv_8_conv;
60483 node_ids_conv_8_conv.inner = untag_ptr(node_ids_conv_8);
60484 node_ids_conv_8_conv.is_owned = ptr_is_owned(node_ids_conv_8);
60485 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_ids_conv_8_conv);
60486 node_ids_conv_8_conv = NodeId_clone(&node_ids_conv_8_conv);
60487 node_ids_constr.data[i] = node_ids_conv_8_conv;
60490 ProbabilisticScoringFeeParameters_add_banned_from_list(&this_arg_conv, node_ids_constr);
60493 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_remove_banned"))) TS_ProbabilisticScoringFeeParameters_remove_banned(uint64_t this_arg, uint64_t node_id) {
60494 LDKProbabilisticScoringFeeParameters this_arg_conv;
60495 this_arg_conv.inner = untag_ptr(this_arg);
60496 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60498 this_arg_conv.is_owned = false;
60499 LDKNodeId node_id_conv;
60500 node_id_conv.inner = untag_ptr(node_id);
60501 node_id_conv.is_owned = ptr_is_owned(node_id);
60502 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
60503 node_id_conv.is_owned = false;
60504 ProbabilisticScoringFeeParameters_remove_banned(&this_arg_conv, &node_id_conv);
60507 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_set_manual_penalty"))) TS_ProbabilisticScoringFeeParameters_set_manual_penalty(uint64_t this_arg, uint64_t node_id, int64_t penalty) {
60508 LDKProbabilisticScoringFeeParameters this_arg_conv;
60509 this_arg_conv.inner = untag_ptr(this_arg);
60510 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60512 this_arg_conv.is_owned = false;
60513 LDKNodeId node_id_conv;
60514 node_id_conv.inner = untag_ptr(node_id);
60515 node_id_conv.is_owned = ptr_is_owned(node_id);
60516 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
60517 node_id_conv.is_owned = false;
60518 ProbabilisticScoringFeeParameters_set_manual_penalty(&this_arg_conv, &node_id_conv, penalty);
60521 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_remove_manual_penalty"))) TS_ProbabilisticScoringFeeParameters_remove_manual_penalty(uint64_t this_arg, uint64_t node_id) {
60522 LDKProbabilisticScoringFeeParameters this_arg_conv;
60523 this_arg_conv.inner = untag_ptr(this_arg);
60524 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60526 this_arg_conv.is_owned = false;
60527 LDKNodeId node_id_conv;
60528 node_id_conv.inner = untag_ptr(node_id);
60529 node_id_conv.is_owned = ptr_is_owned(node_id);
60530 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
60531 node_id_conv.is_owned = false;
60532 ProbabilisticScoringFeeParameters_remove_manual_penalty(&this_arg_conv, &node_id_conv);
60535 void __attribute__((export_name("TS_ProbabilisticScoringFeeParameters_clear_manual_penalties"))) TS_ProbabilisticScoringFeeParameters_clear_manual_penalties(uint64_t this_arg) {
60536 LDKProbabilisticScoringFeeParameters this_arg_conv;
60537 this_arg_conv.inner = untag_ptr(this_arg);
60538 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60540 this_arg_conv.is_owned = false;
60541 ProbabilisticScoringFeeParameters_clear_manual_penalties(&this_arg_conv);
60544 void __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_free"))) TS_ProbabilisticScoringDecayParameters_free(uint64_t this_obj) {
60545 LDKProbabilisticScoringDecayParameters this_obj_conv;
60546 this_obj_conv.inner = untag_ptr(this_obj);
60547 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60549 ProbabilisticScoringDecayParameters_free(this_obj_conv);
60552 int64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life"))) TS_ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(uint64_t this_ptr) {
60553 LDKProbabilisticScoringDecayParameters this_ptr_conv;
60554 this_ptr_conv.inner = untag_ptr(this_ptr);
60555 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60557 this_ptr_conv.is_owned = false;
60558 int64_t ret_conv = ProbabilisticScoringDecayParameters_get_historical_no_updates_half_life(&this_ptr_conv);
60562 void __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life"))) TS_ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(uint64_t this_ptr, int64_t val) {
60563 LDKProbabilisticScoringDecayParameters this_ptr_conv;
60564 this_ptr_conv.inner = untag_ptr(this_ptr);
60565 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60567 this_ptr_conv.is_owned = false;
60568 ProbabilisticScoringDecayParameters_set_historical_no_updates_half_life(&this_ptr_conv, val);
60571 int64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life"))) TS_ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(uint64_t this_ptr) {
60572 LDKProbabilisticScoringDecayParameters this_ptr_conv;
60573 this_ptr_conv.inner = untag_ptr(this_ptr);
60574 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60576 this_ptr_conv.is_owned = false;
60577 int64_t ret_conv = ProbabilisticScoringDecayParameters_get_liquidity_offset_half_life(&this_ptr_conv);
60581 void __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life"))) TS_ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(uint64_t this_ptr, int64_t val) {
60582 LDKProbabilisticScoringDecayParameters this_ptr_conv;
60583 this_ptr_conv.inner = untag_ptr(this_ptr);
60584 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60586 this_ptr_conv.is_owned = false;
60587 ProbabilisticScoringDecayParameters_set_liquidity_offset_half_life(&this_ptr_conv, val);
60590 uint64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_new"))) TS_ProbabilisticScoringDecayParameters_new(int64_t historical_no_updates_half_life_arg, int64_t liquidity_offset_half_life_arg) {
60591 LDKProbabilisticScoringDecayParameters ret_var = ProbabilisticScoringDecayParameters_new(historical_no_updates_half_life_arg, liquidity_offset_half_life_arg);
60592 uint64_t ret_ref = 0;
60593 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60594 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60598 static inline uint64_t ProbabilisticScoringDecayParameters_clone_ptr(LDKProbabilisticScoringDecayParameters *NONNULL_PTR arg) {
60599 LDKProbabilisticScoringDecayParameters ret_var = ProbabilisticScoringDecayParameters_clone(arg);
60600 uint64_t ret_ref = 0;
60601 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60602 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60605 int64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_clone_ptr"))) TS_ProbabilisticScoringDecayParameters_clone_ptr(uint64_t arg) {
60606 LDKProbabilisticScoringDecayParameters arg_conv;
60607 arg_conv.inner = untag_ptr(arg);
60608 arg_conv.is_owned = ptr_is_owned(arg);
60609 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
60610 arg_conv.is_owned = false;
60611 int64_t ret_conv = ProbabilisticScoringDecayParameters_clone_ptr(&arg_conv);
60615 uint64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_clone"))) TS_ProbabilisticScoringDecayParameters_clone(uint64_t orig) {
60616 LDKProbabilisticScoringDecayParameters orig_conv;
60617 orig_conv.inner = untag_ptr(orig);
60618 orig_conv.is_owned = ptr_is_owned(orig);
60619 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
60620 orig_conv.is_owned = false;
60621 LDKProbabilisticScoringDecayParameters ret_var = ProbabilisticScoringDecayParameters_clone(&orig_conv);
60622 uint64_t ret_ref = 0;
60623 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60624 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60628 uint64_t __attribute__((export_name("TS_ProbabilisticScoringDecayParameters_default"))) TS_ProbabilisticScoringDecayParameters_default() {
60629 LDKProbabilisticScoringDecayParameters ret_var = ProbabilisticScoringDecayParameters_default();
60630 uint64_t ret_ref = 0;
60631 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60632 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60636 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_new"))) TS_ProbabilisticScorer_new(uint64_t decay_params, uint64_t network_graph, uint64_t logger) {
60637 LDKProbabilisticScoringDecayParameters decay_params_conv;
60638 decay_params_conv.inner = untag_ptr(decay_params);
60639 decay_params_conv.is_owned = ptr_is_owned(decay_params);
60640 CHECK_INNER_FIELD_ACCESS_OR_NULL(decay_params_conv);
60641 decay_params_conv = ProbabilisticScoringDecayParameters_clone(&decay_params_conv);
60642 LDKNetworkGraph network_graph_conv;
60643 network_graph_conv.inner = untag_ptr(network_graph);
60644 network_graph_conv.is_owned = ptr_is_owned(network_graph);
60645 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
60646 network_graph_conv.is_owned = false;
60647 void* logger_ptr = untag_ptr(logger);
60648 CHECK_ACCESS(logger_ptr);
60649 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
60650 if (logger_conv.free == LDKLogger_JCalls_free) {
60651 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
60652 LDKLogger_JCalls_cloned(&logger_conv);
60654 LDKProbabilisticScorer ret_var = ProbabilisticScorer_new(decay_params_conv, &network_graph_conv, logger_conv);
60655 uint64_t ret_ref = 0;
60656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60657 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60661 void __attribute__((export_name("TS_ProbabilisticScorer_debug_log_liquidity_stats"))) TS_ProbabilisticScorer_debug_log_liquidity_stats(uint64_t this_arg) {
60662 LDKProbabilisticScorer this_arg_conv;
60663 this_arg_conv.inner = untag_ptr(this_arg);
60664 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60666 this_arg_conv.is_owned = false;
60667 ProbabilisticScorer_debug_log_liquidity_stats(&this_arg_conv);
60670 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) {
60671 LDKProbabilisticScorer this_arg_conv;
60672 this_arg_conv.inner = untag_ptr(this_arg);
60673 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60675 this_arg_conv.is_owned = false;
60676 LDKNodeId target_conv;
60677 target_conv.inner = untag_ptr(target);
60678 target_conv.is_owned = ptr_is_owned(target);
60679 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
60680 target_conv.is_owned = false;
60681 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
60682 *ret_copy = ProbabilisticScorer_estimated_channel_liquidity_range(&this_arg_conv, scid, &target_conv);
60683 uint64_t ret_ref = tag_ptr(ret_copy, true);
60687 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) {
60688 LDKProbabilisticScorer this_arg_conv;
60689 this_arg_conv.inner = untag_ptr(this_arg);
60690 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60692 this_arg_conv.is_owned = false;
60693 LDKNodeId target_conv;
60694 target_conv.inner = untag_ptr(target);
60695 target_conv.is_owned = ptr_is_owned(target);
60696 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
60697 target_conv.is_owned = false;
60698 LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ), "LDKCOption_C2Tuple_ThirtyTwoU16sThirtyTwoU16sZZ");
60699 *ret_copy = ProbabilisticScorer_historical_estimated_channel_liquidity_probabilities(&this_arg_conv, scid, &target_conv);
60700 uint64_t ret_ref = tag_ptr(ret_copy, true);
60704 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_historical_estimated_payment_success_probability"))) TS_ProbabilisticScorer_historical_estimated_payment_success_probability(uint64_t this_arg, int64_t scid, uint64_t target, int64_t amount_msat, uint64_t params) {
60705 LDKProbabilisticScorer this_arg_conv;
60706 this_arg_conv.inner = untag_ptr(this_arg);
60707 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60708 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60709 this_arg_conv.is_owned = false;
60710 LDKNodeId target_conv;
60711 target_conv.inner = untag_ptr(target);
60712 target_conv.is_owned = ptr_is_owned(target);
60713 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
60714 target_conv.is_owned = false;
60715 LDKProbabilisticScoringFeeParameters params_conv;
60716 params_conv.inner = untag_ptr(params);
60717 params_conv.is_owned = ptr_is_owned(params);
60718 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
60719 params_conv.is_owned = false;
60720 LDKCOption_f64Z *ret_copy = MALLOC(sizeof(LDKCOption_f64Z), "LDKCOption_f64Z");
60721 *ret_copy = ProbabilisticScorer_historical_estimated_payment_success_probability(&this_arg_conv, scid, &target_conv, amount_msat, ¶ms_conv);
60722 uint64_t ret_ref = tag_ptr(ret_copy, true);
60726 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_ScoreLookUp"))) TS_ProbabilisticScorer_as_ScoreLookUp(uint64_t this_arg) {
60727 LDKProbabilisticScorer this_arg_conv;
60728 this_arg_conv.inner = untag_ptr(this_arg);
60729 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60731 this_arg_conv.is_owned = false;
60732 LDKScoreLookUp* ret_ret = MALLOC(sizeof(LDKScoreLookUp), "LDKScoreLookUp");
60733 *ret_ret = ProbabilisticScorer_as_ScoreLookUp(&this_arg_conv);
60734 return tag_ptr(ret_ret, true);
60737 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_ScoreUpdate"))) TS_ProbabilisticScorer_as_ScoreUpdate(uint64_t this_arg) {
60738 LDKProbabilisticScorer this_arg_conv;
60739 this_arg_conv.inner = untag_ptr(this_arg);
60740 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60742 this_arg_conv.is_owned = false;
60743 LDKScoreUpdate* ret_ret = MALLOC(sizeof(LDKScoreUpdate), "LDKScoreUpdate");
60744 *ret_ret = ProbabilisticScorer_as_ScoreUpdate(&this_arg_conv);
60745 return tag_ptr(ret_ret, true);
60748 uint64_t __attribute__((export_name("TS_ProbabilisticScorer_as_Score"))) TS_ProbabilisticScorer_as_Score(uint64_t this_arg) {
60749 LDKProbabilisticScorer this_arg_conv;
60750 this_arg_conv.inner = untag_ptr(this_arg);
60751 this_arg_conv.is_owned = ptr_is_owned(this_arg);
60752 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
60753 this_arg_conv.is_owned = false;
60754 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
60755 *ret_ret = ProbabilisticScorer_as_Score(&this_arg_conv);
60756 return tag_ptr(ret_ret, true);
60759 int8_tArray __attribute__((export_name("TS_ProbabilisticScorer_write"))) TS_ProbabilisticScorer_write(uint64_t obj) {
60760 LDKProbabilisticScorer obj_conv;
60761 obj_conv.inner = untag_ptr(obj);
60762 obj_conv.is_owned = ptr_is_owned(obj);
60763 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
60764 obj_conv.is_owned = false;
60765 LDKCVec_u8Z ret_var = ProbabilisticScorer_write(&obj_conv);
60766 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
60767 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
60768 CVec_u8Z_free(ret_var);
60772 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) {
60773 LDKu8slice ser_ref;
60774 ser_ref.datalen = ser->arr_len;
60775 ser_ref.data = ser->elems;
60776 LDKProbabilisticScoringDecayParameters arg_a_conv;
60777 arg_a_conv.inner = untag_ptr(arg_a);
60778 arg_a_conv.is_owned = ptr_is_owned(arg_a);
60779 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_a_conv);
60780 arg_a_conv = ProbabilisticScoringDecayParameters_clone(&arg_a_conv);
60781 LDKNetworkGraph arg_b_conv;
60782 arg_b_conv.inner = untag_ptr(arg_b);
60783 arg_b_conv.is_owned = ptr_is_owned(arg_b);
60784 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_b_conv);
60785 arg_b_conv.is_owned = false;
60786 void* arg_c_ptr = untag_ptr(arg_c);
60787 CHECK_ACCESS(arg_c_ptr);
60788 LDKLogger arg_c_conv = *(LDKLogger*)(arg_c_ptr);
60789 if (arg_c_conv.free == LDKLogger_JCalls_free) {
60790 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
60791 LDKLogger_JCalls_cloned(&arg_c_conv);
60793 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
60794 *ret_conv = ProbabilisticScorer_read(ser_ref, arg_a_conv, &arg_b_conv, arg_c_conv);
60796 return tag_ptr(ret_conv, true);
60799 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_free"))) TS_DelayedPaymentOutputDescriptor_free(uint64_t this_obj) {
60800 LDKDelayedPaymentOutputDescriptor this_obj_conv;
60801 this_obj_conv.inner = untag_ptr(this_obj);
60802 this_obj_conv.is_owned = ptr_is_owned(this_obj);
60803 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
60804 DelayedPaymentOutputDescriptor_free(this_obj_conv);
60807 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_outpoint"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
60808 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60809 this_ptr_conv.inner = untag_ptr(this_ptr);
60810 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60812 this_ptr_conv.is_owned = false;
60813 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
60814 uint64_t ret_ref = 0;
60815 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60816 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60820 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_outpoint"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
60821 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60822 this_ptr_conv.inner = untag_ptr(this_ptr);
60823 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60824 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60825 this_ptr_conv.is_owned = false;
60826 LDKOutPoint val_conv;
60827 val_conv.inner = untag_ptr(val);
60828 val_conv.is_owned = ptr_is_owned(val);
60829 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
60830 val_conv = OutPoint_clone(&val_conv);
60831 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
60834 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint64_t this_ptr) {
60835 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60836 this_ptr_conv.inner = untag_ptr(this_ptr);
60837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60839 this_ptr_conv.is_owned = false;
60840 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
60841 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
60845 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
60846 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60847 this_ptr_conv.inner = untag_ptr(this_ptr);
60848 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60849 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60850 this_ptr_conv.is_owned = false;
60851 LDKPublicKey val_ref;
60852 CHECK(val->arr_len == 33);
60853 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
60854 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
60857 int16_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint64_t this_ptr) {
60858 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60859 this_ptr_conv.inner = untag_ptr(this_ptr);
60860 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60862 this_ptr_conv.is_owned = false;
60863 int16_t ret_conv = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
60867 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint64_t this_ptr, int16_t val) {
60868 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60869 this_ptr_conv.inner = untag_ptr(this_ptr);
60870 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60871 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60872 this_ptr_conv.is_owned = false;
60873 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
60876 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_output"))) TS_DelayedPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
60877 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60878 this_ptr_conv.inner = untag_ptr(this_ptr);
60879 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60881 this_ptr_conv.is_owned = false;
60882 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
60883 *ret_ref = DelayedPaymentOutputDescriptor_get_output(&this_ptr_conv);
60884 return tag_ptr(ret_ref, true);
60887 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_output"))) TS_DelayedPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
60888 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60889 this_ptr_conv.inner = untag_ptr(this_ptr);
60890 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60891 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60892 this_ptr_conv.is_owned = false;
60893 void* val_ptr = untag_ptr(val);
60894 CHECK_ACCESS(val_ptr);
60895 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
60896 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
60897 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
60900 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint64_t this_ptr) {
60901 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60902 this_ptr_conv.inner = untag_ptr(this_ptr);
60903 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60905 this_ptr_conv.is_owned = false;
60906 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
60907 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
60911 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint64_t this_ptr, int8_tArray val) {
60912 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60913 this_ptr_conv.inner = untag_ptr(this_ptr);
60914 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60916 this_ptr_conv.is_owned = false;
60917 LDKPublicKey val_ref;
60918 CHECK(val->arr_len == 33);
60919 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
60920 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
60923 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
60924 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60925 this_ptr_conv.inner = untag_ptr(this_ptr);
60926 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60928 this_ptr_conv.is_owned = false;
60929 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
60930 memcpy(ret_arr->elems, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
60934 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
60935 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60936 this_ptr_conv.inner = untag_ptr(this_ptr);
60937 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60938 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60939 this_ptr_conv.is_owned = false;
60940 LDKThirtyTwoBytes val_ref;
60941 CHECK(val->arr_len == 32);
60942 memcpy(val_ref.data, val->elems, 32); FREE(val);
60943 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
60946 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
60947 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60948 this_ptr_conv.inner = untag_ptr(this_ptr);
60949 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60951 this_ptr_conv.is_owned = false;
60952 int64_t ret_conv = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
60956 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
60957 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
60958 this_ptr_conv.inner = untag_ptr(this_ptr);
60959 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
60960 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
60961 this_ptr_conv.is_owned = false;
60962 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
60965 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) {
60966 LDKOutPoint outpoint_arg_conv;
60967 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
60968 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
60969 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
60970 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
60971 LDKPublicKey per_commitment_point_arg_ref;
60972 CHECK(per_commitment_point_arg->arr_len == 33);
60973 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
60974 void* output_arg_ptr = untag_ptr(output_arg);
60975 CHECK_ACCESS(output_arg_ptr);
60976 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
60977 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
60978 LDKPublicKey revocation_pubkey_arg_ref;
60979 CHECK(revocation_pubkey_arg->arr_len == 33);
60980 memcpy(revocation_pubkey_arg_ref.compressed_form, revocation_pubkey_arg->elems, 33); FREE(revocation_pubkey_arg);
60981 LDKThirtyTwoBytes channel_keys_id_arg_ref;
60982 CHECK(channel_keys_id_arg->arr_len == 32);
60983 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
60984 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);
60985 uint64_t ret_ref = 0;
60986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60991 static inline uint64_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
60992 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
60993 uint64_t ret_ref = 0;
60994 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
60995 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
60998 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone_ptr"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
60999 LDKDelayedPaymentOutputDescriptor arg_conv;
61000 arg_conv.inner = untag_ptr(arg);
61001 arg_conv.is_owned = ptr_is_owned(arg);
61002 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
61003 arg_conv.is_owned = false;
61004 int64_t ret_conv = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
61008 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone"))) TS_DelayedPaymentOutputDescriptor_clone(uint64_t orig) {
61009 LDKDelayedPaymentOutputDescriptor orig_conv;
61010 orig_conv.inner = untag_ptr(orig);
61011 orig_conv.is_owned = ptr_is_owned(orig);
61012 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
61013 orig_conv.is_owned = false;
61014 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
61015 uint64_t ret_ref = 0;
61016 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61017 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61021 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_hash"))) TS_DelayedPaymentOutputDescriptor_hash(uint64_t o) {
61022 LDKDelayedPaymentOutputDescriptor o_conv;
61023 o_conv.inner = untag_ptr(o);
61024 o_conv.is_owned = ptr_is_owned(o);
61025 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
61026 o_conv.is_owned = false;
61027 int64_t ret_conv = DelayedPaymentOutputDescriptor_hash(&o_conv);
61031 jboolean __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_eq"))) TS_DelayedPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
61032 LDKDelayedPaymentOutputDescriptor a_conv;
61033 a_conv.inner = untag_ptr(a);
61034 a_conv.is_owned = ptr_is_owned(a);
61035 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
61036 a_conv.is_owned = false;
61037 LDKDelayedPaymentOutputDescriptor b_conv;
61038 b_conv.inner = untag_ptr(b);
61039 b_conv.is_owned = ptr_is_owned(b);
61040 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
61041 b_conv.is_owned = false;
61042 jboolean ret_conv = DelayedPaymentOutputDescriptor_eq(&a_conv, &b_conv);
61046 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_write"))) TS_DelayedPaymentOutputDescriptor_write(uint64_t obj) {
61047 LDKDelayedPaymentOutputDescriptor obj_conv;
61048 obj_conv.inner = untag_ptr(obj);
61049 obj_conv.is_owned = ptr_is_owned(obj);
61050 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
61051 obj_conv.is_owned = false;
61052 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
61053 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
61054 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
61055 CVec_u8Z_free(ret_var);
61059 uint64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_read"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
61060 LDKu8slice ser_ref;
61061 ser_ref.datalen = ser->arr_len;
61062 ser_ref.data = ser->elems;
61063 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
61064 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
61066 return tag_ptr(ret_conv, true);
61069 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_free"))) TS_StaticPaymentOutputDescriptor_free(uint64_t this_obj) {
61070 LDKStaticPaymentOutputDescriptor this_obj_conv;
61071 this_obj_conv.inner = untag_ptr(this_obj);
61072 this_obj_conv.is_owned = ptr_is_owned(this_obj);
61073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
61074 StaticPaymentOutputDescriptor_free(this_obj_conv);
61077 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_outpoint"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint64_t this_ptr) {
61078 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61079 this_ptr_conv.inner = untag_ptr(this_ptr);
61080 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61082 this_ptr_conv.is_owned = false;
61083 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
61084 uint64_t ret_ref = 0;
61085 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61086 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61090 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_outpoint"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
61091 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61092 this_ptr_conv.inner = untag_ptr(this_ptr);
61093 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61095 this_ptr_conv.is_owned = false;
61096 LDKOutPoint val_conv;
61097 val_conv.inner = untag_ptr(val);
61098 val_conv.is_owned = ptr_is_owned(val);
61099 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
61100 val_conv = OutPoint_clone(&val_conv);
61101 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
61104 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_output"))) TS_StaticPaymentOutputDescriptor_get_output(uint64_t this_ptr) {
61105 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61106 this_ptr_conv.inner = untag_ptr(this_ptr);
61107 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61109 this_ptr_conv.is_owned = false;
61110 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
61111 *ret_ref = StaticPaymentOutputDescriptor_get_output(&this_ptr_conv);
61112 return tag_ptr(ret_ref, true);
61115 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_output"))) TS_StaticPaymentOutputDescriptor_set_output(uint64_t this_ptr, uint64_t val) {
61116 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61117 this_ptr_conv.inner = untag_ptr(this_ptr);
61118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61120 this_ptr_conv.is_owned = false;
61121 void* val_ptr = untag_ptr(val);
61122 CHECK_ACCESS(val_ptr);
61123 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
61124 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
61125 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
61128 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint64_t this_ptr) {
61129 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61130 this_ptr_conv.inner = untag_ptr(this_ptr);
61131 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61133 this_ptr_conv.is_owned = false;
61134 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61135 memcpy(ret_arr->elems, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
61139 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint64_t this_ptr, int8_tArray val) {
61140 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61141 this_ptr_conv.inner = untag_ptr(this_ptr);
61142 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61144 this_ptr_conv.is_owned = false;
61145 LDKThirtyTwoBytes val_ref;
61146 CHECK(val->arr_len == 32);
61147 memcpy(val_ref.data, val->elems, 32); FREE(val);
61148 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
61151 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint64_t this_ptr) {
61152 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61153 this_ptr_conv.inner = untag_ptr(this_ptr);
61154 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61156 this_ptr_conv.is_owned = false;
61157 int64_t ret_conv = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
61161 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint64_t this_ptr, int64_t val) {
61162 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61163 this_ptr_conv.inner = untag_ptr(this_ptr);
61164 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61166 this_ptr_conv.is_owned = false;
61167 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
61170 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters"))) TS_StaticPaymentOutputDescriptor_get_channel_transaction_parameters(uint64_t this_ptr) {
61171 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61172 this_ptr_conv.inner = untag_ptr(this_ptr);
61173 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61175 this_ptr_conv.is_owned = false;
61176 LDKChannelTransactionParameters ret_var = StaticPaymentOutputDescriptor_get_channel_transaction_parameters(&this_ptr_conv);
61177 uint64_t ret_ref = 0;
61178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61179 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61183 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters"))) TS_StaticPaymentOutputDescriptor_set_channel_transaction_parameters(uint64_t this_ptr, uint64_t val) {
61184 LDKStaticPaymentOutputDescriptor this_ptr_conv;
61185 this_ptr_conv.inner = untag_ptr(this_ptr);
61186 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61188 this_ptr_conv.is_owned = false;
61189 LDKChannelTransactionParameters val_conv;
61190 val_conv.inner = untag_ptr(val);
61191 val_conv.is_owned = ptr_is_owned(val);
61192 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
61193 val_conv = ChannelTransactionParameters_clone(&val_conv);
61194 StaticPaymentOutputDescriptor_set_channel_transaction_parameters(&this_ptr_conv, val_conv);
61197 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, uint64_t channel_transaction_parameters_arg) {
61198 LDKOutPoint outpoint_arg_conv;
61199 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
61200 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
61201 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
61202 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
61203 void* output_arg_ptr = untag_ptr(output_arg);
61204 CHECK_ACCESS(output_arg_ptr);
61205 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
61206 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
61207 LDKThirtyTwoBytes channel_keys_id_arg_ref;
61208 CHECK(channel_keys_id_arg->arr_len == 32);
61209 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
61210 LDKChannelTransactionParameters channel_transaction_parameters_arg_conv;
61211 channel_transaction_parameters_arg_conv.inner = untag_ptr(channel_transaction_parameters_arg);
61212 channel_transaction_parameters_arg_conv.is_owned = ptr_is_owned(channel_transaction_parameters_arg);
61213 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_transaction_parameters_arg_conv);
61214 channel_transaction_parameters_arg_conv = ChannelTransactionParameters_clone(&channel_transaction_parameters_arg_conv);
61215 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg, channel_transaction_parameters_arg_conv);
61216 uint64_t ret_ref = 0;
61217 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61218 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61222 static inline uint64_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
61223 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
61224 uint64_t ret_ref = 0;
61225 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61226 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61229 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone_ptr"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint64_t arg) {
61230 LDKStaticPaymentOutputDescriptor arg_conv;
61231 arg_conv.inner = untag_ptr(arg);
61232 arg_conv.is_owned = ptr_is_owned(arg);
61233 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
61234 arg_conv.is_owned = false;
61235 int64_t ret_conv = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
61239 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone"))) TS_StaticPaymentOutputDescriptor_clone(uint64_t orig) {
61240 LDKStaticPaymentOutputDescriptor orig_conv;
61241 orig_conv.inner = untag_ptr(orig);
61242 orig_conv.is_owned = ptr_is_owned(orig);
61243 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
61244 orig_conv.is_owned = false;
61245 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
61246 uint64_t ret_ref = 0;
61247 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61248 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61252 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_hash"))) TS_StaticPaymentOutputDescriptor_hash(uint64_t o) {
61253 LDKStaticPaymentOutputDescriptor o_conv;
61254 o_conv.inner = untag_ptr(o);
61255 o_conv.is_owned = ptr_is_owned(o);
61256 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
61257 o_conv.is_owned = false;
61258 int64_t ret_conv = StaticPaymentOutputDescriptor_hash(&o_conv);
61262 jboolean __attribute__((export_name("TS_StaticPaymentOutputDescriptor_eq"))) TS_StaticPaymentOutputDescriptor_eq(uint64_t a, uint64_t b) {
61263 LDKStaticPaymentOutputDescriptor a_conv;
61264 a_conv.inner = untag_ptr(a);
61265 a_conv.is_owned = ptr_is_owned(a);
61266 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
61267 a_conv.is_owned = false;
61268 LDKStaticPaymentOutputDescriptor b_conv;
61269 b_conv.inner = untag_ptr(b);
61270 b_conv.is_owned = ptr_is_owned(b);
61271 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
61272 b_conv.is_owned = false;
61273 jboolean ret_conv = StaticPaymentOutputDescriptor_eq(&a_conv, &b_conv);
61277 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_witness_script"))) TS_StaticPaymentOutputDescriptor_witness_script(uint64_t this_arg) {
61278 LDKStaticPaymentOutputDescriptor this_arg_conv;
61279 this_arg_conv.inner = untag_ptr(this_arg);
61280 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61282 this_arg_conv.is_owned = false;
61283 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
61284 *ret_copy = StaticPaymentOutputDescriptor_witness_script(&this_arg_conv);
61285 uint64_t ret_ref = tag_ptr(ret_copy, true);
61289 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_max_witness_length"))) TS_StaticPaymentOutputDescriptor_max_witness_length(uint64_t this_arg) {
61290 LDKStaticPaymentOutputDescriptor this_arg_conv;
61291 this_arg_conv.inner = untag_ptr(this_arg);
61292 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61293 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61294 this_arg_conv.is_owned = false;
61295 uint32_t ret_conv = StaticPaymentOutputDescriptor_max_witness_length(&this_arg_conv);
61299 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_write"))) TS_StaticPaymentOutputDescriptor_write(uint64_t obj) {
61300 LDKStaticPaymentOutputDescriptor obj_conv;
61301 obj_conv.inner = untag_ptr(obj);
61302 obj_conv.is_owned = ptr_is_owned(obj);
61303 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
61304 obj_conv.is_owned = false;
61305 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
61306 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
61307 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
61308 CVec_u8Z_free(ret_var);
61312 uint64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_read"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
61313 LDKu8slice ser_ref;
61314 ser_ref.datalen = ser->arr_len;
61315 ser_ref.data = ser->elems;
61316 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
61317 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
61319 return tag_ptr(ret_conv, true);
61322 void __attribute__((export_name("TS_SpendableOutputDescriptor_free"))) TS_SpendableOutputDescriptor_free(uint64_t this_ptr) {
61323 if (!ptr_is_owned(this_ptr)) return;
61324 void* this_ptr_ptr = untag_ptr(this_ptr);
61325 CHECK_ACCESS(this_ptr_ptr);
61326 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(this_ptr_ptr);
61327 FREE(untag_ptr(this_ptr));
61328 SpendableOutputDescriptor_free(this_ptr_conv);
61331 static inline uint64_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
61332 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
61333 *ret_copy = SpendableOutputDescriptor_clone(arg);
61334 uint64_t ret_ref = tag_ptr(ret_copy, true);
61337 int64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone_ptr"))) TS_SpendableOutputDescriptor_clone_ptr(uint64_t arg) {
61338 LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)untag_ptr(arg);
61339 int64_t ret_conv = SpendableOutputDescriptor_clone_ptr(arg_conv);
61343 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone"))) TS_SpendableOutputDescriptor_clone(uint64_t orig) {
61344 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)untag_ptr(orig);
61345 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
61346 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
61347 uint64_t ret_ref = tag_ptr(ret_copy, true);
61351 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_output"))) TS_SpendableOutputDescriptor_static_output(uint64_t outpoint, uint64_t output) {
61352 LDKOutPoint outpoint_conv;
61353 outpoint_conv.inner = untag_ptr(outpoint);
61354 outpoint_conv.is_owned = ptr_is_owned(outpoint);
61355 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
61356 outpoint_conv = OutPoint_clone(&outpoint_conv);
61357 void* output_ptr = untag_ptr(output);
61358 CHECK_ACCESS(output_ptr);
61359 LDKTxOut output_conv = *(LDKTxOut*)(output_ptr);
61360 output_conv = TxOut_clone((LDKTxOut*)untag_ptr(output));
61361 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
61362 *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv);
61363 uint64_t ret_ref = tag_ptr(ret_copy, true);
61367 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_delayed_payment_output"))) TS_SpendableOutputDescriptor_delayed_payment_output(uint64_t a) {
61368 LDKDelayedPaymentOutputDescriptor a_conv;
61369 a_conv.inner = untag_ptr(a);
61370 a_conv.is_owned = ptr_is_owned(a);
61371 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
61372 a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
61373 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
61374 *ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
61375 uint64_t ret_ref = tag_ptr(ret_copy, true);
61379 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_payment_output"))) TS_SpendableOutputDescriptor_static_payment_output(uint64_t a) {
61380 LDKStaticPaymentOutputDescriptor a_conv;
61381 a_conv.inner = untag_ptr(a);
61382 a_conv.is_owned = ptr_is_owned(a);
61383 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
61384 a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
61385 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
61386 *ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
61387 uint64_t ret_ref = tag_ptr(ret_copy, true);
61391 int64_t __attribute__((export_name("TS_SpendableOutputDescriptor_hash"))) TS_SpendableOutputDescriptor_hash(uint64_t o) {
61392 LDKSpendableOutputDescriptor* o_conv = (LDKSpendableOutputDescriptor*)untag_ptr(o);
61393 int64_t ret_conv = SpendableOutputDescriptor_hash(o_conv);
61397 jboolean __attribute__((export_name("TS_SpendableOutputDescriptor_eq"))) TS_SpendableOutputDescriptor_eq(uint64_t a, uint64_t b) {
61398 LDKSpendableOutputDescriptor* a_conv = (LDKSpendableOutputDescriptor*)untag_ptr(a);
61399 LDKSpendableOutputDescriptor* b_conv = (LDKSpendableOutputDescriptor*)untag_ptr(b);
61400 jboolean ret_conv = SpendableOutputDescriptor_eq(a_conv, b_conv);
61404 int8_tArray __attribute__((export_name("TS_SpendableOutputDescriptor_write"))) TS_SpendableOutputDescriptor_write(uint64_t obj) {
61405 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)untag_ptr(obj);
61406 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
61407 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
61408 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
61409 CVec_u8Z_free(ret_var);
61413 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_read"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
61414 LDKu8slice ser_ref;
61415 ser_ref.datalen = ser->arr_len;
61416 ser_ref.data = ser->elems;
61417 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
61418 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
61420 return tag_ptr(ret_conv, true);
61423 uint64_t __attribute__((export_name("TS_SpendableOutputDescriptor_create_spendable_outputs_psbt"))) TS_SpendableOutputDescriptor_create_spendable_outputs_psbt(uint64_tArray descriptors, uint64_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight, uint64_t locktime) {
61424 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
61425 descriptors_constr.datalen = descriptors->arr_len;
61426 if (descriptors_constr.datalen > 0)
61427 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
61429 descriptors_constr.data = NULL;
61430 uint64_t* descriptors_vals = descriptors->elems;
61431 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
61432 uint64_t descriptors_conv_27 = descriptors_vals[b];
61433 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
61434 CHECK_ACCESS(descriptors_conv_27_ptr);
61435 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
61436 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
61437 descriptors_constr.data[b] = descriptors_conv_27_conv;
61440 LDKCVec_TxOutZ outputs_constr;
61441 outputs_constr.datalen = outputs->arr_len;
61442 if (outputs_constr.datalen > 0)
61443 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
61445 outputs_constr.data = NULL;
61446 uint64_t* outputs_vals = outputs->elems;
61447 for (size_t h = 0; h < outputs_constr.datalen; h++) {
61448 uint64_t outputs_conv_7 = outputs_vals[h];
61449 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
61450 CHECK_ACCESS(outputs_conv_7_ptr);
61451 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
61452 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
61453 outputs_constr.data[h] = outputs_conv_7_conv;
61456 LDKCVec_u8Z change_destination_script_ref;
61457 change_destination_script_ref.datalen = change_destination_script->arr_len;
61458 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
61459 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
61460 void* locktime_ptr = untag_ptr(locktime);
61461 CHECK_ACCESS(locktime_ptr);
61462 LDKCOption_u32Z locktime_conv = *(LDKCOption_u32Z*)(locktime_ptr);
61463 locktime_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(locktime));
61464 LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ), "LDKCResult_C2Tuple_CVec_u8ZusizeZNoneZ");
61465 *ret_conv = SpendableOutputDescriptor_create_spendable_outputs_psbt(descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight, locktime_conv);
61466 return tag_ptr(ret_conv, true);
61469 void __attribute__((export_name("TS_ChannelSigner_free"))) TS_ChannelSigner_free(uint64_t this_ptr) {
61470 if (!ptr_is_owned(this_ptr)) return;
61471 void* this_ptr_ptr = untag_ptr(this_ptr);
61472 CHECK_ACCESS(this_ptr_ptr);
61473 LDKChannelSigner this_ptr_conv = *(LDKChannelSigner*)(this_ptr_ptr);
61474 FREE(untag_ptr(this_ptr));
61475 ChannelSigner_free(this_ptr_conv);
61478 void __attribute__((export_name("TS_EcdsaChannelSigner_free"))) TS_EcdsaChannelSigner_free(uint64_t this_ptr) {
61479 if (!ptr_is_owned(this_ptr)) return;
61480 void* this_ptr_ptr = untag_ptr(this_ptr);
61481 CHECK_ACCESS(this_ptr_ptr);
61482 LDKEcdsaChannelSigner this_ptr_conv = *(LDKEcdsaChannelSigner*)(this_ptr_ptr);
61483 FREE(untag_ptr(this_ptr));
61484 EcdsaChannelSigner_free(this_ptr_conv);
61487 static inline uint64_t WriteableEcdsaChannelSigner_clone_ptr(LDKWriteableEcdsaChannelSigner *NONNULL_PTR arg) {
61488 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
61489 *ret_ret = WriteableEcdsaChannelSigner_clone(arg);
61490 return tag_ptr(ret_ret, true);
61492 int64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone_ptr"))) TS_WriteableEcdsaChannelSigner_clone_ptr(uint64_t arg) {
61493 void* arg_ptr = untag_ptr(arg);
61494 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
61495 LDKWriteableEcdsaChannelSigner* arg_conv = (LDKWriteableEcdsaChannelSigner*)arg_ptr;
61496 int64_t ret_conv = WriteableEcdsaChannelSigner_clone_ptr(arg_conv);
61500 uint64_t __attribute__((export_name("TS_WriteableEcdsaChannelSigner_clone"))) TS_WriteableEcdsaChannelSigner_clone(uint64_t orig) {
61501 void* orig_ptr = untag_ptr(orig);
61502 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
61503 LDKWriteableEcdsaChannelSigner* orig_conv = (LDKWriteableEcdsaChannelSigner*)orig_ptr;
61504 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
61505 *ret_ret = WriteableEcdsaChannelSigner_clone(orig_conv);
61506 return tag_ptr(ret_ret, true);
61509 void __attribute__((export_name("TS_WriteableEcdsaChannelSigner_free"))) TS_WriteableEcdsaChannelSigner_free(uint64_t this_ptr) {
61510 if (!ptr_is_owned(this_ptr)) return;
61511 void* this_ptr_ptr = untag_ptr(this_ptr);
61512 CHECK_ACCESS(this_ptr_ptr);
61513 LDKWriteableEcdsaChannelSigner this_ptr_conv = *(LDKWriteableEcdsaChannelSigner*)(this_ptr_ptr);
61514 FREE(untag_ptr(this_ptr));
61515 WriteableEcdsaChannelSigner_free(this_ptr_conv);
61518 uint32_t __attribute__((export_name("TS_Recipient_clone"))) TS_Recipient_clone(uint64_t orig) {
61519 LDKRecipient* orig_conv = (LDKRecipient*)untag_ptr(orig);
61520 uint32_t ret_conv = LDKRecipient_to_js(Recipient_clone(orig_conv));
61524 uint32_t __attribute__((export_name("TS_Recipient_node"))) TS_Recipient_node() {
61525 uint32_t ret_conv = LDKRecipient_to_js(Recipient_node());
61529 uint32_t __attribute__((export_name("TS_Recipient_phantom_node"))) TS_Recipient_phantom_node() {
61530 uint32_t ret_conv = LDKRecipient_to_js(Recipient_phantom_node());
61534 void __attribute__((export_name("TS_EntropySource_free"))) TS_EntropySource_free(uint64_t this_ptr) {
61535 if (!ptr_is_owned(this_ptr)) return;
61536 void* this_ptr_ptr = untag_ptr(this_ptr);
61537 CHECK_ACCESS(this_ptr_ptr);
61538 LDKEntropySource this_ptr_conv = *(LDKEntropySource*)(this_ptr_ptr);
61539 FREE(untag_ptr(this_ptr));
61540 EntropySource_free(this_ptr_conv);
61543 void __attribute__((export_name("TS_NodeSigner_free"))) TS_NodeSigner_free(uint64_t this_ptr) {
61544 if (!ptr_is_owned(this_ptr)) return;
61545 void* this_ptr_ptr = untag_ptr(this_ptr);
61546 CHECK_ACCESS(this_ptr_ptr);
61547 LDKNodeSigner this_ptr_conv = *(LDKNodeSigner*)(this_ptr_ptr);
61548 FREE(untag_ptr(this_ptr));
61549 NodeSigner_free(this_ptr_conv);
61552 void __attribute__((export_name("TS_SignerProvider_free"))) TS_SignerProvider_free(uint64_t this_ptr) {
61553 if (!ptr_is_owned(this_ptr)) return;
61554 void* this_ptr_ptr = untag_ptr(this_ptr);
61555 CHECK_ACCESS(this_ptr_ptr);
61556 LDKSignerProvider this_ptr_conv = *(LDKSignerProvider*)(this_ptr_ptr);
61557 FREE(untag_ptr(this_ptr));
61558 SignerProvider_free(this_ptr_conv);
61561 void __attribute__((export_name("TS_InMemorySigner_free"))) TS_InMemorySigner_free(uint64_t this_obj) {
61562 LDKInMemorySigner this_obj_conv;
61563 this_obj_conv.inner = untag_ptr(this_obj);
61564 this_obj_conv.is_owned = ptr_is_owned(this_obj);
61565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
61566 InMemorySigner_free(this_obj_conv);
61569 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_funding_key"))) TS_InMemorySigner_get_funding_key(uint64_t this_ptr) {
61570 LDKInMemorySigner this_ptr_conv;
61571 this_ptr_conv.inner = untag_ptr(this_ptr);
61572 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61574 this_ptr_conv.is_owned = false;
61575 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61576 memcpy(ret_arr->elems, *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
61580 void __attribute__((export_name("TS_InMemorySigner_set_funding_key"))) TS_InMemorySigner_set_funding_key(uint64_t this_ptr, int8_tArray val) {
61581 LDKInMemorySigner this_ptr_conv;
61582 this_ptr_conv.inner = untag_ptr(this_ptr);
61583 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61585 this_ptr_conv.is_owned = false;
61586 LDKSecretKey val_ref;
61587 CHECK(val->arr_len == 32);
61588 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
61589 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
61592 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_revocation_base_key"))) TS_InMemorySigner_get_revocation_base_key(uint64_t this_ptr) {
61593 LDKInMemorySigner this_ptr_conv;
61594 this_ptr_conv.inner = untag_ptr(this_ptr);
61595 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61597 this_ptr_conv.is_owned = false;
61598 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61599 memcpy(ret_arr->elems, *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
61603 void __attribute__((export_name("TS_InMemorySigner_set_revocation_base_key"))) TS_InMemorySigner_set_revocation_base_key(uint64_t this_ptr, int8_tArray val) {
61604 LDKInMemorySigner this_ptr_conv;
61605 this_ptr_conv.inner = untag_ptr(this_ptr);
61606 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61607 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61608 this_ptr_conv.is_owned = false;
61609 LDKSecretKey val_ref;
61610 CHECK(val->arr_len == 32);
61611 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
61612 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
61615 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_payment_key"))) TS_InMemorySigner_get_payment_key(uint64_t this_ptr) {
61616 LDKInMemorySigner this_ptr_conv;
61617 this_ptr_conv.inner = untag_ptr(this_ptr);
61618 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61620 this_ptr_conv.is_owned = false;
61621 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61622 memcpy(ret_arr->elems, *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
61626 void __attribute__((export_name("TS_InMemorySigner_set_payment_key"))) TS_InMemorySigner_set_payment_key(uint64_t this_ptr, int8_tArray val) {
61627 LDKInMemorySigner this_ptr_conv;
61628 this_ptr_conv.inner = untag_ptr(this_ptr);
61629 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61631 this_ptr_conv.is_owned = false;
61632 LDKSecretKey val_ref;
61633 CHECK(val->arr_len == 32);
61634 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
61635 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
61638 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_delayed_payment_base_key"))) TS_InMemorySigner_get_delayed_payment_base_key(uint64_t this_ptr) {
61639 LDKInMemorySigner this_ptr_conv;
61640 this_ptr_conv.inner = untag_ptr(this_ptr);
61641 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61642 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61643 this_ptr_conv.is_owned = false;
61644 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61645 memcpy(ret_arr->elems, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
61649 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) {
61650 LDKInMemorySigner this_ptr_conv;
61651 this_ptr_conv.inner = untag_ptr(this_ptr);
61652 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61654 this_ptr_conv.is_owned = false;
61655 LDKSecretKey val_ref;
61656 CHECK(val->arr_len == 32);
61657 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
61658 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
61661 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_htlc_base_key"))) TS_InMemorySigner_get_htlc_base_key(uint64_t this_ptr) {
61662 LDKInMemorySigner this_ptr_conv;
61663 this_ptr_conv.inner = untag_ptr(this_ptr);
61664 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61666 this_ptr_conv.is_owned = false;
61667 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61668 memcpy(ret_arr->elems, *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
61672 void __attribute__((export_name("TS_InMemorySigner_set_htlc_base_key"))) TS_InMemorySigner_set_htlc_base_key(uint64_t this_ptr, int8_tArray val) {
61673 LDKInMemorySigner this_ptr_conv;
61674 this_ptr_conv.inner = untag_ptr(this_ptr);
61675 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61677 this_ptr_conv.is_owned = false;
61678 LDKSecretKey val_ref;
61679 CHECK(val->arr_len == 32);
61680 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
61681 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
61684 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_commitment_seed"))) TS_InMemorySigner_get_commitment_seed(uint64_t this_ptr) {
61685 LDKInMemorySigner this_ptr_conv;
61686 this_ptr_conv.inner = untag_ptr(this_ptr);
61687 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61689 this_ptr_conv.is_owned = false;
61690 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
61691 memcpy(ret_arr->elems, *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
61695 void __attribute__((export_name("TS_InMemorySigner_set_commitment_seed"))) TS_InMemorySigner_set_commitment_seed(uint64_t this_ptr, int8_tArray val) {
61696 LDKInMemorySigner this_ptr_conv;
61697 this_ptr_conv.inner = untag_ptr(this_ptr);
61698 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
61699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
61700 this_ptr_conv.is_owned = false;
61701 LDKThirtyTwoBytes val_ref;
61702 CHECK(val->arr_len == 32);
61703 memcpy(val_ref.data, val->elems, 32); FREE(val);
61704 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
61707 static inline uint64_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
61708 LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
61709 uint64_t ret_ref = 0;
61710 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61711 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61714 int64_t __attribute__((export_name("TS_InMemorySigner_clone_ptr"))) TS_InMemorySigner_clone_ptr(uint64_t arg) {
61715 LDKInMemorySigner arg_conv;
61716 arg_conv.inner = untag_ptr(arg);
61717 arg_conv.is_owned = ptr_is_owned(arg);
61718 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
61719 arg_conv.is_owned = false;
61720 int64_t ret_conv = InMemorySigner_clone_ptr(&arg_conv);
61724 uint64_t __attribute__((export_name("TS_InMemorySigner_clone"))) TS_InMemorySigner_clone(uint64_t orig) {
61725 LDKInMemorySigner orig_conv;
61726 orig_conv.inner = untag_ptr(orig);
61727 orig_conv.is_owned = ptr_is_owned(orig);
61728 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
61729 orig_conv.is_owned = false;
61730 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
61731 uint64_t ret_ref = 0;
61732 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61733 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61737 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) {
61738 LDKSecretKey funding_key_ref;
61739 CHECK(funding_key->arr_len == 32);
61740 memcpy(funding_key_ref.bytes, funding_key->elems, 32); FREE(funding_key);
61741 LDKSecretKey revocation_base_key_ref;
61742 CHECK(revocation_base_key->arr_len == 32);
61743 memcpy(revocation_base_key_ref.bytes, revocation_base_key->elems, 32); FREE(revocation_base_key);
61744 LDKSecretKey payment_key_ref;
61745 CHECK(payment_key->arr_len == 32);
61746 memcpy(payment_key_ref.bytes, payment_key->elems, 32); FREE(payment_key);
61747 LDKSecretKey delayed_payment_base_key_ref;
61748 CHECK(delayed_payment_base_key->arr_len == 32);
61749 memcpy(delayed_payment_base_key_ref.bytes, delayed_payment_base_key->elems, 32); FREE(delayed_payment_base_key);
61750 LDKSecretKey htlc_base_key_ref;
61751 CHECK(htlc_base_key->arr_len == 32);
61752 memcpy(htlc_base_key_ref.bytes, htlc_base_key->elems, 32); FREE(htlc_base_key);
61753 LDKThirtyTwoBytes commitment_seed_ref;
61754 CHECK(commitment_seed->arr_len == 32);
61755 memcpy(commitment_seed_ref.data, commitment_seed->elems, 32); FREE(commitment_seed);
61756 LDKThirtyTwoBytes channel_keys_id_ref;
61757 CHECK(channel_keys_id->arr_len == 32);
61758 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
61759 LDKThirtyTwoBytes rand_bytes_unique_start_ref;
61760 CHECK(rand_bytes_unique_start->arr_len == 32);
61761 memcpy(rand_bytes_unique_start_ref.data, rand_bytes_unique_start->elems, 32); FREE(rand_bytes_unique_start);
61762 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);
61763 uint64_t ret_ref = 0;
61764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61765 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61769 uint64_t __attribute__((export_name("TS_InMemorySigner_counterparty_pubkeys"))) TS_InMemorySigner_counterparty_pubkeys(uint64_t this_arg) {
61770 LDKInMemorySigner this_arg_conv;
61771 this_arg_conv.inner = untag_ptr(this_arg);
61772 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61774 this_arg_conv.is_owned = false;
61775 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
61776 uint64_t ret_ref = 0;
61777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61778 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61782 uint64_t __attribute__((export_name("TS_InMemorySigner_counterparty_selected_contest_delay"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint64_t this_arg) {
61783 LDKInMemorySigner this_arg_conv;
61784 this_arg_conv.inner = untag_ptr(this_arg);
61785 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61786 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61787 this_arg_conv.is_owned = false;
61788 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
61789 *ret_copy = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
61790 uint64_t ret_ref = tag_ptr(ret_copy, true);
61794 uint64_t __attribute__((export_name("TS_InMemorySigner_holder_selected_contest_delay"))) TS_InMemorySigner_holder_selected_contest_delay(uint64_t this_arg) {
61795 LDKInMemorySigner this_arg_conv;
61796 this_arg_conv.inner = untag_ptr(this_arg);
61797 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61798 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61799 this_arg_conv.is_owned = false;
61800 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
61801 *ret_copy = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
61802 uint64_t ret_ref = tag_ptr(ret_copy, true);
61806 uint64_t __attribute__((export_name("TS_InMemorySigner_is_outbound"))) TS_InMemorySigner_is_outbound(uint64_t this_arg) {
61807 LDKInMemorySigner this_arg_conv;
61808 this_arg_conv.inner = untag_ptr(this_arg);
61809 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61811 this_arg_conv.is_owned = false;
61812 LDKCOption_boolZ *ret_copy = MALLOC(sizeof(LDKCOption_boolZ), "LDKCOption_boolZ");
61813 *ret_copy = InMemorySigner_is_outbound(&this_arg_conv);
61814 uint64_t ret_ref = tag_ptr(ret_copy, true);
61818 uint64_t __attribute__((export_name("TS_InMemorySigner_funding_outpoint"))) TS_InMemorySigner_funding_outpoint(uint64_t this_arg) {
61819 LDKInMemorySigner this_arg_conv;
61820 this_arg_conv.inner = untag_ptr(this_arg);
61821 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61823 this_arg_conv.is_owned = false;
61824 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
61825 uint64_t ret_ref = 0;
61826 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61827 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61831 uint64_t __attribute__((export_name("TS_InMemorySigner_get_channel_parameters"))) TS_InMemorySigner_get_channel_parameters(uint64_t this_arg) {
61832 LDKInMemorySigner this_arg_conv;
61833 this_arg_conv.inner = untag_ptr(this_arg);
61834 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61835 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61836 this_arg_conv.is_owned = false;
61837 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
61838 uint64_t ret_ref = 0;
61839 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61840 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61844 uint64_t __attribute__((export_name("TS_InMemorySigner_channel_type_features"))) TS_InMemorySigner_channel_type_features(uint64_t this_arg) {
61845 LDKInMemorySigner this_arg_conv;
61846 this_arg_conv.inner = untag_ptr(this_arg);
61847 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61849 this_arg_conv.is_owned = false;
61850 LDKChannelTypeFeatures ret_var = InMemorySigner_channel_type_features(&this_arg_conv);
61851 uint64_t ret_ref = 0;
61852 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61853 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61857 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) {
61858 LDKInMemorySigner this_arg_conv;
61859 this_arg_conv.inner = untag_ptr(this_arg);
61860 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61862 this_arg_conv.is_owned = false;
61863 LDKTransaction spend_tx_ref;
61864 spend_tx_ref.datalen = spend_tx->arr_len;
61865 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
61866 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
61867 spend_tx_ref.data_is_owned = true;
61868 LDKStaticPaymentOutputDescriptor descriptor_conv;
61869 descriptor_conv.inner = untag_ptr(descriptor);
61870 descriptor_conv.is_owned = ptr_is_owned(descriptor);
61871 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
61872 descriptor_conv.is_owned = false;
61873 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
61874 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
61875 return tag_ptr(ret_conv, true);
61878 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) {
61879 LDKInMemorySigner this_arg_conv;
61880 this_arg_conv.inner = untag_ptr(this_arg);
61881 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61883 this_arg_conv.is_owned = false;
61884 LDKTransaction spend_tx_ref;
61885 spend_tx_ref.datalen = spend_tx->arr_len;
61886 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
61887 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
61888 spend_tx_ref.data_is_owned = true;
61889 LDKDelayedPaymentOutputDescriptor descriptor_conv;
61890 descriptor_conv.inner = untag_ptr(descriptor);
61891 descriptor_conv.is_owned = ptr_is_owned(descriptor);
61892 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
61893 descriptor_conv.is_owned = false;
61894 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
61895 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
61896 return tag_ptr(ret_conv, true);
61899 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EntropySource"))) TS_InMemorySigner_as_EntropySource(uint64_t this_arg) {
61900 LDKInMemorySigner this_arg_conv;
61901 this_arg_conv.inner = untag_ptr(this_arg);
61902 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61904 this_arg_conv.is_owned = false;
61905 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
61906 *ret_ret = InMemorySigner_as_EntropySource(&this_arg_conv);
61907 return tag_ptr(ret_ret, true);
61910 uint64_t __attribute__((export_name("TS_InMemorySigner_as_ChannelSigner"))) TS_InMemorySigner_as_ChannelSigner(uint64_t this_arg) {
61911 LDKInMemorySigner this_arg_conv;
61912 this_arg_conv.inner = untag_ptr(this_arg);
61913 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61915 this_arg_conv.is_owned = false;
61916 LDKChannelSigner* ret_ret = MALLOC(sizeof(LDKChannelSigner), "LDKChannelSigner");
61917 *ret_ret = InMemorySigner_as_ChannelSigner(&this_arg_conv);
61918 return tag_ptr(ret_ret, true);
61921 uint64_t __attribute__((export_name("TS_InMemorySigner_as_EcdsaChannelSigner"))) TS_InMemorySigner_as_EcdsaChannelSigner(uint64_t this_arg) {
61922 LDKInMemorySigner this_arg_conv;
61923 this_arg_conv.inner = untag_ptr(this_arg);
61924 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61926 this_arg_conv.is_owned = false;
61927 LDKEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKEcdsaChannelSigner), "LDKEcdsaChannelSigner");
61928 *ret_ret = InMemorySigner_as_EcdsaChannelSigner(&this_arg_conv);
61929 return tag_ptr(ret_ret, true);
61932 uint64_t __attribute__((export_name("TS_InMemorySigner_as_WriteableEcdsaChannelSigner"))) TS_InMemorySigner_as_WriteableEcdsaChannelSigner(uint64_t this_arg) {
61933 LDKInMemorySigner this_arg_conv;
61934 this_arg_conv.inner = untag_ptr(this_arg);
61935 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61936 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61937 this_arg_conv.is_owned = false;
61938 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
61939 *ret_ret = InMemorySigner_as_WriteableEcdsaChannelSigner(&this_arg_conv);
61940 return tag_ptr(ret_ret, true);
61943 int8_tArray __attribute__((export_name("TS_InMemorySigner_write"))) TS_InMemorySigner_write(uint64_t obj) {
61944 LDKInMemorySigner obj_conv;
61945 obj_conv.inner = untag_ptr(obj);
61946 obj_conv.is_owned = ptr_is_owned(obj);
61947 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
61948 obj_conv.is_owned = false;
61949 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
61950 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
61951 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
61952 CVec_u8Z_free(ret_var);
61956 uint64_t __attribute__((export_name("TS_InMemorySigner_read"))) TS_InMemorySigner_read(int8_tArray ser, uint64_t arg) {
61957 LDKu8slice ser_ref;
61958 ser_ref.datalen = ser->arr_len;
61959 ser_ref.data = ser->elems;
61960 void* arg_ptr = untag_ptr(arg);
61961 CHECK_ACCESS(arg_ptr);
61962 LDKEntropySource arg_conv = *(LDKEntropySource*)(arg_ptr);
61963 if (arg_conv.free == LDKEntropySource_JCalls_free) {
61964 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
61965 LDKEntropySource_JCalls_cloned(&arg_conv);
61967 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
61968 *ret_conv = InMemorySigner_read(ser_ref, arg_conv);
61970 return tag_ptr(ret_conv, true);
61973 void __attribute__((export_name("TS_KeysManager_free"))) TS_KeysManager_free(uint64_t this_obj) {
61974 LDKKeysManager this_obj_conv;
61975 this_obj_conv.inner = untag_ptr(this_obj);
61976 this_obj_conv.is_owned = ptr_is_owned(this_obj);
61977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
61978 KeysManager_free(this_obj_conv);
61981 uint64_t __attribute__((export_name("TS_KeysManager_new"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
61982 uint8_t seed_arr[32];
61983 CHECK(seed->arr_len == 32);
61984 memcpy(seed_arr, seed->elems, 32); FREE(seed);
61985 uint8_t (*seed_ref)[32] = &seed_arr;
61986 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
61987 uint64_t ret_ref = 0;
61988 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
61989 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
61993 int8_tArray __attribute__((export_name("TS_KeysManager_get_node_secret_key"))) TS_KeysManager_get_node_secret_key(uint64_t this_arg) {
61994 LDKKeysManager this_arg_conv;
61995 this_arg_conv.inner = untag_ptr(this_arg);
61996 this_arg_conv.is_owned = ptr_is_owned(this_arg);
61997 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
61998 this_arg_conv.is_owned = false;
61999 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
62000 memcpy(ret_arr->elems, KeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
62004 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) {
62005 LDKKeysManager this_arg_conv;
62006 this_arg_conv.inner = untag_ptr(this_arg);
62007 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62009 this_arg_conv.is_owned = false;
62010 uint8_t params_arr[32];
62011 CHECK(params->arr_len == 32);
62012 memcpy(params_arr, params->elems, 32); FREE(params);
62013 uint8_t (*params_ref)[32] = ¶ms_arr;
62014 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
62015 uint64_t ret_ref = 0;
62016 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62017 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62021 uint64_t __attribute__((export_name("TS_KeysManager_sign_spendable_outputs_psbt"))) TS_KeysManager_sign_spendable_outputs_psbt(uint64_t this_arg, uint64_tArray descriptors, int8_tArray psbt) {
62022 LDKKeysManager this_arg_conv;
62023 this_arg_conv.inner = untag_ptr(this_arg);
62024 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62025 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62026 this_arg_conv.is_owned = false;
62027 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
62028 descriptors_constr.datalen = descriptors->arr_len;
62029 if (descriptors_constr.datalen > 0)
62030 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
62032 descriptors_constr.data = NULL;
62033 uint64_t* descriptors_vals = descriptors->elems;
62034 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
62035 uint64_t descriptors_conv_27 = descriptors_vals[b];
62036 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
62037 CHECK_ACCESS(descriptors_conv_27_ptr);
62038 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
62039 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
62040 descriptors_constr.data[b] = descriptors_conv_27_conv;
62043 LDKCVec_u8Z psbt_ref;
62044 psbt_ref.datalen = psbt->arr_len;
62045 psbt_ref.data = MALLOC(psbt_ref.datalen, "LDKCVec_u8Z Bytes");
62046 memcpy(psbt_ref.data, psbt->elems, psbt_ref.datalen); FREE(psbt);
62047 LDKCResult_CVec_u8ZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZNoneZ), "LDKCResult_CVec_u8ZNoneZ");
62048 *ret_conv = KeysManager_sign_spendable_outputs_psbt(&this_arg_conv, descriptors_constr, psbt_ref);
62049 return tag_ptr(ret_conv, true);
62052 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, uint64_t locktime) {
62053 LDKKeysManager this_arg_conv;
62054 this_arg_conv.inner = untag_ptr(this_arg);
62055 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62057 this_arg_conv.is_owned = false;
62058 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
62059 descriptors_constr.datalen = descriptors->arr_len;
62060 if (descriptors_constr.datalen > 0)
62061 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
62063 descriptors_constr.data = NULL;
62064 uint64_t* descriptors_vals = descriptors->elems;
62065 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
62066 uint64_t descriptors_conv_27 = descriptors_vals[b];
62067 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
62068 CHECK_ACCESS(descriptors_conv_27_ptr);
62069 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
62070 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
62071 descriptors_constr.data[b] = descriptors_conv_27_conv;
62074 LDKCVec_TxOutZ outputs_constr;
62075 outputs_constr.datalen = outputs->arr_len;
62076 if (outputs_constr.datalen > 0)
62077 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
62079 outputs_constr.data = NULL;
62080 uint64_t* outputs_vals = outputs->elems;
62081 for (size_t h = 0; h < outputs_constr.datalen; h++) {
62082 uint64_t outputs_conv_7 = outputs_vals[h];
62083 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
62084 CHECK_ACCESS(outputs_conv_7_ptr);
62085 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
62086 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
62087 outputs_constr.data[h] = outputs_conv_7_conv;
62090 LDKCVec_u8Z change_destination_script_ref;
62091 change_destination_script_ref.datalen = change_destination_script->arr_len;
62092 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
62093 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
62094 void* locktime_ptr = untag_ptr(locktime);
62095 CHECK_ACCESS(locktime_ptr);
62096 LDKCOption_u32Z locktime_conv = *(LDKCOption_u32Z*)(locktime_ptr);
62097 locktime_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(locktime));
62098 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
62099 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight, locktime_conv);
62100 return tag_ptr(ret_conv, true);
62103 uint64_t __attribute__((export_name("TS_KeysManager_as_EntropySource"))) TS_KeysManager_as_EntropySource(uint64_t this_arg) {
62104 LDKKeysManager this_arg_conv;
62105 this_arg_conv.inner = untag_ptr(this_arg);
62106 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62108 this_arg_conv.is_owned = false;
62109 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
62110 *ret_ret = KeysManager_as_EntropySource(&this_arg_conv);
62111 return tag_ptr(ret_ret, true);
62114 uint64_t __attribute__((export_name("TS_KeysManager_as_NodeSigner"))) TS_KeysManager_as_NodeSigner(uint64_t this_arg) {
62115 LDKKeysManager this_arg_conv;
62116 this_arg_conv.inner = untag_ptr(this_arg);
62117 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62119 this_arg_conv.is_owned = false;
62120 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
62121 *ret_ret = KeysManager_as_NodeSigner(&this_arg_conv);
62122 return tag_ptr(ret_ret, true);
62125 uint64_t __attribute__((export_name("TS_KeysManager_as_SignerProvider"))) TS_KeysManager_as_SignerProvider(uint64_t this_arg) {
62126 LDKKeysManager this_arg_conv;
62127 this_arg_conv.inner = untag_ptr(this_arg);
62128 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62130 this_arg_conv.is_owned = false;
62131 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
62132 *ret_ret = KeysManager_as_SignerProvider(&this_arg_conv);
62133 return tag_ptr(ret_ret, true);
62136 void __attribute__((export_name("TS_PhantomKeysManager_free"))) TS_PhantomKeysManager_free(uint64_t this_obj) {
62137 LDKPhantomKeysManager this_obj_conv;
62138 this_obj_conv.inner = untag_ptr(this_obj);
62139 this_obj_conv.is_owned = ptr_is_owned(this_obj);
62140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
62141 PhantomKeysManager_free(this_obj_conv);
62144 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_EntropySource"))) TS_PhantomKeysManager_as_EntropySource(uint64_t this_arg) {
62145 LDKPhantomKeysManager this_arg_conv;
62146 this_arg_conv.inner = untag_ptr(this_arg);
62147 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62149 this_arg_conv.is_owned = false;
62150 LDKEntropySource* ret_ret = MALLOC(sizeof(LDKEntropySource), "LDKEntropySource");
62151 *ret_ret = PhantomKeysManager_as_EntropySource(&this_arg_conv);
62152 return tag_ptr(ret_ret, true);
62155 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_NodeSigner"))) TS_PhantomKeysManager_as_NodeSigner(uint64_t this_arg) {
62156 LDKPhantomKeysManager this_arg_conv;
62157 this_arg_conv.inner = untag_ptr(this_arg);
62158 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62160 this_arg_conv.is_owned = false;
62161 LDKNodeSigner* ret_ret = MALLOC(sizeof(LDKNodeSigner), "LDKNodeSigner");
62162 *ret_ret = PhantomKeysManager_as_NodeSigner(&this_arg_conv);
62163 return tag_ptr(ret_ret, true);
62166 uint64_t __attribute__((export_name("TS_PhantomKeysManager_as_SignerProvider"))) TS_PhantomKeysManager_as_SignerProvider(uint64_t this_arg) {
62167 LDKPhantomKeysManager this_arg_conv;
62168 this_arg_conv.inner = untag_ptr(this_arg);
62169 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62170 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62171 this_arg_conv.is_owned = false;
62172 LDKSignerProvider* ret_ret = MALLOC(sizeof(LDKSignerProvider), "LDKSignerProvider");
62173 *ret_ret = PhantomKeysManager_as_SignerProvider(&this_arg_conv);
62174 return tag_ptr(ret_ret, true);
62177 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) {
62178 uint8_t seed_arr[32];
62179 CHECK(seed->arr_len == 32);
62180 memcpy(seed_arr, seed->elems, 32); FREE(seed);
62181 uint8_t (*seed_ref)[32] = &seed_arr;
62182 uint8_t cross_node_seed_arr[32];
62183 CHECK(cross_node_seed->arr_len == 32);
62184 memcpy(cross_node_seed_arr, cross_node_seed->elems, 32); FREE(cross_node_seed);
62185 uint8_t (*cross_node_seed_ref)[32] = &cross_node_seed_arr;
62186 LDKPhantomKeysManager ret_var = PhantomKeysManager_new(seed_ref, starting_time_secs, starting_time_nanos, cross_node_seed_ref);
62187 uint64_t ret_ref = 0;
62188 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62189 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62193 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, uint64_t locktime) {
62194 LDKPhantomKeysManager this_arg_conv;
62195 this_arg_conv.inner = untag_ptr(this_arg);
62196 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62198 this_arg_conv.is_owned = false;
62199 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
62200 descriptors_constr.datalen = descriptors->arr_len;
62201 if (descriptors_constr.datalen > 0)
62202 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
62204 descriptors_constr.data = NULL;
62205 uint64_t* descriptors_vals = descriptors->elems;
62206 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
62207 uint64_t descriptors_conv_27 = descriptors_vals[b];
62208 void* descriptors_conv_27_ptr = untag_ptr(descriptors_conv_27);
62209 CHECK_ACCESS(descriptors_conv_27_ptr);
62210 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
62211 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(descriptors_conv_27));
62212 descriptors_constr.data[b] = descriptors_conv_27_conv;
62215 LDKCVec_TxOutZ outputs_constr;
62216 outputs_constr.datalen = outputs->arr_len;
62217 if (outputs_constr.datalen > 0)
62218 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
62220 outputs_constr.data = NULL;
62221 uint64_t* outputs_vals = outputs->elems;
62222 for (size_t h = 0; h < outputs_constr.datalen; h++) {
62223 uint64_t outputs_conv_7 = outputs_vals[h];
62224 void* outputs_conv_7_ptr = untag_ptr(outputs_conv_7);
62225 CHECK_ACCESS(outputs_conv_7_ptr);
62226 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
62227 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)untag_ptr(outputs_conv_7));
62228 outputs_constr.data[h] = outputs_conv_7_conv;
62231 LDKCVec_u8Z change_destination_script_ref;
62232 change_destination_script_ref.datalen = change_destination_script->arr_len;
62233 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
62234 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
62235 void* locktime_ptr = untag_ptr(locktime);
62236 CHECK_ACCESS(locktime_ptr);
62237 LDKCOption_u32Z locktime_conv = *(LDKCOption_u32Z*)(locktime_ptr);
62238 locktime_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(locktime));
62239 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
62240 *ret_conv = PhantomKeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight, locktime_conv);
62241 return tag_ptr(ret_conv, true);
62244 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) {
62245 LDKPhantomKeysManager this_arg_conv;
62246 this_arg_conv.inner = untag_ptr(this_arg);
62247 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62249 this_arg_conv.is_owned = false;
62250 uint8_t params_arr[32];
62251 CHECK(params->arr_len == 32);
62252 memcpy(params_arr, params->elems, 32); FREE(params);
62253 uint8_t (*params_ref)[32] = ¶ms_arr;
62254 LDKInMemorySigner ret_var = PhantomKeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
62255 uint64_t ret_ref = 0;
62256 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62257 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62261 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_node_secret_key"))) TS_PhantomKeysManager_get_node_secret_key(uint64_t this_arg) {
62262 LDKPhantomKeysManager this_arg_conv;
62263 this_arg_conv.inner = untag_ptr(this_arg);
62264 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62266 this_arg_conv.is_owned = false;
62267 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
62268 memcpy(ret_arr->elems, PhantomKeysManager_get_node_secret_key(&this_arg_conv).bytes, 32);
62272 int8_tArray __attribute__((export_name("TS_PhantomKeysManager_get_phantom_node_secret_key"))) TS_PhantomKeysManager_get_phantom_node_secret_key(uint64_t this_arg) {
62273 LDKPhantomKeysManager this_arg_conv;
62274 this_arg_conv.inner = untag_ptr(this_arg);
62275 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62277 this_arg_conv.is_owned = false;
62278 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
62279 memcpy(ret_arr->elems, PhantomKeysManager_get_phantom_node_secret_key(&this_arg_conv).bytes, 32);
62283 void __attribute__((export_name("TS_OnionMessenger_free"))) TS_OnionMessenger_free(uint64_t this_obj) {
62284 LDKOnionMessenger this_obj_conv;
62285 this_obj_conv.inner = untag_ptr(this_obj);
62286 this_obj_conv.is_owned = ptr_is_owned(this_obj);
62287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
62288 OnionMessenger_free(this_obj_conv);
62291 void __attribute__((export_name("TS_MessageRouter_free"))) TS_MessageRouter_free(uint64_t this_ptr) {
62292 if (!ptr_is_owned(this_ptr)) return;
62293 void* this_ptr_ptr = untag_ptr(this_ptr);
62294 CHECK_ACCESS(this_ptr_ptr);
62295 LDKMessageRouter this_ptr_conv = *(LDKMessageRouter*)(this_ptr_ptr);
62296 FREE(untag_ptr(this_ptr));
62297 MessageRouter_free(this_ptr_conv);
62300 void __attribute__((export_name("TS_DefaultMessageRouter_free"))) TS_DefaultMessageRouter_free(uint64_t this_obj) {
62301 LDKDefaultMessageRouter this_obj_conv;
62302 this_obj_conv.inner = untag_ptr(this_obj);
62303 this_obj_conv.is_owned = ptr_is_owned(this_obj);
62304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
62305 DefaultMessageRouter_free(this_obj_conv);
62308 uint64_t __attribute__((export_name("TS_DefaultMessageRouter_new"))) TS_DefaultMessageRouter_new() {
62309 LDKDefaultMessageRouter ret_var = DefaultMessageRouter_new();
62310 uint64_t ret_ref = 0;
62311 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62312 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62316 uint64_t __attribute__((export_name("TS_DefaultMessageRouter_as_MessageRouter"))) TS_DefaultMessageRouter_as_MessageRouter(uint64_t this_arg) {
62317 LDKDefaultMessageRouter this_arg_conv;
62318 this_arg_conv.inner = untag_ptr(this_arg);
62319 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62321 this_arg_conv.is_owned = false;
62322 LDKMessageRouter* ret_ret = MALLOC(sizeof(LDKMessageRouter), "LDKMessageRouter");
62323 *ret_ret = DefaultMessageRouter_as_MessageRouter(&this_arg_conv);
62324 return tag_ptr(ret_ret, true);
62327 void __attribute__((export_name("TS_OnionMessagePath_free"))) TS_OnionMessagePath_free(uint64_t this_obj) {
62328 LDKOnionMessagePath this_obj_conv;
62329 this_obj_conv.inner = untag_ptr(this_obj);
62330 this_obj_conv.is_owned = ptr_is_owned(this_obj);
62331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
62332 OnionMessagePath_free(this_obj_conv);
62335 ptrArray __attribute__((export_name("TS_OnionMessagePath_get_intermediate_nodes"))) TS_OnionMessagePath_get_intermediate_nodes(uint64_t this_ptr) {
62336 LDKOnionMessagePath this_ptr_conv;
62337 this_ptr_conv.inner = untag_ptr(this_ptr);
62338 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62339 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62340 this_ptr_conv.is_owned = false;
62341 LDKCVec_PublicKeyZ ret_var = OnionMessagePath_get_intermediate_nodes(&this_ptr_conv);
62342 ptrArray ret_arr = NULL;
62343 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
62344 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 8);
62345 for (size_t m = 0; m < ret_var.datalen; m++) {
62346 int8_tArray ret_conv_12_arr = init_int8_tArray(33, __LINE__);
62347 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compressed_form, 33);
62348 ret_arr_ptr[m] = ret_conv_12_arr;
62351 FREE(ret_var.data);
62355 void __attribute__((export_name("TS_OnionMessagePath_set_intermediate_nodes"))) TS_OnionMessagePath_set_intermediate_nodes(uint64_t this_ptr, ptrArray val) {
62356 LDKOnionMessagePath this_ptr_conv;
62357 this_ptr_conv.inner = untag_ptr(this_ptr);
62358 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62359 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62360 this_ptr_conv.is_owned = false;
62361 LDKCVec_PublicKeyZ val_constr;
62362 val_constr.datalen = val->arr_len;
62363 if (val_constr.datalen > 0)
62364 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
62366 val_constr.data = NULL;
62367 int8_tArray* val_vals = (void*) val->elems;
62368 for (size_t m = 0; m < val_constr.datalen; m++) {
62369 int8_tArray val_conv_12 = val_vals[m];
62370 LDKPublicKey val_conv_12_ref;
62371 CHECK(val_conv_12->arr_len == 33);
62372 memcpy(val_conv_12_ref.compressed_form, val_conv_12->elems, 33); FREE(val_conv_12);
62373 val_constr.data[m] = val_conv_12_ref;
62376 OnionMessagePath_set_intermediate_nodes(&this_ptr_conv, val_constr);
62379 uint64_t __attribute__((export_name("TS_OnionMessagePath_get_destination"))) TS_OnionMessagePath_get_destination(uint64_t this_ptr) {
62380 LDKOnionMessagePath this_ptr_conv;
62381 this_ptr_conv.inner = untag_ptr(this_ptr);
62382 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62384 this_ptr_conv.is_owned = false;
62385 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
62386 *ret_copy = OnionMessagePath_get_destination(&this_ptr_conv);
62387 uint64_t ret_ref = tag_ptr(ret_copy, true);
62391 void __attribute__((export_name("TS_OnionMessagePath_set_destination"))) TS_OnionMessagePath_set_destination(uint64_t this_ptr, uint64_t val) {
62392 LDKOnionMessagePath this_ptr_conv;
62393 this_ptr_conv.inner = untag_ptr(this_ptr);
62394 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62396 this_ptr_conv.is_owned = false;
62397 void* val_ptr = untag_ptr(val);
62398 CHECK_ACCESS(val_ptr);
62399 LDKDestination val_conv = *(LDKDestination*)(val_ptr);
62400 val_conv = Destination_clone((LDKDestination*)untag_ptr(val));
62401 OnionMessagePath_set_destination(&this_ptr_conv, val_conv);
62404 uint64_t __attribute__((export_name("TS_OnionMessagePath_new"))) TS_OnionMessagePath_new(ptrArray intermediate_nodes_arg, uint64_t destination_arg) {
62405 LDKCVec_PublicKeyZ intermediate_nodes_arg_constr;
62406 intermediate_nodes_arg_constr.datalen = intermediate_nodes_arg->arr_len;
62407 if (intermediate_nodes_arg_constr.datalen > 0)
62408 intermediate_nodes_arg_constr.data = MALLOC(intermediate_nodes_arg_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
62410 intermediate_nodes_arg_constr.data = NULL;
62411 int8_tArray* intermediate_nodes_arg_vals = (void*) intermediate_nodes_arg->elems;
62412 for (size_t m = 0; m < intermediate_nodes_arg_constr.datalen; m++) {
62413 int8_tArray intermediate_nodes_arg_conv_12 = intermediate_nodes_arg_vals[m];
62414 LDKPublicKey intermediate_nodes_arg_conv_12_ref;
62415 CHECK(intermediate_nodes_arg_conv_12->arr_len == 33);
62416 memcpy(intermediate_nodes_arg_conv_12_ref.compressed_form, intermediate_nodes_arg_conv_12->elems, 33); FREE(intermediate_nodes_arg_conv_12);
62417 intermediate_nodes_arg_constr.data[m] = intermediate_nodes_arg_conv_12_ref;
62419 FREE(intermediate_nodes_arg);
62420 void* destination_arg_ptr = untag_ptr(destination_arg);
62421 CHECK_ACCESS(destination_arg_ptr);
62422 LDKDestination destination_arg_conv = *(LDKDestination*)(destination_arg_ptr);
62423 destination_arg_conv = Destination_clone((LDKDestination*)untag_ptr(destination_arg));
62424 LDKOnionMessagePath ret_var = OnionMessagePath_new(intermediate_nodes_arg_constr, destination_arg_conv);
62425 uint64_t ret_ref = 0;
62426 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62427 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62431 static inline uint64_t OnionMessagePath_clone_ptr(LDKOnionMessagePath *NONNULL_PTR arg) {
62432 LDKOnionMessagePath ret_var = OnionMessagePath_clone(arg);
62433 uint64_t ret_ref = 0;
62434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62435 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62438 int64_t __attribute__((export_name("TS_OnionMessagePath_clone_ptr"))) TS_OnionMessagePath_clone_ptr(uint64_t arg) {
62439 LDKOnionMessagePath arg_conv;
62440 arg_conv.inner = untag_ptr(arg);
62441 arg_conv.is_owned = ptr_is_owned(arg);
62442 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
62443 arg_conv.is_owned = false;
62444 int64_t ret_conv = OnionMessagePath_clone_ptr(&arg_conv);
62448 uint64_t __attribute__((export_name("TS_OnionMessagePath_clone"))) TS_OnionMessagePath_clone(uint64_t orig) {
62449 LDKOnionMessagePath orig_conv;
62450 orig_conv.inner = untag_ptr(orig);
62451 orig_conv.is_owned = ptr_is_owned(orig);
62452 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
62453 orig_conv.is_owned = false;
62454 LDKOnionMessagePath ret_var = OnionMessagePath_clone(&orig_conv);
62455 uint64_t ret_ref = 0;
62456 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62457 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62461 void __attribute__((export_name("TS_Destination_free"))) TS_Destination_free(uint64_t this_ptr) {
62462 if (!ptr_is_owned(this_ptr)) return;
62463 void* this_ptr_ptr = untag_ptr(this_ptr);
62464 CHECK_ACCESS(this_ptr_ptr);
62465 LDKDestination this_ptr_conv = *(LDKDestination*)(this_ptr_ptr);
62466 FREE(untag_ptr(this_ptr));
62467 Destination_free(this_ptr_conv);
62470 static inline uint64_t Destination_clone_ptr(LDKDestination *NONNULL_PTR arg) {
62471 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
62472 *ret_copy = Destination_clone(arg);
62473 uint64_t ret_ref = tag_ptr(ret_copy, true);
62476 int64_t __attribute__((export_name("TS_Destination_clone_ptr"))) TS_Destination_clone_ptr(uint64_t arg) {
62477 LDKDestination* arg_conv = (LDKDestination*)untag_ptr(arg);
62478 int64_t ret_conv = Destination_clone_ptr(arg_conv);
62482 uint64_t __attribute__((export_name("TS_Destination_clone"))) TS_Destination_clone(uint64_t orig) {
62483 LDKDestination* orig_conv = (LDKDestination*)untag_ptr(orig);
62484 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
62485 *ret_copy = Destination_clone(orig_conv);
62486 uint64_t ret_ref = tag_ptr(ret_copy, true);
62490 uint64_t __attribute__((export_name("TS_Destination_node"))) TS_Destination_node(int8_tArray a) {
62491 LDKPublicKey a_ref;
62492 CHECK(a->arr_len == 33);
62493 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
62494 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
62495 *ret_copy = Destination_node(a_ref);
62496 uint64_t ret_ref = tag_ptr(ret_copy, true);
62500 uint64_t __attribute__((export_name("TS_Destination_blinded_path"))) TS_Destination_blinded_path(uint64_t a) {
62501 LDKBlindedPath a_conv;
62502 a_conv.inner = untag_ptr(a);
62503 a_conv.is_owned = ptr_is_owned(a);
62504 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
62505 a_conv = BlindedPath_clone(&a_conv);
62506 LDKDestination *ret_copy = MALLOC(sizeof(LDKDestination), "LDKDestination");
62507 *ret_copy = Destination_blinded_path(a_conv);
62508 uint64_t ret_ref = tag_ptr(ret_copy, true);
62512 void __attribute__((export_name("TS_SendError_free"))) TS_SendError_free(uint64_t this_ptr) {
62513 if (!ptr_is_owned(this_ptr)) return;
62514 void* this_ptr_ptr = untag_ptr(this_ptr);
62515 CHECK_ACCESS(this_ptr_ptr);
62516 LDKSendError this_ptr_conv = *(LDKSendError*)(this_ptr_ptr);
62517 FREE(untag_ptr(this_ptr));
62518 SendError_free(this_ptr_conv);
62521 static inline uint64_t SendError_clone_ptr(LDKSendError *NONNULL_PTR arg) {
62522 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62523 *ret_copy = SendError_clone(arg);
62524 uint64_t ret_ref = tag_ptr(ret_copy, true);
62527 int64_t __attribute__((export_name("TS_SendError_clone_ptr"))) TS_SendError_clone_ptr(uint64_t arg) {
62528 LDKSendError* arg_conv = (LDKSendError*)untag_ptr(arg);
62529 int64_t ret_conv = SendError_clone_ptr(arg_conv);
62533 uint64_t __attribute__((export_name("TS_SendError_clone"))) TS_SendError_clone(uint64_t orig) {
62534 LDKSendError* orig_conv = (LDKSendError*)untag_ptr(orig);
62535 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62536 *ret_copy = SendError_clone(orig_conv);
62537 uint64_t ret_ref = tag_ptr(ret_copy, true);
62541 uint64_t __attribute__((export_name("TS_SendError_secp256k1"))) TS_SendError_secp256k1(uint32_t a) {
62542 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
62543 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62544 *ret_copy = SendError_secp256k1(a_conv);
62545 uint64_t ret_ref = tag_ptr(ret_copy, true);
62549 uint64_t __attribute__((export_name("TS_SendError_too_big_packet"))) TS_SendError_too_big_packet() {
62550 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62551 *ret_copy = SendError_too_big_packet();
62552 uint64_t ret_ref = tag_ptr(ret_copy, true);
62556 uint64_t __attribute__((export_name("TS_SendError_too_few_blinded_hops"))) TS_SendError_too_few_blinded_hops() {
62557 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62558 *ret_copy = SendError_too_few_blinded_hops();
62559 uint64_t ret_ref = tag_ptr(ret_copy, true);
62563 uint64_t __attribute__((export_name("TS_SendError_invalid_first_hop"))) TS_SendError_invalid_first_hop() {
62564 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62565 *ret_copy = SendError_invalid_first_hop();
62566 uint64_t ret_ref = tag_ptr(ret_copy, true);
62570 uint64_t __attribute__((export_name("TS_SendError_invalid_message"))) TS_SendError_invalid_message() {
62571 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62572 *ret_copy = SendError_invalid_message();
62573 uint64_t ret_ref = tag_ptr(ret_copy, true);
62577 uint64_t __attribute__((export_name("TS_SendError_buffer_full"))) TS_SendError_buffer_full() {
62578 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62579 *ret_copy = SendError_buffer_full();
62580 uint64_t ret_ref = tag_ptr(ret_copy, true);
62584 uint64_t __attribute__((export_name("TS_SendError_get_node_id_failed"))) TS_SendError_get_node_id_failed() {
62585 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62586 *ret_copy = SendError_get_node_id_failed();
62587 uint64_t ret_ref = tag_ptr(ret_copy, true);
62591 uint64_t __attribute__((export_name("TS_SendError_blinded_path_advance_failed"))) TS_SendError_blinded_path_advance_failed() {
62592 LDKSendError *ret_copy = MALLOC(sizeof(LDKSendError), "LDKSendError");
62593 *ret_copy = SendError_blinded_path_advance_failed();
62594 uint64_t ret_ref = tag_ptr(ret_copy, true);
62598 jboolean __attribute__((export_name("TS_SendError_eq"))) TS_SendError_eq(uint64_t a, uint64_t b) {
62599 LDKSendError* a_conv = (LDKSendError*)untag_ptr(a);
62600 LDKSendError* b_conv = (LDKSendError*)untag_ptr(b);
62601 jboolean ret_conv = SendError_eq(a_conv, b_conv);
62605 void __attribute__((export_name("TS_CustomOnionMessageHandler_free"))) TS_CustomOnionMessageHandler_free(uint64_t this_ptr) {
62606 if (!ptr_is_owned(this_ptr)) return;
62607 void* this_ptr_ptr = untag_ptr(this_ptr);
62608 CHECK_ACCESS(this_ptr_ptr);
62609 LDKCustomOnionMessageHandler this_ptr_conv = *(LDKCustomOnionMessageHandler*)(this_ptr_ptr);
62610 FREE(untag_ptr(this_ptr));
62611 CustomOnionMessageHandler_free(this_ptr_conv);
62614 uint64_t __attribute__((export_name("TS_create_onion_message"))) TS_create_onion_message(uint64_t entropy_source, uint64_t node_signer, uint64_t path, uint64_t message, uint64_t reply_path) {
62615 void* entropy_source_ptr = untag_ptr(entropy_source);
62616 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
62617 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
62618 void* node_signer_ptr = untag_ptr(node_signer);
62619 if (ptr_is_owned(node_signer)) { CHECK_ACCESS(node_signer_ptr); }
62620 LDKNodeSigner* node_signer_conv = (LDKNodeSigner*)node_signer_ptr;
62621 LDKOnionMessagePath path_conv;
62622 path_conv.inner = untag_ptr(path);
62623 path_conv.is_owned = ptr_is_owned(path);
62624 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
62625 path_conv = OnionMessagePath_clone(&path_conv);
62626 void* message_ptr = untag_ptr(message);
62627 CHECK_ACCESS(message_ptr);
62628 LDKOnionMessageContents message_conv = *(LDKOnionMessageContents*)(message_ptr);
62629 message_conv = OnionMessageContents_clone((LDKOnionMessageContents*)untag_ptr(message));
62630 LDKBlindedPath reply_path_conv;
62631 reply_path_conv.inner = untag_ptr(reply_path);
62632 reply_path_conv.is_owned = ptr_is_owned(reply_path);
62633 CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
62634 reply_path_conv = BlindedPath_clone(&reply_path_conv);
62635 LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ), "LDKCResult_C2Tuple_PublicKeyOnionMessageZSendErrorZ");
62636 *ret_conv = create_onion_message(entropy_source_conv, node_signer_conv, path_conv, message_conv, reply_path_conv);
62637 return tag_ptr(ret_conv, true);
62640 uint64_t __attribute__((export_name("TS_OnionMessenger_new"))) TS_OnionMessenger_new(uint64_t entropy_source, uint64_t node_signer, uint64_t logger, uint64_t message_router, uint64_t offers_handler, uint64_t custom_handler) {
62641 void* entropy_source_ptr = untag_ptr(entropy_source);
62642 CHECK_ACCESS(entropy_source_ptr);
62643 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
62644 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
62645 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62646 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
62648 void* node_signer_ptr = untag_ptr(node_signer);
62649 CHECK_ACCESS(node_signer_ptr);
62650 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
62651 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
62652 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62653 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
62655 void* logger_ptr = untag_ptr(logger);
62656 CHECK_ACCESS(logger_ptr);
62657 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
62658 if (logger_conv.free == LDKLogger_JCalls_free) {
62659 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62660 LDKLogger_JCalls_cloned(&logger_conv);
62662 void* message_router_ptr = untag_ptr(message_router);
62663 CHECK_ACCESS(message_router_ptr);
62664 LDKMessageRouter message_router_conv = *(LDKMessageRouter*)(message_router_ptr);
62665 if (message_router_conv.free == LDKMessageRouter_JCalls_free) {
62666 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62667 LDKMessageRouter_JCalls_cloned(&message_router_conv);
62669 void* offers_handler_ptr = untag_ptr(offers_handler);
62670 CHECK_ACCESS(offers_handler_ptr);
62671 LDKOffersMessageHandler offers_handler_conv = *(LDKOffersMessageHandler*)(offers_handler_ptr);
62672 if (offers_handler_conv.free == LDKOffersMessageHandler_JCalls_free) {
62673 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62674 LDKOffersMessageHandler_JCalls_cloned(&offers_handler_conv);
62676 void* custom_handler_ptr = untag_ptr(custom_handler);
62677 CHECK_ACCESS(custom_handler_ptr);
62678 LDKCustomOnionMessageHandler custom_handler_conv = *(LDKCustomOnionMessageHandler*)(custom_handler_ptr);
62679 if (custom_handler_conv.free == LDKCustomOnionMessageHandler_JCalls_free) {
62680 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
62681 LDKCustomOnionMessageHandler_JCalls_cloned(&custom_handler_conv);
62683 LDKOnionMessenger ret_var = OnionMessenger_new(entropy_source_conv, node_signer_conv, logger_conv, message_router_conv, offers_handler_conv, custom_handler_conv);
62684 uint64_t ret_ref = 0;
62685 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62686 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62690 uint64_t __attribute__((export_name("TS_OnionMessenger_send_onion_message"))) TS_OnionMessenger_send_onion_message(uint64_t this_arg, uint64_t path, uint64_t message, uint64_t reply_path) {
62691 LDKOnionMessenger this_arg_conv;
62692 this_arg_conv.inner = untag_ptr(this_arg);
62693 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62695 this_arg_conv.is_owned = false;
62696 LDKOnionMessagePath path_conv;
62697 path_conv.inner = untag_ptr(path);
62698 path_conv.is_owned = ptr_is_owned(path);
62699 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
62700 path_conv = OnionMessagePath_clone(&path_conv);
62701 void* message_ptr = untag_ptr(message);
62702 CHECK_ACCESS(message_ptr);
62703 LDKOnionMessageContents message_conv = *(LDKOnionMessageContents*)(message_ptr);
62704 message_conv = OnionMessageContents_clone((LDKOnionMessageContents*)untag_ptr(message));
62705 LDKBlindedPath reply_path_conv;
62706 reply_path_conv.inner = untag_ptr(reply_path);
62707 reply_path_conv.is_owned = ptr_is_owned(reply_path);
62708 CHECK_INNER_FIELD_ACCESS_OR_NULL(reply_path_conv);
62709 reply_path_conv = BlindedPath_clone(&reply_path_conv);
62710 LDKCResult_NoneSendErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSendErrorZ), "LDKCResult_NoneSendErrorZ");
62711 *ret_conv = OnionMessenger_send_onion_message(&this_arg_conv, path_conv, message_conv, reply_path_conv);
62712 return tag_ptr(ret_conv, true);
62715 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageHandler"))) TS_OnionMessenger_as_OnionMessageHandler(uint64_t this_arg) {
62716 LDKOnionMessenger this_arg_conv;
62717 this_arg_conv.inner = untag_ptr(this_arg);
62718 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62720 this_arg_conv.is_owned = false;
62721 LDKOnionMessageHandler* ret_ret = MALLOC(sizeof(LDKOnionMessageHandler), "LDKOnionMessageHandler");
62722 *ret_ret = OnionMessenger_as_OnionMessageHandler(&this_arg_conv);
62723 return tag_ptr(ret_ret, true);
62726 uint64_t __attribute__((export_name("TS_OnionMessenger_as_OnionMessageProvider"))) TS_OnionMessenger_as_OnionMessageProvider(uint64_t this_arg) {
62727 LDKOnionMessenger this_arg_conv;
62728 this_arg_conv.inner = untag_ptr(this_arg);
62729 this_arg_conv.is_owned = ptr_is_owned(this_arg);
62730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
62731 this_arg_conv.is_owned = false;
62732 LDKOnionMessageProvider* ret_ret = MALLOC(sizeof(LDKOnionMessageProvider), "LDKOnionMessageProvider");
62733 *ret_ret = OnionMessenger_as_OnionMessageProvider(&this_arg_conv);
62734 return tag_ptr(ret_ret, true);
62737 void __attribute__((export_name("TS_OffersMessageHandler_free"))) TS_OffersMessageHandler_free(uint64_t this_ptr) {
62738 if (!ptr_is_owned(this_ptr)) return;
62739 void* this_ptr_ptr = untag_ptr(this_ptr);
62740 CHECK_ACCESS(this_ptr_ptr);
62741 LDKOffersMessageHandler this_ptr_conv = *(LDKOffersMessageHandler*)(this_ptr_ptr);
62742 FREE(untag_ptr(this_ptr));
62743 OffersMessageHandler_free(this_ptr_conv);
62746 void __attribute__((export_name("TS_OffersMessage_free"))) TS_OffersMessage_free(uint64_t this_ptr) {
62747 if (!ptr_is_owned(this_ptr)) return;
62748 void* this_ptr_ptr = untag_ptr(this_ptr);
62749 CHECK_ACCESS(this_ptr_ptr);
62750 LDKOffersMessage this_ptr_conv = *(LDKOffersMessage*)(this_ptr_ptr);
62751 FREE(untag_ptr(this_ptr));
62752 OffersMessage_free(this_ptr_conv);
62755 static inline uint64_t OffersMessage_clone_ptr(LDKOffersMessage *NONNULL_PTR arg) {
62756 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
62757 *ret_copy = OffersMessage_clone(arg);
62758 uint64_t ret_ref = tag_ptr(ret_copy, true);
62761 int64_t __attribute__((export_name("TS_OffersMessage_clone_ptr"))) TS_OffersMessage_clone_ptr(uint64_t arg) {
62762 LDKOffersMessage* arg_conv = (LDKOffersMessage*)untag_ptr(arg);
62763 int64_t ret_conv = OffersMessage_clone_ptr(arg_conv);
62767 uint64_t __attribute__((export_name("TS_OffersMessage_clone"))) TS_OffersMessage_clone(uint64_t orig) {
62768 LDKOffersMessage* orig_conv = (LDKOffersMessage*)untag_ptr(orig);
62769 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
62770 *ret_copy = OffersMessage_clone(orig_conv);
62771 uint64_t ret_ref = tag_ptr(ret_copy, true);
62775 uint64_t __attribute__((export_name("TS_OffersMessage_invoice_request"))) TS_OffersMessage_invoice_request(uint64_t a) {
62776 LDKInvoiceRequest a_conv;
62777 a_conv.inner = untag_ptr(a);
62778 a_conv.is_owned = ptr_is_owned(a);
62779 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
62780 a_conv = InvoiceRequest_clone(&a_conv);
62781 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
62782 *ret_copy = OffersMessage_invoice_request(a_conv);
62783 uint64_t ret_ref = tag_ptr(ret_copy, true);
62787 uint64_t __attribute__((export_name("TS_OffersMessage_invoice"))) TS_OffersMessage_invoice(uint64_t a) {
62788 LDKBolt12Invoice a_conv;
62789 a_conv.inner = untag_ptr(a);
62790 a_conv.is_owned = ptr_is_owned(a);
62791 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
62792 a_conv = Bolt12Invoice_clone(&a_conv);
62793 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
62794 *ret_copy = OffersMessage_invoice(a_conv);
62795 uint64_t ret_ref = tag_ptr(ret_copy, true);
62799 uint64_t __attribute__((export_name("TS_OffersMessage_invoice_error"))) TS_OffersMessage_invoice_error(uint64_t a) {
62800 LDKInvoiceError a_conv;
62801 a_conv.inner = untag_ptr(a);
62802 a_conv.is_owned = ptr_is_owned(a);
62803 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
62804 a_conv = InvoiceError_clone(&a_conv);
62805 LDKOffersMessage *ret_copy = MALLOC(sizeof(LDKOffersMessage), "LDKOffersMessage");
62806 *ret_copy = OffersMessage_invoice_error(a_conv);
62807 uint64_t ret_ref = tag_ptr(ret_copy, true);
62811 jboolean __attribute__((export_name("TS_OffersMessage_is_known_type"))) TS_OffersMessage_is_known_type(int64_t tlv_type) {
62812 jboolean ret_conv = OffersMessage_is_known_type(tlv_type);
62816 int64_t __attribute__((export_name("TS_OffersMessage_tlv_type"))) TS_OffersMessage_tlv_type(uint64_t this_arg) {
62817 LDKOffersMessage* this_arg_conv = (LDKOffersMessage*)untag_ptr(this_arg);
62818 int64_t ret_conv = OffersMessage_tlv_type(this_arg_conv);
62822 int8_tArray __attribute__((export_name("TS_OffersMessage_write"))) TS_OffersMessage_write(uint64_t obj) {
62823 LDKOffersMessage* obj_conv = (LDKOffersMessage*)untag_ptr(obj);
62824 LDKCVec_u8Z ret_var = OffersMessage_write(obj_conv);
62825 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
62826 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
62827 CVec_u8Z_free(ret_var);
62831 uint64_t __attribute__((export_name("TS_OffersMessage_read"))) TS_OffersMessage_read(int8_tArray ser, int64_t arg_a, uint64_t arg_b) {
62832 LDKu8slice ser_ref;
62833 ser_ref.datalen = ser->arr_len;
62834 ser_ref.data = ser->elems;
62835 void* arg_b_ptr = untag_ptr(arg_b);
62836 if (ptr_is_owned(arg_b)) { CHECK_ACCESS(arg_b_ptr); }
62837 LDKLogger* arg_b_conv = (LDKLogger*)arg_b_ptr;
62838 LDKCResult_OffersMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OffersMessageDecodeErrorZ), "LDKCResult_OffersMessageDecodeErrorZ");
62839 *ret_conv = OffersMessage_read(ser_ref, arg_a, arg_b_conv);
62841 return tag_ptr(ret_conv, true);
62844 void __attribute__((export_name("TS_Packet_free"))) TS_Packet_free(uint64_t this_obj) {
62845 LDKPacket this_obj_conv;
62846 this_obj_conv.inner = untag_ptr(this_obj);
62847 this_obj_conv.is_owned = ptr_is_owned(this_obj);
62848 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
62849 Packet_free(this_obj_conv);
62852 int8_t __attribute__((export_name("TS_Packet_get_version"))) TS_Packet_get_version(uint64_t this_ptr) {
62853 LDKPacket this_ptr_conv;
62854 this_ptr_conv.inner = untag_ptr(this_ptr);
62855 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62857 this_ptr_conv.is_owned = false;
62858 int8_t ret_conv = Packet_get_version(&this_ptr_conv);
62862 void __attribute__((export_name("TS_Packet_set_version"))) TS_Packet_set_version(uint64_t this_ptr, int8_t val) {
62863 LDKPacket this_ptr_conv;
62864 this_ptr_conv.inner = untag_ptr(this_ptr);
62865 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62867 this_ptr_conv.is_owned = false;
62868 Packet_set_version(&this_ptr_conv, val);
62871 int8_tArray __attribute__((export_name("TS_Packet_get_public_key"))) TS_Packet_get_public_key(uint64_t this_ptr) {
62872 LDKPacket this_ptr_conv;
62873 this_ptr_conv.inner = untag_ptr(this_ptr);
62874 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62876 this_ptr_conv.is_owned = false;
62877 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
62878 memcpy(ret_arr->elems, Packet_get_public_key(&this_ptr_conv).compressed_form, 33);
62882 void __attribute__((export_name("TS_Packet_set_public_key"))) TS_Packet_set_public_key(uint64_t this_ptr, int8_tArray val) {
62883 LDKPacket this_ptr_conv;
62884 this_ptr_conv.inner = untag_ptr(this_ptr);
62885 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62886 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62887 this_ptr_conv.is_owned = false;
62888 LDKPublicKey val_ref;
62889 CHECK(val->arr_len == 33);
62890 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
62891 Packet_set_public_key(&this_ptr_conv, val_ref);
62894 int8_tArray __attribute__((export_name("TS_Packet_get_hop_data"))) TS_Packet_get_hop_data(uint64_t this_ptr) {
62895 LDKPacket this_ptr_conv;
62896 this_ptr_conv.inner = untag_ptr(this_ptr);
62897 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62899 this_ptr_conv.is_owned = false;
62900 LDKCVec_u8Z ret_var = Packet_get_hop_data(&this_ptr_conv);
62901 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
62902 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
62903 CVec_u8Z_free(ret_var);
62907 void __attribute__((export_name("TS_Packet_set_hop_data"))) TS_Packet_set_hop_data(uint64_t this_ptr, int8_tArray val) {
62908 LDKPacket this_ptr_conv;
62909 this_ptr_conv.inner = untag_ptr(this_ptr);
62910 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62912 this_ptr_conv.is_owned = false;
62913 LDKCVec_u8Z val_ref;
62914 val_ref.datalen = val->arr_len;
62915 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
62916 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
62917 Packet_set_hop_data(&this_ptr_conv, val_ref);
62920 int8_tArray __attribute__((export_name("TS_Packet_get_hmac"))) TS_Packet_get_hmac(uint64_t this_ptr) {
62921 LDKPacket this_ptr_conv;
62922 this_ptr_conv.inner = untag_ptr(this_ptr);
62923 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62925 this_ptr_conv.is_owned = false;
62926 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
62927 memcpy(ret_arr->elems, *Packet_get_hmac(&this_ptr_conv), 32);
62931 void __attribute__((export_name("TS_Packet_set_hmac"))) TS_Packet_set_hmac(uint64_t this_ptr, int8_tArray val) {
62932 LDKPacket this_ptr_conv;
62933 this_ptr_conv.inner = untag_ptr(this_ptr);
62934 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
62935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
62936 this_ptr_conv.is_owned = false;
62937 LDKThirtyTwoBytes val_ref;
62938 CHECK(val->arr_len == 32);
62939 memcpy(val_ref.data, val->elems, 32); FREE(val);
62940 Packet_set_hmac(&this_ptr_conv, val_ref);
62943 uint64_t __attribute__((export_name("TS_Packet_new"))) TS_Packet_new(int8_t version_arg, int8_tArray public_key_arg, int8_tArray hop_data_arg, int8_tArray hmac_arg) {
62944 LDKPublicKey public_key_arg_ref;
62945 CHECK(public_key_arg->arr_len == 33);
62946 memcpy(public_key_arg_ref.compressed_form, public_key_arg->elems, 33); FREE(public_key_arg);
62947 LDKCVec_u8Z hop_data_arg_ref;
62948 hop_data_arg_ref.datalen = hop_data_arg->arr_len;
62949 hop_data_arg_ref.data = MALLOC(hop_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
62950 memcpy(hop_data_arg_ref.data, hop_data_arg->elems, hop_data_arg_ref.datalen); FREE(hop_data_arg);
62951 LDKThirtyTwoBytes hmac_arg_ref;
62952 CHECK(hmac_arg->arr_len == 32);
62953 memcpy(hmac_arg_ref.data, hmac_arg->elems, 32); FREE(hmac_arg);
62954 LDKPacket ret_var = Packet_new(version_arg, public_key_arg_ref, hop_data_arg_ref, hmac_arg_ref);
62955 uint64_t ret_ref = 0;
62956 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62957 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62961 static inline uint64_t Packet_clone_ptr(LDKPacket *NONNULL_PTR arg) {
62962 LDKPacket ret_var = Packet_clone(arg);
62963 uint64_t ret_ref = 0;
62964 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62965 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62968 int64_t __attribute__((export_name("TS_Packet_clone_ptr"))) TS_Packet_clone_ptr(uint64_t arg) {
62969 LDKPacket arg_conv;
62970 arg_conv.inner = untag_ptr(arg);
62971 arg_conv.is_owned = ptr_is_owned(arg);
62972 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
62973 arg_conv.is_owned = false;
62974 int64_t ret_conv = Packet_clone_ptr(&arg_conv);
62978 uint64_t __attribute__((export_name("TS_Packet_clone"))) TS_Packet_clone(uint64_t orig) {
62979 LDKPacket orig_conv;
62980 orig_conv.inner = untag_ptr(orig);
62981 orig_conv.is_owned = ptr_is_owned(orig);
62982 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
62983 orig_conv.is_owned = false;
62984 LDKPacket ret_var = Packet_clone(&orig_conv);
62985 uint64_t ret_ref = 0;
62986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
62987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
62991 jboolean __attribute__((export_name("TS_Packet_eq"))) TS_Packet_eq(uint64_t a, uint64_t b) {
62993 a_conv.inner = untag_ptr(a);
62994 a_conv.is_owned = ptr_is_owned(a);
62995 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
62996 a_conv.is_owned = false;
62998 b_conv.inner = untag_ptr(b);
62999 b_conv.is_owned = ptr_is_owned(b);
63000 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
63001 b_conv.is_owned = false;
63002 jboolean ret_conv = Packet_eq(&a_conv, &b_conv);
63006 int8_tArray __attribute__((export_name("TS_Packet_write"))) TS_Packet_write(uint64_t obj) {
63007 LDKPacket obj_conv;
63008 obj_conv.inner = untag_ptr(obj);
63009 obj_conv.is_owned = ptr_is_owned(obj);
63010 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
63011 obj_conv.is_owned = false;
63012 LDKCVec_u8Z ret_var = Packet_write(&obj_conv);
63013 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
63014 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
63015 CVec_u8Z_free(ret_var);
63019 void __attribute__((export_name("TS_OnionMessageContents_free"))) TS_OnionMessageContents_free(uint64_t this_ptr) {
63020 if (!ptr_is_owned(this_ptr)) return;
63021 void* this_ptr_ptr = untag_ptr(this_ptr);
63022 CHECK_ACCESS(this_ptr_ptr);
63023 LDKOnionMessageContents this_ptr_conv = *(LDKOnionMessageContents*)(this_ptr_ptr);
63024 FREE(untag_ptr(this_ptr));
63025 OnionMessageContents_free(this_ptr_conv);
63028 static inline uint64_t OnionMessageContents_clone_ptr(LDKOnionMessageContents *NONNULL_PTR arg) {
63029 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
63030 *ret_copy = OnionMessageContents_clone(arg);
63031 uint64_t ret_ref = tag_ptr(ret_copy, true);
63034 int64_t __attribute__((export_name("TS_OnionMessageContents_clone_ptr"))) TS_OnionMessageContents_clone_ptr(uint64_t arg) {
63035 LDKOnionMessageContents* arg_conv = (LDKOnionMessageContents*)untag_ptr(arg);
63036 int64_t ret_conv = OnionMessageContents_clone_ptr(arg_conv);
63040 uint64_t __attribute__((export_name("TS_OnionMessageContents_clone"))) TS_OnionMessageContents_clone(uint64_t orig) {
63041 LDKOnionMessageContents* orig_conv = (LDKOnionMessageContents*)untag_ptr(orig);
63042 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
63043 *ret_copy = OnionMessageContents_clone(orig_conv);
63044 uint64_t ret_ref = tag_ptr(ret_copy, true);
63048 uint64_t __attribute__((export_name("TS_OnionMessageContents_offers"))) TS_OnionMessageContents_offers(uint64_t a) {
63049 void* a_ptr = untag_ptr(a);
63050 CHECK_ACCESS(a_ptr);
63051 LDKOffersMessage a_conv = *(LDKOffersMessage*)(a_ptr);
63052 a_conv = OffersMessage_clone((LDKOffersMessage*)untag_ptr(a));
63053 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
63054 *ret_copy = OnionMessageContents_offers(a_conv);
63055 uint64_t ret_ref = tag_ptr(ret_copy, true);
63059 uint64_t __attribute__((export_name("TS_OnionMessageContents_custom"))) TS_OnionMessageContents_custom(uint64_t a) {
63060 void* a_ptr = untag_ptr(a);
63061 CHECK_ACCESS(a_ptr);
63062 LDKCustomOnionMessageContents a_conv = *(LDKCustomOnionMessageContents*)(a_ptr);
63063 if (a_conv.free == LDKCustomOnionMessageContents_JCalls_free) {
63064 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
63065 LDKCustomOnionMessageContents_JCalls_cloned(&a_conv);
63067 LDKOnionMessageContents *ret_copy = MALLOC(sizeof(LDKOnionMessageContents), "LDKOnionMessageContents");
63068 *ret_copy = OnionMessageContents_custom(a_conv);
63069 uint64_t ret_ref = tag_ptr(ret_copy, true);
63073 static inline uint64_t CustomOnionMessageContents_clone_ptr(LDKCustomOnionMessageContents *NONNULL_PTR arg) {
63074 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
63075 *ret_ret = CustomOnionMessageContents_clone(arg);
63076 return tag_ptr(ret_ret, true);
63078 int64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone_ptr"))) TS_CustomOnionMessageContents_clone_ptr(uint64_t arg) {
63079 void* arg_ptr = untag_ptr(arg);
63080 if (ptr_is_owned(arg)) { CHECK_ACCESS(arg_ptr); }
63081 LDKCustomOnionMessageContents* arg_conv = (LDKCustomOnionMessageContents*)arg_ptr;
63082 int64_t ret_conv = CustomOnionMessageContents_clone_ptr(arg_conv);
63086 uint64_t __attribute__((export_name("TS_CustomOnionMessageContents_clone"))) TS_CustomOnionMessageContents_clone(uint64_t orig) {
63087 void* orig_ptr = untag_ptr(orig);
63088 if (ptr_is_owned(orig)) { CHECK_ACCESS(orig_ptr); }
63089 LDKCustomOnionMessageContents* orig_conv = (LDKCustomOnionMessageContents*)orig_ptr;
63090 LDKCustomOnionMessageContents* ret_ret = MALLOC(sizeof(LDKCustomOnionMessageContents), "LDKCustomOnionMessageContents");
63091 *ret_ret = CustomOnionMessageContents_clone(orig_conv);
63092 return tag_ptr(ret_ret, true);
63095 void __attribute__((export_name("TS_CustomOnionMessageContents_free"))) TS_CustomOnionMessageContents_free(uint64_t this_ptr) {
63096 if (!ptr_is_owned(this_ptr)) return;
63097 void* this_ptr_ptr = untag_ptr(this_ptr);
63098 CHECK_ACCESS(this_ptr_ptr);
63099 LDKCustomOnionMessageContents this_ptr_conv = *(LDKCustomOnionMessageContents*)(this_ptr_ptr);
63100 FREE(untag_ptr(this_ptr));
63101 CustomOnionMessageContents_free(this_ptr_conv);
63104 void __attribute__((export_name("TS_BlindedPath_free"))) TS_BlindedPath_free(uint64_t this_obj) {
63105 LDKBlindedPath this_obj_conv;
63106 this_obj_conv.inner = untag_ptr(this_obj);
63107 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63109 BlindedPath_free(this_obj_conv);
63112 int8_tArray __attribute__((export_name("TS_BlindedPath_get_introduction_node_id"))) TS_BlindedPath_get_introduction_node_id(uint64_t this_ptr) {
63113 LDKBlindedPath this_ptr_conv;
63114 this_ptr_conv.inner = untag_ptr(this_ptr);
63115 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63117 this_ptr_conv.is_owned = false;
63118 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
63119 memcpy(ret_arr->elems, BlindedPath_get_introduction_node_id(&this_ptr_conv).compressed_form, 33);
63123 void __attribute__((export_name("TS_BlindedPath_set_introduction_node_id"))) TS_BlindedPath_set_introduction_node_id(uint64_t this_ptr, int8_tArray val) {
63124 LDKBlindedPath this_ptr_conv;
63125 this_ptr_conv.inner = untag_ptr(this_ptr);
63126 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63128 this_ptr_conv.is_owned = false;
63129 LDKPublicKey val_ref;
63130 CHECK(val->arr_len == 33);
63131 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
63132 BlindedPath_set_introduction_node_id(&this_ptr_conv, val_ref);
63135 int8_tArray __attribute__((export_name("TS_BlindedPath_get_blinding_point"))) TS_BlindedPath_get_blinding_point(uint64_t this_ptr) {
63136 LDKBlindedPath this_ptr_conv;
63137 this_ptr_conv.inner = untag_ptr(this_ptr);
63138 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63139 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63140 this_ptr_conv.is_owned = false;
63141 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
63142 memcpy(ret_arr->elems, BlindedPath_get_blinding_point(&this_ptr_conv).compressed_form, 33);
63146 void __attribute__((export_name("TS_BlindedPath_set_blinding_point"))) TS_BlindedPath_set_blinding_point(uint64_t this_ptr, int8_tArray val) {
63147 LDKBlindedPath this_ptr_conv;
63148 this_ptr_conv.inner = untag_ptr(this_ptr);
63149 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63151 this_ptr_conv.is_owned = false;
63152 LDKPublicKey val_ref;
63153 CHECK(val->arr_len == 33);
63154 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
63155 BlindedPath_set_blinding_point(&this_ptr_conv, val_ref);
63158 uint64_tArray __attribute__((export_name("TS_BlindedPath_get_blinded_hops"))) TS_BlindedPath_get_blinded_hops(uint64_t this_ptr) {
63159 LDKBlindedPath this_ptr_conv;
63160 this_ptr_conv.inner = untag_ptr(this_ptr);
63161 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63163 this_ptr_conv.is_owned = false;
63164 LDKCVec_BlindedHopZ ret_var = BlindedPath_get_blinded_hops(&this_ptr_conv);
63165 uint64_tArray ret_arr = NULL;
63166 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
63167 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
63168 for (size_t m = 0; m < ret_var.datalen; m++) {
63169 LDKBlindedHop ret_conv_12_var = ret_var.data[m];
63170 uint64_t ret_conv_12_ref = 0;
63171 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_var);
63172 ret_conv_12_ref = tag_ptr(ret_conv_12_var.inner, ret_conv_12_var.is_owned);
63173 ret_arr_ptr[m] = ret_conv_12_ref;
63176 FREE(ret_var.data);
63180 void __attribute__((export_name("TS_BlindedPath_set_blinded_hops"))) TS_BlindedPath_set_blinded_hops(uint64_t this_ptr, uint64_tArray val) {
63181 LDKBlindedPath this_ptr_conv;
63182 this_ptr_conv.inner = untag_ptr(this_ptr);
63183 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63185 this_ptr_conv.is_owned = false;
63186 LDKCVec_BlindedHopZ val_constr;
63187 val_constr.datalen = val->arr_len;
63188 if (val_constr.datalen > 0)
63189 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
63191 val_constr.data = NULL;
63192 uint64_t* val_vals = val->elems;
63193 for (size_t m = 0; m < val_constr.datalen; m++) {
63194 uint64_t val_conv_12 = val_vals[m];
63195 LDKBlindedHop val_conv_12_conv;
63196 val_conv_12_conv.inner = untag_ptr(val_conv_12);
63197 val_conv_12_conv.is_owned = ptr_is_owned(val_conv_12);
63198 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv);
63199 val_conv_12_conv = BlindedHop_clone(&val_conv_12_conv);
63200 val_constr.data[m] = val_conv_12_conv;
63203 BlindedPath_set_blinded_hops(&this_ptr_conv, val_constr);
63206 uint64_t __attribute__((export_name("TS_BlindedPath_new"))) TS_BlindedPath_new(int8_tArray introduction_node_id_arg, int8_tArray blinding_point_arg, uint64_tArray blinded_hops_arg) {
63207 LDKPublicKey introduction_node_id_arg_ref;
63208 CHECK(introduction_node_id_arg->arr_len == 33);
63209 memcpy(introduction_node_id_arg_ref.compressed_form, introduction_node_id_arg->elems, 33); FREE(introduction_node_id_arg);
63210 LDKPublicKey blinding_point_arg_ref;
63211 CHECK(blinding_point_arg->arr_len == 33);
63212 memcpy(blinding_point_arg_ref.compressed_form, blinding_point_arg->elems, 33); FREE(blinding_point_arg);
63213 LDKCVec_BlindedHopZ blinded_hops_arg_constr;
63214 blinded_hops_arg_constr.datalen = blinded_hops_arg->arr_len;
63215 if (blinded_hops_arg_constr.datalen > 0)
63216 blinded_hops_arg_constr.data = MALLOC(blinded_hops_arg_constr.datalen * sizeof(LDKBlindedHop), "LDKCVec_BlindedHopZ Elements");
63218 blinded_hops_arg_constr.data = NULL;
63219 uint64_t* blinded_hops_arg_vals = blinded_hops_arg->elems;
63220 for (size_t m = 0; m < blinded_hops_arg_constr.datalen; m++) {
63221 uint64_t blinded_hops_arg_conv_12 = blinded_hops_arg_vals[m];
63222 LDKBlindedHop blinded_hops_arg_conv_12_conv;
63223 blinded_hops_arg_conv_12_conv.inner = untag_ptr(blinded_hops_arg_conv_12);
63224 blinded_hops_arg_conv_12_conv.is_owned = ptr_is_owned(blinded_hops_arg_conv_12);
63225 CHECK_INNER_FIELD_ACCESS_OR_NULL(blinded_hops_arg_conv_12_conv);
63226 blinded_hops_arg_conv_12_conv = BlindedHop_clone(&blinded_hops_arg_conv_12_conv);
63227 blinded_hops_arg_constr.data[m] = blinded_hops_arg_conv_12_conv;
63229 FREE(blinded_hops_arg);
63230 LDKBlindedPath ret_var = BlindedPath_new(introduction_node_id_arg_ref, blinding_point_arg_ref, blinded_hops_arg_constr);
63231 uint64_t ret_ref = 0;
63232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63233 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63237 static inline uint64_t BlindedPath_clone_ptr(LDKBlindedPath *NONNULL_PTR arg) {
63238 LDKBlindedPath ret_var = BlindedPath_clone(arg);
63239 uint64_t ret_ref = 0;
63240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63241 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63244 int64_t __attribute__((export_name("TS_BlindedPath_clone_ptr"))) TS_BlindedPath_clone_ptr(uint64_t arg) {
63245 LDKBlindedPath arg_conv;
63246 arg_conv.inner = untag_ptr(arg);
63247 arg_conv.is_owned = ptr_is_owned(arg);
63248 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63249 arg_conv.is_owned = false;
63250 int64_t ret_conv = BlindedPath_clone_ptr(&arg_conv);
63254 uint64_t __attribute__((export_name("TS_BlindedPath_clone"))) TS_BlindedPath_clone(uint64_t orig) {
63255 LDKBlindedPath orig_conv;
63256 orig_conv.inner = untag_ptr(orig);
63257 orig_conv.is_owned = ptr_is_owned(orig);
63258 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63259 orig_conv.is_owned = false;
63260 LDKBlindedPath ret_var = BlindedPath_clone(&orig_conv);
63261 uint64_t ret_ref = 0;
63262 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63263 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63267 int64_t __attribute__((export_name("TS_BlindedPath_hash"))) TS_BlindedPath_hash(uint64_t o) {
63268 LDKBlindedPath o_conv;
63269 o_conv.inner = untag_ptr(o);
63270 o_conv.is_owned = ptr_is_owned(o);
63271 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
63272 o_conv.is_owned = false;
63273 int64_t ret_conv = BlindedPath_hash(&o_conv);
63277 jboolean __attribute__((export_name("TS_BlindedPath_eq"))) TS_BlindedPath_eq(uint64_t a, uint64_t b) {
63278 LDKBlindedPath a_conv;
63279 a_conv.inner = untag_ptr(a);
63280 a_conv.is_owned = ptr_is_owned(a);
63281 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
63282 a_conv.is_owned = false;
63283 LDKBlindedPath b_conv;
63284 b_conv.inner = untag_ptr(b);
63285 b_conv.is_owned = ptr_is_owned(b);
63286 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
63287 b_conv.is_owned = false;
63288 jboolean ret_conv = BlindedPath_eq(&a_conv, &b_conv);
63292 void __attribute__((export_name("TS_BlindedHop_free"))) TS_BlindedHop_free(uint64_t this_obj) {
63293 LDKBlindedHop this_obj_conv;
63294 this_obj_conv.inner = untag_ptr(this_obj);
63295 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63297 BlindedHop_free(this_obj_conv);
63300 int8_tArray __attribute__((export_name("TS_BlindedHop_get_blinded_node_id"))) TS_BlindedHop_get_blinded_node_id(uint64_t this_ptr) {
63301 LDKBlindedHop this_ptr_conv;
63302 this_ptr_conv.inner = untag_ptr(this_ptr);
63303 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63305 this_ptr_conv.is_owned = false;
63306 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
63307 memcpy(ret_arr->elems, BlindedHop_get_blinded_node_id(&this_ptr_conv).compressed_form, 33);
63311 void __attribute__((export_name("TS_BlindedHop_set_blinded_node_id"))) TS_BlindedHop_set_blinded_node_id(uint64_t this_ptr, int8_tArray val) {
63312 LDKBlindedHop this_ptr_conv;
63313 this_ptr_conv.inner = untag_ptr(this_ptr);
63314 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63316 this_ptr_conv.is_owned = false;
63317 LDKPublicKey val_ref;
63318 CHECK(val->arr_len == 33);
63319 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
63320 BlindedHop_set_blinded_node_id(&this_ptr_conv, val_ref);
63323 int8_tArray __attribute__((export_name("TS_BlindedHop_get_encrypted_payload"))) TS_BlindedHop_get_encrypted_payload(uint64_t this_ptr) {
63324 LDKBlindedHop this_ptr_conv;
63325 this_ptr_conv.inner = untag_ptr(this_ptr);
63326 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63328 this_ptr_conv.is_owned = false;
63329 LDKCVec_u8Z ret_var = BlindedHop_get_encrypted_payload(&this_ptr_conv);
63330 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
63331 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
63332 CVec_u8Z_free(ret_var);
63336 void __attribute__((export_name("TS_BlindedHop_set_encrypted_payload"))) TS_BlindedHop_set_encrypted_payload(uint64_t this_ptr, int8_tArray val) {
63337 LDKBlindedHop this_ptr_conv;
63338 this_ptr_conv.inner = untag_ptr(this_ptr);
63339 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63341 this_ptr_conv.is_owned = false;
63342 LDKCVec_u8Z val_ref;
63343 val_ref.datalen = val->arr_len;
63344 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
63345 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
63346 BlindedHop_set_encrypted_payload(&this_ptr_conv, val_ref);
63349 uint64_t __attribute__((export_name("TS_BlindedHop_new"))) TS_BlindedHop_new(int8_tArray blinded_node_id_arg, int8_tArray encrypted_payload_arg) {
63350 LDKPublicKey blinded_node_id_arg_ref;
63351 CHECK(blinded_node_id_arg->arr_len == 33);
63352 memcpy(blinded_node_id_arg_ref.compressed_form, blinded_node_id_arg->elems, 33); FREE(blinded_node_id_arg);
63353 LDKCVec_u8Z encrypted_payload_arg_ref;
63354 encrypted_payload_arg_ref.datalen = encrypted_payload_arg->arr_len;
63355 encrypted_payload_arg_ref.data = MALLOC(encrypted_payload_arg_ref.datalen, "LDKCVec_u8Z Bytes");
63356 memcpy(encrypted_payload_arg_ref.data, encrypted_payload_arg->elems, encrypted_payload_arg_ref.datalen); FREE(encrypted_payload_arg);
63357 LDKBlindedHop ret_var = BlindedHop_new(blinded_node_id_arg_ref, encrypted_payload_arg_ref);
63358 uint64_t ret_ref = 0;
63359 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63360 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63364 static inline uint64_t BlindedHop_clone_ptr(LDKBlindedHop *NONNULL_PTR arg) {
63365 LDKBlindedHop ret_var = BlindedHop_clone(arg);
63366 uint64_t ret_ref = 0;
63367 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63368 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63371 int64_t __attribute__((export_name("TS_BlindedHop_clone_ptr"))) TS_BlindedHop_clone_ptr(uint64_t arg) {
63372 LDKBlindedHop arg_conv;
63373 arg_conv.inner = untag_ptr(arg);
63374 arg_conv.is_owned = ptr_is_owned(arg);
63375 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63376 arg_conv.is_owned = false;
63377 int64_t ret_conv = BlindedHop_clone_ptr(&arg_conv);
63381 uint64_t __attribute__((export_name("TS_BlindedHop_clone"))) TS_BlindedHop_clone(uint64_t orig) {
63382 LDKBlindedHop orig_conv;
63383 orig_conv.inner = untag_ptr(orig);
63384 orig_conv.is_owned = ptr_is_owned(orig);
63385 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63386 orig_conv.is_owned = false;
63387 LDKBlindedHop ret_var = BlindedHop_clone(&orig_conv);
63388 uint64_t ret_ref = 0;
63389 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63390 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63394 int64_t __attribute__((export_name("TS_BlindedHop_hash"))) TS_BlindedHop_hash(uint64_t o) {
63395 LDKBlindedHop o_conv;
63396 o_conv.inner = untag_ptr(o);
63397 o_conv.is_owned = ptr_is_owned(o);
63398 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
63399 o_conv.is_owned = false;
63400 int64_t ret_conv = BlindedHop_hash(&o_conv);
63404 jboolean __attribute__((export_name("TS_BlindedHop_eq"))) TS_BlindedHop_eq(uint64_t a, uint64_t b) {
63405 LDKBlindedHop a_conv;
63406 a_conv.inner = untag_ptr(a);
63407 a_conv.is_owned = ptr_is_owned(a);
63408 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
63409 a_conv.is_owned = false;
63410 LDKBlindedHop b_conv;
63411 b_conv.inner = untag_ptr(b);
63412 b_conv.is_owned = ptr_is_owned(b);
63413 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
63414 b_conv.is_owned = false;
63415 jboolean ret_conv = BlindedHop_eq(&a_conv, &b_conv);
63419 uint64_t __attribute__((export_name("TS_BlindedPath_new_for_message"))) TS_BlindedPath_new_for_message(ptrArray node_pks, uint64_t entropy_source) {
63420 LDKCVec_PublicKeyZ node_pks_constr;
63421 node_pks_constr.datalen = node_pks->arr_len;
63422 if (node_pks_constr.datalen > 0)
63423 node_pks_constr.data = MALLOC(node_pks_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
63425 node_pks_constr.data = NULL;
63426 int8_tArray* node_pks_vals = (void*) node_pks->elems;
63427 for (size_t m = 0; m < node_pks_constr.datalen; m++) {
63428 int8_tArray node_pks_conv_12 = node_pks_vals[m];
63429 LDKPublicKey node_pks_conv_12_ref;
63430 CHECK(node_pks_conv_12->arr_len == 33);
63431 memcpy(node_pks_conv_12_ref.compressed_form, node_pks_conv_12->elems, 33); FREE(node_pks_conv_12);
63432 node_pks_constr.data[m] = node_pks_conv_12_ref;
63435 void* entropy_source_ptr = untag_ptr(entropy_source);
63436 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
63437 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
63438 LDKCResult_BlindedPathNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathNoneZ), "LDKCResult_BlindedPathNoneZ");
63439 *ret_conv = BlindedPath_new_for_message(node_pks_constr, entropy_source_conv);
63440 return tag_ptr(ret_conv, true);
63443 uint64_t __attribute__((export_name("TS_BlindedPath_one_hop_for_payment"))) TS_BlindedPath_one_hop_for_payment(int8_tArray payee_node_id, uint64_t payee_tlvs, uint64_t entropy_source) {
63444 LDKPublicKey payee_node_id_ref;
63445 CHECK(payee_node_id->arr_len == 33);
63446 memcpy(payee_node_id_ref.compressed_form, payee_node_id->elems, 33); FREE(payee_node_id);
63447 LDKReceiveTlvs payee_tlvs_conv;
63448 payee_tlvs_conv.inner = untag_ptr(payee_tlvs);
63449 payee_tlvs_conv.is_owned = ptr_is_owned(payee_tlvs);
63450 CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_tlvs_conv);
63451 payee_tlvs_conv = ReceiveTlvs_clone(&payee_tlvs_conv);
63452 void* entropy_source_ptr = untag_ptr(entropy_source);
63453 if (ptr_is_owned(entropy_source)) { CHECK_ACCESS(entropy_source_ptr); }
63454 LDKEntropySource* entropy_source_conv = (LDKEntropySource*)entropy_source_ptr;
63455 LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ), "LDKCResult_C2Tuple_BlindedPayInfoBlindedPathZNoneZ");
63456 *ret_conv = BlindedPath_one_hop_for_payment(payee_node_id_ref, payee_tlvs_conv, entropy_source_conv);
63457 return tag_ptr(ret_conv, true);
63460 int8_tArray __attribute__((export_name("TS_BlindedPath_write"))) TS_BlindedPath_write(uint64_t obj) {
63461 LDKBlindedPath obj_conv;
63462 obj_conv.inner = untag_ptr(obj);
63463 obj_conv.is_owned = ptr_is_owned(obj);
63464 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
63465 obj_conv.is_owned = false;
63466 LDKCVec_u8Z ret_var = BlindedPath_write(&obj_conv);
63467 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
63468 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
63469 CVec_u8Z_free(ret_var);
63473 uint64_t __attribute__((export_name("TS_BlindedPath_read"))) TS_BlindedPath_read(int8_tArray ser) {
63474 LDKu8slice ser_ref;
63475 ser_ref.datalen = ser->arr_len;
63476 ser_ref.data = ser->elems;
63477 LDKCResult_BlindedPathDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedPathDecodeErrorZ), "LDKCResult_BlindedPathDecodeErrorZ");
63478 *ret_conv = BlindedPath_read(ser_ref);
63480 return tag_ptr(ret_conv, true);
63483 int8_tArray __attribute__((export_name("TS_BlindedHop_write"))) TS_BlindedHop_write(uint64_t obj) {
63484 LDKBlindedHop obj_conv;
63485 obj_conv.inner = untag_ptr(obj);
63486 obj_conv.is_owned = ptr_is_owned(obj);
63487 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
63488 obj_conv.is_owned = false;
63489 LDKCVec_u8Z ret_var = BlindedHop_write(&obj_conv);
63490 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
63491 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
63492 CVec_u8Z_free(ret_var);
63496 uint64_t __attribute__((export_name("TS_BlindedHop_read"))) TS_BlindedHop_read(int8_tArray ser) {
63497 LDKu8slice ser_ref;
63498 ser_ref.datalen = ser->arr_len;
63499 ser_ref.data = ser->elems;
63500 LDKCResult_BlindedHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BlindedHopDecodeErrorZ), "LDKCResult_BlindedHopDecodeErrorZ");
63501 *ret_conv = BlindedHop_read(ser_ref);
63503 return tag_ptr(ret_conv, true);
63506 void __attribute__((export_name("TS_ForwardNode_free"))) TS_ForwardNode_free(uint64_t this_obj) {
63507 LDKForwardNode this_obj_conv;
63508 this_obj_conv.inner = untag_ptr(this_obj);
63509 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63510 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63511 ForwardNode_free(this_obj_conv);
63514 uint64_t __attribute__((export_name("TS_ForwardNode_get_tlvs"))) TS_ForwardNode_get_tlvs(uint64_t this_ptr) {
63515 LDKForwardNode this_ptr_conv;
63516 this_ptr_conv.inner = untag_ptr(this_ptr);
63517 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63518 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63519 this_ptr_conv.is_owned = false;
63520 LDKForwardTlvs ret_var = ForwardNode_get_tlvs(&this_ptr_conv);
63521 uint64_t ret_ref = 0;
63522 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63523 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63527 void __attribute__((export_name("TS_ForwardNode_set_tlvs"))) TS_ForwardNode_set_tlvs(uint64_t this_ptr, uint64_t val) {
63528 LDKForwardNode this_ptr_conv;
63529 this_ptr_conv.inner = untag_ptr(this_ptr);
63530 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63531 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63532 this_ptr_conv.is_owned = false;
63533 LDKForwardTlvs val_conv;
63534 val_conv.inner = untag_ptr(val);
63535 val_conv.is_owned = ptr_is_owned(val);
63536 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
63537 val_conv = ForwardTlvs_clone(&val_conv);
63538 ForwardNode_set_tlvs(&this_ptr_conv, val_conv);
63541 int8_tArray __attribute__((export_name("TS_ForwardNode_get_node_id"))) TS_ForwardNode_get_node_id(uint64_t this_ptr) {
63542 LDKForwardNode this_ptr_conv;
63543 this_ptr_conv.inner = untag_ptr(this_ptr);
63544 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63546 this_ptr_conv.is_owned = false;
63547 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
63548 memcpy(ret_arr->elems, ForwardNode_get_node_id(&this_ptr_conv).compressed_form, 33);
63552 void __attribute__((export_name("TS_ForwardNode_set_node_id"))) TS_ForwardNode_set_node_id(uint64_t this_ptr, int8_tArray val) {
63553 LDKForwardNode this_ptr_conv;
63554 this_ptr_conv.inner = untag_ptr(this_ptr);
63555 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63557 this_ptr_conv.is_owned = false;
63558 LDKPublicKey val_ref;
63559 CHECK(val->arr_len == 33);
63560 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
63561 ForwardNode_set_node_id(&this_ptr_conv, val_ref);
63564 int64_t __attribute__((export_name("TS_ForwardNode_get_htlc_maximum_msat"))) TS_ForwardNode_get_htlc_maximum_msat(uint64_t this_ptr) {
63565 LDKForwardNode this_ptr_conv;
63566 this_ptr_conv.inner = untag_ptr(this_ptr);
63567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63569 this_ptr_conv.is_owned = false;
63570 int64_t ret_conv = ForwardNode_get_htlc_maximum_msat(&this_ptr_conv);
63574 void __attribute__((export_name("TS_ForwardNode_set_htlc_maximum_msat"))) TS_ForwardNode_set_htlc_maximum_msat(uint64_t this_ptr, int64_t val) {
63575 LDKForwardNode this_ptr_conv;
63576 this_ptr_conv.inner = untag_ptr(this_ptr);
63577 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63578 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63579 this_ptr_conv.is_owned = false;
63580 ForwardNode_set_htlc_maximum_msat(&this_ptr_conv, val);
63583 uint64_t __attribute__((export_name("TS_ForwardNode_new"))) TS_ForwardNode_new(uint64_t tlvs_arg, int8_tArray node_id_arg, int64_t htlc_maximum_msat_arg) {
63584 LDKForwardTlvs tlvs_arg_conv;
63585 tlvs_arg_conv.inner = untag_ptr(tlvs_arg);
63586 tlvs_arg_conv.is_owned = ptr_is_owned(tlvs_arg);
63587 CHECK_INNER_FIELD_ACCESS_OR_NULL(tlvs_arg_conv);
63588 tlvs_arg_conv = ForwardTlvs_clone(&tlvs_arg_conv);
63589 LDKPublicKey node_id_arg_ref;
63590 CHECK(node_id_arg->arr_len == 33);
63591 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
63592 LDKForwardNode ret_var = ForwardNode_new(tlvs_arg_conv, node_id_arg_ref, htlc_maximum_msat_arg);
63593 uint64_t ret_ref = 0;
63594 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63595 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63599 static inline uint64_t ForwardNode_clone_ptr(LDKForwardNode *NONNULL_PTR arg) {
63600 LDKForwardNode ret_var = ForwardNode_clone(arg);
63601 uint64_t ret_ref = 0;
63602 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63603 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63606 int64_t __attribute__((export_name("TS_ForwardNode_clone_ptr"))) TS_ForwardNode_clone_ptr(uint64_t arg) {
63607 LDKForwardNode arg_conv;
63608 arg_conv.inner = untag_ptr(arg);
63609 arg_conv.is_owned = ptr_is_owned(arg);
63610 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63611 arg_conv.is_owned = false;
63612 int64_t ret_conv = ForwardNode_clone_ptr(&arg_conv);
63616 uint64_t __attribute__((export_name("TS_ForwardNode_clone"))) TS_ForwardNode_clone(uint64_t orig) {
63617 LDKForwardNode orig_conv;
63618 orig_conv.inner = untag_ptr(orig);
63619 orig_conv.is_owned = ptr_is_owned(orig);
63620 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63621 orig_conv.is_owned = false;
63622 LDKForwardNode ret_var = ForwardNode_clone(&orig_conv);
63623 uint64_t ret_ref = 0;
63624 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63625 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63629 void __attribute__((export_name("TS_ForwardTlvs_free"))) TS_ForwardTlvs_free(uint64_t this_obj) {
63630 LDKForwardTlvs this_obj_conv;
63631 this_obj_conv.inner = untag_ptr(this_obj);
63632 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63634 ForwardTlvs_free(this_obj_conv);
63637 int64_t __attribute__((export_name("TS_ForwardTlvs_get_short_channel_id"))) TS_ForwardTlvs_get_short_channel_id(uint64_t this_ptr) {
63638 LDKForwardTlvs this_ptr_conv;
63639 this_ptr_conv.inner = untag_ptr(this_ptr);
63640 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63641 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63642 this_ptr_conv.is_owned = false;
63643 int64_t ret_conv = ForwardTlvs_get_short_channel_id(&this_ptr_conv);
63647 void __attribute__((export_name("TS_ForwardTlvs_set_short_channel_id"))) TS_ForwardTlvs_set_short_channel_id(uint64_t this_ptr, int64_t val) {
63648 LDKForwardTlvs this_ptr_conv;
63649 this_ptr_conv.inner = untag_ptr(this_ptr);
63650 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63651 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63652 this_ptr_conv.is_owned = false;
63653 ForwardTlvs_set_short_channel_id(&this_ptr_conv, val);
63656 uint64_t __attribute__((export_name("TS_ForwardTlvs_get_payment_relay"))) TS_ForwardTlvs_get_payment_relay(uint64_t this_ptr) {
63657 LDKForwardTlvs this_ptr_conv;
63658 this_ptr_conv.inner = untag_ptr(this_ptr);
63659 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63660 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63661 this_ptr_conv.is_owned = false;
63662 LDKPaymentRelay ret_var = ForwardTlvs_get_payment_relay(&this_ptr_conv);
63663 uint64_t ret_ref = 0;
63664 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63665 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63669 void __attribute__((export_name("TS_ForwardTlvs_set_payment_relay"))) TS_ForwardTlvs_set_payment_relay(uint64_t this_ptr, uint64_t val) {
63670 LDKForwardTlvs this_ptr_conv;
63671 this_ptr_conv.inner = untag_ptr(this_ptr);
63672 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63674 this_ptr_conv.is_owned = false;
63675 LDKPaymentRelay val_conv;
63676 val_conv.inner = untag_ptr(val);
63677 val_conv.is_owned = ptr_is_owned(val);
63678 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
63679 val_conv = PaymentRelay_clone(&val_conv);
63680 ForwardTlvs_set_payment_relay(&this_ptr_conv, val_conv);
63683 uint64_t __attribute__((export_name("TS_ForwardTlvs_get_payment_constraints"))) TS_ForwardTlvs_get_payment_constraints(uint64_t this_ptr) {
63684 LDKForwardTlvs this_ptr_conv;
63685 this_ptr_conv.inner = untag_ptr(this_ptr);
63686 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63687 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63688 this_ptr_conv.is_owned = false;
63689 LDKPaymentConstraints ret_var = ForwardTlvs_get_payment_constraints(&this_ptr_conv);
63690 uint64_t ret_ref = 0;
63691 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63692 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63696 void __attribute__((export_name("TS_ForwardTlvs_set_payment_constraints"))) TS_ForwardTlvs_set_payment_constraints(uint64_t this_ptr, uint64_t val) {
63697 LDKForwardTlvs this_ptr_conv;
63698 this_ptr_conv.inner = untag_ptr(this_ptr);
63699 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63700 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63701 this_ptr_conv.is_owned = false;
63702 LDKPaymentConstraints val_conv;
63703 val_conv.inner = untag_ptr(val);
63704 val_conv.is_owned = ptr_is_owned(val);
63705 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
63706 val_conv = PaymentConstraints_clone(&val_conv);
63707 ForwardTlvs_set_payment_constraints(&this_ptr_conv, val_conv);
63710 uint64_t __attribute__((export_name("TS_ForwardTlvs_get_features"))) TS_ForwardTlvs_get_features(uint64_t this_ptr) {
63711 LDKForwardTlvs this_ptr_conv;
63712 this_ptr_conv.inner = untag_ptr(this_ptr);
63713 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63715 this_ptr_conv.is_owned = false;
63716 LDKBlindedHopFeatures ret_var = ForwardTlvs_get_features(&this_ptr_conv);
63717 uint64_t ret_ref = 0;
63718 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63719 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63723 void __attribute__((export_name("TS_ForwardTlvs_set_features"))) TS_ForwardTlvs_set_features(uint64_t this_ptr, uint64_t val) {
63724 LDKForwardTlvs this_ptr_conv;
63725 this_ptr_conv.inner = untag_ptr(this_ptr);
63726 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63728 this_ptr_conv.is_owned = false;
63729 LDKBlindedHopFeatures val_conv;
63730 val_conv.inner = untag_ptr(val);
63731 val_conv.is_owned = ptr_is_owned(val);
63732 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
63733 val_conv = BlindedHopFeatures_clone(&val_conv);
63734 ForwardTlvs_set_features(&this_ptr_conv, val_conv);
63737 uint64_t __attribute__((export_name("TS_ForwardTlvs_new"))) TS_ForwardTlvs_new(int64_t short_channel_id_arg, uint64_t payment_relay_arg, uint64_t payment_constraints_arg, uint64_t features_arg) {
63738 LDKPaymentRelay payment_relay_arg_conv;
63739 payment_relay_arg_conv.inner = untag_ptr(payment_relay_arg);
63740 payment_relay_arg_conv.is_owned = ptr_is_owned(payment_relay_arg);
63741 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_relay_arg_conv);
63742 payment_relay_arg_conv = PaymentRelay_clone(&payment_relay_arg_conv);
63743 LDKPaymentConstraints payment_constraints_arg_conv;
63744 payment_constraints_arg_conv.inner = untag_ptr(payment_constraints_arg);
63745 payment_constraints_arg_conv.is_owned = ptr_is_owned(payment_constraints_arg);
63746 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_constraints_arg_conv);
63747 payment_constraints_arg_conv = PaymentConstraints_clone(&payment_constraints_arg_conv);
63748 LDKBlindedHopFeatures features_arg_conv;
63749 features_arg_conv.inner = untag_ptr(features_arg);
63750 features_arg_conv.is_owned = ptr_is_owned(features_arg);
63751 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
63752 features_arg_conv = BlindedHopFeatures_clone(&features_arg_conv);
63753 LDKForwardTlvs ret_var = ForwardTlvs_new(short_channel_id_arg, payment_relay_arg_conv, payment_constraints_arg_conv, features_arg_conv);
63754 uint64_t ret_ref = 0;
63755 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63756 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63760 static inline uint64_t ForwardTlvs_clone_ptr(LDKForwardTlvs *NONNULL_PTR arg) {
63761 LDKForwardTlvs ret_var = ForwardTlvs_clone(arg);
63762 uint64_t ret_ref = 0;
63763 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63764 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63767 int64_t __attribute__((export_name("TS_ForwardTlvs_clone_ptr"))) TS_ForwardTlvs_clone_ptr(uint64_t arg) {
63768 LDKForwardTlvs arg_conv;
63769 arg_conv.inner = untag_ptr(arg);
63770 arg_conv.is_owned = ptr_is_owned(arg);
63771 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63772 arg_conv.is_owned = false;
63773 int64_t ret_conv = ForwardTlvs_clone_ptr(&arg_conv);
63777 uint64_t __attribute__((export_name("TS_ForwardTlvs_clone"))) TS_ForwardTlvs_clone(uint64_t orig) {
63778 LDKForwardTlvs orig_conv;
63779 orig_conv.inner = untag_ptr(orig);
63780 orig_conv.is_owned = ptr_is_owned(orig);
63781 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63782 orig_conv.is_owned = false;
63783 LDKForwardTlvs ret_var = ForwardTlvs_clone(&orig_conv);
63784 uint64_t ret_ref = 0;
63785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63786 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63790 void __attribute__((export_name("TS_ReceiveTlvs_free"))) TS_ReceiveTlvs_free(uint64_t this_obj) {
63791 LDKReceiveTlvs this_obj_conv;
63792 this_obj_conv.inner = untag_ptr(this_obj);
63793 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63795 ReceiveTlvs_free(this_obj_conv);
63798 int8_tArray __attribute__((export_name("TS_ReceiveTlvs_get_payment_secret"))) TS_ReceiveTlvs_get_payment_secret(uint64_t this_ptr) {
63799 LDKReceiveTlvs this_ptr_conv;
63800 this_ptr_conv.inner = untag_ptr(this_ptr);
63801 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63803 this_ptr_conv.is_owned = false;
63804 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
63805 memcpy(ret_arr->elems, *ReceiveTlvs_get_payment_secret(&this_ptr_conv), 32);
63809 void __attribute__((export_name("TS_ReceiveTlvs_set_payment_secret"))) TS_ReceiveTlvs_set_payment_secret(uint64_t this_ptr, int8_tArray val) {
63810 LDKReceiveTlvs this_ptr_conv;
63811 this_ptr_conv.inner = untag_ptr(this_ptr);
63812 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63814 this_ptr_conv.is_owned = false;
63815 LDKThirtyTwoBytes val_ref;
63816 CHECK(val->arr_len == 32);
63817 memcpy(val_ref.data, val->elems, 32); FREE(val);
63818 ReceiveTlvs_set_payment_secret(&this_ptr_conv, val_ref);
63821 uint64_t __attribute__((export_name("TS_ReceiveTlvs_get_payment_constraints"))) TS_ReceiveTlvs_get_payment_constraints(uint64_t this_ptr) {
63822 LDKReceiveTlvs this_ptr_conv;
63823 this_ptr_conv.inner = untag_ptr(this_ptr);
63824 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63826 this_ptr_conv.is_owned = false;
63827 LDKPaymentConstraints ret_var = ReceiveTlvs_get_payment_constraints(&this_ptr_conv);
63828 uint64_t ret_ref = 0;
63829 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63830 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63834 void __attribute__((export_name("TS_ReceiveTlvs_set_payment_constraints"))) TS_ReceiveTlvs_set_payment_constraints(uint64_t this_ptr, uint64_t val) {
63835 LDKReceiveTlvs this_ptr_conv;
63836 this_ptr_conv.inner = untag_ptr(this_ptr);
63837 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63839 this_ptr_conv.is_owned = false;
63840 LDKPaymentConstraints val_conv;
63841 val_conv.inner = untag_ptr(val);
63842 val_conv.is_owned = ptr_is_owned(val);
63843 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
63844 val_conv = PaymentConstraints_clone(&val_conv);
63845 ReceiveTlvs_set_payment_constraints(&this_ptr_conv, val_conv);
63848 uint64_t __attribute__((export_name("TS_ReceiveTlvs_new"))) TS_ReceiveTlvs_new(int8_tArray payment_secret_arg, uint64_t payment_constraints_arg) {
63849 LDKThirtyTwoBytes payment_secret_arg_ref;
63850 CHECK(payment_secret_arg->arr_len == 32);
63851 memcpy(payment_secret_arg_ref.data, payment_secret_arg->elems, 32); FREE(payment_secret_arg);
63852 LDKPaymentConstraints payment_constraints_arg_conv;
63853 payment_constraints_arg_conv.inner = untag_ptr(payment_constraints_arg);
63854 payment_constraints_arg_conv.is_owned = ptr_is_owned(payment_constraints_arg);
63855 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_constraints_arg_conv);
63856 payment_constraints_arg_conv = PaymentConstraints_clone(&payment_constraints_arg_conv);
63857 LDKReceiveTlvs ret_var = ReceiveTlvs_new(payment_secret_arg_ref, payment_constraints_arg_conv);
63858 uint64_t ret_ref = 0;
63859 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63860 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63864 static inline uint64_t ReceiveTlvs_clone_ptr(LDKReceiveTlvs *NONNULL_PTR arg) {
63865 LDKReceiveTlvs ret_var = ReceiveTlvs_clone(arg);
63866 uint64_t ret_ref = 0;
63867 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63868 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63871 int64_t __attribute__((export_name("TS_ReceiveTlvs_clone_ptr"))) TS_ReceiveTlvs_clone_ptr(uint64_t arg) {
63872 LDKReceiveTlvs arg_conv;
63873 arg_conv.inner = untag_ptr(arg);
63874 arg_conv.is_owned = ptr_is_owned(arg);
63875 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63876 arg_conv.is_owned = false;
63877 int64_t ret_conv = ReceiveTlvs_clone_ptr(&arg_conv);
63881 uint64_t __attribute__((export_name("TS_ReceiveTlvs_clone"))) TS_ReceiveTlvs_clone(uint64_t orig) {
63882 LDKReceiveTlvs orig_conv;
63883 orig_conv.inner = untag_ptr(orig);
63884 orig_conv.is_owned = ptr_is_owned(orig);
63885 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63886 orig_conv.is_owned = false;
63887 LDKReceiveTlvs ret_var = ReceiveTlvs_clone(&orig_conv);
63888 uint64_t ret_ref = 0;
63889 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63890 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63894 void __attribute__((export_name("TS_PaymentRelay_free"))) TS_PaymentRelay_free(uint64_t this_obj) {
63895 LDKPaymentRelay this_obj_conv;
63896 this_obj_conv.inner = untag_ptr(this_obj);
63897 this_obj_conv.is_owned = ptr_is_owned(this_obj);
63898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
63899 PaymentRelay_free(this_obj_conv);
63902 int16_t __attribute__((export_name("TS_PaymentRelay_get_cltv_expiry_delta"))) TS_PaymentRelay_get_cltv_expiry_delta(uint64_t this_ptr) {
63903 LDKPaymentRelay this_ptr_conv;
63904 this_ptr_conv.inner = untag_ptr(this_ptr);
63905 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63906 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63907 this_ptr_conv.is_owned = false;
63908 int16_t ret_conv = PaymentRelay_get_cltv_expiry_delta(&this_ptr_conv);
63912 void __attribute__((export_name("TS_PaymentRelay_set_cltv_expiry_delta"))) TS_PaymentRelay_set_cltv_expiry_delta(uint64_t this_ptr, int16_t val) {
63913 LDKPaymentRelay this_ptr_conv;
63914 this_ptr_conv.inner = untag_ptr(this_ptr);
63915 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63917 this_ptr_conv.is_owned = false;
63918 PaymentRelay_set_cltv_expiry_delta(&this_ptr_conv, val);
63921 int32_t __attribute__((export_name("TS_PaymentRelay_get_fee_proportional_millionths"))) TS_PaymentRelay_get_fee_proportional_millionths(uint64_t this_ptr) {
63922 LDKPaymentRelay this_ptr_conv;
63923 this_ptr_conv.inner = untag_ptr(this_ptr);
63924 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63926 this_ptr_conv.is_owned = false;
63927 int32_t ret_conv = PaymentRelay_get_fee_proportional_millionths(&this_ptr_conv);
63931 void __attribute__((export_name("TS_PaymentRelay_set_fee_proportional_millionths"))) TS_PaymentRelay_set_fee_proportional_millionths(uint64_t this_ptr, int32_t val) {
63932 LDKPaymentRelay this_ptr_conv;
63933 this_ptr_conv.inner = untag_ptr(this_ptr);
63934 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63936 this_ptr_conv.is_owned = false;
63937 PaymentRelay_set_fee_proportional_millionths(&this_ptr_conv, val);
63940 int32_t __attribute__((export_name("TS_PaymentRelay_get_fee_base_msat"))) TS_PaymentRelay_get_fee_base_msat(uint64_t this_ptr) {
63941 LDKPaymentRelay this_ptr_conv;
63942 this_ptr_conv.inner = untag_ptr(this_ptr);
63943 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63945 this_ptr_conv.is_owned = false;
63946 int32_t ret_conv = PaymentRelay_get_fee_base_msat(&this_ptr_conv);
63950 void __attribute__((export_name("TS_PaymentRelay_set_fee_base_msat"))) TS_PaymentRelay_set_fee_base_msat(uint64_t this_ptr, int32_t val) {
63951 LDKPaymentRelay this_ptr_conv;
63952 this_ptr_conv.inner = untag_ptr(this_ptr);
63953 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
63954 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
63955 this_ptr_conv.is_owned = false;
63956 PaymentRelay_set_fee_base_msat(&this_ptr_conv, val);
63959 uint64_t __attribute__((export_name("TS_PaymentRelay_new"))) TS_PaymentRelay_new(int16_t cltv_expiry_delta_arg, int32_t fee_proportional_millionths_arg, int32_t fee_base_msat_arg) {
63960 LDKPaymentRelay ret_var = PaymentRelay_new(cltv_expiry_delta_arg, fee_proportional_millionths_arg, fee_base_msat_arg);
63961 uint64_t ret_ref = 0;
63962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63963 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63967 static inline uint64_t PaymentRelay_clone_ptr(LDKPaymentRelay *NONNULL_PTR arg) {
63968 LDKPaymentRelay ret_var = PaymentRelay_clone(arg);
63969 uint64_t ret_ref = 0;
63970 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63971 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63974 int64_t __attribute__((export_name("TS_PaymentRelay_clone_ptr"))) TS_PaymentRelay_clone_ptr(uint64_t arg) {
63975 LDKPaymentRelay arg_conv;
63976 arg_conv.inner = untag_ptr(arg);
63977 arg_conv.is_owned = ptr_is_owned(arg);
63978 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
63979 arg_conv.is_owned = false;
63980 int64_t ret_conv = PaymentRelay_clone_ptr(&arg_conv);
63984 uint64_t __attribute__((export_name("TS_PaymentRelay_clone"))) TS_PaymentRelay_clone(uint64_t orig) {
63985 LDKPaymentRelay orig_conv;
63986 orig_conv.inner = untag_ptr(orig);
63987 orig_conv.is_owned = ptr_is_owned(orig);
63988 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
63989 orig_conv.is_owned = false;
63990 LDKPaymentRelay ret_var = PaymentRelay_clone(&orig_conv);
63991 uint64_t ret_ref = 0;
63992 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
63993 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
63997 void __attribute__((export_name("TS_PaymentConstraints_free"))) TS_PaymentConstraints_free(uint64_t this_obj) {
63998 LDKPaymentConstraints this_obj_conv;
63999 this_obj_conv.inner = untag_ptr(this_obj);
64000 this_obj_conv.is_owned = ptr_is_owned(this_obj);
64001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
64002 PaymentConstraints_free(this_obj_conv);
64005 int32_t __attribute__((export_name("TS_PaymentConstraints_get_max_cltv_expiry"))) TS_PaymentConstraints_get_max_cltv_expiry(uint64_t this_ptr) {
64006 LDKPaymentConstraints this_ptr_conv;
64007 this_ptr_conv.inner = untag_ptr(this_ptr);
64008 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64009 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64010 this_ptr_conv.is_owned = false;
64011 int32_t ret_conv = PaymentConstraints_get_max_cltv_expiry(&this_ptr_conv);
64015 void __attribute__((export_name("TS_PaymentConstraints_set_max_cltv_expiry"))) TS_PaymentConstraints_set_max_cltv_expiry(uint64_t this_ptr, int32_t val) {
64016 LDKPaymentConstraints this_ptr_conv;
64017 this_ptr_conv.inner = untag_ptr(this_ptr);
64018 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64020 this_ptr_conv.is_owned = false;
64021 PaymentConstraints_set_max_cltv_expiry(&this_ptr_conv, val);
64024 int64_t __attribute__((export_name("TS_PaymentConstraints_get_htlc_minimum_msat"))) TS_PaymentConstraints_get_htlc_minimum_msat(uint64_t this_ptr) {
64025 LDKPaymentConstraints this_ptr_conv;
64026 this_ptr_conv.inner = untag_ptr(this_ptr);
64027 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64028 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64029 this_ptr_conv.is_owned = false;
64030 int64_t ret_conv = PaymentConstraints_get_htlc_minimum_msat(&this_ptr_conv);
64034 void __attribute__((export_name("TS_PaymentConstraints_set_htlc_minimum_msat"))) TS_PaymentConstraints_set_htlc_minimum_msat(uint64_t this_ptr, int64_t val) {
64035 LDKPaymentConstraints this_ptr_conv;
64036 this_ptr_conv.inner = untag_ptr(this_ptr);
64037 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64039 this_ptr_conv.is_owned = false;
64040 PaymentConstraints_set_htlc_minimum_msat(&this_ptr_conv, val);
64043 uint64_t __attribute__((export_name("TS_PaymentConstraints_new"))) TS_PaymentConstraints_new(int32_t max_cltv_expiry_arg, int64_t htlc_minimum_msat_arg) {
64044 LDKPaymentConstraints ret_var = PaymentConstraints_new(max_cltv_expiry_arg, htlc_minimum_msat_arg);
64045 uint64_t ret_ref = 0;
64046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64047 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64051 static inline uint64_t PaymentConstraints_clone_ptr(LDKPaymentConstraints *NONNULL_PTR arg) {
64052 LDKPaymentConstraints ret_var = PaymentConstraints_clone(arg);
64053 uint64_t ret_ref = 0;
64054 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64055 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64058 int64_t __attribute__((export_name("TS_PaymentConstraints_clone_ptr"))) TS_PaymentConstraints_clone_ptr(uint64_t arg) {
64059 LDKPaymentConstraints arg_conv;
64060 arg_conv.inner = untag_ptr(arg);
64061 arg_conv.is_owned = ptr_is_owned(arg);
64062 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
64063 arg_conv.is_owned = false;
64064 int64_t ret_conv = PaymentConstraints_clone_ptr(&arg_conv);
64068 uint64_t __attribute__((export_name("TS_PaymentConstraints_clone"))) TS_PaymentConstraints_clone(uint64_t orig) {
64069 LDKPaymentConstraints orig_conv;
64070 orig_conv.inner = untag_ptr(orig);
64071 orig_conv.is_owned = ptr_is_owned(orig);
64072 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
64073 orig_conv.is_owned = false;
64074 LDKPaymentConstraints ret_var = PaymentConstraints_clone(&orig_conv);
64075 uint64_t ret_ref = 0;
64076 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64077 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64081 int8_tArray __attribute__((export_name("TS_ForwardTlvs_write"))) TS_ForwardTlvs_write(uint64_t obj) {
64082 LDKForwardTlvs obj_conv;
64083 obj_conv.inner = untag_ptr(obj);
64084 obj_conv.is_owned = ptr_is_owned(obj);
64085 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
64086 obj_conv.is_owned = false;
64087 LDKCVec_u8Z ret_var = ForwardTlvs_write(&obj_conv);
64088 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64089 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64090 CVec_u8Z_free(ret_var);
64094 int8_tArray __attribute__((export_name("TS_ReceiveTlvs_write"))) TS_ReceiveTlvs_write(uint64_t obj) {
64095 LDKReceiveTlvs obj_conv;
64096 obj_conv.inner = untag_ptr(obj);
64097 obj_conv.is_owned = ptr_is_owned(obj);
64098 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
64099 obj_conv.is_owned = false;
64100 LDKCVec_u8Z ret_var = ReceiveTlvs_write(&obj_conv);
64101 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64102 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64103 CVec_u8Z_free(ret_var);
64107 uint64_t __attribute__((export_name("TS_ReceiveTlvs_read"))) TS_ReceiveTlvs_read(int8_tArray ser) {
64108 LDKu8slice ser_ref;
64109 ser_ref.datalen = ser->arr_len;
64110 ser_ref.data = ser->elems;
64111 LDKCResult_ReceiveTlvsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReceiveTlvsDecodeErrorZ), "LDKCResult_ReceiveTlvsDecodeErrorZ");
64112 *ret_conv = ReceiveTlvs_read(ser_ref);
64114 return tag_ptr(ret_conv, true);
64117 int8_tArray __attribute__((export_name("TS_PaymentRelay_write"))) TS_PaymentRelay_write(uint64_t obj) {
64118 LDKPaymentRelay obj_conv;
64119 obj_conv.inner = untag_ptr(obj);
64120 obj_conv.is_owned = ptr_is_owned(obj);
64121 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
64122 obj_conv.is_owned = false;
64123 LDKCVec_u8Z ret_var = PaymentRelay_write(&obj_conv);
64124 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64125 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64126 CVec_u8Z_free(ret_var);
64130 uint64_t __attribute__((export_name("TS_PaymentRelay_read"))) TS_PaymentRelay_read(int8_tArray ser) {
64131 LDKu8slice ser_ref;
64132 ser_ref.datalen = ser->arr_len;
64133 ser_ref.data = ser->elems;
64134 LDKCResult_PaymentRelayDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentRelayDecodeErrorZ), "LDKCResult_PaymentRelayDecodeErrorZ");
64135 *ret_conv = PaymentRelay_read(ser_ref);
64137 return tag_ptr(ret_conv, true);
64140 int8_tArray __attribute__((export_name("TS_PaymentConstraints_write"))) TS_PaymentConstraints_write(uint64_t obj) {
64141 LDKPaymentConstraints obj_conv;
64142 obj_conv.inner = untag_ptr(obj);
64143 obj_conv.is_owned = ptr_is_owned(obj);
64144 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
64145 obj_conv.is_owned = false;
64146 LDKCVec_u8Z ret_var = PaymentConstraints_write(&obj_conv);
64147 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64148 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64149 CVec_u8Z_free(ret_var);
64153 uint64_t __attribute__((export_name("TS_PaymentConstraints_read"))) TS_PaymentConstraints_read(int8_tArray ser) {
64154 LDKu8slice ser_ref;
64155 ser_ref.datalen = ser->arr_len;
64156 ser_ref.data = ser->elems;
64157 LDKCResult_PaymentConstraintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentConstraintsDecodeErrorZ), "LDKCResult_PaymentConstraintsDecodeErrorZ");
64158 *ret_conv = PaymentConstraints_read(ser_ref);
64160 return tag_ptr(ret_conv, true);
64163 void __attribute__((export_name("TS_PaymentPurpose_free"))) TS_PaymentPurpose_free(uint64_t this_ptr) {
64164 if (!ptr_is_owned(this_ptr)) return;
64165 void* this_ptr_ptr = untag_ptr(this_ptr);
64166 CHECK_ACCESS(this_ptr_ptr);
64167 LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
64168 FREE(untag_ptr(this_ptr));
64169 PaymentPurpose_free(this_ptr_conv);
64172 static inline uint64_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
64173 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
64174 *ret_copy = PaymentPurpose_clone(arg);
64175 uint64_t ret_ref = tag_ptr(ret_copy, true);
64178 int64_t __attribute__((export_name("TS_PaymentPurpose_clone_ptr"))) TS_PaymentPurpose_clone_ptr(uint64_t arg) {
64179 LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)untag_ptr(arg);
64180 int64_t ret_conv = PaymentPurpose_clone_ptr(arg_conv);
64184 uint64_t __attribute__((export_name("TS_PaymentPurpose_clone"))) TS_PaymentPurpose_clone(uint64_t orig) {
64185 LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)untag_ptr(orig);
64186 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
64187 *ret_copy = PaymentPurpose_clone(orig_conv);
64188 uint64_t ret_ref = tag_ptr(ret_copy, true);
64192 uint64_t __attribute__((export_name("TS_PaymentPurpose_invoice_payment"))) TS_PaymentPurpose_invoice_payment(uint64_t payment_preimage, int8_tArray payment_secret) {
64193 void* payment_preimage_ptr = untag_ptr(payment_preimage);
64194 CHECK_ACCESS(payment_preimage_ptr);
64195 LDKCOption_ThirtyTwoBytesZ payment_preimage_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_preimage_ptr);
64196 payment_preimage_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_preimage));
64197 LDKThirtyTwoBytes payment_secret_ref;
64198 CHECK(payment_secret->arr_len == 32);
64199 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
64200 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
64201 *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_conv, payment_secret_ref);
64202 uint64_t ret_ref = tag_ptr(ret_copy, true);
64206 uint64_t __attribute__((export_name("TS_PaymentPurpose_spontaneous_payment"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
64207 LDKThirtyTwoBytes a_ref;
64208 CHECK(a->arr_len == 32);
64209 memcpy(a_ref.data, a->elems, 32); FREE(a);
64210 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
64211 *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
64212 uint64_t ret_ref = tag_ptr(ret_copy, true);
64216 jboolean __attribute__((export_name("TS_PaymentPurpose_eq"))) TS_PaymentPurpose_eq(uint64_t a, uint64_t b) {
64217 LDKPaymentPurpose* a_conv = (LDKPaymentPurpose*)untag_ptr(a);
64218 LDKPaymentPurpose* b_conv = (LDKPaymentPurpose*)untag_ptr(b);
64219 jboolean ret_conv = PaymentPurpose_eq(a_conv, b_conv);
64223 int8_tArray __attribute__((export_name("TS_PaymentPurpose_write"))) TS_PaymentPurpose_write(uint64_t obj) {
64224 LDKPaymentPurpose* obj_conv = (LDKPaymentPurpose*)untag_ptr(obj);
64225 LDKCVec_u8Z ret_var = PaymentPurpose_write(obj_conv);
64226 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64227 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64228 CVec_u8Z_free(ret_var);
64232 uint64_t __attribute__((export_name("TS_PaymentPurpose_read"))) TS_PaymentPurpose_read(int8_tArray ser) {
64233 LDKu8slice ser_ref;
64234 ser_ref.datalen = ser->arr_len;
64235 ser_ref.data = ser->elems;
64236 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
64237 *ret_conv = PaymentPurpose_read(ser_ref);
64239 return tag_ptr(ret_conv, true);
64242 void __attribute__((export_name("TS_ClaimedHTLC_free"))) TS_ClaimedHTLC_free(uint64_t this_obj) {
64243 LDKClaimedHTLC this_obj_conv;
64244 this_obj_conv.inner = untag_ptr(this_obj);
64245 this_obj_conv.is_owned = ptr_is_owned(this_obj);
64246 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
64247 ClaimedHTLC_free(this_obj_conv);
64250 int8_tArray __attribute__((export_name("TS_ClaimedHTLC_get_channel_id"))) TS_ClaimedHTLC_get_channel_id(uint64_t this_ptr) {
64251 LDKClaimedHTLC this_ptr_conv;
64252 this_ptr_conv.inner = untag_ptr(this_ptr);
64253 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64255 this_ptr_conv.is_owned = false;
64256 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
64257 memcpy(ret_arr->elems, *ClaimedHTLC_get_channel_id(&this_ptr_conv), 32);
64261 void __attribute__((export_name("TS_ClaimedHTLC_set_channel_id"))) TS_ClaimedHTLC_set_channel_id(uint64_t this_ptr, int8_tArray val) {
64262 LDKClaimedHTLC this_ptr_conv;
64263 this_ptr_conv.inner = untag_ptr(this_ptr);
64264 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64266 this_ptr_conv.is_owned = false;
64267 LDKThirtyTwoBytes val_ref;
64268 CHECK(val->arr_len == 32);
64269 memcpy(val_ref.data, val->elems, 32); FREE(val);
64270 ClaimedHTLC_set_channel_id(&this_ptr_conv, val_ref);
64273 int8_tArray __attribute__((export_name("TS_ClaimedHTLC_get_user_channel_id"))) TS_ClaimedHTLC_get_user_channel_id(uint64_t this_ptr) {
64274 LDKClaimedHTLC this_ptr_conv;
64275 this_ptr_conv.inner = untag_ptr(this_ptr);
64276 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64278 this_ptr_conv.is_owned = false;
64279 int8_tArray ret_arr = init_int8_tArray(16, __LINE__);
64280 memcpy(ret_arr->elems, ClaimedHTLC_get_user_channel_id(&this_ptr_conv).le_bytes, 16);
64284 void __attribute__((export_name("TS_ClaimedHTLC_set_user_channel_id"))) TS_ClaimedHTLC_set_user_channel_id(uint64_t this_ptr, int8_tArray val) {
64285 LDKClaimedHTLC this_ptr_conv;
64286 this_ptr_conv.inner = untag_ptr(this_ptr);
64287 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64289 this_ptr_conv.is_owned = false;
64291 CHECK(val->arr_len == 16);
64292 memcpy(val_ref.le_bytes, val->elems, 16); FREE(val);
64293 ClaimedHTLC_set_user_channel_id(&this_ptr_conv, val_ref);
64296 int32_t __attribute__((export_name("TS_ClaimedHTLC_get_cltv_expiry"))) TS_ClaimedHTLC_get_cltv_expiry(uint64_t this_ptr) {
64297 LDKClaimedHTLC this_ptr_conv;
64298 this_ptr_conv.inner = untag_ptr(this_ptr);
64299 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64300 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64301 this_ptr_conv.is_owned = false;
64302 int32_t ret_conv = ClaimedHTLC_get_cltv_expiry(&this_ptr_conv);
64306 void __attribute__((export_name("TS_ClaimedHTLC_set_cltv_expiry"))) TS_ClaimedHTLC_set_cltv_expiry(uint64_t this_ptr, int32_t val) {
64307 LDKClaimedHTLC this_ptr_conv;
64308 this_ptr_conv.inner = untag_ptr(this_ptr);
64309 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64310 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64311 this_ptr_conv.is_owned = false;
64312 ClaimedHTLC_set_cltv_expiry(&this_ptr_conv, val);
64315 int64_t __attribute__((export_name("TS_ClaimedHTLC_get_value_msat"))) TS_ClaimedHTLC_get_value_msat(uint64_t this_ptr) {
64316 LDKClaimedHTLC this_ptr_conv;
64317 this_ptr_conv.inner = untag_ptr(this_ptr);
64318 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64319 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64320 this_ptr_conv.is_owned = false;
64321 int64_t ret_conv = ClaimedHTLC_get_value_msat(&this_ptr_conv);
64325 void __attribute__((export_name("TS_ClaimedHTLC_set_value_msat"))) TS_ClaimedHTLC_set_value_msat(uint64_t this_ptr, int64_t val) {
64326 LDKClaimedHTLC this_ptr_conv;
64327 this_ptr_conv.inner = untag_ptr(this_ptr);
64328 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
64329 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
64330 this_ptr_conv.is_owned = false;
64331 ClaimedHTLC_set_value_msat(&this_ptr_conv, val);
64334 uint64_t __attribute__((export_name("TS_ClaimedHTLC_new"))) TS_ClaimedHTLC_new(int8_tArray channel_id_arg, int8_tArray user_channel_id_arg, int32_t cltv_expiry_arg, int64_t value_msat_arg) {
64335 LDKThirtyTwoBytes channel_id_arg_ref;
64336 CHECK(channel_id_arg->arr_len == 32);
64337 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
64338 LDKU128 user_channel_id_arg_ref;
64339 CHECK(user_channel_id_arg->arr_len == 16);
64340 memcpy(user_channel_id_arg_ref.le_bytes, user_channel_id_arg->elems, 16); FREE(user_channel_id_arg);
64341 LDKClaimedHTLC ret_var = ClaimedHTLC_new(channel_id_arg_ref, user_channel_id_arg_ref, cltv_expiry_arg, value_msat_arg);
64342 uint64_t ret_ref = 0;
64343 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64344 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64348 static inline uint64_t ClaimedHTLC_clone_ptr(LDKClaimedHTLC *NONNULL_PTR arg) {
64349 LDKClaimedHTLC ret_var = ClaimedHTLC_clone(arg);
64350 uint64_t ret_ref = 0;
64351 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64352 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64355 int64_t __attribute__((export_name("TS_ClaimedHTLC_clone_ptr"))) TS_ClaimedHTLC_clone_ptr(uint64_t arg) {
64356 LDKClaimedHTLC arg_conv;
64357 arg_conv.inner = untag_ptr(arg);
64358 arg_conv.is_owned = ptr_is_owned(arg);
64359 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
64360 arg_conv.is_owned = false;
64361 int64_t ret_conv = ClaimedHTLC_clone_ptr(&arg_conv);
64365 uint64_t __attribute__((export_name("TS_ClaimedHTLC_clone"))) TS_ClaimedHTLC_clone(uint64_t orig) {
64366 LDKClaimedHTLC orig_conv;
64367 orig_conv.inner = untag_ptr(orig);
64368 orig_conv.is_owned = ptr_is_owned(orig);
64369 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
64370 orig_conv.is_owned = false;
64371 LDKClaimedHTLC ret_var = ClaimedHTLC_clone(&orig_conv);
64372 uint64_t ret_ref = 0;
64373 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
64374 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
64378 jboolean __attribute__((export_name("TS_ClaimedHTLC_eq"))) TS_ClaimedHTLC_eq(uint64_t a, uint64_t b) {
64379 LDKClaimedHTLC a_conv;
64380 a_conv.inner = untag_ptr(a);
64381 a_conv.is_owned = ptr_is_owned(a);
64382 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
64383 a_conv.is_owned = false;
64384 LDKClaimedHTLC b_conv;
64385 b_conv.inner = untag_ptr(b);
64386 b_conv.is_owned = ptr_is_owned(b);
64387 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
64388 b_conv.is_owned = false;
64389 jboolean ret_conv = ClaimedHTLC_eq(&a_conv, &b_conv);
64393 int8_tArray __attribute__((export_name("TS_ClaimedHTLC_write"))) TS_ClaimedHTLC_write(uint64_t obj) {
64394 LDKClaimedHTLC obj_conv;
64395 obj_conv.inner = untag_ptr(obj);
64396 obj_conv.is_owned = ptr_is_owned(obj);
64397 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
64398 obj_conv.is_owned = false;
64399 LDKCVec_u8Z ret_var = ClaimedHTLC_write(&obj_conv);
64400 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64401 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64402 CVec_u8Z_free(ret_var);
64406 uint64_t __attribute__((export_name("TS_ClaimedHTLC_read"))) TS_ClaimedHTLC_read(int8_tArray ser) {
64407 LDKu8slice ser_ref;
64408 ser_ref.datalen = ser->arr_len;
64409 ser_ref.data = ser->elems;
64410 LDKCResult_ClaimedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClaimedHTLCDecodeErrorZ), "LDKCResult_ClaimedHTLCDecodeErrorZ");
64411 *ret_conv = ClaimedHTLC_read(ser_ref);
64413 return tag_ptr(ret_conv, true);
64416 void __attribute__((export_name("TS_PathFailure_free"))) TS_PathFailure_free(uint64_t this_ptr) {
64417 if (!ptr_is_owned(this_ptr)) return;
64418 void* this_ptr_ptr = untag_ptr(this_ptr);
64419 CHECK_ACCESS(this_ptr_ptr);
64420 LDKPathFailure this_ptr_conv = *(LDKPathFailure*)(this_ptr_ptr);
64421 FREE(untag_ptr(this_ptr));
64422 PathFailure_free(this_ptr_conv);
64425 static inline uint64_t PathFailure_clone_ptr(LDKPathFailure *NONNULL_PTR arg) {
64426 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
64427 *ret_copy = PathFailure_clone(arg);
64428 uint64_t ret_ref = tag_ptr(ret_copy, true);
64431 int64_t __attribute__((export_name("TS_PathFailure_clone_ptr"))) TS_PathFailure_clone_ptr(uint64_t arg) {
64432 LDKPathFailure* arg_conv = (LDKPathFailure*)untag_ptr(arg);
64433 int64_t ret_conv = PathFailure_clone_ptr(arg_conv);
64437 uint64_t __attribute__((export_name("TS_PathFailure_clone"))) TS_PathFailure_clone(uint64_t orig) {
64438 LDKPathFailure* orig_conv = (LDKPathFailure*)untag_ptr(orig);
64439 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
64440 *ret_copy = PathFailure_clone(orig_conv);
64441 uint64_t ret_ref = tag_ptr(ret_copy, true);
64445 uint64_t __attribute__((export_name("TS_PathFailure_initial_send"))) TS_PathFailure_initial_send(uint64_t err) {
64446 void* err_ptr = untag_ptr(err);
64447 CHECK_ACCESS(err_ptr);
64448 LDKAPIError err_conv = *(LDKAPIError*)(err_ptr);
64449 err_conv = APIError_clone((LDKAPIError*)untag_ptr(err));
64450 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
64451 *ret_copy = PathFailure_initial_send(err_conv);
64452 uint64_t ret_ref = tag_ptr(ret_copy, true);
64456 uint64_t __attribute__((export_name("TS_PathFailure_on_path"))) TS_PathFailure_on_path(uint64_t network_update) {
64457 void* network_update_ptr = untag_ptr(network_update);
64458 CHECK_ACCESS(network_update_ptr);
64459 LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
64460 network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)untag_ptr(network_update));
64461 LDKPathFailure *ret_copy = MALLOC(sizeof(LDKPathFailure), "LDKPathFailure");
64462 *ret_copy = PathFailure_on_path(network_update_conv);
64463 uint64_t ret_ref = tag_ptr(ret_copy, true);
64467 jboolean __attribute__((export_name("TS_PathFailure_eq"))) TS_PathFailure_eq(uint64_t a, uint64_t b) {
64468 LDKPathFailure* a_conv = (LDKPathFailure*)untag_ptr(a);
64469 LDKPathFailure* b_conv = (LDKPathFailure*)untag_ptr(b);
64470 jboolean ret_conv = PathFailure_eq(a_conv, b_conv);
64474 int8_tArray __attribute__((export_name("TS_PathFailure_write"))) TS_PathFailure_write(uint64_t obj) {
64475 LDKPathFailure* obj_conv = (LDKPathFailure*)untag_ptr(obj);
64476 LDKCVec_u8Z ret_var = PathFailure_write(obj_conv);
64477 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64478 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64479 CVec_u8Z_free(ret_var);
64483 uint64_t __attribute__((export_name("TS_PathFailure_read"))) TS_PathFailure_read(int8_tArray ser) {
64484 LDKu8slice ser_ref;
64485 ser_ref.datalen = ser->arr_len;
64486 ser_ref.data = ser->elems;
64487 LDKCResult_COption_PathFailureZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_PathFailureZDecodeErrorZ), "LDKCResult_COption_PathFailureZDecodeErrorZ");
64488 *ret_conv = PathFailure_read(ser_ref);
64490 return tag_ptr(ret_conv, true);
64493 void __attribute__((export_name("TS_ClosureReason_free"))) TS_ClosureReason_free(uint64_t this_ptr) {
64494 if (!ptr_is_owned(this_ptr)) return;
64495 void* this_ptr_ptr = untag_ptr(this_ptr);
64496 CHECK_ACCESS(this_ptr_ptr);
64497 LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
64498 FREE(untag_ptr(this_ptr));
64499 ClosureReason_free(this_ptr_conv);
64502 static inline uint64_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
64503 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64504 *ret_copy = ClosureReason_clone(arg);
64505 uint64_t ret_ref = tag_ptr(ret_copy, true);
64508 int64_t __attribute__((export_name("TS_ClosureReason_clone_ptr"))) TS_ClosureReason_clone_ptr(uint64_t arg) {
64509 LDKClosureReason* arg_conv = (LDKClosureReason*)untag_ptr(arg);
64510 int64_t ret_conv = ClosureReason_clone_ptr(arg_conv);
64514 uint64_t __attribute__((export_name("TS_ClosureReason_clone"))) TS_ClosureReason_clone(uint64_t orig) {
64515 LDKClosureReason* orig_conv = (LDKClosureReason*)untag_ptr(orig);
64516 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64517 *ret_copy = ClosureReason_clone(orig_conv);
64518 uint64_t ret_ref = tag_ptr(ret_copy, true);
64522 uint64_t __attribute__((export_name("TS_ClosureReason_counterparty_force_closed"))) TS_ClosureReason_counterparty_force_closed(uint64_t peer_msg) {
64523 LDKUntrustedString peer_msg_conv;
64524 peer_msg_conv.inner = untag_ptr(peer_msg);
64525 peer_msg_conv.is_owned = ptr_is_owned(peer_msg);
64526 CHECK_INNER_FIELD_ACCESS_OR_NULL(peer_msg_conv);
64527 peer_msg_conv = UntrustedString_clone(&peer_msg_conv);
64528 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64529 *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
64530 uint64_t ret_ref = tag_ptr(ret_copy, true);
64534 uint64_t __attribute__((export_name("TS_ClosureReason_holder_force_closed"))) TS_ClosureReason_holder_force_closed() {
64535 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64536 *ret_copy = ClosureReason_holder_force_closed();
64537 uint64_t ret_ref = tag_ptr(ret_copy, true);
64541 uint64_t __attribute__((export_name("TS_ClosureReason_cooperative_closure"))) TS_ClosureReason_cooperative_closure() {
64542 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64543 *ret_copy = ClosureReason_cooperative_closure();
64544 uint64_t ret_ref = tag_ptr(ret_copy, true);
64548 uint64_t __attribute__((export_name("TS_ClosureReason_commitment_tx_confirmed"))) TS_ClosureReason_commitment_tx_confirmed() {
64549 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64550 *ret_copy = ClosureReason_commitment_tx_confirmed();
64551 uint64_t ret_ref = tag_ptr(ret_copy, true);
64555 uint64_t __attribute__((export_name("TS_ClosureReason_funding_timed_out"))) TS_ClosureReason_funding_timed_out() {
64556 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64557 *ret_copy = ClosureReason_funding_timed_out();
64558 uint64_t ret_ref = tag_ptr(ret_copy, true);
64562 uint64_t __attribute__((export_name("TS_ClosureReason_processing_error"))) TS_ClosureReason_processing_error(jstring err) {
64563 LDKStr err_conv = str_ref_to_owned_c(err);
64564 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64565 *ret_copy = ClosureReason_processing_error(err_conv);
64566 uint64_t ret_ref = tag_ptr(ret_copy, true);
64570 uint64_t __attribute__((export_name("TS_ClosureReason_disconnected_peer"))) TS_ClosureReason_disconnected_peer() {
64571 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64572 *ret_copy = ClosureReason_disconnected_peer();
64573 uint64_t ret_ref = tag_ptr(ret_copy, true);
64577 uint64_t __attribute__((export_name("TS_ClosureReason_outdated_channel_manager"))) TS_ClosureReason_outdated_channel_manager() {
64578 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64579 *ret_copy = ClosureReason_outdated_channel_manager();
64580 uint64_t ret_ref = tag_ptr(ret_copy, true);
64584 uint64_t __attribute__((export_name("TS_ClosureReason_counterparty_coop_closed_unfunded_channel"))) TS_ClosureReason_counterparty_coop_closed_unfunded_channel() {
64585 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64586 *ret_copy = ClosureReason_counterparty_coop_closed_unfunded_channel();
64587 uint64_t ret_ref = tag_ptr(ret_copy, true);
64591 uint64_t __attribute__((export_name("TS_ClosureReason_funding_batch_closure"))) TS_ClosureReason_funding_batch_closure() {
64592 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
64593 *ret_copy = ClosureReason_funding_batch_closure();
64594 uint64_t ret_ref = tag_ptr(ret_copy, true);
64598 jboolean __attribute__((export_name("TS_ClosureReason_eq"))) TS_ClosureReason_eq(uint64_t a, uint64_t b) {
64599 LDKClosureReason* a_conv = (LDKClosureReason*)untag_ptr(a);
64600 LDKClosureReason* b_conv = (LDKClosureReason*)untag_ptr(b);
64601 jboolean ret_conv = ClosureReason_eq(a_conv, b_conv);
64605 int8_tArray __attribute__((export_name("TS_ClosureReason_write"))) TS_ClosureReason_write(uint64_t obj) {
64606 LDKClosureReason* obj_conv = (LDKClosureReason*)untag_ptr(obj);
64607 LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
64608 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64609 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64610 CVec_u8Z_free(ret_var);
64614 uint64_t __attribute__((export_name("TS_ClosureReason_read"))) TS_ClosureReason_read(int8_tArray ser) {
64615 LDKu8slice ser_ref;
64616 ser_ref.datalen = ser->arr_len;
64617 ser_ref.data = ser->elems;
64618 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
64619 *ret_conv = ClosureReason_read(ser_ref);
64621 return tag_ptr(ret_conv, true);
64624 void __attribute__((export_name("TS_HTLCDestination_free"))) TS_HTLCDestination_free(uint64_t this_ptr) {
64625 if (!ptr_is_owned(this_ptr)) return;
64626 void* this_ptr_ptr = untag_ptr(this_ptr);
64627 CHECK_ACCESS(this_ptr_ptr);
64628 LDKHTLCDestination this_ptr_conv = *(LDKHTLCDestination*)(this_ptr_ptr);
64629 FREE(untag_ptr(this_ptr));
64630 HTLCDestination_free(this_ptr_conv);
64633 static inline uint64_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg) {
64634 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64635 *ret_copy = HTLCDestination_clone(arg);
64636 uint64_t ret_ref = tag_ptr(ret_copy, true);
64639 int64_t __attribute__((export_name("TS_HTLCDestination_clone_ptr"))) TS_HTLCDestination_clone_ptr(uint64_t arg) {
64640 LDKHTLCDestination* arg_conv = (LDKHTLCDestination*)untag_ptr(arg);
64641 int64_t ret_conv = HTLCDestination_clone_ptr(arg_conv);
64645 uint64_t __attribute__((export_name("TS_HTLCDestination_clone"))) TS_HTLCDestination_clone(uint64_t orig) {
64646 LDKHTLCDestination* orig_conv = (LDKHTLCDestination*)untag_ptr(orig);
64647 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64648 *ret_copy = HTLCDestination_clone(orig_conv);
64649 uint64_t ret_ref = tag_ptr(ret_copy, true);
64653 uint64_t __attribute__((export_name("TS_HTLCDestination_next_hop_channel"))) TS_HTLCDestination_next_hop_channel(int8_tArray node_id, int8_tArray channel_id) {
64654 LDKPublicKey node_id_ref;
64655 CHECK(node_id->arr_len == 33);
64656 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
64657 LDKThirtyTwoBytes channel_id_ref;
64658 CHECK(channel_id->arr_len == 32);
64659 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
64660 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64661 *ret_copy = HTLCDestination_next_hop_channel(node_id_ref, channel_id_ref);
64662 uint64_t ret_ref = tag_ptr(ret_copy, true);
64666 uint64_t __attribute__((export_name("TS_HTLCDestination_unknown_next_hop"))) TS_HTLCDestination_unknown_next_hop(int64_t requested_forward_scid) {
64667 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64668 *ret_copy = HTLCDestination_unknown_next_hop(requested_forward_scid);
64669 uint64_t ret_ref = tag_ptr(ret_copy, true);
64673 uint64_t __attribute__((export_name("TS_HTLCDestination_invalid_forward"))) TS_HTLCDestination_invalid_forward(int64_t requested_forward_scid) {
64674 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64675 *ret_copy = HTLCDestination_invalid_forward(requested_forward_scid);
64676 uint64_t ret_ref = tag_ptr(ret_copy, true);
64680 uint64_t __attribute__((export_name("TS_HTLCDestination_failed_payment"))) TS_HTLCDestination_failed_payment(int8_tArray payment_hash) {
64681 LDKThirtyTwoBytes payment_hash_ref;
64682 CHECK(payment_hash->arr_len == 32);
64683 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64684 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
64685 *ret_copy = HTLCDestination_failed_payment(payment_hash_ref);
64686 uint64_t ret_ref = tag_ptr(ret_copy, true);
64690 jboolean __attribute__((export_name("TS_HTLCDestination_eq"))) TS_HTLCDestination_eq(uint64_t a, uint64_t b) {
64691 LDKHTLCDestination* a_conv = (LDKHTLCDestination*)untag_ptr(a);
64692 LDKHTLCDestination* b_conv = (LDKHTLCDestination*)untag_ptr(b);
64693 jboolean ret_conv = HTLCDestination_eq(a_conv, b_conv);
64697 int8_tArray __attribute__((export_name("TS_HTLCDestination_write"))) TS_HTLCDestination_write(uint64_t obj) {
64698 LDKHTLCDestination* obj_conv = (LDKHTLCDestination*)untag_ptr(obj);
64699 LDKCVec_u8Z ret_var = HTLCDestination_write(obj_conv);
64700 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64701 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64702 CVec_u8Z_free(ret_var);
64706 uint64_t __attribute__((export_name("TS_HTLCDestination_read"))) TS_HTLCDestination_read(int8_tArray ser) {
64707 LDKu8slice ser_ref;
64708 ser_ref.datalen = ser->arr_len;
64709 ser_ref.data = ser->elems;
64710 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
64711 *ret_conv = HTLCDestination_read(ser_ref);
64713 return tag_ptr(ret_conv, true);
64716 uint32_t __attribute__((export_name("TS_PaymentFailureReason_clone"))) TS_PaymentFailureReason_clone(uint64_t orig) {
64717 LDKPaymentFailureReason* orig_conv = (LDKPaymentFailureReason*)untag_ptr(orig);
64718 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_clone(orig_conv));
64722 uint32_t __attribute__((export_name("TS_PaymentFailureReason_recipient_rejected"))) TS_PaymentFailureReason_recipient_rejected() {
64723 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_recipient_rejected());
64727 uint32_t __attribute__((export_name("TS_PaymentFailureReason_user_abandoned"))) TS_PaymentFailureReason_user_abandoned() {
64728 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_user_abandoned());
64732 uint32_t __attribute__((export_name("TS_PaymentFailureReason_retries_exhausted"))) TS_PaymentFailureReason_retries_exhausted() {
64733 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_retries_exhausted());
64737 uint32_t __attribute__((export_name("TS_PaymentFailureReason_payment_expired"))) TS_PaymentFailureReason_payment_expired() {
64738 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_payment_expired());
64742 uint32_t __attribute__((export_name("TS_PaymentFailureReason_route_not_found"))) TS_PaymentFailureReason_route_not_found() {
64743 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_route_not_found());
64747 uint32_t __attribute__((export_name("TS_PaymentFailureReason_unexpected_error"))) TS_PaymentFailureReason_unexpected_error() {
64748 uint32_t ret_conv = LDKPaymentFailureReason_to_js(PaymentFailureReason_unexpected_error());
64752 jboolean __attribute__((export_name("TS_PaymentFailureReason_eq"))) TS_PaymentFailureReason_eq(uint64_t a, uint64_t b) {
64753 LDKPaymentFailureReason* a_conv = (LDKPaymentFailureReason*)untag_ptr(a);
64754 LDKPaymentFailureReason* b_conv = (LDKPaymentFailureReason*)untag_ptr(b);
64755 jboolean ret_conv = PaymentFailureReason_eq(a_conv, b_conv);
64759 int8_tArray __attribute__((export_name("TS_PaymentFailureReason_write"))) TS_PaymentFailureReason_write(uint64_t obj) {
64760 LDKPaymentFailureReason* obj_conv = (LDKPaymentFailureReason*)untag_ptr(obj);
64761 LDKCVec_u8Z ret_var = PaymentFailureReason_write(obj_conv);
64762 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
64763 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
64764 CVec_u8Z_free(ret_var);
64768 uint64_t __attribute__((export_name("TS_PaymentFailureReason_read"))) TS_PaymentFailureReason_read(int8_tArray ser) {
64769 LDKu8slice ser_ref;
64770 ser_ref.datalen = ser->arr_len;
64771 ser_ref.data = ser->elems;
64772 LDKCResult_PaymentFailureReasonDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentFailureReasonDecodeErrorZ), "LDKCResult_PaymentFailureReasonDecodeErrorZ");
64773 *ret_conv = PaymentFailureReason_read(ser_ref);
64775 return tag_ptr(ret_conv, true);
64778 void __attribute__((export_name("TS_Event_free"))) TS_Event_free(uint64_t this_ptr) {
64779 if (!ptr_is_owned(this_ptr)) return;
64780 void* this_ptr_ptr = untag_ptr(this_ptr);
64781 CHECK_ACCESS(this_ptr_ptr);
64782 LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
64783 FREE(untag_ptr(this_ptr));
64784 Event_free(this_ptr_conv);
64787 static inline uint64_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
64788 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64789 *ret_copy = Event_clone(arg);
64790 uint64_t ret_ref = tag_ptr(ret_copy, true);
64793 int64_t __attribute__((export_name("TS_Event_clone_ptr"))) TS_Event_clone_ptr(uint64_t arg) {
64794 LDKEvent* arg_conv = (LDKEvent*)untag_ptr(arg);
64795 int64_t ret_conv = Event_clone_ptr(arg_conv);
64799 uint64_t __attribute__((export_name("TS_Event_clone"))) TS_Event_clone(uint64_t orig) {
64800 LDKEvent* orig_conv = (LDKEvent*)untag_ptr(orig);
64801 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64802 *ret_copy = Event_clone(orig_conv);
64803 uint64_t ret_ref = tag_ptr(ret_copy, true);
64807 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) {
64808 LDKThirtyTwoBytes temporary_channel_id_ref;
64809 CHECK(temporary_channel_id->arr_len == 32);
64810 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
64811 LDKPublicKey counterparty_node_id_ref;
64812 CHECK(counterparty_node_id->arr_len == 33);
64813 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
64814 LDKCVec_u8Z output_script_ref;
64815 output_script_ref.datalen = output_script->arr_len;
64816 output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
64817 memcpy(output_script_ref.data, output_script->elems, output_script_ref.datalen); FREE(output_script);
64818 LDKU128 user_channel_id_ref;
64819 CHECK(user_channel_id->arr_len == 16);
64820 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
64821 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64822 *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, counterparty_node_id_ref, channel_value_satoshis, output_script_ref, user_channel_id_ref);
64823 uint64_t ret_ref = tag_ptr(ret_copy, true);
64827 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, int64_t counterparty_skimmed_fee_msat, uint64_t purpose, uint64_t via_channel_id, uint64_t via_user_channel_id, uint64_t claim_deadline) {
64828 LDKPublicKey receiver_node_id_ref;
64829 CHECK(receiver_node_id->arr_len == 33);
64830 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
64831 LDKThirtyTwoBytes payment_hash_ref;
64832 CHECK(payment_hash->arr_len == 32);
64833 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64834 LDKRecipientOnionFields onion_fields_conv;
64835 onion_fields_conv.inner = untag_ptr(onion_fields);
64836 onion_fields_conv.is_owned = ptr_is_owned(onion_fields);
64837 CHECK_INNER_FIELD_ACCESS_OR_NULL(onion_fields_conv);
64838 onion_fields_conv = RecipientOnionFields_clone(&onion_fields_conv);
64839 void* purpose_ptr = untag_ptr(purpose);
64840 CHECK_ACCESS(purpose_ptr);
64841 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
64842 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
64843 void* via_channel_id_ptr = untag_ptr(via_channel_id);
64844 CHECK_ACCESS(via_channel_id_ptr);
64845 LDKCOption_ThirtyTwoBytesZ via_channel_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(via_channel_id_ptr);
64846 via_channel_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(via_channel_id));
64847 void* via_user_channel_id_ptr = untag_ptr(via_user_channel_id);
64848 CHECK_ACCESS(via_user_channel_id_ptr);
64849 LDKCOption_U128Z via_user_channel_id_conv = *(LDKCOption_U128Z*)(via_user_channel_id_ptr);
64850 via_user_channel_id_conv = COption_U128Z_clone((LDKCOption_U128Z*)untag_ptr(via_user_channel_id));
64851 void* claim_deadline_ptr = untag_ptr(claim_deadline);
64852 CHECK_ACCESS(claim_deadline_ptr);
64853 LDKCOption_u32Z claim_deadline_conv = *(LDKCOption_u32Z*)(claim_deadline_ptr);
64854 claim_deadline_conv = COption_u32Z_clone((LDKCOption_u32Z*)untag_ptr(claim_deadline));
64855 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64856 *ret_copy = Event_payment_claimable(receiver_node_id_ref, payment_hash_ref, onion_fields_conv, amount_msat, counterparty_skimmed_fee_msat, purpose_conv, via_channel_id_conv, via_user_channel_id_conv, claim_deadline_conv);
64857 uint64_t ret_ref = tag_ptr(ret_copy, true);
64861 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, uint64_tArray htlcs, uint64_t sender_intended_total_msat) {
64862 LDKPublicKey receiver_node_id_ref;
64863 CHECK(receiver_node_id->arr_len == 33);
64864 memcpy(receiver_node_id_ref.compressed_form, receiver_node_id->elems, 33); FREE(receiver_node_id);
64865 LDKThirtyTwoBytes payment_hash_ref;
64866 CHECK(payment_hash->arr_len == 32);
64867 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64868 void* purpose_ptr = untag_ptr(purpose);
64869 CHECK_ACCESS(purpose_ptr);
64870 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
64871 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)untag_ptr(purpose));
64872 LDKCVec_ClaimedHTLCZ htlcs_constr;
64873 htlcs_constr.datalen = htlcs->arr_len;
64874 if (htlcs_constr.datalen > 0)
64875 htlcs_constr.data = MALLOC(htlcs_constr.datalen * sizeof(LDKClaimedHTLC), "LDKCVec_ClaimedHTLCZ Elements");
64877 htlcs_constr.data = NULL;
64878 uint64_t* htlcs_vals = htlcs->elems;
64879 for (size_t n = 0; n < htlcs_constr.datalen; n++) {
64880 uint64_t htlcs_conv_13 = htlcs_vals[n];
64881 LDKClaimedHTLC htlcs_conv_13_conv;
64882 htlcs_conv_13_conv.inner = untag_ptr(htlcs_conv_13);
64883 htlcs_conv_13_conv.is_owned = ptr_is_owned(htlcs_conv_13);
64884 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlcs_conv_13_conv);
64885 htlcs_conv_13_conv = ClaimedHTLC_clone(&htlcs_conv_13_conv);
64886 htlcs_constr.data[n] = htlcs_conv_13_conv;
64889 void* sender_intended_total_msat_ptr = untag_ptr(sender_intended_total_msat);
64890 CHECK_ACCESS(sender_intended_total_msat_ptr);
64891 LDKCOption_u64Z sender_intended_total_msat_conv = *(LDKCOption_u64Z*)(sender_intended_total_msat_ptr);
64892 sender_intended_total_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(sender_intended_total_msat));
64893 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64894 *ret_copy = Event_payment_claimed(receiver_node_id_ref, payment_hash_ref, amount_msat, purpose_conv, htlcs_constr, sender_intended_total_msat_conv);
64895 uint64_t ret_ref = tag_ptr(ret_copy, true);
64899 uint64_t __attribute__((export_name("TS_Event_payment_sent"))) TS_Event_payment_sent(uint64_t payment_id, int8_tArray payment_preimage, int8_tArray payment_hash, uint64_t fee_paid_msat) {
64900 void* payment_id_ptr = untag_ptr(payment_id);
64901 CHECK_ACCESS(payment_id_ptr);
64902 LDKCOption_ThirtyTwoBytesZ payment_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_id_ptr);
64903 payment_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_id));
64904 LDKThirtyTwoBytes payment_preimage_ref;
64905 CHECK(payment_preimage->arr_len == 32);
64906 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
64907 LDKThirtyTwoBytes payment_hash_ref;
64908 CHECK(payment_hash->arr_len == 32);
64909 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64910 void* fee_paid_msat_ptr = untag_ptr(fee_paid_msat);
64911 CHECK_ACCESS(fee_paid_msat_ptr);
64912 LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
64913 fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_paid_msat));
64914 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64915 *ret_copy = Event_payment_sent(payment_id_conv, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
64916 uint64_t ret_ref = tag_ptr(ret_copy, true);
64920 uint64_t __attribute__((export_name("TS_Event_payment_failed"))) TS_Event_payment_failed(int8_tArray payment_id, int8_tArray payment_hash, uint64_t reason) {
64921 LDKThirtyTwoBytes payment_id_ref;
64922 CHECK(payment_id->arr_len == 32);
64923 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
64924 LDKThirtyTwoBytes payment_hash_ref;
64925 CHECK(payment_hash->arr_len == 32);
64926 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64927 void* reason_ptr = untag_ptr(reason);
64928 CHECK_ACCESS(reason_ptr);
64929 LDKCOption_PaymentFailureReasonZ reason_conv = *(LDKCOption_PaymentFailureReasonZ*)(reason_ptr);
64930 reason_conv = COption_PaymentFailureReasonZ_clone((LDKCOption_PaymentFailureReasonZ*)untag_ptr(reason));
64931 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64932 *ret_copy = Event_payment_failed(payment_id_ref, payment_hash_ref, reason_conv);
64933 uint64_t ret_ref = tag_ptr(ret_copy, true);
64937 uint64_t __attribute__((export_name("TS_Event_payment_path_successful"))) TS_Event_payment_path_successful(int8_tArray payment_id, uint64_t payment_hash, uint64_t path) {
64938 LDKThirtyTwoBytes payment_id_ref;
64939 CHECK(payment_id->arr_len == 32);
64940 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
64941 void* payment_hash_ptr = untag_ptr(payment_hash);
64942 CHECK_ACCESS(payment_hash_ptr);
64943 LDKCOption_ThirtyTwoBytesZ payment_hash_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_hash_ptr);
64944 payment_hash_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_hash));
64946 path_conv.inner = untag_ptr(path);
64947 path_conv.is_owned = ptr_is_owned(path);
64948 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
64949 path_conv = Path_clone(&path_conv);
64950 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64951 *ret_copy = Event_payment_path_successful(payment_id_ref, payment_hash_conv, path_conv);
64952 uint64_t ret_ref = tag_ptr(ret_copy, true);
64956 uint64_t __attribute__((export_name("TS_Event_payment_path_failed"))) TS_Event_payment_path_failed(uint64_t payment_id, int8_tArray payment_hash, jboolean payment_failed_permanently, uint64_t failure, uint64_t path, uint64_t short_channel_id) {
64957 void* payment_id_ptr = untag_ptr(payment_id);
64958 CHECK_ACCESS(payment_id_ptr);
64959 LDKCOption_ThirtyTwoBytesZ payment_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_id_ptr);
64960 payment_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_id));
64961 LDKThirtyTwoBytes payment_hash_ref;
64962 CHECK(payment_hash->arr_len == 32);
64963 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64964 void* failure_ptr = untag_ptr(failure);
64965 CHECK_ACCESS(failure_ptr);
64966 LDKPathFailure failure_conv = *(LDKPathFailure*)(failure_ptr);
64967 failure_conv = PathFailure_clone((LDKPathFailure*)untag_ptr(failure));
64969 path_conv.inner = untag_ptr(path);
64970 path_conv.is_owned = ptr_is_owned(path);
64971 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
64972 path_conv = Path_clone(&path_conv);
64973 void* short_channel_id_ptr = untag_ptr(short_channel_id);
64974 CHECK_ACCESS(short_channel_id_ptr);
64975 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
64976 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
64977 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64978 *ret_copy = Event_payment_path_failed(payment_id_conv, payment_hash_ref, payment_failed_permanently, failure_conv, path_conv, short_channel_id_conv);
64979 uint64_t ret_ref = tag_ptr(ret_copy, true);
64983 uint64_t __attribute__((export_name("TS_Event_probe_successful"))) TS_Event_probe_successful(int8_tArray payment_id, int8_tArray payment_hash, uint64_t path) {
64984 LDKThirtyTwoBytes payment_id_ref;
64985 CHECK(payment_id->arr_len == 32);
64986 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
64987 LDKThirtyTwoBytes payment_hash_ref;
64988 CHECK(payment_hash->arr_len == 32);
64989 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
64991 path_conv.inner = untag_ptr(path);
64992 path_conv.is_owned = ptr_is_owned(path);
64993 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
64994 path_conv = Path_clone(&path_conv);
64995 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
64996 *ret_copy = Event_probe_successful(payment_id_ref, payment_hash_ref, path_conv);
64997 uint64_t ret_ref = tag_ptr(ret_copy, true);
65001 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) {
65002 LDKThirtyTwoBytes payment_id_ref;
65003 CHECK(payment_id->arr_len == 32);
65004 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
65005 LDKThirtyTwoBytes payment_hash_ref;
65006 CHECK(payment_hash->arr_len == 32);
65007 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
65009 path_conv.inner = untag_ptr(path);
65010 path_conv.is_owned = ptr_is_owned(path);
65011 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv);
65012 path_conv = Path_clone(&path_conv);
65013 void* short_channel_id_ptr = untag_ptr(short_channel_id);
65014 CHECK_ACCESS(short_channel_id_ptr);
65015 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
65016 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(short_channel_id));
65017 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65018 *ret_copy = Event_probe_failed(payment_id_ref, payment_hash_ref, path_conv, short_channel_id_conv);
65019 uint64_t ret_ref = tag_ptr(ret_copy, true);
65023 uint64_t __attribute__((export_name("TS_Event_pending_htlcs_forwardable"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
65024 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65025 *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
65026 uint64_t ret_ref = tag_ptr(ret_copy, true);
65030 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) {
65031 LDKThirtyTwoBytes intercept_id_ref;
65032 CHECK(intercept_id->arr_len == 32);
65033 memcpy(intercept_id_ref.data, intercept_id->elems, 32); FREE(intercept_id);
65034 LDKThirtyTwoBytes payment_hash_ref;
65035 CHECK(payment_hash->arr_len == 32);
65036 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
65037 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65038 *ret_copy = Event_htlcintercepted(intercept_id_ref, requested_next_hop_scid, payment_hash_ref, inbound_amount_msat, expected_outbound_amount_msat);
65039 uint64_t ret_ref = tag_ptr(ret_copy, true);
65043 uint64_t __attribute__((export_name("TS_Event_spendable_outputs"))) TS_Event_spendable_outputs(uint64_tArray outputs, uint64_t channel_id) {
65044 LDKCVec_SpendableOutputDescriptorZ outputs_constr;
65045 outputs_constr.datalen = outputs->arr_len;
65046 if (outputs_constr.datalen > 0)
65047 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
65049 outputs_constr.data = NULL;
65050 uint64_t* outputs_vals = outputs->elems;
65051 for (size_t b = 0; b < outputs_constr.datalen; b++) {
65052 uint64_t outputs_conv_27 = outputs_vals[b];
65053 void* outputs_conv_27_ptr = untag_ptr(outputs_conv_27);
65054 CHECK_ACCESS(outputs_conv_27_ptr);
65055 LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
65056 outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)untag_ptr(outputs_conv_27));
65057 outputs_constr.data[b] = outputs_conv_27_conv;
65060 void* channel_id_ptr = untag_ptr(channel_id);
65061 CHECK_ACCESS(channel_id_ptr);
65062 LDKCOption_ThirtyTwoBytesZ channel_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(channel_id_ptr);
65063 channel_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(channel_id));
65064 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65065 *ret_copy = Event_spendable_outputs(outputs_constr, channel_id_conv);
65066 uint64_t ret_ref = tag_ptr(ret_copy, true);
65070 uint64_t __attribute__((export_name("TS_Event_payment_forwarded"))) TS_Event_payment_forwarded(uint64_t prev_channel_id, uint64_t next_channel_id, uint64_t fee_earned_msat, jboolean claim_from_onchain_tx, uint64_t outbound_amount_forwarded_msat) {
65071 void* prev_channel_id_ptr = untag_ptr(prev_channel_id);
65072 CHECK_ACCESS(prev_channel_id_ptr);
65073 LDKCOption_ThirtyTwoBytesZ prev_channel_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(prev_channel_id_ptr);
65074 prev_channel_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(prev_channel_id));
65075 void* next_channel_id_ptr = untag_ptr(next_channel_id);
65076 CHECK_ACCESS(next_channel_id_ptr);
65077 LDKCOption_ThirtyTwoBytesZ next_channel_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(next_channel_id_ptr);
65078 next_channel_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(next_channel_id));
65079 void* fee_earned_msat_ptr = untag_ptr(fee_earned_msat);
65080 CHECK_ACCESS(fee_earned_msat_ptr);
65081 LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
65082 fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(fee_earned_msat));
65083 void* outbound_amount_forwarded_msat_ptr = untag_ptr(outbound_amount_forwarded_msat);
65084 CHECK_ACCESS(outbound_amount_forwarded_msat_ptr);
65085 LDKCOption_u64Z outbound_amount_forwarded_msat_conv = *(LDKCOption_u64Z*)(outbound_amount_forwarded_msat_ptr);
65086 outbound_amount_forwarded_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(outbound_amount_forwarded_msat));
65087 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65088 *ret_copy = Event_payment_forwarded(prev_channel_id_conv, next_channel_id_conv, fee_earned_msat_conv, claim_from_onchain_tx, outbound_amount_forwarded_msat_conv);
65089 uint64_t ret_ref = tag_ptr(ret_copy, true);
65093 uint64_t __attribute__((export_name("TS_Event_channel_pending"))) TS_Event_channel_pending(int8_tArray channel_id, int8_tArray user_channel_id, uint64_t former_temporary_channel_id, int8_tArray counterparty_node_id, uint64_t funding_txo) {
65094 LDKThirtyTwoBytes channel_id_ref;
65095 CHECK(channel_id->arr_len == 32);
65096 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
65097 LDKU128 user_channel_id_ref;
65098 CHECK(user_channel_id->arr_len == 16);
65099 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
65100 void* former_temporary_channel_id_ptr = untag_ptr(former_temporary_channel_id);
65101 CHECK_ACCESS(former_temporary_channel_id_ptr);
65102 LDKCOption_ThirtyTwoBytesZ former_temporary_channel_id_conv = *(LDKCOption_ThirtyTwoBytesZ*)(former_temporary_channel_id_ptr);
65103 former_temporary_channel_id_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(former_temporary_channel_id));
65104 LDKPublicKey counterparty_node_id_ref;
65105 CHECK(counterparty_node_id->arr_len == 33);
65106 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
65107 LDKOutPoint funding_txo_conv;
65108 funding_txo_conv.inner = untag_ptr(funding_txo);
65109 funding_txo_conv.is_owned = ptr_is_owned(funding_txo);
65110 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
65111 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
65112 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65113 *ret_copy = Event_channel_pending(channel_id_ref, user_channel_id_ref, former_temporary_channel_id_conv, counterparty_node_id_ref, funding_txo_conv);
65114 uint64_t ret_ref = tag_ptr(ret_copy, true);
65118 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) {
65119 LDKThirtyTwoBytes channel_id_ref;
65120 CHECK(channel_id->arr_len == 32);
65121 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
65122 LDKU128 user_channel_id_ref;
65123 CHECK(user_channel_id->arr_len == 16);
65124 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
65125 LDKPublicKey counterparty_node_id_ref;
65126 CHECK(counterparty_node_id->arr_len == 33);
65127 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
65128 LDKChannelTypeFeatures channel_type_conv;
65129 channel_type_conv.inner = untag_ptr(channel_type);
65130 channel_type_conv.is_owned = ptr_is_owned(channel_type);
65131 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
65132 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
65133 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65134 *ret_copy = Event_channel_ready(channel_id_ref, user_channel_id_ref, counterparty_node_id_ref, channel_type_conv);
65135 uint64_t ret_ref = tag_ptr(ret_copy, true);
65139 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, int8_tArray counterparty_node_id, uint64_t channel_capacity_sats) {
65140 LDKThirtyTwoBytes channel_id_ref;
65141 CHECK(channel_id->arr_len == 32);
65142 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
65143 LDKU128 user_channel_id_ref;
65144 CHECK(user_channel_id->arr_len == 16);
65145 memcpy(user_channel_id_ref.le_bytes, user_channel_id->elems, 16); FREE(user_channel_id);
65146 void* reason_ptr = untag_ptr(reason);
65147 CHECK_ACCESS(reason_ptr);
65148 LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
65149 reason_conv = ClosureReason_clone((LDKClosureReason*)untag_ptr(reason));
65150 LDKPublicKey counterparty_node_id_ref;
65151 CHECK(counterparty_node_id->arr_len == 33);
65152 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
65153 void* channel_capacity_sats_ptr = untag_ptr(channel_capacity_sats);
65154 CHECK_ACCESS(channel_capacity_sats_ptr);
65155 LDKCOption_u64Z channel_capacity_sats_conv = *(LDKCOption_u64Z*)(channel_capacity_sats_ptr);
65156 channel_capacity_sats_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(channel_capacity_sats));
65157 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65158 *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id_ref, reason_conv, counterparty_node_id_ref, channel_capacity_sats_conv);
65159 uint64_t ret_ref = tag_ptr(ret_copy, true);
65163 uint64_t __attribute__((export_name("TS_Event_discard_funding"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
65164 LDKThirtyTwoBytes channel_id_ref;
65165 CHECK(channel_id->arr_len == 32);
65166 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
65167 LDKTransaction transaction_ref;
65168 transaction_ref.datalen = transaction->arr_len;
65169 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
65170 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
65171 transaction_ref.data_is_owned = true;
65172 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65173 *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
65174 uint64_t ret_ref = tag_ptr(ret_copy, true);
65178 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) {
65179 LDKThirtyTwoBytes temporary_channel_id_ref;
65180 CHECK(temporary_channel_id->arr_len == 32);
65181 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
65182 LDKPublicKey counterparty_node_id_ref;
65183 CHECK(counterparty_node_id->arr_len == 33);
65184 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
65185 LDKChannelTypeFeatures channel_type_conv;
65186 channel_type_conv.inner = untag_ptr(channel_type);
65187 channel_type_conv.is_owned = ptr_is_owned(channel_type);
65188 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
65189 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
65190 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65191 *ret_copy = Event_open_channel_request(temporary_channel_id_ref, counterparty_node_id_ref, funding_satoshis, push_msat, channel_type_conv);
65192 uint64_t ret_ref = tag_ptr(ret_copy, true);
65196 uint64_t __attribute__((export_name("TS_Event_htlchandling_failed"))) TS_Event_htlchandling_failed(int8_tArray prev_channel_id, uint64_t failed_next_destination) {
65197 LDKThirtyTwoBytes prev_channel_id_ref;
65198 CHECK(prev_channel_id->arr_len == 32);
65199 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
65200 void* failed_next_destination_ptr = untag_ptr(failed_next_destination);
65201 CHECK_ACCESS(failed_next_destination_ptr);
65202 LDKHTLCDestination failed_next_destination_conv = *(LDKHTLCDestination*)(failed_next_destination_ptr);
65203 failed_next_destination_conv = HTLCDestination_clone((LDKHTLCDestination*)untag_ptr(failed_next_destination));
65204 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65205 *ret_copy = Event_htlchandling_failed(prev_channel_id_ref, failed_next_destination_conv);
65206 uint64_t ret_ref = tag_ptr(ret_copy, true);
65210 uint64_t __attribute__((export_name("TS_Event_bump_transaction"))) TS_Event_bump_transaction(uint64_t a) {
65211 void* a_ptr = untag_ptr(a);
65212 CHECK_ACCESS(a_ptr);
65213 LDKBumpTransactionEvent a_conv = *(LDKBumpTransactionEvent*)(a_ptr);
65214 a_conv = BumpTransactionEvent_clone((LDKBumpTransactionEvent*)untag_ptr(a));
65215 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
65216 *ret_copy = Event_bump_transaction(a_conv);
65217 uint64_t ret_ref = tag_ptr(ret_copy, true);
65221 jboolean __attribute__((export_name("TS_Event_eq"))) TS_Event_eq(uint64_t a, uint64_t b) {
65222 LDKEvent* a_conv = (LDKEvent*)untag_ptr(a);
65223 LDKEvent* b_conv = (LDKEvent*)untag_ptr(b);
65224 jboolean ret_conv = Event_eq(a_conv, b_conv);
65228 int8_tArray __attribute__((export_name("TS_Event_write"))) TS_Event_write(uint64_t obj) {
65229 LDKEvent* obj_conv = (LDKEvent*)untag_ptr(obj);
65230 LDKCVec_u8Z ret_var = Event_write(obj_conv);
65231 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
65232 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
65233 CVec_u8Z_free(ret_var);
65237 uint64_t __attribute__((export_name("TS_Event_read"))) TS_Event_read(int8_tArray ser) {
65238 LDKu8slice ser_ref;
65239 ser_ref.datalen = ser->arr_len;
65240 ser_ref.data = ser->elems;
65241 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
65242 *ret_conv = Event_read(ser_ref);
65244 return tag_ptr(ret_conv, true);
65247 void __attribute__((export_name("TS_MessageSendEvent_free"))) TS_MessageSendEvent_free(uint64_t this_ptr) {
65248 if (!ptr_is_owned(this_ptr)) return;
65249 void* this_ptr_ptr = untag_ptr(this_ptr);
65250 CHECK_ACCESS(this_ptr_ptr);
65251 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
65252 FREE(untag_ptr(this_ptr));
65253 MessageSendEvent_free(this_ptr_conv);
65256 static inline uint64_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
65257 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65258 *ret_copy = MessageSendEvent_clone(arg);
65259 uint64_t ret_ref = tag_ptr(ret_copy, true);
65262 int64_t __attribute__((export_name("TS_MessageSendEvent_clone_ptr"))) TS_MessageSendEvent_clone_ptr(uint64_t arg) {
65263 LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)untag_ptr(arg);
65264 int64_t ret_conv = MessageSendEvent_clone_ptr(arg_conv);
65268 uint64_t __attribute__((export_name("TS_MessageSendEvent_clone"))) TS_MessageSendEvent_clone(uint64_t orig) {
65269 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)untag_ptr(orig);
65270 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65271 *ret_copy = MessageSendEvent_clone(orig_conv);
65272 uint64_t ret_ref = tag_ptr(ret_copy, true);
65276 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint64_t msg) {
65277 LDKPublicKey node_id_ref;
65278 CHECK(node_id->arr_len == 33);
65279 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65280 LDKAcceptChannel msg_conv;
65281 msg_conv.inner = untag_ptr(msg);
65282 msg_conv.is_owned = ptr_is_owned(msg);
65283 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65284 msg_conv = AcceptChannel_clone(&msg_conv);
65285 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65286 *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
65287 uint64_t ret_ref = tag_ptr(ret_copy, true);
65291 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel_v2"))) TS_MessageSendEvent_send_accept_channel_v2(int8_tArray node_id, uint64_t msg) {
65292 LDKPublicKey node_id_ref;
65293 CHECK(node_id->arr_len == 33);
65294 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65295 LDKAcceptChannelV2 msg_conv;
65296 msg_conv.inner = untag_ptr(msg);
65297 msg_conv.is_owned = ptr_is_owned(msg);
65298 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65299 msg_conv = AcceptChannelV2_clone(&msg_conv);
65300 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65301 *ret_copy = MessageSendEvent_send_accept_channel_v2(node_id_ref, msg_conv);
65302 uint64_t ret_ref = tag_ptr(ret_copy, true);
65306 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint64_t msg) {
65307 LDKPublicKey node_id_ref;
65308 CHECK(node_id->arr_len == 33);
65309 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65310 LDKOpenChannel msg_conv;
65311 msg_conv.inner = untag_ptr(msg);
65312 msg_conv.is_owned = ptr_is_owned(msg);
65313 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65314 msg_conv = OpenChannel_clone(&msg_conv);
65315 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65316 *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
65317 uint64_t ret_ref = tag_ptr(ret_copy, true);
65321 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel_v2"))) TS_MessageSendEvent_send_open_channel_v2(int8_tArray node_id, uint64_t msg) {
65322 LDKPublicKey node_id_ref;
65323 CHECK(node_id->arr_len == 33);
65324 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65325 LDKOpenChannelV2 msg_conv;
65326 msg_conv.inner = untag_ptr(msg);
65327 msg_conv.is_owned = ptr_is_owned(msg);
65328 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65329 msg_conv = OpenChannelV2_clone(&msg_conv);
65330 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65331 *ret_copy = MessageSendEvent_send_open_channel_v2(node_id_ref, msg_conv);
65332 uint64_t ret_ref = tag_ptr(ret_copy, true);
65336 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_created"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint64_t msg) {
65337 LDKPublicKey node_id_ref;
65338 CHECK(node_id->arr_len == 33);
65339 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65340 LDKFundingCreated msg_conv;
65341 msg_conv.inner = untag_ptr(msg);
65342 msg_conv.is_owned = ptr_is_owned(msg);
65343 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65344 msg_conv = FundingCreated_clone(&msg_conv);
65345 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65346 *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
65347 uint64_t ret_ref = tag_ptr(ret_copy, true);
65351 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_funding_signed"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint64_t msg) {
65352 LDKPublicKey node_id_ref;
65353 CHECK(node_id->arr_len == 33);
65354 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65355 LDKFundingSigned msg_conv;
65356 msg_conv.inner = untag_ptr(msg);
65357 msg_conv.is_owned = ptr_is_owned(msg);
65358 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65359 msg_conv = FundingSigned_clone(&msg_conv);
65360 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65361 *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
65362 uint64_t ret_ref = tag_ptr(ret_copy, true);
65366 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_add_input"))) TS_MessageSendEvent_send_tx_add_input(int8_tArray node_id, uint64_t msg) {
65367 LDKPublicKey node_id_ref;
65368 CHECK(node_id->arr_len == 33);
65369 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65370 LDKTxAddInput msg_conv;
65371 msg_conv.inner = untag_ptr(msg);
65372 msg_conv.is_owned = ptr_is_owned(msg);
65373 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65374 msg_conv = TxAddInput_clone(&msg_conv);
65375 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65376 *ret_copy = MessageSendEvent_send_tx_add_input(node_id_ref, msg_conv);
65377 uint64_t ret_ref = tag_ptr(ret_copy, true);
65381 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_add_output"))) TS_MessageSendEvent_send_tx_add_output(int8_tArray node_id, uint64_t msg) {
65382 LDKPublicKey node_id_ref;
65383 CHECK(node_id->arr_len == 33);
65384 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65385 LDKTxAddOutput msg_conv;
65386 msg_conv.inner = untag_ptr(msg);
65387 msg_conv.is_owned = ptr_is_owned(msg);
65388 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65389 msg_conv = TxAddOutput_clone(&msg_conv);
65390 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65391 *ret_copy = MessageSendEvent_send_tx_add_output(node_id_ref, msg_conv);
65392 uint64_t ret_ref = tag_ptr(ret_copy, true);
65396 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_remove_input"))) TS_MessageSendEvent_send_tx_remove_input(int8_tArray node_id, uint64_t msg) {
65397 LDKPublicKey node_id_ref;
65398 CHECK(node_id->arr_len == 33);
65399 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65400 LDKTxRemoveInput msg_conv;
65401 msg_conv.inner = untag_ptr(msg);
65402 msg_conv.is_owned = ptr_is_owned(msg);
65403 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65404 msg_conv = TxRemoveInput_clone(&msg_conv);
65405 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65406 *ret_copy = MessageSendEvent_send_tx_remove_input(node_id_ref, msg_conv);
65407 uint64_t ret_ref = tag_ptr(ret_copy, true);
65411 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_remove_output"))) TS_MessageSendEvent_send_tx_remove_output(int8_tArray node_id, uint64_t msg) {
65412 LDKPublicKey node_id_ref;
65413 CHECK(node_id->arr_len == 33);
65414 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65415 LDKTxRemoveOutput msg_conv;
65416 msg_conv.inner = untag_ptr(msg);
65417 msg_conv.is_owned = ptr_is_owned(msg);
65418 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65419 msg_conv = TxRemoveOutput_clone(&msg_conv);
65420 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65421 *ret_copy = MessageSendEvent_send_tx_remove_output(node_id_ref, msg_conv);
65422 uint64_t ret_ref = tag_ptr(ret_copy, true);
65426 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_complete"))) TS_MessageSendEvent_send_tx_complete(int8_tArray node_id, uint64_t msg) {
65427 LDKPublicKey node_id_ref;
65428 CHECK(node_id->arr_len == 33);
65429 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65430 LDKTxComplete msg_conv;
65431 msg_conv.inner = untag_ptr(msg);
65432 msg_conv.is_owned = ptr_is_owned(msg);
65433 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65434 msg_conv = TxComplete_clone(&msg_conv);
65435 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65436 *ret_copy = MessageSendEvent_send_tx_complete(node_id_ref, msg_conv);
65437 uint64_t ret_ref = tag_ptr(ret_copy, true);
65441 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_signatures"))) TS_MessageSendEvent_send_tx_signatures(int8_tArray node_id, uint64_t msg) {
65442 LDKPublicKey node_id_ref;
65443 CHECK(node_id->arr_len == 33);
65444 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65445 LDKTxSignatures msg_conv;
65446 msg_conv.inner = untag_ptr(msg);
65447 msg_conv.is_owned = ptr_is_owned(msg);
65448 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65449 msg_conv = TxSignatures_clone(&msg_conv);
65450 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65451 *ret_copy = MessageSendEvent_send_tx_signatures(node_id_ref, msg_conv);
65452 uint64_t ret_ref = tag_ptr(ret_copy, true);
65456 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_init_rbf"))) TS_MessageSendEvent_send_tx_init_rbf(int8_tArray node_id, uint64_t msg) {
65457 LDKPublicKey node_id_ref;
65458 CHECK(node_id->arr_len == 33);
65459 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65460 LDKTxInitRbf msg_conv;
65461 msg_conv.inner = untag_ptr(msg);
65462 msg_conv.is_owned = ptr_is_owned(msg);
65463 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65464 msg_conv = TxInitRbf_clone(&msg_conv);
65465 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65466 *ret_copy = MessageSendEvent_send_tx_init_rbf(node_id_ref, msg_conv);
65467 uint64_t ret_ref = tag_ptr(ret_copy, true);
65471 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_ack_rbf"))) TS_MessageSendEvent_send_tx_ack_rbf(int8_tArray node_id, uint64_t msg) {
65472 LDKPublicKey node_id_ref;
65473 CHECK(node_id->arr_len == 33);
65474 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65475 LDKTxAckRbf msg_conv;
65476 msg_conv.inner = untag_ptr(msg);
65477 msg_conv.is_owned = ptr_is_owned(msg);
65478 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65479 msg_conv = TxAckRbf_clone(&msg_conv);
65480 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65481 *ret_copy = MessageSendEvent_send_tx_ack_rbf(node_id_ref, msg_conv);
65482 uint64_t ret_ref = tag_ptr(ret_copy, true);
65486 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_tx_abort"))) TS_MessageSendEvent_send_tx_abort(int8_tArray node_id, uint64_t msg) {
65487 LDKPublicKey node_id_ref;
65488 CHECK(node_id->arr_len == 33);
65489 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65490 LDKTxAbort msg_conv;
65491 msg_conv.inner = untag_ptr(msg);
65492 msg_conv.is_owned = ptr_is_owned(msg);
65493 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65494 msg_conv = TxAbort_clone(&msg_conv);
65495 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65496 *ret_copy = MessageSendEvent_send_tx_abort(node_id_ref, msg_conv);
65497 uint64_t ret_ref = tag_ptr(ret_copy, true);
65501 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_ready"))) TS_MessageSendEvent_send_channel_ready(int8_tArray node_id, uint64_t msg) {
65502 LDKPublicKey node_id_ref;
65503 CHECK(node_id->arr_len == 33);
65504 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65505 LDKChannelReady msg_conv;
65506 msg_conv.inner = untag_ptr(msg);
65507 msg_conv.is_owned = ptr_is_owned(msg);
65508 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65509 msg_conv = ChannelReady_clone(&msg_conv);
65510 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65511 *ret_copy = MessageSendEvent_send_channel_ready(node_id_ref, msg_conv);
65512 uint64_t ret_ref = tag_ptr(ret_copy, true);
65516 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_announcement_signatures"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint64_t msg) {
65517 LDKPublicKey node_id_ref;
65518 CHECK(node_id->arr_len == 33);
65519 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65520 LDKAnnouncementSignatures msg_conv;
65521 msg_conv.inner = untag_ptr(msg);
65522 msg_conv.is_owned = ptr_is_owned(msg);
65523 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65524 msg_conv = AnnouncementSignatures_clone(&msg_conv);
65525 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65526 *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
65527 uint64_t ret_ref = tag_ptr(ret_copy, true);
65531 uint64_t __attribute__((export_name("TS_MessageSendEvent_update_htlcs"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint64_t updates) {
65532 LDKPublicKey node_id_ref;
65533 CHECK(node_id->arr_len == 33);
65534 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65535 LDKCommitmentUpdate updates_conv;
65536 updates_conv.inner = untag_ptr(updates);
65537 updates_conv.is_owned = ptr_is_owned(updates);
65538 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
65539 updates_conv = CommitmentUpdate_clone(&updates_conv);
65540 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65541 *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
65542 uint64_t ret_ref = tag_ptr(ret_copy, true);
65546 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_revoke_and_ack"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint64_t msg) {
65547 LDKPublicKey node_id_ref;
65548 CHECK(node_id->arr_len == 33);
65549 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65550 LDKRevokeAndACK msg_conv;
65551 msg_conv.inner = untag_ptr(msg);
65552 msg_conv.is_owned = ptr_is_owned(msg);
65553 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65554 msg_conv = RevokeAndACK_clone(&msg_conv);
65555 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65556 *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
65557 uint64_t ret_ref = tag_ptr(ret_copy, true);
65561 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_closing_signed"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint64_t msg) {
65562 LDKPublicKey node_id_ref;
65563 CHECK(node_id->arr_len == 33);
65564 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65565 LDKClosingSigned msg_conv;
65566 msg_conv.inner = untag_ptr(msg);
65567 msg_conv.is_owned = ptr_is_owned(msg);
65568 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65569 msg_conv = ClosingSigned_clone(&msg_conv);
65570 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65571 *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
65572 uint64_t ret_ref = tag_ptr(ret_copy, true);
65576 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_shutdown"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint64_t msg) {
65577 LDKPublicKey node_id_ref;
65578 CHECK(node_id->arr_len == 33);
65579 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65580 LDKShutdown msg_conv;
65581 msg_conv.inner = untag_ptr(msg);
65582 msg_conv.is_owned = ptr_is_owned(msg);
65583 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65584 msg_conv = Shutdown_clone(&msg_conv);
65585 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65586 *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
65587 uint64_t ret_ref = tag_ptr(ret_copy, true);
65591 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_reestablish"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint64_t msg) {
65592 LDKPublicKey node_id_ref;
65593 CHECK(node_id->arr_len == 33);
65594 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65595 LDKChannelReestablish msg_conv;
65596 msg_conv.inner = untag_ptr(msg);
65597 msg_conv.is_owned = ptr_is_owned(msg);
65598 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65599 msg_conv = ChannelReestablish_clone(&msg_conv);
65600 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65601 *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
65602 uint64_t ret_ref = tag_ptr(ret_copy, true);
65606 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) {
65607 LDKPublicKey node_id_ref;
65608 CHECK(node_id->arr_len == 33);
65609 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65610 LDKChannelAnnouncement msg_conv;
65611 msg_conv.inner = untag_ptr(msg);
65612 msg_conv.is_owned = ptr_is_owned(msg);
65613 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65614 msg_conv = ChannelAnnouncement_clone(&msg_conv);
65615 LDKChannelUpdate update_msg_conv;
65616 update_msg_conv.inner = untag_ptr(update_msg);
65617 update_msg_conv.is_owned = ptr_is_owned(update_msg);
65618 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
65619 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
65620 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65621 *ret_copy = MessageSendEvent_send_channel_announcement(node_id_ref, msg_conv, update_msg_conv);
65622 uint64_t ret_ref = tag_ptr(ret_copy, true);
65626 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_announcement"))) TS_MessageSendEvent_broadcast_channel_announcement(uint64_t msg, uint64_t update_msg) {
65627 LDKChannelAnnouncement msg_conv;
65628 msg_conv.inner = untag_ptr(msg);
65629 msg_conv.is_owned = ptr_is_owned(msg);
65630 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65631 msg_conv = ChannelAnnouncement_clone(&msg_conv);
65632 LDKChannelUpdate update_msg_conv;
65633 update_msg_conv.inner = untag_ptr(update_msg);
65634 update_msg_conv.is_owned = ptr_is_owned(update_msg);
65635 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
65636 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
65637 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65638 *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
65639 uint64_t ret_ref = tag_ptr(ret_copy, true);
65643 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_update"))) TS_MessageSendEvent_broadcast_channel_update(uint64_t msg) {
65644 LDKChannelUpdate msg_conv;
65645 msg_conv.inner = untag_ptr(msg);
65646 msg_conv.is_owned = ptr_is_owned(msg);
65647 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65648 msg_conv = ChannelUpdate_clone(&msg_conv);
65649 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65650 *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
65651 uint64_t ret_ref = tag_ptr(ret_copy, true);
65655 uint64_t __attribute__((export_name("TS_MessageSendEvent_broadcast_node_announcement"))) TS_MessageSendEvent_broadcast_node_announcement(uint64_t msg) {
65656 LDKNodeAnnouncement msg_conv;
65657 msg_conv.inner = untag_ptr(msg);
65658 msg_conv.is_owned = ptr_is_owned(msg);
65659 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65660 msg_conv = NodeAnnouncement_clone(&msg_conv);
65661 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65662 *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
65663 uint64_t ret_ref = tag_ptr(ret_copy, true);
65667 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_update"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint64_t msg) {
65668 LDKPublicKey node_id_ref;
65669 CHECK(node_id->arr_len == 33);
65670 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65671 LDKChannelUpdate msg_conv;
65672 msg_conv.inner = untag_ptr(msg);
65673 msg_conv.is_owned = ptr_is_owned(msg);
65674 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65675 msg_conv = ChannelUpdate_clone(&msg_conv);
65676 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65677 *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
65678 uint64_t ret_ref = tag_ptr(ret_copy, true);
65682 uint64_t __attribute__((export_name("TS_MessageSendEvent_handle_error"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint64_t action) {
65683 LDKPublicKey node_id_ref;
65684 CHECK(node_id->arr_len == 33);
65685 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65686 void* action_ptr = untag_ptr(action);
65687 CHECK_ACCESS(action_ptr);
65688 LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
65689 action_conv = ErrorAction_clone((LDKErrorAction*)untag_ptr(action));
65690 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65691 *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
65692 uint64_t ret_ref = tag_ptr(ret_copy, true);
65696 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_channel_range_query"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint64_t msg) {
65697 LDKPublicKey node_id_ref;
65698 CHECK(node_id->arr_len == 33);
65699 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65700 LDKQueryChannelRange msg_conv;
65701 msg_conv.inner = untag_ptr(msg);
65702 msg_conv.is_owned = ptr_is_owned(msg);
65703 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65704 msg_conv = QueryChannelRange_clone(&msg_conv);
65705 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65706 *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
65707 uint64_t ret_ref = tag_ptr(ret_copy, true);
65711 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_short_ids_query"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint64_t msg) {
65712 LDKPublicKey node_id_ref;
65713 CHECK(node_id->arr_len == 33);
65714 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65715 LDKQueryShortChannelIds msg_conv;
65716 msg_conv.inner = untag_ptr(msg);
65717 msg_conv.is_owned = ptr_is_owned(msg);
65718 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65719 msg_conv = QueryShortChannelIds_clone(&msg_conv);
65720 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65721 *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
65722 uint64_t ret_ref = tag_ptr(ret_copy, true);
65726 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_reply_channel_range"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint64_t msg) {
65727 LDKPublicKey node_id_ref;
65728 CHECK(node_id->arr_len == 33);
65729 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65730 LDKReplyChannelRange msg_conv;
65731 msg_conv.inner = untag_ptr(msg);
65732 msg_conv.is_owned = ptr_is_owned(msg);
65733 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65734 msg_conv = ReplyChannelRange_clone(&msg_conv);
65735 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65736 *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
65737 uint64_t ret_ref = tag_ptr(ret_copy, true);
65741 uint64_t __attribute__((export_name("TS_MessageSendEvent_send_gossip_timestamp_filter"))) TS_MessageSendEvent_send_gossip_timestamp_filter(int8_tArray node_id, uint64_t msg) {
65742 LDKPublicKey node_id_ref;
65743 CHECK(node_id->arr_len == 33);
65744 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
65745 LDKGossipTimestampFilter msg_conv;
65746 msg_conv.inner = untag_ptr(msg);
65747 msg_conv.is_owned = ptr_is_owned(msg);
65748 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
65749 msg_conv = GossipTimestampFilter_clone(&msg_conv);
65750 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
65751 *ret_copy = MessageSendEvent_send_gossip_timestamp_filter(node_id_ref, msg_conv);
65752 uint64_t ret_ref = tag_ptr(ret_copy, true);
65756 void __attribute__((export_name("TS_MessageSendEventsProvider_free"))) TS_MessageSendEventsProvider_free(uint64_t this_ptr) {
65757 if (!ptr_is_owned(this_ptr)) return;
65758 void* this_ptr_ptr = untag_ptr(this_ptr);
65759 CHECK_ACCESS(this_ptr_ptr);
65760 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
65761 FREE(untag_ptr(this_ptr));
65762 MessageSendEventsProvider_free(this_ptr_conv);
65765 void __attribute__((export_name("TS_OnionMessageProvider_free"))) TS_OnionMessageProvider_free(uint64_t this_ptr) {
65766 if (!ptr_is_owned(this_ptr)) return;
65767 void* this_ptr_ptr = untag_ptr(this_ptr);
65768 CHECK_ACCESS(this_ptr_ptr);
65769 LDKOnionMessageProvider this_ptr_conv = *(LDKOnionMessageProvider*)(this_ptr_ptr);
65770 FREE(untag_ptr(this_ptr));
65771 OnionMessageProvider_free(this_ptr_conv);
65774 void __attribute__((export_name("TS_EventsProvider_free"))) TS_EventsProvider_free(uint64_t this_ptr) {
65775 if (!ptr_is_owned(this_ptr)) return;
65776 void* this_ptr_ptr = untag_ptr(this_ptr);
65777 CHECK_ACCESS(this_ptr_ptr);
65778 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
65779 FREE(untag_ptr(this_ptr));
65780 EventsProvider_free(this_ptr_conv);
65783 void __attribute__((export_name("TS_EventHandler_free"))) TS_EventHandler_free(uint64_t this_ptr) {
65784 if (!ptr_is_owned(this_ptr)) return;
65785 void* this_ptr_ptr = untag_ptr(this_ptr);
65786 CHECK_ACCESS(this_ptr_ptr);
65787 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
65788 FREE(untag_ptr(this_ptr));
65789 EventHandler_free(this_ptr_conv);
65792 void __attribute__((export_name("TS_ChannelDerivationParameters_free"))) TS_ChannelDerivationParameters_free(uint64_t this_obj) {
65793 LDKChannelDerivationParameters this_obj_conv;
65794 this_obj_conv.inner = untag_ptr(this_obj);
65795 this_obj_conv.is_owned = ptr_is_owned(this_obj);
65796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
65797 ChannelDerivationParameters_free(this_obj_conv);
65800 int64_t __attribute__((export_name("TS_ChannelDerivationParameters_get_value_satoshis"))) TS_ChannelDerivationParameters_get_value_satoshis(uint64_t this_ptr) {
65801 LDKChannelDerivationParameters this_ptr_conv;
65802 this_ptr_conv.inner = untag_ptr(this_ptr);
65803 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65805 this_ptr_conv.is_owned = false;
65806 int64_t ret_conv = ChannelDerivationParameters_get_value_satoshis(&this_ptr_conv);
65810 void __attribute__((export_name("TS_ChannelDerivationParameters_set_value_satoshis"))) TS_ChannelDerivationParameters_set_value_satoshis(uint64_t this_ptr, int64_t val) {
65811 LDKChannelDerivationParameters this_ptr_conv;
65812 this_ptr_conv.inner = untag_ptr(this_ptr);
65813 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65815 this_ptr_conv.is_owned = false;
65816 ChannelDerivationParameters_set_value_satoshis(&this_ptr_conv, val);
65819 int8_tArray __attribute__((export_name("TS_ChannelDerivationParameters_get_keys_id"))) TS_ChannelDerivationParameters_get_keys_id(uint64_t this_ptr) {
65820 LDKChannelDerivationParameters this_ptr_conv;
65821 this_ptr_conv.inner = untag_ptr(this_ptr);
65822 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65824 this_ptr_conv.is_owned = false;
65825 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
65826 memcpy(ret_arr->elems, *ChannelDerivationParameters_get_keys_id(&this_ptr_conv), 32);
65830 void __attribute__((export_name("TS_ChannelDerivationParameters_set_keys_id"))) TS_ChannelDerivationParameters_set_keys_id(uint64_t this_ptr, int8_tArray val) {
65831 LDKChannelDerivationParameters this_ptr_conv;
65832 this_ptr_conv.inner = untag_ptr(this_ptr);
65833 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65835 this_ptr_conv.is_owned = false;
65836 LDKThirtyTwoBytes val_ref;
65837 CHECK(val->arr_len == 32);
65838 memcpy(val_ref.data, val->elems, 32); FREE(val);
65839 ChannelDerivationParameters_set_keys_id(&this_ptr_conv, val_ref);
65842 uint64_t __attribute__((export_name("TS_ChannelDerivationParameters_get_transaction_parameters"))) TS_ChannelDerivationParameters_get_transaction_parameters(uint64_t this_ptr) {
65843 LDKChannelDerivationParameters this_ptr_conv;
65844 this_ptr_conv.inner = untag_ptr(this_ptr);
65845 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65847 this_ptr_conv.is_owned = false;
65848 LDKChannelTransactionParameters ret_var = ChannelDerivationParameters_get_transaction_parameters(&this_ptr_conv);
65849 uint64_t ret_ref = 0;
65850 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65851 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
65855 void __attribute__((export_name("TS_ChannelDerivationParameters_set_transaction_parameters"))) TS_ChannelDerivationParameters_set_transaction_parameters(uint64_t this_ptr, uint64_t val) {
65856 LDKChannelDerivationParameters this_ptr_conv;
65857 this_ptr_conv.inner = untag_ptr(this_ptr);
65858 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65860 this_ptr_conv.is_owned = false;
65861 LDKChannelTransactionParameters val_conv;
65862 val_conv.inner = untag_ptr(val);
65863 val_conv.is_owned = ptr_is_owned(val);
65864 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
65865 val_conv = ChannelTransactionParameters_clone(&val_conv);
65866 ChannelDerivationParameters_set_transaction_parameters(&this_ptr_conv, val_conv);
65869 uint64_t __attribute__((export_name("TS_ChannelDerivationParameters_new"))) TS_ChannelDerivationParameters_new(int64_t value_satoshis_arg, int8_tArray keys_id_arg, uint64_t transaction_parameters_arg) {
65870 LDKThirtyTwoBytes keys_id_arg_ref;
65871 CHECK(keys_id_arg->arr_len == 32);
65872 memcpy(keys_id_arg_ref.data, keys_id_arg->elems, 32); FREE(keys_id_arg);
65873 LDKChannelTransactionParameters transaction_parameters_arg_conv;
65874 transaction_parameters_arg_conv.inner = untag_ptr(transaction_parameters_arg);
65875 transaction_parameters_arg_conv.is_owned = ptr_is_owned(transaction_parameters_arg);
65876 CHECK_INNER_FIELD_ACCESS_OR_NULL(transaction_parameters_arg_conv);
65877 transaction_parameters_arg_conv = ChannelTransactionParameters_clone(&transaction_parameters_arg_conv);
65878 LDKChannelDerivationParameters ret_var = ChannelDerivationParameters_new(value_satoshis_arg, keys_id_arg_ref, transaction_parameters_arg_conv);
65879 uint64_t ret_ref = 0;
65880 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65881 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
65885 static inline uint64_t ChannelDerivationParameters_clone_ptr(LDKChannelDerivationParameters *NONNULL_PTR arg) {
65886 LDKChannelDerivationParameters ret_var = ChannelDerivationParameters_clone(arg);
65887 uint64_t ret_ref = 0;
65888 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65889 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
65892 int64_t __attribute__((export_name("TS_ChannelDerivationParameters_clone_ptr"))) TS_ChannelDerivationParameters_clone_ptr(uint64_t arg) {
65893 LDKChannelDerivationParameters arg_conv;
65894 arg_conv.inner = untag_ptr(arg);
65895 arg_conv.is_owned = ptr_is_owned(arg);
65896 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
65897 arg_conv.is_owned = false;
65898 int64_t ret_conv = ChannelDerivationParameters_clone_ptr(&arg_conv);
65902 uint64_t __attribute__((export_name("TS_ChannelDerivationParameters_clone"))) TS_ChannelDerivationParameters_clone(uint64_t orig) {
65903 LDKChannelDerivationParameters orig_conv;
65904 orig_conv.inner = untag_ptr(orig);
65905 orig_conv.is_owned = ptr_is_owned(orig);
65906 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
65907 orig_conv.is_owned = false;
65908 LDKChannelDerivationParameters ret_var = ChannelDerivationParameters_clone(&orig_conv);
65909 uint64_t ret_ref = 0;
65910 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65911 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
65915 jboolean __attribute__((export_name("TS_ChannelDerivationParameters_eq"))) TS_ChannelDerivationParameters_eq(uint64_t a, uint64_t b) {
65916 LDKChannelDerivationParameters a_conv;
65917 a_conv.inner = untag_ptr(a);
65918 a_conv.is_owned = ptr_is_owned(a);
65919 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
65920 a_conv.is_owned = false;
65921 LDKChannelDerivationParameters b_conv;
65922 b_conv.inner = untag_ptr(b);
65923 b_conv.is_owned = ptr_is_owned(b);
65924 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
65925 b_conv.is_owned = false;
65926 jboolean ret_conv = ChannelDerivationParameters_eq(&a_conv, &b_conv);
65930 int8_tArray __attribute__((export_name("TS_ChannelDerivationParameters_write"))) TS_ChannelDerivationParameters_write(uint64_t obj) {
65931 LDKChannelDerivationParameters obj_conv;
65932 obj_conv.inner = untag_ptr(obj);
65933 obj_conv.is_owned = ptr_is_owned(obj);
65934 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
65935 obj_conv.is_owned = false;
65936 LDKCVec_u8Z ret_var = ChannelDerivationParameters_write(&obj_conv);
65937 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
65938 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
65939 CVec_u8Z_free(ret_var);
65943 uint64_t __attribute__((export_name("TS_ChannelDerivationParameters_read"))) TS_ChannelDerivationParameters_read(int8_tArray ser) {
65944 LDKu8slice ser_ref;
65945 ser_ref.datalen = ser->arr_len;
65946 ser_ref.data = ser->elems;
65947 LDKCResult_ChannelDerivationParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDerivationParametersDecodeErrorZ), "LDKCResult_ChannelDerivationParametersDecodeErrorZ");
65948 *ret_conv = ChannelDerivationParameters_read(ser_ref);
65950 return tag_ptr(ret_conv, true);
65953 void __attribute__((export_name("TS_AnchorDescriptor_free"))) TS_AnchorDescriptor_free(uint64_t this_obj) {
65954 LDKAnchorDescriptor this_obj_conv;
65955 this_obj_conv.inner = untag_ptr(this_obj);
65956 this_obj_conv.is_owned = ptr_is_owned(this_obj);
65957 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
65958 AnchorDescriptor_free(this_obj_conv);
65961 uint64_t __attribute__((export_name("TS_AnchorDescriptor_get_channel_derivation_parameters"))) TS_AnchorDescriptor_get_channel_derivation_parameters(uint64_t this_ptr) {
65962 LDKAnchorDescriptor this_ptr_conv;
65963 this_ptr_conv.inner = untag_ptr(this_ptr);
65964 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65965 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65966 this_ptr_conv.is_owned = false;
65967 LDKChannelDerivationParameters ret_var = AnchorDescriptor_get_channel_derivation_parameters(&this_ptr_conv);
65968 uint64_t ret_ref = 0;
65969 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65970 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
65974 void __attribute__((export_name("TS_AnchorDescriptor_set_channel_derivation_parameters"))) TS_AnchorDescriptor_set_channel_derivation_parameters(uint64_t this_ptr, uint64_t val) {
65975 LDKAnchorDescriptor this_ptr_conv;
65976 this_ptr_conv.inner = untag_ptr(this_ptr);
65977 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65979 this_ptr_conv.is_owned = false;
65980 LDKChannelDerivationParameters val_conv;
65981 val_conv.inner = untag_ptr(val);
65982 val_conv.is_owned = ptr_is_owned(val);
65983 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
65984 val_conv = ChannelDerivationParameters_clone(&val_conv);
65985 AnchorDescriptor_set_channel_derivation_parameters(&this_ptr_conv, val_conv);
65988 uint64_t __attribute__((export_name("TS_AnchorDescriptor_get_outpoint"))) TS_AnchorDescriptor_get_outpoint(uint64_t this_ptr) {
65989 LDKAnchorDescriptor this_ptr_conv;
65990 this_ptr_conv.inner = untag_ptr(this_ptr);
65991 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
65992 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
65993 this_ptr_conv.is_owned = false;
65994 LDKOutPoint ret_var = AnchorDescriptor_get_outpoint(&this_ptr_conv);
65995 uint64_t ret_ref = 0;
65996 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
65997 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66001 void __attribute__((export_name("TS_AnchorDescriptor_set_outpoint"))) TS_AnchorDescriptor_set_outpoint(uint64_t this_ptr, uint64_t val) {
66002 LDKAnchorDescriptor this_ptr_conv;
66003 this_ptr_conv.inner = untag_ptr(this_ptr);
66004 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66006 this_ptr_conv.is_owned = false;
66007 LDKOutPoint val_conv;
66008 val_conv.inner = untag_ptr(val);
66009 val_conv.is_owned = ptr_is_owned(val);
66010 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
66011 val_conv = OutPoint_clone(&val_conv);
66012 AnchorDescriptor_set_outpoint(&this_ptr_conv, val_conv);
66015 uint64_t __attribute__((export_name("TS_AnchorDescriptor_new"))) TS_AnchorDescriptor_new(uint64_t channel_derivation_parameters_arg, uint64_t outpoint_arg) {
66016 LDKChannelDerivationParameters channel_derivation_parameters_arg_conv;
66017 channel_derivation_parameters_arg_conv.inner = untag_ptr(channel_derivation_parameters_arg);
66018 channel_derivation_parameters_arg_conv.is_owned = ptr_is_owned(channel_derivation_parameters_arg);
66019 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_derivation_parameters_arg_conv);
66020 channel_derivation_parameters_arg_conv = ChannelDerivationParameters_clone(&channel_derivation_parameters_arg_conv);
66021 LDKOutPoint outpoint_arg_conv;
66022 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
66023 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
66024 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
66025 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
66026 LDKAnchorDescriptor ret_var = AnchorDescriptor_new(channel_derivation_parameters_arg_conv, outpoint_arg_conv);
66027 uint64_t ret_ref = 0;
66028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66033 static inline uint64_t AnchorDescriptor_clone_ptr(LDKAnchorDescriptor *NONNULL_PTR arg) {
66034 LDKAnchorDescriptor ret_var = AnchorDescriptor_clone(arg);
66035 uint64_t ret_ref = 0;
66036 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66037 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66040 int64_t __attribute__((export_name("TS_AnchorDescriptor_clone_ptr"))) TS_AnchorDescriptor_clone_ptr(uint64_t arg) {
66041 LDKAnchorDescriptor arg_conv;
66042 arg_conv.inner = untag_ptr(arg);
66043 arg_conv.is_owned = ptr_is_owned(arg);
66044 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
66045 arg_conv.is_owned = false;
66046 int64_t ret_conv = AnchorDescriptor_clone_ptr(&arg_conv);
66050 uint64_t __attribute__((export_name("TS_AnchorDescriptor_clone"))) TS_AnchorDescriptor_clone(uint64_t orig) {
66051 LDKAnchorDescriptor orig_conv;
66052 orig_conv.inner = untag_ptr(orig);
66053 orig_conv.is_owned = ptr_is_owned(orig);
66054 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
66055 orig_conv.is_owned = false;
66056 LDKAnchorDescriptor ret_var = AnchorDescriptor_clone(&orig_conv);
66057 uint64_t ret_ref = 0;
66058 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66059 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66063 jboolean __attribute__((export_name("TS_AnchorDescriptor_eq"))) TS_AnchorDescriptor_eq(uint64_t a, uint64_t b) {
66064 LDKAnchorDescriptor a_conv;
66065 a_conv.inner = untag_ptr(a);
66066 a_conv.is_owned = ptr_is_owned(a);
66067 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
66068 a_conv.is_owned = false;
66069 LDKAnchorDescriptor b_conv;
66070 b_conv.inner = untag_ptr(b);
66071 b_conv.is_owned = ptr_is_owned(b);
66072 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
66073 b_conv.is_owned = false;
66074 jboolean ret_conv = AnchorDescriptor_eq(&a_conv, &b_conv);
66078 uint64_t __attribute__((export_name("TS_AnchorDescriptor_previous_utxo"))) TS_AnchorDescriptor_previous_utxo(uint64_t this_arg) {
66079 LDKAnchorDescriptor this_arg_conv;
66080 this_arg_conv.inner = untag_ptr(this_arg);
66081 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66083 this_arg_conv.is_owned = false;
66084 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
66085 *ret_ref = AnchorDescriptor_previous_utxo(&this_arg_conv);
66086 return tag_ptr(ret_ref, true);
66089 uint64_t __attribute__((export_name("TS_AnchorDescriptor_unsigned_tx_input"))) TS_AnchorDescriptor_unsigned_tx_input(uint64_t this_arg) {
66090 LDKAnchorDescriptor this_arg_conv;
66091 this_arg_conv.inner = untag_ptr(this_arg);
66092 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66093 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66094 this_arg_conv.is_owned = false;
66095 LDKTxIn* ret_ref = MALLOC(sizeof(LDKTxIn), "LDKTxIn");
66096 *ret_ref = AnchorDescriptor_unsigned_tx_input(&this_arg_conv);
66097 return tag_ptr(ret_ref, true);
66100 int8_tArray __attribute__((export_name("TS_AnchorDescriptor_witness_script"))) TS_AnchorDescriptor_witness_script(uint64_t this_arg) {
66101 LDKAnchorDescriptor this_arg_conv;
66102 this_arg_conv.inner = untag_ptr(this_arg);
66103 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66105 this_arg_conv.is_owned = false;
66106 LDKCVec_u8Z ret_var = AnchorDescriptor_witness_script(&this_arg_conv);
66107 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
66108 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
66109 CVec_u8Z_free(ret_var);
66113 int8_tArray __attribute__((export_name("TS_AnchorDescriptor_tx_input_witness"))) TS_AnchorDescriptor_tx_input_witness(uint64_t this_arg, int8_tArray signature) {
66114 LDKAnchorDescriptor this_arg_conv;
66115 this_arg_conv.inner = untag_ptr(this_arg);
66116 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66117 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66118 this_arg_conv.is_owned = false;
66119 LDKECDSASignature signature_ref;
66120 CHECK(signature->arr_len == 64);
66121 memcpy(signature_ref.compact_form, signature->elems, 64); FREE(signature);
66122 LDKWitness ret_var = AnchorDescriptor_tx_input_witness(&this_arg_conv, signature_ref);
66123 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
66124 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
66125 Witness_free(ret_var);
66129 uint64_t __attribute__((export_name("TS_AnchorDescriptor_derive_channel_signer"))) TS_AnchorDescriptor_derive_channel_signer(uint64_t this_arg, uint64_t signer_provider) {
66130 LDKAnchorDescriptor this_arg_conv;
66131 this_arg_conv.inner = untag_ptr(this_arg);
66132 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66134 this_arg_conv.is_owned = false;
66135 void* signer_provider_ptr = untag_ptr(signer_provider);
66136 if (ptr_is_owned(signer_provider)) { CHECK_ACCESS(signer_provider_ptr); }
66137 LDKSignerProvider* signer_provider_conv = (LDKSignerProvider*)signer_provider_ptr;
66138 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
66139 *ret_ret = AnchorDescriptor_derive_channel_signer(&this_arg_conv, signer_provider_conv);
66140 return tag_ptr(ret_ret, true);
66143 void __attribute__((export_name("TS_HTLCDescriptor_free"))) TS_HTLCDescriptor_free(uint64_t this_obj) {
66144 LDKHTLCDescriptor this_obj_conv;
66145 this_obj_conv.inner = untag_ptr(this_obj);
66146 this_obj_conv.is_owned = ptr_is_owned(this_obj);
66147 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
66148 HTLCDescriptor_free(this_obj_conv);
66151 uint64_t __attribute__((export_name("TS_HTLCDescriptor_get_channel_derivation_parameters"))) TS_HTLCDescriptor_get_channel_derivation_parameters(uint64_t this_ptr) {
66152 LDKHTLCDescriptor this_ptr_conv;
66153 this_ptr_conv.inner = untag_ptr(this_ptr);
66154 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66155 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66156 this_ptr_conv.is_owned = false;
66157 LDKChannelDerivationParameters ret_var = HTLCDescriptor_get_channel_derivation_parameters(&this_ptr_conv);
66158 uint64_t ret_ref = 0;
66159 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66160 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66164 void __attribute__((export_name("TS_HTLCDescriptor_set_channel_derivation_parameters"))) TS_HTLCDescriptor_set_channel_derivation_parameters(uint64_t this_ptr, uint64_t val) {
66165 LDKHTLCDescriptor this_ptr_conv;
66166 this_ptr_conv.inner = untag_ptr(this_ptr);
66167 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66169 this_ptr_conv.is_owned = false;
66170 LDKChannelDerivationParameters val_conv;
66171 val_conv.inner = untag_ptr(val);
66172 val_conv.is_owned = ptr_is_owned(val);
66173 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
66174 val_conv = ChannelDerivationParameters_clone(&val_conv);
66175 HTLCDescriptor_set_channel_derivation_parameters(&this_ptr_conv, val_conv);
66178 int64_t __attribute__((export_name("TS_HTLCDescriptor_get_per_commitment_number"))) TS_HTLCDescriptor_get_per_commitment_number(uint64_t this_ptr) {
66179 LDKHTLCDescriptor this_ptr_conv;
66180 this_ptr_conv.inner = untag_ptr(this_ptr);
66181 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66183 this_ptr_conv.is_owned = false;
66184 int64_t ret_conv = HTLCDescriptor_get_per_commitment_number(&this_ptr_conv);
66188 void __attribute__((export_name("TS_HTLCDescriptor_set_per_commitment_number"))) TS_HTLCDescriptor_set_per_commitment_number(uint64_t this_ptr, int64_t val) {
66189 LDKHTLCDescriptor this_ptr_conv;
66190 this_ptr_conv.inner = untag_ptr(this_ptr);
66191 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66193 this_ptr_conv.is_owned = false;
66194 HTLCDescriptor_set_per_commitment_number(&this_ptr_conv, val);
66197 int8_tArray __attribute__((export_name("TS_HTLCDescriptor_get_per_commitment_point"))) TS_HTLCDescriptor_get_per_commitment_point(uint64_t this_ptr) {
66198 LDKHTLCDescriptor this_ptr_conv;
66199 this_ptr_conv.inner = untag_ptr(this_ptr);
66200 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66202 this_ptr_conv.is_owned = false;
66203 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
66204 memcpy(ret_arr->elems, HTLCDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
66208 void __attribute__((export_name("TS_HTLCDescriptor_set_per_commitment_point"))) TS_HTLCDescriptor_set_per_commitment_point(uint64_t this_ptr, int8_tArray val) {
66209 LDKHTLCDescriptor this_ptr_conv;
66210 this_ptr_conv.inner = untag_ptr(this_ptr);
66211 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66212 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66213 this_ptr_conv.is_owned = false;
66214 LDKPublicKey val_ref;
66215 CHECK(val->arr_len == 33);
66216 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
66217 HTLCDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
66220 uint64_t __attribute__((export_name("TS_HTLCDescriptor_get_htlc"))) TS_HTLCDescriptor_get_htlc(uint64_t this_ptr) {
66221 LDKHTLCDescriptor this_ptr_conv;
66222 this_ptr_conv.inner = untag_ptr(this_ptr);
66223 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66224 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66225 this_ptr_conv.is_owned = false;
66226 LDKHTLCOutputInCommitment ret_var = HTLCDescriptor_get_htlc(&this_ptr_conv);
66227 uint64_t ret_ref = 0;
66228 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66229 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66233 void __attribute__((export_name("TS_HTLCDescriptor_set_htlc"))) TS_HTLCDescriptor_set_htlc(uint64_t this_ptr, uint64_t val) {
66234 LDKHTLCDescriptor this_ptr_conv;
66235 this_ptr_conv.inner = untag_ptr(this_ptr);
66236 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66238 this_ptr_conv.is_owned = false;
66239 LDKHTLCOutputInCommitment val_conv;
66240 val_conv.inner = untag_ptr(val);
66241 val_conv.is_owned = ptr_is_owned(val);
66242 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
66243 val_conv = HTLCOutputInCommitment_clone(&val_conv);
66244 HTLCDescriptor_set_htlc(&this_ptr_conv, val_conv);
66247 uint64_t __attribute__((export_name("TS_HTLCDescriptor_get_preimage"))) TS_HTLCDescriptor_get_preimage(uint64_t this_ptr) {
66248 LDKHTLCDescriptor this_ptr_conv;
66249 this_ptr_conv.inner = untag_ptr(this_ptr);
66250 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66251 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66252 this_ptr_conv.is_owned = false;
66253 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
66254 *ret_copy = HTLCDescriptor_get_preimage(&this_ptr_conv);
66255 uint64_t ret_ref = tag_ptr(ret_copy, true);
66259 void __attribute__((export_name("TS_HTLCDescriptor_set_preimage"))) TS_HTLCDescriptor_set_preimage(uint64_t this_ptr, uint64_t val) {
66260 LDKHTLCDescriptor this_ptr_conv;
66261 this_ptr_conv.inner = untag_ptr(this_ptr);
66262 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66263 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66264 this_ptr_conv.is_owned = false;
66265 void* val_ptr = untag_ptr(val);
66266 CHECK_ACCESS(val_ptr);
66267 LDKCOption_ThirtyTwoBytesZ val_conv = *(LDKCOption_ThirtyTwoBytesZ*)(val_ptr);
66268 val_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(val));
66269 HTLCDescriptor_set_preimage(&this_ptr_conv, val_conv);
66272 int8_tArray __attribute__((export_name("TS_HTLCDescriptor_get_counterparty_sig"))) TS_HTLCDescriptor_get_counterparty_sig(uint64_t this_ptr) {
66273 LDKHTLCDescriptor this_ptr_conv;
66274 this_ptr_conv.inner = untag_ptr(this_ptr);
66275 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66277 this_ptr_conv.is_owned = false;
66278 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
66279 memcpy(ret_arr->elems, HTLCDescriptor_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
66283 void __attribute__((export_name("TS_HTLCDescriptor_set_counterparty_sig"))) TS_HTLCDescriptor_set_counterparty_sig(uint64_t this_ptr, int8_tArray val) {
66284 LDKHTLCDescriptor this_ptr_conv;
66285 this_ptr_conv.inner = untag_ptr(this_ptr);
66286 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66288 this_ptr_conv.is_owned = false;
66289 LDKECDSASignature val_ref;
66290 CHECK(val->arr_len == 64);
66291 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
66292 HTLCDescriptor_set_counterparty_sig(&this_ptr_conv, val_ref);
66295 static inline uint64_t HTLCDescriptor_clone_ptr(LDKHTLCDescriptor *NONNULL_PTR arg) {
66296 LDKHTLCDescriptor ret_var = HTLCDescriptor_clone(arg);
66297 uint64_t ret_ref = 0;
66298 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66299 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66302 int64_t __attribute__((export_name("TS_HTLCDescriptor_clone_ptr"))) TS_HTLCDescriptor_clone_ptr(uint64_t arg) {
66303 LDKHTLCDescriptor arg_conv;
66304 arg_conv.inner = untag_ptr(arg);
66305 arg_conv.is_owned = ptr_is_owned(arg);
66306 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
66307 arg_conv.is_owned = false;
66308 int64_t ret_conv = HTLCDescriptor_clone_ptr(&arg_conv);
66312 uint64_t __attribute__((export_name("TS_HTLCDescriptor_clone"))) TS_HTLCDescriptor_clone(uint64_t orig) {
66313 LDKHTLCDescriptor orig_conv;
66314 orig_conv.inner = untag_ptr(orig);
66315 orig_conv.is_owned = ptr_is_owned(orig);
66316 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
66317 orig_conv.is_owned = false;
66318 LDKHTLCDescriptor ret_var = HTLCDescriptor_clone(&orig_conv);
66319 uint64_t ret_ref = 0;
66320 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66321 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66325 jboolean __attribute__((export_name("TS_HTLCDescriptor_eq"))) TS_HTLCDescriptor_eq(uint64_t a, uint64_t b) {
66326 LDKHTLCDescriptor a_conv;
66327 a_conv.inner = untag_ptr(a);
66328 a_conv.is_owned = ptr_is_owned(a);
66329 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
66330 a_conv.is_owned = false;
66331 LDKHTLCDescriptor b_conv;
66332 b_conv.inner = untag_ptr(b);
66333 b_conv.is_owned = ptr_is_owned(b);
66334 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
66335 b_conv.is_owned = false;
66336 jboolean ret_conv = HTLCDescriptor_eq(&a_conv, &b_conv);
66340 int8_tArray __attribute__((export_name("TS_HTLCDescriptor_write"))) TS_HTLCDescriptor_write(uint64_t obj) {
66341 LDKHTLCDescriptor obj_conv;
66342 obj_conv.inner = untag_ptr(obj);
66343 obj_conv.is_owned = ptr_is_owned(obj);
66344 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
66345 obj_conv.is_owned = false;
66346 LDKCVec_u8Z ret_var = HTLCDescriptor_write(&obj_conv);
66347 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
66348 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
66349 CVec_u8Z_free(ret_var);
66353 uint64_t __attribute__((export_name("TS_HTLCDescriptor_read"))) TS_HTLCDescriptor_read(int8_tArray ser) {
66354 LDKu8slice ser_ref;
66355 ser_ref.datalen = ser->arr_len;
66356 ser_ref.data = ser->elems;
66357 LDKCResult_HTLCDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCDescriptorDecodeErrorZ), "LDKCResult_HTLCDescriptorDecodeErrorZ");
66358 *ret_conv = HTLCDescriptor_read(ser_ref);
66360 return tag_ptr(ret_conv, true);
66363 uint64_t __attribute__((export_name("TS_HTLCDescriptor_outpoint"))) TS_HTLCDescriptor_outpoint(uint64_t this_arg) {
66364 LDKHTLCDescriptor this_arg_conv;
66365 this_arg_conv.inner = untag_ptr(this_arg);
66366 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66368 this_arg_conv.is_owned = false;
66369 LDKOutPoint ret_var = HTLCDescriptor_outpoint(&this_arg_conv);
66370 uint64_t ret_ref = 0;
66371 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66372 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66376 uint64_t __attribute__((export_name("TS_HTLCDescriptor_previous_utxo"))) TS_HTLCDescriptor_previous_utxo(uint64_t this_arg) {
66377 LDKHTLCDescriptor this_arg_conv;
66378 this_arg_conv.inner = untag_ptr(this_arg);
66379 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66380 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66381 this_arg_conv.is_owned = false;
66382 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
66383 *ret_ref = HTLCDescriptor_previous_utxo(&this_arg_conv);
66384 return tag_ptr(ret_ref, true);
66387 uint64_t __attribute__((export_name("TS_HTLCDescriptor_unsigned_tx_input"))) TS_HTLCDescriptor_unsigned_tx_input(uint64_t this_arg) {
66388 LDKHTLCDescriptor this_arg_conv;
66389 this_arg_conv.inner = untag_ptr(this_arg);
66390 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66391 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66392 this_arg_conv.is_owned = false;
66393 LDKTxIn* ret_ref = MALLOC(sizeof(LDKTxIn), "LDKTxIn");
66394 *ret_ref = HTLCDescriptor_unsigned_tx_input(&this_arg_conv);
66395 return tag_ptr(ret_ref, true);
66398 uint64_t __attribute__((export_name("TS_HTLCDescriptor_tx_output"))) TS_HTLCDescriptor_tx_output(uint64_t this_arg) {
66399 LDKHTLCDescriptor this_arg_conv;
66400 this_arg_conv.inner = untag_ptr(this_arg);
66401 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66402 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66403 this_arg_conv.is_owned = false;
66404 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
66405 *ret_ref = HTLCDescriptor_tx_output(&this_arg_conv);
66406 return tag_ptr(ret_ref, true);
66409 int8_tArray __attribute__((export_name("TS_HTLCDescriptor_witness_script"))) TS_HTLCDescriptor_witness_script(uint64_t this_arg) {
66410 LDKHTLCDescriptor this_arg_conv;
66411 this_arg_conv.inner = untag_ptr(this_arg);
66412 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66414 this_arg_conv.is_owned = false;
66415 LDKCVec_u8Z ret_var = HTLCDescriptor_witness_script(&this_arg_conv);
66416 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
66417 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
66418 CVec_u8Z_free(ret_var);
66422 int8_tArray __attribute__((export_name("TS_HTLCDescriptor_tx_input_witness"))) TS_HTLCDescriptor_tx_input_witness(uint64_t this_arg, int8_tArray signature, int8_tArray witness_script) {
66423 LDKHTLCDescriptor this_arg_conv;
66424 this_arg_conv.inner = untag_ptr(this_arg);
66425 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66427 this_arg_conv.is_owned = false;
66428 LDKECDSASignature signature_ref;
66429 CHECK(signature->arr_len == 64);
66430 memcpy(signature_ref.compact_form, signature->elems, 64); FREE(signature);
66431 LDKu8slice witness_script_ref;
66432 witness_script_ref.datalen = witness_script->arr_len;
66433 witness_script_ref.data = witness_script->elems;
66434 LDKWitness ret_var = HTLCDescriptor_tx_input_witness(&this_arg_conv, signature_ref, witness_script_ref);
66435 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
66436 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
66437 Witness_free(ret_var);
66438 FREE(witness_script);
66442 uint64_t __attribute__((export_name("TS_HTLCDescriptor_derive_channel_signer"))) TS_HTLCDescriptor_derive_channel_signer(uint64_t this_arg, uint64_t signer_provider) {
66443 LDKHTLCDescriptor this_arg_conv;
66444 this_arg_conv.inner = untag_ptr(this_arg);
66445 this_arg_conv.is_owned = ptr_is_owned(this_arg);
66446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
66447 this_arg_conv.is_owned = false;
66448 void* signer_provider_ptr = untag_ptr(signer_provider);
66449 if (ptr_is_owned(signer_provider)) { CHECK_ACCESS(signer_provider_ptr); }
66450 LDKSignerProvider* signer_provider_conv = (LDKSignerProvider*)signer_provider_ptr;
66451 LDKWriteableEcdsaChannelSigner* ret_ret = MALLOC(sizeof(LDKWriteableEcdsaChannelSigner), "LDKWriteableEcdsaChannelSigner");
66452 *ret_ret = HTLCDescriptor_derive_channel_signer(&this_arg_conv, signer_provider_conv);
66453 return tag_ptr(ret_ret, true);
66456 void __attribute__((export_name("TS_BumpTransactionEvent_free"))) TS_BumpTransactionEvent_free(uint64_t this_ptr) {
66457 if (!ptr_is_owned(this_ptr)) return;
66458 void* this_ptr_ptr = untag_ptr(this_ptr);
66459 CHECK_ACCESS(this_ptr_ptr);
66460 LDKBumpTransactionEvent this_ptr_conv = *(LDKBumpTransactionEvent*)(this_ptr_ptr);
66461 FREE(untag_ptr(this_ptr));
66462 BumpTransactionEvent_free(this_ptr_conv);
66465 static inline uint64_t BumpTransactionEvent_clone_ptr(LDKBumpTransactionEvent *NONNULL_PTR arg) {
66466 LDKBumpTransactionEvent *ret_copy = MALLOC(sizeof(LDKBumpTransactionEvent), "LDKBumpTransactionEvent");
66467 *ret_copy = BumpTransactionEvent_clone(arg);
66468 uint64_t ret_ref = tag_ptr(ret_copy, true);
66471 int64_t __attribute__((export_name("TS_BumpTransactionEvent_clone_ptr"))) TS_BumpTransactionEvent_clone_ptr(uint64_t arg) {
66472 LDKBumpTransactionEvent* arg_conv = (LDKBumpTransactionEvent*)untag_ptr(arg);
66473 int64_t ret_conv = BumpTransactionEvent_clone_ptr(arg_conv);
66477 uint64_t __attribute__((export_name("TS_BumpTransactionEvent_clone"))) TS_BumpTransactionEvent_clone(uint64_t orig) {
66478 LDKBumpTransactionEvent* orig_conv = (LDKBumpTransactionEvent*)untag_ptr(orig);
66479 LDKBumpTransactionEvent *ret_copy = MALLOC(sizeof(LDKBumpTransactionEvent), "LDKBumpTransactionEvent");
66480 *ret_copy = BumpTransactionEvent_clone(orig_conv);
66481 uint64_t ret_ref = tag_ptr(ret_copy, true);
66485 uint64_t __attribute__((export_name("TS_BumpTransactionEvent_channel_close"))) TS_BumpTransactionEvent_channel_close(int8_tArray claim_id, int32_t package_target_feerate_sat_per_1000_weight, int8_tArray commitment_tx, int64_t commitment_tx_fee_satoshis, uint64_t anchor_descriptor, uint64_tArray pending_htlcs) {
66486 LDKThirtyTwoBytes claim_id_ref;
66487 CHECK(claim_id->arr_len == 32);
66488 memcpy(claim_id_ref.data, claim_id->elems, 32); FREE(claim_id);
66489 LDKTransaction commitment_tx_ref;
66490 commitment_tx_ref.datalen = commitment_tx->arr_len;
66491 commitment_tx_ref.data = MALLOC(commitment_tx_ref.datalen, "LDKTransaction Bytes");
66492 memcpy(commitment_tx_ref.data, commitment_tx->elems, commitment_tx_ref.datalen); FREE(commitment_tx);
66493 commitment_tx_ref.data_is_owned = true;
66494 LDKAnchorDescriptor anchor_descriptor_conv;
66495 anchor_descriptor_conv.inner = untag_ptr(anchor_descriptor);
66496 anchor_descriptor_conv.is_owned = ptr_is_owned(anchor_descriptor);
66497 CHECK_INNER_FIELD_ACCESS_OR_NULL(anchor_descriptor_conv);
66498 anchor_descriptor_conv = AnchorDescriptor_clone(&anchor_descriptor_conv);
66499 LDKCVec_HTLCOutputInCommitmentZ pending_htlcs_constr;
66500 pending_htlcs_constr.datalen = pending_htlcs->arr_len;
66501 if (pending_htlcs_constr.datalen > 0)
66502 pending_htlcs_constr.data = MALLOC(pending_htlcs_constr.datalen * sizeof(LDKHTLCOutputInCommitment), "LDKCVec_HTLCOutputInCommitmentZ Elements");
66504 pending_htlcs_constr.data = NULL;
66505 uint64_t* pending_htlcs_vals = pending_htlcs->elems;
66506 for (size_t y = 0; y < pending_htlcs_constr.datalen; y++) {
66507 uint64_t pending_htlcs_conv_24 = pending_htlcs_vals[y];
66508 LDKHTLCOutputInCommitment pending_htlcs_conv_24_conv;
66509 pending_htlcs_conv_24_conv.inner = untag_ptr(pending_htlcs_conv_24);
66510 pending_htlcs_conv_24_conv.is_owned = ptr_is_owned(pending_htlcs_conv_24);
66511 CHECK_INNER_FIELD_ACCESS_OR_NULL(pending_htlcs_conv_24_conv);
66512 pending_htlcs_conv_24_conv = HTLCOutputInCommitment_clone(&pending_htlcs_conv_24_conv);
66513 pending_htlcs_constr.data[y] = pending_htlcs_conv_24_conv;
66515 FREE(pending_htlcs);
66516 LDKBumpTransactionEvent *ret_copy = MALLOC(sizeof(LDKBumpTransactionEvent), "LDKBumpTransactionEvent");
66517 *ret_copy = BumpTransactionEvent_channel_close(claim_id_ref, package_target_feerate_sat_per_1000_weight, commitment_tx_ref, commitment_tx_fee_satoshis, anchor_descriptor_conv, pending_htlcs_constr);
66518 uint64_t ret_ref = tag_ptr(ret_copy, true);
66522 uint64_t __attribute__((export_name("TS_BumpTransactionEvent_htlcresolution"))) TS_BumpTransactionEvent_htlcresolution(int8_tArray claim_id, int32_t target_feerate_sat_per_1000_weight, uint64_tArray htlc_descriptors, int32_t tx_lock_time) {
66523 LDKThirtyTwoBytes claim_id_ref;
66524 CHECK(claim_id->arr_len == 32);
66525 memcpy(claim_id_ref.data, claim_id->elems, 32); FREE(claim_id);
66526 LDKCVec_HTLCDescriptorZ htlc_descriptors_constr;
66527 htlc_descriptors_constr.datalen = htlc_descriptors->arr_len;
66528 if (htlc_descriptors_constr.datalen > 0)
66529 htlc_descriptors_constr.data = MALLOC(htlc_descriptors_constr.datalen * sizeof(LDKHTLCDescriptor), "LDKCVec_HTLCDescriptorZ Elements");
66531 htlc_descriptors_constr.data = NULL;
66532 uint64_t* htlc_descriptors_vals = htlc_descriptors->elems;
66533 for (size_t q = 0; q < htlc_descriptors_constr.datalen; q++) {
66534 uint64_t htlc_descriptors_conv_16 = htlc_descriptors_vals[q];
66535 LDKHTLCDescriptor htlc_descriptors_conv_16_conv;
66536 htlc_descriptors_conv_16_conv.inner = untag_ptr(htlc_descriptors_conv_16);
66537 htlc_descriptors_conv_16_conv.is_owned = ptr_is_owned(htlc_descriptors_conv_16);
66538 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_descriptors_conv_16_conv);
66539 htlc_descriptors_conv_16_conv = HTLCDescriptor_clone(&htlc_descriptors_conv_16_conv);
66540 htlc_descriptors_constr.data[q] = htlc_descriptors_conv_16_conv;
66542 FREE(htlc_descriptors);
66543 LDKBumpTransactionEvent *ret_copy = MALLOC(sizeof(LDKBumpTransactionEvent), "LDKBumpTransactionEvent");
66544 *ret_copy = BumpTransactionEvent_htlcresolution(claim_id_ref, target_feerate_sat_per_1000_weight, htlc_descriptors_constr, tx_lock_time);
66545 uint64_t ret_ref = tag_ptr(ret_copy, true);
66549 jboolean __attribute__((export_name("TS_BumpTransactionEvent_eq"))) TS_BumpTransactionEvent_eq(uint64_t a, uint64_t b) {
66550 LDKBumpTransactionEvent* a_conv = (LDKBumpTransactionEvent*)untag_ptr(a);
66551 LDKBumpTransactionEvent* b_conv = (LDKBumpTransactionEvent*)untag_ptr(b);
66552 jboolean ret_conv = BumpTransactionEvent_eq(a_conv, b_conv);
66556 void __attribute__((export_name("TS_Input_free"))) TS_Input_free(uint64_t this_obj) {
66557 LDKInput this_obj_conv;
66558 this_obj_conv.inner = untag_ptr(this_obj);
66559 this_obj_conv.is_owned = ptr_is_owned(this_obj);
66560 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
66561 Input_free(this_obj_conv);
66564 uint64_t __attribute__((export_name("TS_Input_get_outpoint"))) TS_Input_get_outpoint(uint64_t this_ptr) {
66565 LDKInput this_ptr_conv;
66566 this_ptr_conv.inner = untag_ptr(this_ptr);
66567 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66569 this_ptr_conv.is_owned = false;
66570 LDKOutPoint ret_var = Input_get_outpoint(&this_ptr_conv);
66571 uint64_t ret_ref = 0;
66572 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66573 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66577 void __attribute__((export_name("TS_Input_set_outpoint"))) TS_Input_set_outpoint(uint64_t this_ptr, uint64_t val) {
66578 LDKInput this_ptr_conv;
66579 this_ptr_conv.inner = untag_ptr(this_ptr);
66580 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66582 this_ptr_conv.is_owned = false;
66583 LDKOutPoint val_conv;
66584 val_conv.inner = untag_ptr(val);
66585 val_conv.is_owned = ptr_is_owned(val);
66586 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
66587 val_conv = OutPoint_clone(&val_conv);
66588 Input_set_outpoint(&this_ptr_conv, val_conv);
66591 uint64_t __attribute__((export_name("TS_Input_get_previous_utxo"))) TS_Input_get_previous_utxo(uint64_t this_ptr) {
66592 LDKInput this_ptr_conv;
66593 this_ptr_conv.inner = untag_ptr(this_ptr);
66594 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66596 this_ptr_conv.is_owned = false;
66597 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
66598 *ret_ref = Input_get_previous_utxo(&this_ptr_conv);
66599 return tag_ptr(ret_ref, true);
66602 void __attribute__((export_name("TS_Input_set_previous_utxo"))) TS_Input_set_previous_utxo(uint64_t this_ptr, uint64_t val) {
66603 LDKInput this_ptr_conv;
66604 this_ptr_conv.inner = untag_ptr(this_ptr);
66605 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66607 this_ptr_conv.is_owned = false;
66608 void* val_ptr = untag_ptr(val);
66609 CHECK_ACCESS(val_ptr);
66610 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
66611 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
66612 Input_set_previous_utxo(&this_ptr_conv, val_conv);
66615 int64_t __attribute__((export_name("TS_Input_get_satisfaction_weight"))) TS_Input_get_satisfaction_weight(uint64_t this_ptr) {
66616 LDKInput this_ptr_conv;
66617 this_ptr_conv.inner = untag_ptr(this_ptr);
66618 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66620 this_ptr_conv.is_owned = false;
66621 int64_t ret_conv = Input_get_satisfaction_weight(&this_ptr_conv);
66625 void __attribute__((export_name("TS_Input_set_satisfaction_weight"))) TS_Input_set_satisfaction_weight(uint64_t this_ptr, int64_t val) {
66626 LDKInput this_ptr_conv;
66627 this_ptr_conv.inner = untag_ptr(this_ptr);
66628 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66629 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66630 this_ptr_conv.is_owned = false;
66631 Input_set_satisfaction_weight(&this_ptr_conv, val);
66634 uint64_t __attribute__((export_name("TS_Input_new"))) TS_Input_new(uint64_t outpoint_arg, uint64_t previous_utxo_arg, int64_t satisfaction_weight_arg) {
66635 LDKOutPoint outpoint_arg_conv;
66636 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
66637 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
66638 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
66639 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
66640 void* previous_utxo_arg_ptr = untag_ptr(previous_utxo_arg);
66641 CHECK_ACCESS(previous_utxo_arg_ptr);
66642 LDKTxOut previous_utxo_arg_conv = *(LDKTxOut*)(previous_utxo_arg_ptr);
66643 previous_utxo_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(previous_utxo_arg));
66644 LDKInput ret_var = Input_new(outpoint_arg_conv, previous_utxo_arg_conv, satisfaction_weight_arg);
66645 uint64_t ret_ref = 0;
66646 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66647 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66651 static inline uint64_t Input_clone_ptr(LDKInput *NONNULL_PTR arg) {
66652 LDKInput ret_var = Input_clone(arg);
66653 uint64_t ret_ref = 0;
66654 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66655 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66658 int64_t __attribute__((export_name("TS_Input_clone_ptr"))) TS_Input_clone_ptr(uint64_t arg) {
66660 arg_conv.inner = untag_ptr(arg);
66661 arg_conv.is_owned = ptr_is_owned(arg);
66662 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
66663 arg_conv.is_owned = false;
66664 int64_t ret_conv = Input_clone_ptr(&arg_conv);
66668 uint64_t __attribute__((export_name("TS_Input_clone"))) TS_Input_clone(uint64_t orig) {
66669 LDKInput orig_conv;
66670 orig_conv.inner = untag_ptr(orig);
66671 orig_conv.is_owned = ptr_is_owned(orig);
66672 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
66673 orig_conv.is_owned = false;
66674 LDKInput ret_var = Input_clone(&orig_conv);
66675 uint64_t ret_ref = 0;
66676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66677 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66681 int64_t __attribute__((export_name("TS_Input_hash"))) TS_Input_hash(uint64_t o) {
66683 o_conv.inner = untag_ptr(o);
66684 o_conv.is_owned = ptr_is_owned(o);
66685 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
66686 o_conv.is_owned = false;
66687 int64_t ret_conv = Input_hash(&o_conv);
66691 jboolean __attribute__((export_name("TS_Input_eq"))) TS_Input_eq(uint64_t a, uint64_t b) {
66693 a_conv.inner = untag_ptr(a);
66694 a_conv.is_owned = ptr_is_owned(a);
66695 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
66696 a_conv.is_owned = false;
66698 b_conv.inner = untag_ptr(b);
66699 b_conv.is_owned = ptr_is_owned(b);
66700 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
66701 b_conv.is_owned = false;
66702 jboolean ret_conv = Input_eq(&a_conv, &b_conv);
66706 void __attribute__((export_name("TS_Utxo_free"))) TS_Utxo_free(uint64_t this_obj) {
66707 LDKUtxo this_obj_conv;
66708 this_obj_conv.inner = untag_ptr(this_obj);
66709 this_obj_conv.is_owned = ptr_is_owned(this_obj);
66710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
66711 Utxo_free(this_obj_conv);
66714 uint64_t __attribute__((export_name("TS_Utxo_get_outpoint"))) TS_Utxo_get_outpoint(uint64_t this_ptr) {
66715 LDKUtxo this_ptr_conv;
66716 this_ptr_conv.inner = untag_ptr(this_ptr);
66717 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66718 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66719 this_ptr_conv.is_owned = false;
66720 LDKOutPoint ret_var = Utxo_get_outpoint(&this_ptr_conv);
66721 uint64_t ret_ref = 0;
66722 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66723 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66727 void __attribute__((export_name("TS_Utxo_set_outpoint"))) TS_Utxo_set_outpoint(uint64_t this_ptr, uint64_t val) {
66728 LDKUtxo this_ptr_conv;
66729 this_ptr_conv.inner = untag_ptr(this_ptr);
66730 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66731 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66732 this_ptr_conv.is_owned = false;
66733 LDKOutPoint val_conv;
66734 val_conv.inner = untag_ptr(val);
66735 val_conv.is_owned = ptr_is_owned(val);
66736 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
66737 val_conv = OutPoint_clone(&val_conv);
66738 Utxo_set_outpoint(&this_ptr_conv, val_conv);
66741 uint64_t __attribute__((export_name("TS_Utxo_get_output"))) TS_Utxo_get_output(uint64_t this_ptr) {
66742 LDKUtxo this_ptr_conv;
66743 this_ptr_conv.inner = untag_ptr(this_ptr);
66744 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66746 this_ptr_conv.is_owned = false;
66747 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
66748 *ret_ref = Utxo_get_output(&this_ptr_conv);
66749 return tag_ptr(ret_ref, true);
66752 void __attribute__((export_name("TS_Utxo_set_output"))) TS_Utxo_set_output(uint64_t this_ptr, uint64_t val) {
66753 LDKUtxo this_ptr_conv;
66754 this_ptr_conv.inner = untag_ptr(this_ptr);
66755 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66756 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66757 this_ptr_conv.is_owned = false;
66758 void* val_ptr = untag_ptr(val);
66759 CHECK_ACCESS(val_ptr);
66760 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
66761 val_conv = TxOut_clone((LDKTxOut*)untag_ptr(val));
66762 Utxo_set_output(&this_ptr_conv, val_conv);
66765 int64_t __attribute__((export_name("TS_Utxo_get_satisfaction_weight"))) TS_Utxo_get_satisfaction_weight(uint64_t this_ptr) {
66766 LDKUtxo this_ptr_conv;
66767 this_ptr_conv.inner = untag_ptr(this_ptr);
66768 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66769 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66770 this_ptr_conv.is_owned = false;
66771 int64_t ret_conv = Utxo_get_satisfaction_weight(&this_ptr_conv);
66775 void __attribute__((export_name("TS_Utxo_set_satisfaction_weight"))) TS_Utxo_set_satisfaction_weight(uint64_t this_ptr, int64_t val) {
66776 LDKUtxo this_ptr_conv;
66777 this_ptr_conv.inner = untag_ptr(this_ptr);
66778 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66780 this_ptr_conv.is_owned = false;
66781 Utxo_set_satisfaction_weight(&this_ptr_conv, val);
66784 uint64_t __attribute__((export_name("TS_Utxo_new"))) TS_Utxo_new(uint64_t outpoint_arg, uint64_t output_arg, int64_t satisfaction_weight_arg) {
66785 LDKOutPoint outpoint_arg_conv;
66786 outpoint_arg_conv.inner = untag_ptr(outpoint_arg);
66787 outpoint_arg_conv.is_owned = ptr_is_owned(outpoint_arg);
66788 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
66789 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
66790 void* output_arg_ptr = untag_ptr(output_arg);
66791 CHECK_ACCESS(output_arg_ptr);
66792 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
66793 output_arg_conv = TxOut_clone((LDKTxOut*)untag_ptr(output_arg));
66794 LDKUtxo ret_var = Utxo_new(outpoint_arg_conv, output_arg_conv, satisfaction_weight_arg);
66795 uint64_t ret_ref = 0;
66796 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66797 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66801 static inline uint64_t Utxo_clone_ptr(LDKUtxo *NONNULL_PTR arg) {
66802 LDKUtxo ret_var = Utxo_clone(arg);
66803 uint64_t ret_ref = 0;
66804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66805 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66808 int64_t __attribute__((export_name("TS_Utxo_clone_ptr"))) TS_Utxo_clone_ptr(uint64_t arg) {
66810 arg_conv.inner = untag_ptr(arg);
66811 arg_conv.is_owned = ptr_is_owned(arg);
66812 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
66813 arg_conv.is_owned = false;
66814 int64_t ret_conv = Utxo_clone_ptr(&arg_conv);
66818 uint64_t __attribute__((export_name("TS_Utxo_clone"))) TS_Utxo_clone(uint64_t orig) {
66820 orig_conv.inner = untag_ptr(orig);
66821 orig_conv.is_owned = ptr_is_owned(orig);
66822 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
66823 orig_conv.is_owned = false;
66824 LDKUtxo ret_var = Utxo_clone(&orig_conv);
66825 uint64_t ret_ref = 0;
66826 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66827 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66831 int64_t __attribute__((export_name("TS_Utxo_hash"))) TS_Utxo_hash(uint64_t o) {
66833 o_conv.inner = untag_ptr(o);
66834 o_conv.is_owned = ptr_is_owned(o);
66835 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
66836 o_conv.is_owned = false;
66837 int64_t ret_conv = Utxo_hash(&o_conv);
66841 jboolean __attribute__((export_name("TS_Utxo_eq"))) TS_Utxo_eq(uint64_t a, uint64_t b) {
66843 a_conv.inner = untag_ptr(a);
66844 a_conv.is_owned = ptr_is_owned(a);
66845 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
66846 a_conv.is_owned = false;
66848 b_conv.inner = untag_ptr(b);
66849 b_conv.is_owned = ptr_is_owned(b);
66850 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
66851 b_conv.is_owned = false;
66852 jboolean ret_conv = Utxo_eq(&a_conv, &b_conv);
66856 uint64_t __attribute__((export_name("TS_Utxo_new_p2pkh"))) TS_Utxo_new_p2pkh(uint64_t outpoint, int64_t value, int8_tArray pubkey_hash) {
66857 LDKOutPoint outpoint_conv;
66858 outpoint_conv.inner = untag_ptr(outpoint);
66859 outpoint_conv.is_owned = ptr_is_owned(outpoint);
66860 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
66861 outpoint_conv = OutPoint_clone(&outpoint_conv);
66862 uint8_t pubkey_hash_arr[20];
66863 CHECK(pubkey_hash->arr_len == 20);
66864 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
66865 uint8_t (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
66866 LDKUtxo ret_var = Utxo_new_p2pkh(outpoint_conv, value, pubkey_hash_ref);
66867 uint64_t ret_ref = 0;
66868 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66869 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66873 void __attribute__((export_name("TS_CoinSelection_free"))) TS_CoinSelection_free(uint64_t this_obj) {
66874 LDKCoinSelection this_obj_conv;
66875 this_obj_conv.inner = untag_ptr(this_obj);
66876 this_obj_conv.is_owned = ptr_is_owned(this_obj);
66877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
66878 CoinSelection_free(this_obj_conv);
66881 uint64_tArray __attribute__((export_name("TS_CoinSelection_get_confirmed_utxos"))) TS_CoinSelection_get_confirmed_utxos(uint64_t this_ptr) {
66882 LDKCoinSelection this_ptr_conv;
66883 this_ptr_conv.inner = untag_ptr(this_ptr);
66884 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66886 this_ptr_conv.is_owned = false;
66887 LDKCVec_UtxoZ ret_var = CoinSelection_get_confirmed_utxos(&this_ptr_conv);
66888 uint64_tArray ret_arr = NULL;
66889 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
66890 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
66891 for (size_t g = 0; g < ret_var.datalen; g++) {
66892 LDKUtxo ret_conv_6_var = ret_var.data[g];
66893 uint64_t ret_conv_6_ref = 0;
66894 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_6_var);
66895 ret_conv_6_ref = tag_ptr(ret_conv_6_var.inner, ret_conv_6_var.is_owned);
66896 ret_arr_ptr[g] = ret_conv_6_ref;
66899 FREE(ret_var.data);
66903 void __attribute__((export_name("TS_CoinSelection_set_confirmed_utxos"))) TS_CoinSelection_set_confirmed_utxos(uint64_t this_ptr, uint64_tArray val) {
66904 LDKCoinSelection this_ptr_conv;
66905 this_ptr_conv.inner = untag_ptr(this_ptr);
66906 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66908 this_ptr_conv.is_owned = false;
66909 LDKCVec_UtxoZ val_constr;
66910 val_constr.datalen = val->arr_len;
66911 if (val_constr.datalen > 0)
66912 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUtxo), "LDKCVec_UtxoZ Elements");
66914 val_constr.data = NULL;
66915 uint64_t* val_vals = val->elems;
66916 for (size_t g = 0; g < val_constr.datalen; g++) {
66917 uint64_t val_conv_6 = val_vals[g];
66918 LDKUtxo val_conv_6_conv;
66919 val_conv_6_conv.inner = untag_ptr(val_conv_6);
66920 val_conv_6_conv.is_owned = ptr_is_owned(val_conv_6);
66921 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_6_conv);
66922 val_conv_6_conv = Utxo_clone(&val_conv_6_conv);
66923 val_constr.data[g] = val_conv_6_conv;
66926 CoinSelection_set_confirmed_utxos(&this_ptr_conv, val_constr);
66929 uint64_t __attribute__((export_name("TS_CoinSelection_get_change_output"))) TS_CoinSelection_get_change_output(uint64_t this_ptr) {
66930 LDKCoinSelection this_ptr_conv;
66931 this_ptr_conv.inner = untag_ptr(this_ptr);
66932 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66933 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66934 this_ptr_conv.is_owned = false;
66935 LDKCOption_TxOutZ *ret_copy = MALLOC(sizeof(LDKCOption_TxOutZ), "LDKCOption_TxOutZ");
66936 *ret_copy = CoinSelection_get_change_output(&this_ptr_conv);
66937 uint64_t ret_ref = tag_ptr(ret_copy, true);
66941 void __attribute__((export_name("TS_CoinSelection_set_change_output"))) TS_CoinSelection_set_change_output(uint64_t this_ptr, uint64_t val) {
66942 LDKCoinSelection this_ptr_conv;
66943 this_ptr_conv.inner = untag_ptr(this_ptr);
66944 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
66945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
66946 this_ptr_conv.is_owned = false;
66947 void* val_ptr = untag_ptr(val);
66948 CHECK_ACCESS(val_ptr);
66949 LDKCOption_TxOutZ val_conv = *(LDKCOption_TxOutZ*)(val_ptr);
66950 val_conv = COption_TxOutZ_clone((LDKCOption_TxOutZ*)untag_ptr(val));
66951 CoinSelection_set_change_output(&this_ptr_conv, val_conv);
66954 uint64_t __attribute__((export_name("TS_CoinSelection_new"))) TS_CoinSelection_new(uint64_tArray confirmed_utxos_arg, uint64_t change_output_arg) {
66955 LDKCVec_UtxoZ confirmed_utxos_arg_constr;
66956 confirmed_utxos_arg_constr.datalen = confirmed_utxos_arg->arr_len;
66957 if (confirmed_utxos_arg_constr.datalen > 0)
66958 confirmed_utxos_arg_constr.data = MALLOC(confirmed_utxos_arg_constr.datalen * sizeof(LDKUtxo), "LDKCVec_UtxoZ Elements");
66960 confirmed_utxos_arg_constr.data = NULL;
66961 uint64_t* confirmed_utxos_arg_vals = confirmed_utxos_arg->elems;
66962 for (size_t g = 0; g < confirmed_utxos_arg_constr.datalen; g++) {
66963 uint64_t confirmed_utxos_arg_conv_6 = confirmed_utxos_arg_vals[g];
66964 LDKUtxo confirmed_utxos_arg_conv_6_conv;
66965 confirmed_utxos_arg_conv_6_conv.inner = untag_ptr(confirmed_utxos_arg_conv_6);
66966 confirmed_utxos_arg_conv_6_conv.is_owned = ptr_is_owned(confirmed_utxos_arg_conv_6);
66967 CHECK_INNER_FIELD_ACCESS_OR_NULL(confirmed_utxos_arg_conv_6_conv);
66968 confirmed_utxos_arg_conv_6_conv = Utxo_clone(&confirmed_utxos_arg_conv_6_conv);
66969 confirmed_utxos_arg_constr.data[g] = confirmed_utxos_arg_conv_6_conv;
66971 FREE(confirmed_utxos_arg);
66972 void* change_output_arg_ptr = untag_ptr(change_output_arg);
66973 CHECK_ACCESS(change_output_arg_ptr);
66974 LDKCOption_TxOutZ change_output_arg_conv = *(LDKCOption_TxOutZ*)(change_output_arg_ptr);
66975 change_output_arg_conv = COption_TxOutZ_clone((LDKCOption_TxOutZ*)untag_ptr(change_output_arg));
66976 LDKCoinSelection ret_var = CoinSelection_new(confirmed_utxos_arg_constr, change_output_arg_conv);
66977 uint64_t ret_ref = 0;
66978 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66979 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66983 static inline uint64_t CoinSelection_clone_ptr(LDKCoinSelection *NONNULL_PTR arg) {
66984 LDKCoinSelection ret_var = CoinSelection_clone(arg);
66985 uint64_t ret_ref = 0;
66986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
66987 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
66990 int64_t __attribute__((export_name("TS_CoinSelection_clone_ptr"))) TS_CoinSelection_clone_ptr(uint64_t arg) {
66991 LDKCoinSelection arg_conv;
66992 arg_conv.inner = untag_ptr(arg);
66993 arg_conv.is_owned = ptr_is_owned(arg);
66994 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
66995 arg_conv.is_owned = false;
66996 int64_t ret_conv = CoinSelection_clone_ptr(&arg_conv);
67000 uint64_t __attribute__((export_name("TS_CoinSelection_clone"))) TS_CoinSelection_clone(uint64_t orig) {
67001 LDKCoinSelection orig_conv;
67002 orig_conv.inner = untag_ptr(orig);
67003 orig_conv.is_owned = ptr_is_owned(orig);
67004 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67005 orig_conv.is_owned = false;
67006 LDKCoinSelection ret_var = CoinSelection_clone(&orig_conv);
67007 uint64_t ret_ref = 0;
67008 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67009 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67013 void __attribute__((export_name("TS_CoinSelectionSource_free"))) TS_CoinSelectionSource_free(uint64_t this_ptr) {
67014 if (!ptr_is_owned(this_ptr)) return;
67015 void* this_ptr_ptr = untag_ptr(this_ptr);
67016 CHECK_ACCESS(this_ptr_ptr);
67017 LDKCoinSelectionSource this_ptr_conv = *(LDKCoinSelectionSource*)(this_ptr_ptr);
67018 FREE(untag_ptr(this_ptr));
67019 CoinSelectionSource_free(this_ptr_conv);
67022 void __attribute__((export_name("TS_WalletSource_free"))) TS_WalletSource_free(uint64_t this_ptr) {
67023 if (!ptr_is_owned(this_ptr)) return;
67024 void* this_ptr_ptr = untag_ptr(this_ptr);
67025 CHECK_ACCESS(this_ptr_ptr);
67026 LDKWalletSource this_ptr_conv = *(LDKWalletSource*)(this_ptr_ptr);
67027 FREE(untag_ptr(this_ptr));
67028 WalletSource_free(this_ptr_conv);
67031 void __attribute__((export_name("TS_Wallet_free"))) TS_Wallet_free(uint64_t this_obj) {
67032 LDKWallet this_obj_conv;
67033 this_obj_conv.inner = untag_ptr(this_obj);
67034 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67035 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67036 Wallet_free(this_obj_conv);
67039 uint64_t __attribute__((export_name("TS_Wallet_new"))) TS_Wallet_new(uint64_t source, uint64_t logger) {
67040 void* source_ptr = untag_ptr(source);
67041 CHECK_ACCESS(source_ptr);
67042 LDKWalletSource source_conv = *(LDKWalletSource*)(source_ptr);
67043 if (source_conv.free == LDKWalletSource_JCalls_free) {
67044 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67045 LDKWalletSource_JCalls_cloned(&source_conv);
67047 void* logger_ptr = untag_ptr(logger);
67048 CHECK_ACCESS(logger_ptr);
67049 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
67050 if (logger_conv.free == LDKLogger_JCalls_free) {
67051 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67052 LDKLogger_JCalls_cloned(&logger_conv);
67054 LDKWallet ret_var = Wallet_new(source_conv, logger_conv);
67055 uint64_t ret_ref = 0;
67056 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67057 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67061 uint64_t __attribute__((export_name("TS_Wallet_as_CoinSelectionSource"))) TS_Wallet_as_CoinSelectionSource(uint64_t this_arg) {
67062 LDKWallet this_arg_conv;
67063 this_arg_conv.inner = untag_ptr(this_arg);
67064 this_arg_conv.is_owned = ptr_is_owned(this_arg);
67065 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
67066 this_arg_conv.is_owned = false;
67067 LDKCoinSelectionSource* ret_ret = MALLOC(sizeof(LDKCoinSelectionSource), "LDKCoinSelectionSource");
67068 *ret_ret = Wallet_as_CoinSelectionSource(&this_arg_conv);
67069 return tag_ptr(ret_ret, true);
67072 void __attribute__((export_name("TS_BumpTransactionEventHandler_free"))) TS_BumpTransactionEventHandler_free(uint64_t this_obj) {
67073 LDKBumpTransactionEventHandler this_obj_conv;
67074 this_obj_conv.inner = untag_ptr(this_obj);
67075 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67077 BumpTransactionEventHandler_free(this_obj_conv);
67080 uint64_t __attribute__((export_name("TS_BumpTransactionEventHandler_new"))) TS_BumpTransactionEventHandler_new(uint64_t broadcaster, uint64_t utxo_source, uint64_t signer_provider, uint64_t logger) {
67081 void* broadcaster_ptr = untag_ptr(broadcaster);
67082 CHECK_ACCESS(broadcaster_ptr);
67083 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
67084 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
67085 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67086 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
67088 void* utxo_source_ptr = untag_ptr(utxo_source);
67089 CHECK_ACCESS(utxo_source_ptr);
67090 LDKCoinSelectionSource utxo_source_conv = *(LDKCoinSelectionSource*)(utxo_source_ptr);
67091 if (utxo_source_conv.free == LDKCoinSelectionSource_JCalls_free) {
67092 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67093 LDKCoinSelectionSource_JCalls_cloned(&utxo_source_conv);
67095 void* signer_provider_ptr = untag_ptr(signer_provider);
67096 CHECK_ACCESS(signer_provider_ptr);
67097 LDKSignerProvider signer_provider_conv = *(LDKSignerProvider*)(signer_provider_ptr);
67098 if (signer_provider_conv.free == LDKSignerProvider_JCalls_free) {
67099 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67100 LDKSignerProvider_JCalls_cloned(&signer_provider_conv);
67102 void* logger_ptr = untag_ptr(logger);
67103 CHECK_ACCESS(logger_ptr);
67104 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
67105 if (logger_conv.free == LDKLogger_JCalls_free) {
67106 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67107 LDKLogger_JCalls_cloned(&logger_conv);
67109 LDKBumpTransactionEventHandler ret_var = BumpTransactionEventHandler_new(broadcaster_conv, utxo_source_conv, signer_provider_conv, logger_conv);
67110 uint64_t ret_ref = 0;
67111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67112 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67116 void __attribute__((export_name("TS_BumpTransactionEventHandler_handle_event"))) TS_BumpTransactionEventHandler_handle_event(uint64_t this_arg, uint64_t event) {
67117 LDKBumpTransactionEventHandler this_arg_conv;
67118 this_arg_conv.inner = untag_ptr(this_arg);
67119 this_arg_conv.is_owned = ptr_is_owned(this_arg);
67120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
67121 this_arg_conv.is_owned = false;
67122 LDKBumpTransactionEvent* event_conv = (LDKBumpTransactionEvent*)untag_ptr(event);
67123 BumpTransactionEventHandler_handle_event(&this_arg_conv, event_conv);
67126 void __attribute__((export_name("TS_GossipSync_free"))) TS_GossipSync_free(uint64_t this_ptr) {
67127 if (!ptr_is_owned(this_ptr)) return;
67128 void* this_ptr_ptr = untag_ptr(this_ptr);
67129 CHECK_ACCESS(this_ptr_ptr);
67130 LDKGossipSync this_ptr_conv = *(LDKGossipSync*)(this_ptr_ptr);
67131 FREE(untag_ptr(this_ptr));
67132 GossipSync_free(this_ptr_conv);
67135 uint64_t __attribute__((export_name("TS_GossipSync_p2_p"))) TS_GossipSync_p2_p(uint64_t a) {
67136 LDKP2PGossipSync a_conv;
67137 a_conv.inner = untag_ptr(a);
67138 a_conv.is_owned = ptr_is_owned(a);
67139 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67140 a_conv.is_owned = false;
67141 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
67142 *ret_copy = GossipSync_p2_p(&a_conv);
67143 uint64_t ret_ref = tag_ptr(ret_copy, true);
67147 uint64_t __attribute__((export_name("TS_GossipSync_rapid"))) TS_GossipSync_rapid(uint64_t a) {
67148 LDKRapidGossipSync a_conv;
67149 a_conv.inner = untag_ptr(a);
67150 a_conv.is_owned = ptr_is_owned(a);
67151 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67152 a_conv.is_owned = false;
67153 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
67154 *ret_copy = GossipSync_rapid(&a_conv);
67155 uint64_t ret_ref = tag_ptr(ret_copy, true);
67159 uint64_t __attribute__((export_name("TS_GossipSync_none"))) TS_GossipSync_none() {
67160 LDKGossipSync *ret_copy = MALLOC(sizeof(LDKGossipSync), "LDKGossipSync");
67161 *ret_copy = GossipSync_none();
67162 uint64_t ret_ref = tag_ptr(ret_copy, true);
67166 void __attribute__((export_name("TS_RapidGossipSync_free"))) TS_RapidGossipSync_free(uint64_t this_obj) {
67167 LDKRapidGossipSync this_obj_conv;
67168 this_obj_conv.inner = untag_ptr(this_obj);
67169 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67170 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67171 RapidGossipSync_free(this_obj_conv);
67174 uint64_t __attribute__((export_name("TS_RapidGossipSync_new"))) TS_RapidGossipSync_new(uint64_t network_graph, uint64_t logger) {
67175 LDKNetworkGraph network_graph_conv;
67176 network_graph_conv.inner = untag_ptr(network_graph);
67177 network_graph_conv.is_owned = ptr_is_owned(network_graph);
67178 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
67179 network_graph_conv.is_owned = false;
67180 void* logger_ptr = untag_ptr(logger);
67181 CHECK_ACCESS(logger_ptr);
67182 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
67183 if (logger_conv.free == LDKLogger_JCalls_free) {
67184 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
67185 LDKLogger_JCalls_cloned(&logger_conv);
67187 LDKRapidGossipSync ret_var = RapidGossipSync_new(&network_graph_conv, logger_conv);
67188 uint64_t ret_ref = 0;
67189 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67190 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67194 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) {
67195 LDKRapidGossipSync this_arg_conv;
67196 this_arg_conv.inner = untag_ptr(this_arg);
67197 this_arg_conv.is_owned = ptr_is_owned(this_arg);
67198 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
67199 this_arg_conv.is_owned = false;
67200 LDKu8slice update_data_ref;
67201 update_data_ref.datalen = update_data->arr_len;
67202 update_data_ref.data = update_data->elems;
67203 void* current_time_unix_ptr = untag_ptr(current_time_unix);
67204 CHECK_ACCESS(current_time_unix_ptr);
67205 LDKCOption_u64Z current_time_unix_conv = *(LDKCOption_u64Z*)(current_time_unix_ptr);
67206 current_time_unix_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(current_time_unix));
67207 LDKCResult_u32GraphSyncErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_u32GraphSyncErrorZ), "LDKCResult_u32GraphSyncErrorZ");
67208 *ret_conv = RapidGossipSync_update_network_graph_no_std(&this_arg_conv, update_data_ref, current_time_unix_conv);
67210 return tag_ptr(ret_conv, true);
67213 jboolean __attribute__((export_name("TS_RapidGossipSync_is_initial_sync_complete"))) TS_RapidGossipSync_is_initial_sync_complete(uint64_t this_arg) {
67214 LDKRapidGossipSync this_arg_conv;
67215 this_arg_conv.inner = untag_ptr(this_arg);
67216 this_arg_conv.is_owned = ptr_is_owned(this_arg);
67217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
67218 this_arg_conv.is_owned = false;
67219 jboolean ret_conv = RapidGossipSync_is_initial_sync_complete(&this_arg_conv);
67223 void __attribute__((export_name("TS_GraphSyncError_free"))) TS_GraphSyncError_free(uint64_t this_ptr) {
67224 if (!ptr_is_owned(this_ptr)) return;
67225 void* this_ptr_ptr = untag_ptr(this_ptr);
67226 CHECK_ACCESS(this_ptr_ptr);
67227 LDKGraphSyncError this_ptr_conv = *(LDKGraphSyncError*)(this_ptr_ptr);
67228 FREE(untag_ptr(this_ptr));
67229 GraphSyncError_free(this_ptr_conv);
67232 static inline uint64_t GraphSyncError_clone_ptr(LDKGraphSyncError *NONNULL_PTR arg) {
67233 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
67234 *ret_copy = GraphSyncError_clone(arg);
67235 uint64_t ret_ref = tag_ptr(ret_copy, true);
67238 int64_t __attribute__((export_name("TS_GraphSyncError_clone_ptr"))) TS_GraphSyncError_clone_ptr(uint64_t arg) {
67239 LDKGraphSyncError* arg_conv = (LDKGraphSyncError*)untag_ptr(arg);
67240 int64_t ret_conv = GraphSyncError_clone_ptr(arg_conv);
67244 uint64_t __attribute__((export_name("TS_GraphSyncError_clone"))) TS_GraphSyncError_clone(uint64_t orig) {
67245 LDKGraphSyncError* orig_conv = (LDKGraphSyncError*)untag_ptr(orig);
67246 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
67247 *ret_copy = GraphSyncError_clone(orig_conv);
67248 uint64_t ret_ref = tag_ptr(ret_copy, true);
67252 uint64_t __attribute__((export_name("TS_GraphSyncError_decode_error"))) TS_GraphSyncError_decode_error(uint64_t a) {
67253 void* a_ptr = untag_ptr(a);
67254 CHECK_ACCESS(a_ptr);
67255 LDKDecodeError a_conv = *(LDKDecodeError*)(a_ptr);
67256 a_conv = DecodeError_clone((LDKDecodeError*)untag_ptr(a));
67257 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
67258 *ret_copy = GraphSyncError_decode_error(a_conv);
67259 uint64_t ret_ref = tag_ptr(ret_copy, true);
67263 uint64_t __attribute__((export_name("TS_GraphSyncError_lightning_error"))) TS_GraphSyncError_lightning_error(uint64_t a) {
67264 LDKLightningError a_conv;
67265 a_conv.inner = untag_ptr(a);
67266 a_conv.is_owned = ptr_is_owned(a);
67267 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67268 a_conv = LightningError_clone(&a_conv);
67269 LDKGraphSyncError *ret_copy = MALLOC(sizeof(LDKGraphSyncError), "LDKGraphSyncError");
67270 *ret_copy = GraphSyncError_lightning_error(a_conv);
67271 uint64_t ret_ref = tag_ptr(ret_copy, true);
67275 void __attribute__((export_name("TS_Bolt11ParseError_free"))) TS_Bolt11ParseError_free(uint64_t this_ptr) {
67276 if (!ptr_is_owned(this_ptr)) return;
67277 void* this_ptr_ptr = untag_ptr(this_ptr);
67278 CHECK_ACCESS(this_ptr_ptr);
67279 LDKBolt11ParseError this_ptr_conv = *(LDKBolt11ParseError*)(this_ptr_ptr);
67280 FREE(untag_ptr(this_ptr));
67281 Bolt11ParseError_free(this_ptr_conv);
67284 static inline uint64_t Bolt11ParseError_clone_ptr(LDKBolt11ParseError *NONNULL_PTR arg) {
67285 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67286 *ret_copy = Bolt11ParseError_clone(arg);
67287 uint64_t ret_ref = tag_ptr(ret_copy, true);
67290 int64_t __attribute__((export_name("TS_Bolt11ParseError_clone_ptr"))) TS_Bolt11ParseError_clone_ptr(uint64_t arg) {
67291 LDKBolt11ParseError* arg_conv = (LDKBolt11ParseError*)untag_ptr(arg);
67292 int64_t ret_conv = Bolt11ParseError_clone_ptr(arg_conv);
67296 uint64_t __attribute__((export_name("TS_Bolt11ParseError_clone"))) TS_Bolt11ParseError_clone(uint64_t orig) {
67297 LDKBolt11ParseError* orig_conv = (LDKBolt11ParseError*)untag_ptr(orig);
67298 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67299 *ret_copy = Bolt11ParseError_clone(orig_conv);
67300 uint64_t ret_ref = tag_ptr(ret_copy, true);
67304 uint64_t __attribute__((export_name("TS_Bolt11ParseError_bech32_error"))) TS_Bolt11ParseError_bech32_error(uint64_t a) {
67305 void* a_ptr = untag_ptr(a);
67306 CHECK_ACCESS(a_ptr);
67307 LDKBech32Error a_conv = *(LDKBech32Error*)(a_ptr);
67308 a_conv = Bech32Error_clone((LDKBech32Error*)untag_ptr(a));
67309 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67310 *ret_copy = Bolt11ParseError_bech32_error(a_conv);
67311 uint64_t ret_ref = tag_ptr(ret_copy, true);
67315 uint64_t __attribute__((export_name("TS_Bolt11ParseError_parse_amount_error"))) TS_Bolt11ParseError_parse_amount_error(int32_t a) {
67317 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67318 *ret_copy = Bolt11ParseError_parse_amount_error((LDKError){ ._dummy = 0 });
67319 uint64_t ret_ref = tag_ptr(ret_copy, true);
67323 uint64_t __attribute__((export_name("TS_Bolt11ParseError_malformed_signature"))) TS_Bolt11ParseError_malformed_signature(uint32_t a) {
67324 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
67325 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67326 *ret_copy = Bolt11ParseError_malformed_signature(a_conv);
67327 uint64_t ret_ref = tag_ptr(ret_copy, true);
67331 uint64_t __attribute__((export_name("TS_Bolt11ParseError_bad_prefix"))) TS_Bolt11ParseError_bad_prefix() {
67332 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67333 *ret_copy = Bolt11ParseError_bad_prefix();
67334 uint64_t ret_ref = tag_ptr(ret_copy, true);
67338 uint64_t __attribute__((export_name("TS_Bolt11ParseError_unknown_currency"))) TS_Bolt11ParseError_unknown_currency() {
67339 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67340 *ret_copy = Bolt11ParseError_unknown_currency();
67341 uint64_t ret_ref = tag_ptr(ret_copy, true);
67345 uint64_t __attribute__((export_name("TS_Bolt11ParseError_unknown_si_prefix"))) TS_Bolt11ParseError_unknown_si_prefix() {
67346 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67347 *ret_copy = Bolt11ParseError_unknown_si_prefix();
67348 uint64_t ret_ref = tag_ptr(ret_copy, true);
67352 uint64_t __attribute__((export_name("TS_Bolt11ParseError_malformed_hrp"))) TS_Bolt11ParseError_malformed_hrp() {
67353 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67354 *ret_copy = Bolt11ParseError_malformed_hrp();
67355 uint64_t ret_ref = tag_ptr(ret_copy, true);
67359 uint64_t __attribute__((export_name("TS_Bolt11ParseError_too_short_data_part"))) TS_Bolt11ParseError_too_short_data_part() {
67360 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67361 *ret_copy = Bolt11ParseError_too_short_data_part();
67362 uint64_t ret_ref = tag_ptr(ret_copy, true);
67366 uint64_t __attribute__((export_name("TS_Bolt11ParseError_unexpected_end_of_tagged_fields"))) TS_Bolt11ParseError_unexpected_end_of_tagged_fields() {
67367 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67368 *ret_copy = Bolt11ParseError_unexpected_end_of_tagged_fields();
67369 uint64_t ret_ref = tag_ptr(ret_copy, true);
67373 uint64_t __attribute__((export_name("TS_Bolt11ParseError_description_decode_error"))) TS_Bolt11ParseError_description_decode_error(int32_t a) {
67375 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67376 *ret_copy = Bolt11ParseError_description_decode_error((LDKError){ ._dummy = 0 });
67377 uint64_t ret_ref = tag_ptr(ret_copy, true);
67381 uint64_t __attribute__((export_name("TS_Bolt11ParseError_padding_error"))) TS_Bolt11ParseError_padding_error() {
67382 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67383 *ret_copy = Bolt11ParseError_padding_error();
67384 uint64_t ret_ref = tag_ptr(ret_copy, true);
67388 uint64_t __attribute__((export_name("TS_Bolt11ParseError_integer_overflow_error"))) TS_Bolt11ParseError_integer_overflow_error() {
67389 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67390 *ret_copy = Bolt11ParseError_integer_overflow_error();
67391 uint64_t ret_ref = tag_ptr(ret_copy, true);
67395 uint64_t __attribute__((export_name("TS_Bolt11ParseError_invalid_seg_wit_program_length"))) TS_Bolt11ParseError_invalid_seg_wit_program_length() {
67396 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67397 *ret_copy = Bolt11ParseError_invalid_seg_wit_program_length();
67398 uint64_t ret_ref = tag_ptr(ret_copy, true);
67402 uint64_t __attribute__((export_name("TS_Bolt11ParseError_invalid_pub_key_hash_length"))) TS_Bolt11ParseError_invalid_pub_key_hash_length() {
67403 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67404 *ret_copy = Bolt11ParseError_invalid_pub_key_hash_length();
67405 uint64_t ret_ref = tag_ptr(ret_copy, true);
67409 uint64_t __attribute__((export_name("TS_Bolt11ParseError_invalid_script_hash_length"))) TS_Bolt11ParseError_invalid_script_hash_length() {
67410 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67411 *ret_copy = Bolt11ParseError_invalid_script_hash_length();
67412 uint64_t ret_ref = tag_ptr(ret_copy, true);
67416 uint64_t __attribute__((export_name("TS_Bolt11ParseError_invalid_recovery_id"))) TS_Bolt11ParseError_invalid_recovery_id() {
67417 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67418 *ret_copy = Bolt11ParseError_invalid_recovery_id();
67419 uint64_t ret_ref = tag_ptr(ret_copy, true);
67423 uint64_t __attribute__((export_name("TS_Bolt11ParseError_invalid_slice_length"))) TS_Bolt11ParseError_invalid_slice_length(jstring a) {
67424 LDKStr a_conv = str_ref_to_owned_c(a);
67425 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67426 *ret_copy = Bolt11ParseError_invalid_slice_length(a_conv);
67427 uint64_t ret_ref = tag_ptr(ret_copy, true);
67431 uint64_t __attribute__((export_name("TS_Bolt11ParseError_skip"))) TS_Bolt11ParseError_skip() {
67432 LDKBolt11ParseError *ret_copy = MALLOC(sizeof(LDKBolt11ParseError), "LDKBolt11ParseError");
67433 *ret_copy = Bolt11ParseError_skip();
67434 uint64_t ret_ref = tag_ptr(ret_copy, true);
67438 jboolean __attribute__((export_name("TS_Bolt11ParseError_eq"))) TS_Bolt11ParseError_eq(uint64_t a, uint64_t b) {
67439 LDKBolt11ParseError* a_conv = (LDKBolt11ParseError*)untag_ptr(a);
67440 LDKBolt11ParseError* b_conv = (LDKBolt11ParseError*)untag_ptr(b);
67441 jboolean ret_conv = Bolt11ParseError_eq(a_conv, b_conv);
67445 void __attribute__((export_name("TS_ParseOrSemanticError_free"))) TS_ParseOrSemanticError_free(uint64_t this_ptr) {
67446 if (!ptr_is_owned(this_ptr)) return;
67447 void* this_ptr_ptr = untag_ptr(this_ptr);
67448 CHECK_ACCESS(this_ptr_ptr);
67449 LDKParseOrSemanticError this_ptr_conv = *(LDKParseOrSemanticError*)(this_ptr_ptr);
67450 FREE(untag_ptr(this_ptr));
67451 ParseOrSemanticError_free(this_ptr_conv);
67454 static inline uint64_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg) {
67455 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
67456 *ret_copy = ParseOrSemanticError_clone(arg);
67457 uint64_t ret_ref = tag_ptr(ret_copy, true);
67460 int64_t __attribute__((export_name("TS_ParseOrSemanticError_clone_ptr"))) TS_ParseOrSemanticError_clone_ptr(uint64_t arg) {
67461 LDKParseOrSemanticError* arg_conv = (LDKParseOrSemanticError*)untag_ptr(arg);
67462 int64_t ret_conv = ParseOrSemanticError_clone_ptr(arg_conv);
67466 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_clone"))) TS_ParseOrSemanticError_clone(uint64_t orig) {
67467 LDKParseOrSemanticError* orig_conv = (LDKParseOrSemanticError*)untag_ptr(orig);
67468 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
67469 *ret_copy = ParseOrSemanticError_clone(orig_conv);
67470 uint64_t ret_ref = tag_ptr(ret_copy, true);
67474 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_parse_error"))) TS_ParseOrSemanticError_parse_error(uint64_t a) {
67475 void* a_ptr = untag_ptr(a);
67476 CHECK_ACCESS(a_ptr);
67477 LDKBolt11ParseError a_conv = *(LDKBolt11ParseError*)(a_ptr);
67478 a_conv = Bolt11ParseError_clone((LDKBolt11ParseError*)untag_ptr(a));
67479 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
67480 *ret_copy = ParseOrSemanticError_parse_error(a_conv);
67481 uint64_t ret_ref = tag_ptr(ret_copy, true);
67485 uint64_t __attribute__((export_name("TS_ParseOrSemanticError_semantic_error"))) TS_ParseOrSemanticError_semantic_error(uint32_t a) {
67486 LDKBolt11SemanticError a_conv = LDKBolt11SemanticError_from_js(a);
67487 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
67488 *ret_copy = ParseOrSemanticError_semantic_error(a_conv);
67489 uint64_t ret_ref = tag_ptr(ret_copy, true);
67493 jboolean __attribute__((export_name("TS_ParseOrSemanticError_eq"))) TS_ParseOrSemanticError_eq(uint64_t a, uint64_t b) {
67494 LDKParseOrSemanticError* a_conv = (LDKParseOrSemanticError*)untag_ptr(a);
67495 LDKParseOrSemanticError* b_conv = (LDKParseOrSemanticError*)untag_ptr(b);
67496 jboolean ret_conv = ParseOrSemanticError_eq(a_conv, b_conv);
67500 void __attribute__((export_name("TS_Bolt11Invoice_free"))) TS_Bolt11Invoice_free(uint64_t this_obj) {
67501 LDKBolt11Invoice this_obj_conv;
67502 this_obj_conv.inner = untag_ptr(this_obj);
67503 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67505 Bolt11Invoice_free(this_obj_conv);
67508 jboolean __attribute__((export_name("TS_Bolt11Invoice_eq"))) TS_Bolt11Invoice_eq(uint64_t a, uint64_t b) {
67509 LDKBolt11Invoice a_conv;
67510 a_conv.inner = untag_ptr(a);
67511 a_conv.is_owned = ptr_is_owned(a);
67512 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67513 a_conv.is_owned = false;
67514 LDKBolt11Invoice b_conv;
67515 b_conv.inner = untag_ptr(b);
67516 b_conv.is_owned = ptr_is_owned(b);
67517 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
67518 b_conv.is_owned = false;
67519 jboolean ret_conv = Bolt11Invoice_eq(&a_conv, &b_conv);
67523 static inline uint64_t Bolt11Invoice_clone_ptr(LDKBolt11Invoice *NONNULL_PTR arg) {
67524 LDKBolt11Invoice ret_var = Bolt11Invoice_clone(arg);
67525 uint64_t ret_ref = 0;
67526 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67527 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67530 int64_t __attribute__((export_name("TS_Bolt11Invoice_clone_ptr"))) TS_Bolt11Invoice_clone_ptr(uint64_t arg) {
67531 LDKBolt11Invoice arg_conv;
67532 arg_conv.inner = untag_ptr(arg);
67533 arg_conv.is_owned = ptr_is_owned(arg);
67534 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67535 arg_conv.is_owned = false;
67536 int64_t ret_conv = Bolt11Invoice_clone_ptr(&arg_conv);
67540 uint64_t __attribute__((export_name("TS_Bolt11Invoice_clone"))) TS_Bolt11Invoice_clone(uint64_t orig) {
67541 LDKBolt11Invoice orig_conv;
67542 orig_conv.inner = untag_ptr(orig);
67543 orig_conv.is_owned = ptr_is_owned(orig);
67544 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67545 orig_conv.is_owned = false;
67546 LDKBolt11Invoice ret_var = Bolt11Invoice_clone(&orig_conv);
67547 uint64_t ret_ref = 0;
67548 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67549 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67553 int64_t __attribute__((export_name("TS_Bolt11Invoice_hash"))) TS_Bolt11Invoice_hash(uint64_t o) {
67554 LDKBolt11Invoice o_conv;
67555 o_conv.inner = untag_ptr(o);
67556 o_conv.is_owned = ptr_is_owned(o);
67557 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
67558 o_conv.is_owned = false;
67559 int64_t ret_conv = Bolt11Invoice_hash(&o_conv);
67563 void __attribute__((export_name("TS_SignedRawBolt11Invoice_free"))) TS_SignedRawBolt11Invoice_free(uint64_t this_obj) {
67564 LDKSignedRawBolt11Invoice this_obj_conv;
67565 this_obj_conv.inner = untag_ptr(this_obj);
67566 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67568 SignedRawBolt11Invoice_free(this_obj_conv);
67571 jboolean __attribute__((export_name("TS_SignedRawBolt11Invoice_eq"))) TS_SignedRawBolt11Invoice_eq(uint64_t a, uint64_t b) {
67572 LDKSignedRawBolt11Invoice a_conv;
67573 a_conv.inner = untag_ptr(a);
67574 a_conv.is_owned = ptr_is_owned(a);
67575 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67576 a_conv.is_owned = false;
67577 LDKSignedRawBolt11Invoice b_conv;
67578 b_conv.inner = untag_ptr(b);
67579 b_conv.is_owned = ptr_is_owned(b);
67580 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
67581 b_conv.is_owned = false;
67582 jboolean ret_conv = SignedRawBolt11Invoice_eq(&a_conv, &b_conv);
67586 static inline uint64_t SignedRawBolt11Invoice_clone_ptr(LDKSignedRawBolt11Invoice *NONNULL_PTR arg) {
67587 LDKSignedRawBolt11Invoice ret_var = SignedRawBolt11Invoice_clone(arg);
67588 uint64_t ret_ref = 0;
67589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67593 int64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_clone_ptr"))) TS_SignedRawBolt11Invoice_clone_ptr(uint64_t arg) {
67594 LDKSignedRawBolt11Invoice arg_conv;
67595 arg_conv.inner = untag_ptr(arg);
67596 arg_conv.is_owned = ptr_is_owned(arg);
67597 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67598 arg_conv.is_owned = false;
67599 int64_t ret_conv = SignedRawBolt11Invoice_clone_ptr(&arg_conv);
67603 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_clone"))) TS_SignedRawBolt11Invoice_clone(uint64_t orig) {
67604 LDKSignedRawBolt11Invoice orig_conv;
67605 orig_conv.inner = untag_ptr(orig);
67606 orig_conv.is_owned = ptr_is_owned(orig);
67607 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67608 orig_conv.is_owned = false;
67609 LDKSignedRawBolt11Invoice ret_var = SignedRawBolt11Invoice_clone(&orig_conv);
67610 uint64_t ret_ref = 0;
67611 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67612 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67616 int64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_hash"))) TS_SignedRawBolt11Invoice_hash(uint64_t o) {
67617 LDKSignedRawBolt11Invoice o_conv;
67618 o_conv.inner = untag_ptr(o);
67619 o_conv.is_owned = ptr_is_owned(o);
67620 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
67621 o_conv.is_owned = false;
67622 int64_t ret_conv = SignedRawBolt11Invoice_hash(&o_conv);
67626 void __attribute__((export_name("TS_RawBolt11Invoice_free"))) TS_RawBolt11Invoice_free(uint64_t this_obj) {
67627 LDKRawBolt11Invoice this_obj_conv;
67628 this_obj_conv.inner = untag_ptr(this_obj);
67629 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67631 RawBolt11Invoice_free(this_obj_conv);
67634 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_get_data"))) TS_RawBolt11Invoice_get_data(uint64_t this_ptr) {
67635 LDKRawBolt11Invoice this_ptr_conv;
67636 this_ptr_conv.inner = untag_ptr(this_ptr);
67637 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
67638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
67639 this_ptr_conv.is_owned = false;
67640 LDKRawDataPart ret_var = RawBolt11Invoice_get_data(&this_ptr_conv);
67641 uint64_t ret_ref = 0;
67642 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67643 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67647 void __attribute__((export_name("TS_RawBolt11Invoice_set_data"))) TS_RawBolt11Invoice_set_data(uint64_t this_ptr, uint64_t val) {
67648 LDKRawBolt11Invoice this_ptr_conv;
67649 this_ptr_conv.inner = untag_ptr(this_ptr);
67650 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
67651 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
67652 this_ptr_conv.is_owned = false;
67653 LDKRawDataPart val_conv;
67654 val_conv.inner = untag_ptr(val);
67655 val_conv.is_owned = ptr_is_owned(val);
67656 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
67657 val_conv = RawDataPart_clone(&val_conv);
67658 RawBolt11Invoice_set_data(&this_ptr_conv, val_conv);
67661 jboolean __attribute__((export_name("TS_RawBolt11Invoice_eq"))) TS_RawBolt11Invoice_eq(uint64_t a, uint64_t b) {
67662 LDKRawBolt11Invoice a_conv;
67663 a_conv.inner = untag_ptr(a);
67664 a_conv.is_owned = ptr_is_owned(a);
67665 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67666 a_conv.is_owned = false;
67667 LDKRawBolt11Invoice b_conv;
67668 b_conv.inner = untag_ptr(b);
67669 b_conv.is_owned = ptr_is_owned(b);
67670 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
67671 b_conv.is_owned = false;
67672 jboolean ret_conv = RawBolt11Invoice_eq(&a_conv, &b_conv);
67676 static inline uint64_t RawBolt11Invoice_clone_ptr(LDKRawBolt11Invoice *NONNULL_PTR arg) {
67677 LDKRawBolt11Invoice ret_var = RawBolt11Invoice_clone(arg);
67678 uint64_t ret_ref = 0;
67679 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67680 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67683 int64_t __attribute__((export_name("TS_RawBolt11Invoice_clone_ptr"))) TS_RawBolt11Invoice_clone_ptr(uint64_t arg) {
67684 LDKRawBolt11Invoice arg_conv;
67685 arg_conv.inner = untag_ptr(arg);
67686 arg_conv.is_owned = ptr_is_owned(arg);
67687 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67688 arg_conv.is_owned = false;
67689 int64_t ret_conv = RawBolt11Invoice_clone_ptr(&arg_conv);
67693 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_clone"))) TS_RawBolt11Invoice_clone(uint64_t orig) {
67694 LDKRawBolt11Invoice orig_conv;
67695 orig_conv.inner = untag_ptr(orig);
67696 orig_conv.is_owned = ptr_is_owned(orig);
67697 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67698 orig_conv.is_owned = false;
67699 LDKRawBolt11Invoice ret_var = RawBolt11Invoice_clone(&orig_conv);
67700 uint64_t ret_ref = 0;
67701 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67702 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67706 int64_t __attribute__((export_name("TS_RawBolt11Invoice_hash"))) TS_RawBolt11Invoice_hash(uint64_t o) {
67707 LDKRawBolt11Invoice o_conv;
67708 o_conv.inner = untag_ptr(o);
67709 o_conv.is_owned = ptr_is_owned(o);
67710 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
67711 o_conv.is_owned = false;
67712 int64_t ret_conv = RawBolt11Invoice_hash(&o_conv);
67716 void __attribute__((export_name("TS_RawDataPart_free"))) TS_RawDataPart_free(uint64_t this_obj) {
67717 LDKRawDataPart this_obj_conv;
67718 this_obj_conv.inner = untag_ptr(this_obj);
67719 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67721 RawDataPart_free(this_obj_conv);
67724 uint64_t __attribute__((export_name("TS_RawDataPart_get_timestamp"))) TS_RawDataPart_get_timestamp(uint64_t this_ptr) {
67725 LDKRawDataPart this_ptr_conv;
67726 this_ptr_conv.inner = untag_ptr(this_ptr);
67727 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
67728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
67729 this_ptr_conv.is_owned = false;
67730 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
67731 uint64_t ret_ref = 0;
67732 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67733 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67737 void __attribute__((export_name("TS_RawDataPart_set_timestamp"))) TS_RawDataPart_set_timestamp(uint64_t this_ptr, uint64_t val) {
67738 LDKRawDataPart this_ptr_conv;
67739 this_ptr_conv.inner = untag_ptr(this_ptr);
67740 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
67741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
67742 this_ptr_conv.is_owned = false;
67743 LDKPositiveTimestamp val_conv;
67744 val_conv.inner = untag_ptr(val);
67745 val_conv.is_owned = ptr_is_owned(val);
67746 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
67747 val_conv = PositiveTimestamp_clone(&val_conv);
67748 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
67751 jboolean __attribute__((export_name("TS_RawDataPart_eq"))) TS_RawDataPart_eq(uint64_t a, uint64_t b) {
67752 LDKRawDataPart a_conv;
67753 a_conv.inner = untag_ptr(a);
67754 a_conv.is_owned = ptr_is_owned(a);
67755 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67756 a_conv.is_owned = false;
67757 LDKRawDataPart b_conv;
67758 b_conv.inner = untag_ptr(b);
67759 b_conv.is_owned = ptr_is_owned(b);
67760 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
67761 b_conv.is_owned = false;
67762 jboolean ret_conv = RawDataPart_eq(&a_conv, &b_conv);
67766 static inline uint64_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
67767 LDKRawDataPart ret_var = RawDataPart_clone(arg);
67768 uint64_t ret_ref = 0;
67769 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67770 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67773 int64_t __attribute__((export_name("TS_RawDataPart_clone_ptr"))) TS_RawDataPart_clone_ptr(uint64_t arg) {
67774 LDKRawDataPart arg_conv;
67775 arg_conv.inner = untag_ptr(arg);
67776 arg_conv.is_owned = ptr_is_owned(arg);
67777 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67778 arg_conv.is_owned = false;
67779 int64_t ret_conv = RawDataPart_clone_ptr(&arg_conv);
67783 uint64_t __attribute__((export_name("TS_RawDataPart_clone"))) TS_RawDataPart_clone(uint64_t orig) {
67784 LDKRawDataPart orig_conv;
67785 orig_conv.inner = untag_ptr(orig);
67786 orig_conv.is_owned = ptr_is_owned(orig);
67787 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67788 orig_conv.is_owned = false;
67789 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
67790 uint64_t ret_ref = 0;
67791 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67792 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67796 int64_t __attribute__((export_name("TS_RawDataPart_hash"))) TS_RawDataPart_hash(uint64_t o) {
67797 LDKRawDataPart o_conv;
67798 o_conv.inner = untag_ptr(o);
67799 o_conv.is_owned = ptr_is_owned(o);
67800 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
67801 o_conv.is_owned = false;
67802 int64_t ret_conv = RawDataPart_hash(&o_conv);
67806 void __attribute__((export_name("TS_PositiveTimestamp_free"))) TS_PositiveTimestamp_free(uint64_t this_obj) {
67807 LDKPositiveTimestamp this_obj_conv;
67808 this_obj_conv.inner = untag_ptr(this_obj);
67809 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67811 PositiveTimestamp_free(this_obj_conv);
67814 jboolean __attribute__((export_name("TS_PositiveTimestamp_eq"))) TS_PositiveTimestamp_eq(uint64_t a, uint64_t b) {
67815 LDKPositiveTimestamp a_conv;
67816 a_conv.inner = untag_ptr(a);
67817 a_conv.is_owned = ptr_is_owned(a);
67818 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
67819 a_conv.is_owned = false;
67820 LDKPositiveTimestamp b_conv;
67821 b_conv.inner = untag_ptr(b);
67822 b_conv.is_owned = ptr_is_owned(b);
67823 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
67824 b_conv.is_owned = false;
67825 jboolean ret_conv = PositiveTimestamp_eq(&a_conv, &b_conv);
67829 static inline uint64_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
67830 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
67831 uint64_t ret_ref = 0;
67832 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67833 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67836 int64_t __attribute__((export_name("TS_PositiveTimestamp_clone_ptr"))) TS_PositiveTimestamp_clone_ptr(uint64_t arg) {
67837 LDKPositiveTimestamp arg_conv;
67838 arg_conv.inner = untag_ptr(arg);
67839 arg_conv.is_owned = ptr_is_owned(arg);
67840 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67841 arg_conv.is_owned = false;
67842 int64_t ret_conv = PositiveTimestamp_clone_ptr(&arg_conv);
67846 uint64_t __attribute__((export_name("TS_PositiveTimestamp_clone"))) TS_PositiveTimestamp_clone(uint64_t orig) {
67847 LDKPositiveTimestamp orig_conv;
67848 orig_conv.inner = untag_ptr(orig);
67849 orig_conv.is_owned = ptr_is_owned(orig);
67850 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67851 orig_conv.is_owned = false;
67852 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
67853 uint64_t ret_ref = 0;
67854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67855 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67859 int64_t __attribute__((export_name("TS_PositiveTimestamp_hash"))) TS_PositiveTimestamp_hash(uint64_t o) {
67860 LDKPositiveTimestamp o_conv;
67861 o_conv.inner = untag_ptr(o);
67862 o_conv.is_owned = ptr_is_owned(o);
67863 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
67864 o_conv.is_owned = false;
67865 int64_t ret_conv = PositiveTimestamp_hash(&o_conv);
67869 uint32_t __attribute__((export_name("TS_SiPrefix_clone"))) TS_SiPrefix_clone(uint64_t orig) {
67870 LDKSiPrefix* orig_conv = (LDKSiPrefix*)untag_ptr(orig);
67871 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
67875 uint32_t __attribute__((export_name("TS_SiPrefix_milli"))) TS_SiPrefix_milli() {
67876 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_milli());
67880 uint32_t __attribute__((export_name("TS_SiPrefix_micro"))) TS_SiPrefix_micro() {
67881 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_micro());
67885 uint32_t __attribute__((export_name("TS_SiPrefix_nano"))) TS_SiPrefix_nano() {
67886 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_nano());
67890 uint32_t __attribute__((export_name("TS_SiPrefix_pico"))) TS_SiPrefix_pico() {
67891 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_pico());
67895 jboolean __attribute__((export_name("TS_SiPrefix_eq"))) TS_SiPrefix_eq(uint64_t a, uint64_t b) {
67896 LDKSiPrefix* a_conv = (LDKSiPrefix*)untag_ptr(a);
67897 LDKSiPrefix* b_conv = (LDKSiPrefix*)untag_ptr(b);
67898 jboolean ret_conv = SiPrefix_eq(a_conv, b_conv);
67902 int64_t __attribute__((export_name("TS_SiPrefix_hash"))) TS_SiPrefix_hash(uint64_t o) {
67903 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
67904 int64_t ret_conv = SiPrefix_hash(o_conv);
67908 int64_t __attribute__((export_name("TS_SiPrefix_multiplier"))) TS_SiPrefix_multiplier(uint64_t this_arg) {
67909 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)untag_ptr(this_arg);
67910 int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
67914 uint32_t __attribute__((export_name("TS_Currency_clone"))) TS_Currency_clone(uint64_t orig) {
67915 LDKCurrency* orig_conv = (LDKCurrency*)untag_ptr(orig);
67916 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
67920 uint32_t __attribute__((export_name("TS_Currency_bitcoin"))) TS_Currency_bitcoin() {
67921 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin());
67925 uint32_t __attribute__((export_name("TS_Currency_bitcoin_testnet"))) TS_Currency_bitcoin_testnet() {
67926 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin_testnet());
67930 uint32_t __attribute__((export_name("TS_Currency_regtest"))) TS_Currency_regtest() {
67931 uint32_t ret_conv = LDKCurrency_to_js(Currency_regtest());
67935 uint32_t __attribute__((export_name("TS_Currency_simnet"))) TS_Currency_simnet() {
67936 uint32_t ret_conv = LDKCurrency_to_js(Currency_simnet());
67940 uint32_t __attribute__((export_name("TS_Currency_signet"))) TS_Currency_signet() {
67941 uint32_t ret_conv = LDKCurrency_to_js(Currency_signet());
67945 int64_t __attribute__((export_name("TS_Currency_hash"))) TS_Currency_hash(uint64_t o) {
67946 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
67947 int64_t ret_conv = Currency_hash(o_conv);
67951 jboolean __attribute__((export_name("TS_Currency_eq"))) TS_Currency_eq(uint64_t a, uint64_t b) {
67952 LDKCurrency* a_conv = (LDKCurrency*)untag_ptr(a);
67953 LDKCurrency* b_conv = (LDKCurrency*)untag_ptr(b);
67954 jboolean ret_conv = Currency_eq(a_conv, b_conv);
67958 void __attribute__((export_name("TS_Sha256_free"))) TS_Sha256_free(uint64_t this_obj) {
67959 LDKSha256 this_obj_conv;
67960 this_obj_conv.inner = untag_ptr(this_obj);
67961 this_obj_conv.is_owned = ptr_is_owned(this_obj);
67962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
67963 Sha256_free(this_obj_conv);
67966 static inline uint64_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
67967 LDKSha256 ret_var = Sha256_clone(arg);
67968 uint64_t ret_ref = 0;
67969 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67970 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67973 int64_t __attribute__((export_name("TS_Sha256_clone_ptr"))) TS_Sha256_clone_ptr(uint64_t arg) {
67974 LDKSha256 arg_conv;
67975 arg_conv.inner = untag_ptr(arg);
67976 arg_conv.is_owned = ptr_is_owned(arg);
67977 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
67978 arg_conv.is_owned = false;
67979 int64_t ret_conv = Sha256_clone_ptr(&arg_conv);
67983 uint64_t __attribute__((export_name("TS_Sha256_clone"))) TS_Sha256_clone(uint64_t orig) {
67984 LDKSha256 orig_conv;
67985 orig_conv.inner = untag_ptr(orig);
67986 orig_conv.is_owned = ptr_is_owned(orig);
67987 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
67988 orig_conv.is_owned = false;
67989 LDKSha256 ret_var = Sha256_clone(&orig_conv);
67990 uint64_t ret_ref = 0;
67991 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
67992 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
67996 int64_t __attribute__((export_name("TS_Sha256_hash"))) TS_Sha256_hash(uint64_t o) {
67998 o_conv.inner = untag_ptr(o);
67999 o_conv.is_owned = ptr_is_owned(o);
68000 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68001 o_conv.is_owned = false;
68002 int64_t ret_conv = Sha256_hash(&o_conv);
68006 jboolean __attribute__((export_name("TS_Sha256_eq"))) TS_Sha256_eq(uint64_t a, uint64_t b) {
68008 a_conv.inner = untag_ptr(a);
68009 a_conv.is_owned = ptr_is_owned(a);
68010 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68011 a_conv.is_owned = false;
68013 b_conv.inner = untag_ptr(b);
68014 b_conv.is_owned = ptr_is_owned(b);
68015 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68016 b_conv.is_owned = false;
68017 jboolean ret_conv = Sha256_eq(&a_conv, &b_conv);
68021 uint64_t __attribute__((export_name("TS_Sha256_from_bytes"))) TS_Sha256_from_bytes(int8_tArray bytes) {
68022 uint8_t bytes_arr[32];
68023 CHECK(bytes->arr_len == 32);
68024 memcpy(bytes_arr, bytes->elems, 32); FREE(bytes);
68025 uint8_t (*bytes_ref)[32] = &bytes_arr;
68026 LDKSha256 ret_var = Sha256_from_bytes(bytes_ref);
68027 uint64_t ret_ref = 0;
68028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68029 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68033 void __attribute__((export_name("TS_Description_free"))) TS_Description_free(uint64_t this_obj) {
68034 LDKDescription this_obj_conv;
68035 this_obj_conv.inner = untag_ptr(this_obj);
68036 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68037 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68038 Description_free(this_obj_conv);
68041 static inline uint64_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
68042 LDKDescription ret_var = Description_clone(arg);
68043 uint64_t ret_ref = 0;
68044 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68045 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68048 int64_t __attribute__((export_name("TS_Description_clone_ptr"))) TS_Description_clone_ptr(uint64_t arg) {
68049 LDKDescription arg_conv;
68050 arg_conv.inner = untag_ptr(arg);
68051 arg_conv.is_owned = ptr_is_owned(arg);
68052 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68053 arg_conv.is_owned = false;
68054 int64_t ret_conv = Description_clone_ptr(&arg_conv);
68058 uint64_t __attribute__((export_name("TS_Description_clone"))) TS_Description_clone(uint64_t orig) {
68059 LDKDescription orig_conv;
68060 orig_conv.inner = untag_ptr(orig);
68061 orig_conv.is_owned = ptr_is_owned(orig);
68062 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68063 orig_conv.is_owned = false;
68064 LDKDescription ret_var = Description_clone(&orig_conv);
68065 uint64_t ret_ref = 0;
68066 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68067 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68071 int64_t __attribute__((export_name("TS_Description_hash"))) TS_Description_hash(uint64_t o) {
68072 LDKDescription o_conv;
68073 o_conv.inner = untag_ptr(o);
68074 o_conv.is_owned = ptr_is_owned(o);
68075 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68076 o_conv.is_owned = false;
68077 int64_t ret_conv = Description_hash(&o_conv);
68081 jboolean __attribute__((export_name("TS_Description_eq"))) TS_Description_eq(uint64_t a, uint64_t b) {
68082 LDKDescription a_conv;
68083 a_conv.inner = untag_ptr(a);
68084 a_conv.is_owned = ptr_is_owned(a);
68085 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68086 a_conv.is_owned = false;
68087 LDKDescription b_conv;
68088 b_conv.inner = untag_ptr(b);
68089 b_conv.is_owned = ptr_is_owned(b);
68090 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68091 b_conv.is_owned = false;
68092 jboolean ret_conv = Description_eq(&a_conv, &b_conv);
68096 void __attribute__((export_name("TS_PayeePubKey_free"))) TS_PayeePubKey_free(uint64_t this_obj) {
68097 LDKPayeePubKey this_obj_conv;
68098 this_obj_conv.inner = untag_ptr(this_obj);
68099 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68101 PayeePubKey_free(this_obj_conv);
68104 int8_tArray __attribute__((export_name("TS_PayeePubKey_get_a"))) TS_PayeePubKey_get_a(uint64_t this_ptr) {
68105 LDKPayeePubKey this_ptr_conv;
68106 this_ptr_conv.inner = untag_ptr(this_ptr);
68107 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
68108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
68109 this_ptr_conv.is_owned = false;
68110 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
68111 memcpy(ret_arr->elems, PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
68115 void __attribute__((export_name("TS_PayeePubKey_set_a"))) TS_PayeePubKey_set_a(uint64_t this_ptr, int8_tArray val) {
68116 LDKPayeePubKey this_ptr_conv;
68117 this_ptr_conv.inner = untag_ptr(this_ptr);
68118 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
68119 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
68120 this_ptr_conv.is_owned = false;
68121 LDKPublicKey val_ref;
68122 CHECK(val->arr_len == 33);
68123 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
68124 PayeePubKey_set_a(&this_ptr_conv, val_ref);
68127 uint64_t __attribute__((export_name("TS_PayeePubKey_new"))) TS_PayeePubKey_new(int8_tArray a_arg) {
68128 LDKPublicKey a_arg_ref;
68129 CHECK(a_arg->arr_len == 33);
68130 memcpy(a_arg_ref.compressed_form, a_arg->elems, 33); FREE(a_arg);
68131 LDKPayeePubKey ret_var = PayeePubKey_new(a_arg_ref);
68132 uint64_t ret_ref = 0;
68133 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68134 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68138 static inline uint64_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
68139 LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
68140 uint64_t ret_ref = 0;
68141 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68142 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68145 int64_t __attribute__((export_name("TS_PayeePubKey_clone_ptr"))) TS_PayeePubKey_clone_ptr(uint64_t arg) {
68146 LDKPayeePubKey arg_conv;
68147 arg_conv.inner = untag_ptr(arg);
68148 arg_conv.is_owned = ptr_is_owned(arg);
68149 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68150 arg_conv.is_owned = false;
68151 int64_t ret_conv = PayeePubKey_clone_ptr(&arg_conv);
68155 uint64_t __attribute__((export_name("TS_PayeePubKey_clone"))) TS_PayeePubKey_clone(uint64_t orig) {
68156 LDKPayeePubKey orig_conv;
68157 orig_conv.inner = untag_ptr(orig);
68158 orig_conv.is_owned = ptr_is_owned(orig);
68159 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68160 orig_conv.is_owned = false;
68161 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
68162 uint64_t ret_ref = 0;
68163 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68164 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68168 int64_t __attribute__((export_name("TS_PayeePubKey_hash"))) TS_PayeePubKey_hash(uint64_t o) {
68169 LDKPayeePubKey o_conv;
68170 o_conv.inner = untag_ptr(o);
68171 o_conv.is_owned = ptr_is_owned(o);
68172 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68173 o_conv.is_owned = false;
68174 int64_t ret_conv = PayeePubKey_hash(&o_conv);
68178 jboolean __attribute__((export_name("TS_PayeePubKey_eq"))) TS_PayeePubKey_eq(uint64_t a, uint64_t b) {
68179 LDKPayeePubKey a_conv;
68180 a_conv.inner = untag_ptr(a);
68181 a_conv.is_owned = ptr_is_owned(a);
68182 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68183 a_conv.is_owned = false;
68184 LDKPayeePubKey b_conv;
68185 b_conv.inner = untag_ptr(b);
68186 b_conv.is_owned = ptr_is_owned(b);
68187 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68188 b_conv.is_owned = false;
68189 jboolean ret_conv = PayeePubKey_eq(&a_conv, &b_conv);
68193 void __attribute__((export_name("TS_ExpiryTime_free"))) TS_ExpiryTime_free(uint64_t this_obj) {
68194 LDKExpiryTime this_obj_conv;
68195 this_obj_conv.inner = untag_ptr(this_obj);
68196 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68198 ExpiryTime_free(this_obj_conv);
68201 static inline uint64_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
68202 LDKExpiryTime ret_var = ExpiryTime_clone(arg);
68203 uint64_t ret_ref = 0;
68204 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68205 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68208 int64_t __attribute__((export_name("TS_ExpiryTime_clone_ptr"))) TS_ExpiryTime_clone_ptr(uint64_t arg) {
68209 LDKExpiryTime arg_conv;
68210 arg_conv.inner = untag_ptr(arg);
68211 arg_conv.is_owned = ptr_is_owned(arg);
68212 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68213 arg_conv.is_owned = false;
68214 int64_t ret_conv = ExpiryTime_clone_ptr(&arg_conv);
68218 uint64_t __attribute__((export_name("TS_ExpiryTime_clone"))) TS_ExpiryTime_clone(uint64_t orig) {
68219 LDKExpiryTime orig_conv;
68220 orig_conv.inner = untag_ptr(orig);
68221 orig_conv.is_owned = ptr_is_owned(orig);
68222 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68223 orig_conv.is_owned = false;
68224 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
68225 uint64_t ret_ref = 0;
68226 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68227 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68231 int64_t __attribute__((export_name("TS_ExpiryTime_hash"))) TS_ExpiryTime_hash(uint64_t o) {
68232 LDKExpiryTime o_conv;
68233 o_conv.inner = untag_ptr(o);
68234 o_conv.is_owned = ptr_is_owned(o);
68235 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68236 o_conv.is_owned = false;
68237 int64_t ret_conv = ExpiryTime_hash(&o_conv);
68241 jboolean __attribute__((export_name("TS_ExpiryTime_eq"))) TS_ExpiryTime_eq(uint64_t a, uint64_t b) {
68242 LDKExpiryTime a_conv;
68243 a_conv.inner = untag_ptr(a);
68244 a_conv.is_owned = ptr_is_owned(a);
68245 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68246 a_conv.is_owned = false;
68247 LDKExpiryTime b_conv;
68248 b_conv.inner = untag_ptr(b);
68249 b_conv.is_owned = ptr_is_owned(b);
68250 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68251 b_conv.is_owned = false;
68252 jboolean ret_conv = ExpiryTime_eq(&a_conv, &b_conv);
68256 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_free"))) TS_MinFinalCltvExpiryDelta_free(uint64_t this_obj) {
68257 LDKMinFinalCltvExpiryDelta this_obj_conv;
68258 this_obj_conv.inner = untag_ptr(this_obj);
68259 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68261 MinFinalCltvExpiryDelta_free(this_obj_conv);
68264 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_get_a"))) TS_MinFinalCltvExpiryDelta_get_a(uint64_t this_ptr) {
68265 LDKMinFinalCltvExpiryDelta this_ptr_conv;
68266 this_ptr_conv.inner = untag_ptr(this_ptr);
68267 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
68268 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
68269 this_ptr_conv.is_owned = false;
68270 int64_t ret_conv = MinFinalCltvExpiryDelta_get_a(&this_ptr_conv);
68274 void __attribute__((export_name("TS_MinFinalCltvExpiryDelta_set_a"))) TS_MinFinalCltvExpiryDelta_set_a(uint64_t this_ptr, int64_t val) {
68275 LDKMinFinalCltvExpiryDelta this_ptr_conv;
68276 this_ptr_conv.inner = untag_ptr(this_ptr);
68277 this_ptr_conv.is_owned = ptr_is_owned(this_ptr);
68278 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
68279 this_ptr_conv.is_owned = false;
68280 MinFinalCltvExpiryDelta_set_a(&this_ptr_conv, val);
68283 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_new"))) TS_MinFinalCltvExpiryDelta_new(int64_t a_arg) {
68284 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_new(a_arg);
68285 uint64_t ret_ref = 0;
68286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68287 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68291 static inline uint64_t MinFinalCltvExpiryDelta_clone_ptr(LDKMinFinalCltvExpiryDelta *NONNULL_PTR arg) {
68292 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(arg);
68293 uint64_t ret_ref = 0;
68294 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68295 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68298 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone_ptr"))) TS_MinFinalCltvExpiryDelta_clone_ptr(uint64_t arg) {
68299 LDKMinFinalCltvExpiryDelta arg_conv;
68300 arg_conv.inner = untag_ptr(arg);
68301 arg_conv.is_owned = ptr_is_owned(arg);
68302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68303 arg_conv.is_owned = false;
68304 int64_t ret_conv = MinFinalCltvExpiryDelta_clone_ptr(&arg_conv);
68308 uint64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_clone"))) TS_MinFinalCltvExpiryDelta_clone(uint64_t orig) {
68309 LDKMinFinalCltvExpiryDelta orig_conv;
68310 orig_conv.inner = untag_ptr(orig);
68311 orig_conv.is_owned = ptr_is_owned(orig);
68312 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68313 orig_conv.is_owned = false;
68314 LDKMinFinalCltvExpiryDelta ret_var = MinFinalCltvExpiryDelta_clone(&orig_conv);
68315 uint64_t ret_ref = 0;
68316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68317 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68321 int64_t __attribute__((export_name("TS_MinFinalCltvExpiryDelta_hash"))) TS_MinFinalCltvExpiryDelta_hash(uint64_t o) {
68322 LDKMinFinalCltvExpiryDelta o_conv;
68323 o_conv.inner = untag_ptr(o);
68324 o_conv.is_owned = ptr_is_owned(o);
68325 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68326 o_conv.is_owned = false;
68327 int64_t ret_conv = MinFinalCltvExpiryDelta_hash(&o_conv);
68331 jboolean __attribute__((export_name("TS_MinFinalCltvExpiryDelta_eq"))) TS_MinFinalCltvExpiryDelta_eq(uint64_t a, uint64_t b) {
68332 LDKMinFinalCltvExpiryDelta a_conv;
68333 a_conv.inner = untag_ptr(a);
68334 a_conv.is_owned = ptr_is_owned(a);
68335 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68336 a_conv.is_owned = false;
68337 LDKMinFinalCltvExpiryDelta b_conv;
68338 b_conv.inner = untag_ptr(b);
68339 b_conv.is_owned = ptr_is_owned(b);
68340 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68341 b_conv.is_owned = false;
68342 jboolean ret_conv = MinFinalCltvExpiryDelta_eq(&a_conv, &b_conv);
68346 void __attribute__((export_name("TS_Fallback_free"))) TS_Fallback_free(uint64_t this_ptr) {
68347 if (!ptr_is_owned(this_ptr)) return;
68348 void* this_ptr_ptr = untag_ptr(this_ptr);
68349 CHECK_ACCESS(this_ptr_ptr);
68350 LDKFallback this_ptr_conv = *(LDKFallback*)(this_ptr_ptr);
68351 FREE(untag_ptr(this_ptr));
68352 Fallback_free(this_ptr_conv);
68355 static inline uint64_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
68356 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
68357 *ret_copy = Fallback_clone(arg);
68358 uint64_t ret_ref = tag_ptr(ret_copy, true);
68361 int64_t __attribute__((export_name("TS_Fallback_clone_ptr"))) TS_Fallback_clone_ptr(uint64_t arg) {
68362 LDKFallback* arg_conv = (LDKFallback*)untag_ptr(arg);
68363 int64_t ret_conv = Fallback_clone_ptr(arg_conv);
68367 uint64_t __attribute__((export_name("TS_Fallback_clone"))) TS_Fallback_clone(uint64_t orig) {
68368 LDKFallback* orig_conv = (LDKFallback*)untag_ptr(orig);
68369 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
68370 *ret_copy = Fallback_clone(orig_conv);
68371 uint64_t ret_ref = tag_ptr(ret_copy, true);
68375 uint64_t __attribute__((export_name("TS_Fallback_seg_wit_program"))) TS_Fallback_seg_wit_program(int8_t version, int8_tArray program) {
68377 LDKCVec_u8Z program_ref;
68378 program_ref.datalen = program->arr_len;
68379 program_ref.data = MALLOC(program_ref.datalen, "LDKCVec_u8Z Bytes");
68380 memcpy(program_ref.data, program->elems, program_ref.datalen); FREE(program);
68381 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
68382 *ret_copy = Fallback_seg_wit_program((LDKWitnessVersion){ ._0 = version }, program_ref);
68383 uint64_t ret_ref = tag_ptr(ret_copy, true);
68387 uint64_t __attribute__((export_name("TS_Fallback_pub_key_hash"))) TS_Fallback_pub_key_hash(int8_tArray a) {
68388 LDKTwentyBytes a_ref;
68389 CHECK(a->arr_len == 20);
68390 memcpy(a_ref.data, a->elems, 20); FREE(a);
68391 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
68392 *ret_copy = Fallback_pub_key_hash(a_ref);
68393 uint64_t ret_ref = tag_ptr(ret_copy, true);
68397 uint64_t __attribute__((export_name("TS_Fallback_script_hash"))) TS_Fallback_script_hash(int8_tArray a) {
68398 LDKTwentyBytes a_ref;
68399 CHECK(a->arr_len == 20);
68400 memcpy(a_ref.data, a->elems, 20); FREE(a);
68401 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
68402 *ret_copy = Fallback_script_hash(a_ref);
68403 uint64_t ret_ref = tag_ptr(ret_copy, true);
68407 int64_t __attribute__((export_name("TS_Fallback_hash"))) TS_Fallback_hash(uint64_t o) {
68408 LDKFallback* o_conv = (LDKFallback*)untag_ptr(o);
68409 int64_t ret_conv = Fallback_hash(o_conv);
68413 jboolean __attribute__((export_name("TS_Fallback_eq"))) TS_Fallback_eq(uint64_t a, uint64_t b) {
68414 LDKFallback* a_conv = (LDKFallback*)untag_ptr(a);
68415 LDKFallback* b_conv = (LDKFallback*)untag_ptr(b);
68416 jboolean ret_conv = Fallback_eq(a_conv, b_conv);
68420 void __attribute__((export_name("TS_Bolt11InvoiceSignature_free"))) TS_Bolt11InvoiceSignature_free(uint64_t this_obj) {
68421 LDKBolt11InvoiceSignature this_obj_conv;
68422 this_obj_conv.inner = untag_ptr(this_obj);
68423 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68424 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68425 Bolt11InvoiceSignature_free(this_obj_conv);
68428 static inline uint64_t Bolt11InvoiceSignature_clone_ptr(LDKBolt11InvoiceSignature *NONNULL_PTR arg) {
68429 LDKBolt11InvoiceSignature ret_var = Bolt11InvoiceSignature_clone(arg);
68430 uint64_t ret_ref = 0;
68431 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68432 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68435 int64_t __attribute__((export_name("TS_Bolt11InvoiceSignature_clone_ptr"))) TS_Bolt11InvoiceSignature_clone_ptr(uint64_t arg) {
68436 LDKBolt11InvoiceSignature arg_conv;
68437 arg_conv.inner = untag_ptr(arg);
68438 arg_conv.is_owned = ptr_is_owned(arg);
68439 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68440 arg_conv.is_owned = false;
68441 int64_t ret_conv = Bolt11InvoiceSignature_clone_ptr(&arg_conv);
68445 uint64_t __attribute__((export_name("TS_Bolt11InvoiceSignature_clone"))) TS_Bolt11InvoiceSignature_clone(uint64_t orig) {
68446 LDKBolt11InvoiceSignature orig_conv;
68447 orig_conv.inner = untag_ptr(orig);
68448 orig_conv.is_owned = ptr_is_owned(orig);
68449 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68450 orig_conv.is_owned = false;
68451 LDKBolt11InvoiceSignature ret_var = Bolt11InvoiceSignature_clone(&orig_conv);
68452 uint64_t ret_ref = 0;
68453 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68454 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68458 int64_t __attribute__((export_name("TS_Bolt11InvoiceSignature_hash"))) TS_Bolt11InvoiceSignature_hash(uint64_t o) {
68459 LDKBolt11InvoiceSignature o_conv;
68460 o_conv.inner = untag_ptr(o);
68461 o_conv.is_owned = ptr_is_owned(o);
68462 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68463 o_conv.is_owned = false;
68464 int64_t ret_conv = Bolt11InvoiceSignature_hash(&o_conv);
68468 jboolean __attribute__((export_name("TS_Bolt11InvoiceSignature_eq"))) TS_Bolt11InvoiceSignature_eq(uint64_t a, uint64_t b) {
68469 LDKBolt11InvoiceSignature a_conv;
68470 a_conv.inner = untag_ptr(a);
68471 a_conv.is_owned = ptr_is_owned(a);
68472 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68473 a_conv.is_owned = false;
68474 LDKBolt11InvoiceSignature b_conv;
68475 b_conv.inner = untag_ptr(b);
68476 b_conv.is_owned = ptr_is_owned(b);
68477 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68478 b_conv.is_owned = false;
68479 jboolean ret_conv = Bolt11InvoiceSignature_eq(&a_conv, &b_conv);
68483 void __attribute__((export_name("TS_PrivateRoute_free"))) TS_PrivateRoute_free(uint64_t this_obj) {
68484 LDKPrivateRoute this_obj_conv;
68485 this_obj_conv.inner = untag_ptr(this_obj);
68486 this_obj_conv.is_owned = ptr_is_owned(this_obj);
68487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
68488 PrivateRoute_free(this_obj_conv);
68491 static inline uint64_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
68492 LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
68493 uint64_t ret_ref = 0;
68494 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68495 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68498 int64_t __attribute__((export_name("TS_PrivateRoute_clone_ptr"))) TS_PrivateRoute_clone_ptr(uint64_t arg) {
68499 LDKPrivateRoute arg_conv;
68500 arg_conv.inner = untag_ptr(arg);
68501 arg_conv.is_owned = ptr_is_owned(arg);
68502 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
68503 arg_conv.is_owned = false;
68504 int64_t ret_conv = PrivateRoute_clone_ptr(&arg_conv);
68508 uint64_t __attribute__((export_name("TS_PrivateRoute_clone"))) TS_PrivateRoute_clone(uint64_t orig) {
68509 LDKPrivateRoute orig_conv;
68510 orig_conv.inner = untag_ptr(orig);
68511 orig_conv.is_owned = ptr_is_owned(orig);
68512 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
68513 orig_conv.is_owned = false;
68514 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
68515 uint64_t ret_ref = 0;
68516 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68517 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68521 int64_t __attribute__((export_name("TS_PrivateRoute_hash"))) TS_PrivateRoute_hash(uint64_t o) {
68522 LDKPrivateRoute o_conv;
68523 o_conv.inner = untag_ptr(o);
68524 o_conv.is_owned = ptr_is_owned(o);
68525 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
68526 o_conv.is_owned = false;
68527 int64_t ret_conv = PrivateRoute_hash(&o_conv);
68531 jboolean __attribute__((export_name("TS_PrivateRoute_eq"))) TS_PrivateRoute_eq(uint64_t a, uint64_t b) {
68532 LDKPrivateRoute a_conv;
68533 a_conv.inner = untag_ptr(a);
68534 a_conv.is_owned = ptr_is_owned(a);
68535 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
68536 a_conv.is_owned = false;
68537 LDKPrivateRoute b_conv;
68538 b_conv.inner = untag_ptr(b);
68539 b_conv.is_owned = ptr_is_owned(b);
68540 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
68541 b_conv.is_owned = false;
68542 jboolean ret_conv = PrivateRoute_eq(&a_conv, &b_conv);
68546 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_into_parts"))) TS_SignedRawBolt11Invoice_into_parts(uint64_t this_arg) {
68547 LDKSignedRawBolt11Invoice this_arg_conv;
68548 this_arg_conv.inner = untag_ptr(this_arg);
68549 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68550 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68551 this_arg_conv = SignedRawBolt11Invoice_clone(&this_arg_conv);
68552 LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ), "LDKC3Tuple_RawBolt11Invoice_u832Bolt11InvoiceSignatureZ");
68553 *ret_conv = SignedRawBolt11Invoice_into_parts(this_arg_conv);
68554 return tag_ptr(ret_conv, true);
68557 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_raw_invoice"))) TS_SignedRawBolt11Invoice_raw_invoice(uint64_t this_arg) {
68558 LDKSignedRawBolt11Invoice this_arg_conv;
68559 this_arg_conv.inner = untag_ptr(this_arg);
68560 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68561 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68562 this_arg_conv.is_owned = false;
68563 LDKRawBolt11Invoice ret_var = SignedRawBolt11Invoice_raw_invoice(&this_arg_conv);
68564 uint64_t ret_ref = 0;
68565 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68566 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68570 int8_tArray __attribute__((export_name("TS_SignedRawBolt11Invoice_signable_hash"))) TS_SignedRawBolt11Invoice_signable_hash(uint64_t this_arg) {
68571 LDKSignedRawBolt11Invoice this_arg_conv;
68572 this_arg_conv.inner = untag_ptr(this_arg);
68573 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68575 this_arg_conv.is_owned = false;
68576 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
68577 memcpy(ret_arr->elems, *SignedRawBolt11Invoice_signable_hash(&this_arg_conv), 32);
68581 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_signature"))) TS_SignedRawBolt11Invoice_signature(uint64_t this_arg) {
68582 LDKSignedRawBolt11Invoice this_arg_conv;
68583 this_arg_conv.inner = untag_ptr(this_arg);
68584 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68586 this_arg_conv.is_owned = false;
68587 LDKBolt11InvoiceSignature ret_var = SignedRawBolt11Invoice_signature(&this_arg_conv);
68588 uint64_t ret_ref = 0;
68589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68590 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68594 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_recover_payee_pub_key"))) TS_SignedRawBolt11Invoice_recover_payee_pub_key(uint64_t this_arg) {
68595 LDKSignedRawBolt11Invoice this_arg_conv;
68596 this_arg_conv.inner = untag_ptr(this_arg);
68597 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68598 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68599 this_arg_conv.is_owned = false;
68600 LDKCResult_PayeePubKeySecp256k1ErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeySecp256k1ErrorZ), "LDKCResult_PayeePubKeySecp256k1ErrorZ");
68601 *ret_conv = SignedRawBolt11Invoice_recover_payee_pub_key(&this_arg_conv);
68602 return tag_ptr(ret_conv, true);
68605 jboolean __attribute__((export_name("TS_SignedRawBolt11Invoice_check_signature"))) TS_SignedRawBolt11Invoice_check_signature(uint64_t this_arg) {
68606 LDKSignedRawBolt11Invoice this_arg_conv;
68607 this_arg_conv.inner = untag_ptr(this_arg);
68608 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68609 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68610 this_arg_conv.is_owned = false;
68611 jboolean ret_conv = SignedRawBolt11Invoice_check_signature(&this_arg_conv);
68615 int8_tArray __attribute__((export_name("TS_RawBolt11Invoice_signable_hash"))) TS_RawBolt11Invoice_signable_hash(uint64_t this_arg) {
68616 LDKRawBolt11Invoice this_arg_conv;
68617 this_arg_conv.inner = untag_ptr(this_arg);
68618 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68620 this_arg_conv.is_owned = false;
68621 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
68622 memcpy(ret_arr->elems, RawBolt11Invoice_signable_hash(&this_arg_conv).data, 32);
68626 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_payment_hash"))) TS_RawBolt11Invoice_payment_hash(uint64_t this_arg) {
68627 LDKRawBolt11Invoice this_arg_conv;
68628 this_arg_conv.inner = untag_ptr(this_arg);
68629 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68630 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68631 this_arg_conv.is_owned = false;
68632 LDKSha256 ret_var = RawBolt11Invoice_payment_hash(&this_arg_conv);
68633 uint64_t ret_ref = 0;
68634 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68635 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68639 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_description"))) TS_RawBolt11Invoice_description(uint64_t this_arg) {
68640 LDKRawBolt11Invoice this_arg_conv;
68641 this_arg_conv.inner = untag_ptr(this_arg);
68642 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68643 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68644 this_arg_conv.is_owned = false;
68645 LDKDescription ret_var = RawBolt11Invoice_description(&this_arg_conv);
68646 uint64_t ret_ref = 0;
68647 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68648 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68652 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_payee_pub_key"))) TS_RawBolt11Invoice_payee_pub_key(uint64_t this_arg) {
68653 LDKRawBolt11Invoice this_arg_conv;
68654 this_arg_conv.inner = untag_ptr(this_arg);
68655 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68657 this_arg_conv.is_owned = false;
68658 LDKPayeePubKey ret_var = RawBolt11Invoice_payee_pub_key(&this_arg_conv);
68659 uint64_t ret_ref = 0;
68660 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68661 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68665 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_description_hash"))) TS_RawBolt11Invoice_description_hash(uint64_t this_arg) {
68666 LDKRawBolt11Invoice this_arg_conv;
68667 this_arg_conv.inner = untag_ptr(this_arg);
68668 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68670 this_arg_conv.is_owned = false;
68671 LDKSha256 ret_var = RawBolt11Invoice_description_hash(&this_arg_conv);
68672 uint64_t ret_ref = 0;
68673 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68674 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68678 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_expiry_time"))) TS_RawBolt11Invoice_expiry_time(uint64_t this_arg) {
68679 LDKRawBolt11Invoice this_arg_conv;
68680 this_arg_conv.inner = untag_ptr(this_arg);
68681 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68683 this_arg_conv.is_owned = false;
68684 LDKExpiryTime ret_var = RawBolt11Invoice_expiry_time(&this_arg_conv);
68685 uint64_t ret_ref = 0;
68686 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68687 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68691 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_min_final_cltv_expiry_delta"))) TS_RawBolt11Invoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
68692 LDKRawBolt11Invoice this_arg_conv;
68693 this_arg_conv.inner = untag_ptr(this_arg);
68694 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68695 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68696 this_arg_conv.is_owned = false;
68697 LDKMinFinalCltvExpiryDelta ret_var = RawBolt11Invoice_min_final_cltv_expiry_delta(&this_arg_conv);
68698 uint64_t ret_ref = 0;
68699 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68700 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68704 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_payment_secret"))) TS_RawBolt11Invoice_payment_secret(uint64_t this_arg) {
68705 LDKRawBolt11Invoice this_arg_conv;
68706 this_arg_conv.inner = untag_ptr(this_arg);
68707 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68708 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68709 this_arg_conv.is_owned = false;
68710 LDKCOption_ThirtyTwoBytesZ *ret_copy = MALLOC(sizeof(LDKCOption_ThirtyTwoBytesZ), "LDKCOption_ThirtyTwoBytesZ");
68711 *ret_copy = RawBolt11Invoice_payment_secret(&this_arg_conv);
68712 uint64_t ret_ref = tag_ptr(ret_copy, true);
68716 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_payment_metadata"))) TS_RawBolt11Invoice_payment_metadata(uint64_t this_arg) {
68717 LDKRawBolt11Invoice this_arg_conv;
68718 this_arg_conv.inner = untag_ptr(this_arg);
68719 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68720 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68721 this_arg_conv.is_owned = false;
68722 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
68723 *ret_copy = RawBolt11Invoice_payment_metadata(&this_arg_conv);
68724 uint64_t ret_ref = tag_ptr(ret_copy, true);
68728 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_features"))) TS_RawBolt11Invoice_features(uint64_t this_arg) {
68729 LDKRawBolt11Invoice this_arg_conv;
68730 this_arg_conv.inner = untag_ptr(this_arg);
68731 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68733 this_arg_conv.is_owned = false;
68734 LDKBolt11InvoiceFeatures ret_var = RawBolt11Invoice_features(&this_arg_conv);
68735 uint64_t ret_ref = 0;
68736 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68737 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68741 uint64_tArray __attribute__((export_name("TS_RawBolt11Invoice_private_routes"))) TS_RawBolt11Invoice_private_routes(uint64_t this_arg) {
68742 LDKRawBolt11Invoice this_arg_conv;
68743 this_arg_conv.inner = untag_ptr(this_arg);
68744 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68746 this_arg_conv.is_owned = false;
68747 LDKCVec_PrivateRouteZ ret_var = RawBolt11Invoice_private_routes(&this_arg_conv);
68748 uint64_tArray ret_arr = NULL;
68749 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
68750 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
68751 for (size_t o = 0; o < ret_var.datalen; o++) {
68752 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
68753 uint64_t ret_conv_14_ref = 0;
68754 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
68755 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
68756 ret_arr_ptr[o] = ret_conv_14_ref;
68759 FREE(ret_var.data);
68763 uint64_t __attribute__((export_name("TS_RawBolt11Invoice_amount_pico_btc"))) TS_RawBolt11Invoice_amount_pico_btc(uint64_t this_arg) {
68764 LDKRawBolt11Invoice this_arg_conv;
68765 this_arg_conv.inner = untag_ptr(this_arg);
68766 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68767 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68768 this_arg_conv.is_owned = false;
68769 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
68770 *ret_copy = RawBolt11Invoice_amount_pico_btc(&this_arg_conv);
68771 uint64_t ret_ref = tag_ptr(ret_copy, true);
68775 uint32_t __attribute__((export_name("TS_RawBolt11Invoice_currency"))) TS_RawBolt11Invoice_currency(uint64_t this_arg) {
68776 LDKRawBolt11Invoice this_arg_conv;
68777 this_arg_conv.inner = untag_ptr(this_arg);
68778 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68780 this_arg_conv.is_owned = false;
68781 uint32_t ret_conv = LDKCurrency_to_js(RawBolt11Invoice_currency(&this_arg_conv));
68785 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_unix_timestamp"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
68786 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
68787 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
68788 return tag_ptr(ret_conv, true);
68791 uint64_t __attribute__((export_name("TS_PositiveTimestamp_from_duration_since_epoch"))) TS_PositiveTimestamp_from_duration_since_epoch(int64_t duration) {
68792 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
68793 *ret_conv = PositiveTimestamp_from_duration_since_epoch(duration);
68794 return tag_ptr(ret_conv, true);
68797 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_unix_timestamp"))) TS_PositiveTimestamp_as_unix_timestamp(uint64_t this_arg) {
68798 LDKPositiveTimestamp this_arg_conv;
68799 this_arg_conv.inner = untag_ptr(this_arg);
68800 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68802 this_arg_conv.is_owned = false;
68803 int64_t ret_conv = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
68807 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_duration_since_epoch"))) TS_PositiveTimestamp_as_duration_since_epoch(uint64_t this_arg) {
68808 LDKPositiveTimestamp this_arg_conv;
68809 this_arg_conv.inner = untag_ptr(this_arg);
68810 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68811 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68812 this_arg_conv.is_owned = false;
68813 int64_t ret_conv = PositiveTimestamp_as_duration_since_epoch(&this_arg_conv);
68817 int8_tArray __attribute__((export_name("TS_Bolt11Invoice_signable_hash"))) TS_Bolt11Invoice_signable_hash(uint64_t this_arg) {
68818 LDKBolt11Invoice this_arg_conv;
68819 this_arg_conv.inner = untag_ptr(this_arg);
68820 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68822 this_arg_conv.is_owned = false;
68823 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
68824 memcpy(ret_arr->elems, Bolt11Invoice_signable_hash(&this_arg_conv).data, 32);
68828 uint64_t __attribute__((export_name("TS_Bolt11Invoice_into_signed_raw"))) TS_Bolt11Invoice_into_signed_raw(uint64_t this_arg) {
68829 LDKBolt11Invoice this_arg_conv;
68830 this_arg_conv.inner = untag_ptr(this_arg);
68831 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68833 this_arg_conv = Bolt11Invoice_clone(&this_arg_conv);
68834 LDKSignedRawBolt11Invoice ret_var = Bolt11Invoice_into_signed_raw(this_arg_conv);
68835 uint64_t ret_ref = 0;
68836 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68837 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68841 uint64_t __attribute__((export_name("TS_Bolt11Invoice_check_signature"))) TS_Bolt11Invoice_check_signature(uint64_t this_arg) {
68842 LDKBolt11Invoice this_arg_conv;
68843 this_arg_conv.inner = untag_ptr(this_arg);
68844 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68846 this_arg_conv.is_owned = false;
68847 LDKCResult_NoneBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneBolt11SemanticErrorZ), "LDKCResult_NoneBolt11SemanticErrorZ");
68848 *ret_conv = Bolt11Invoice_check_signature(&this_arg_conv);
68849 return tag_ptr(ret_conv, true);
68852 uint64_t __attribute__((export_name("TS_Bolt11Invoice_from_signed"))) TS_Bolt11Invoice_from_signed(uint64_t signed_invoice) {
68853 LDKSignedRawBolt11Invoice signed_invoice_conv;
68854 signed_invoice_conv.inner = untag_ptr(signed_invoice);
68855 signed_invoice_conv.is_owned = ptr_is_owned(signed_invoice);
68856 CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
68857 signed_invoice_conv = SignedRawBolt11Invoice_clone(&signed_invoice_conv);
68858 LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ), "LDKCResult_Bolt11InvoiceBolt11SemanticErrorZ");
68859 *ret_conv = Bolt11Invoice_from_signed(signed_invoice_conv);
68860 return tag_ptr(ret_conv, true);
68863 int64_t __attribute__((export_name("TS_Bolt11Invoice_duration_since_epoch"))) TS_Bolt11Invoice_duration_since_epoch(uint64_t this_arg) {
68864 LDKBolt11Invoice this_arg_conv;
68865 this_arg_conv.inner = untag_ptr(this_arg);
68866 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68867 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68868 this_arg_conv.is_owned = false;
68869 int64_t ret_conv = Bolt11Invoice_duration_since_epoch(&this_arg_conv);
68873 int8_tArray __attribute__((export_name("TS_Bolt11Invoice_payment_hash"))) TS_Bolt11Invoice_payment_hash(uint64_t this_arg) {
68874 LDKBolt11Invoice this_arg_conv;
68875 this_arg_conv.inner = untag_ptr(this_arg);
68876 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68878 this_arg_conv.is_owned = false;
68879 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
68880 memcpy(ret_arr->elems, *Bolt11Invoice_payment_hash(&this_arg_conv), 32);
68884 int8_tArray __attribute__((export_name("TS_Bolt11Invoice_payee_pub_key"))) TS_Bolt11Invoice_payee_pub_key(uint64_t this_arg) {
68885 LDKBolt11Invoice this_arg_conv;
68886 this_arg_conv.inner = untag_ptr(this_arg);
68887 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68888 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68889 this_arg_conv.is_owned = false;
68890 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
68891 memcpy(ret_arr->elems, Bolt11Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
68895 int8_tArray __attribute__((export_name("TS_Bolt11Invoice_payment_secret"))) TS_Bolt11Invoice_payment_secret(uint64_t this_arg) {
68896 LDKBolt11Invoice this_arg_conv;
68897 this_arg_conv.inner = untag_ptr(this_arg);
68898 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68900 this_arg_conv.is_owned = false;
68901 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
68902 memcpy(ret_arr->elems, *Bolt11Invoice_payment_secret(&this_arg_conv), 32);
68906 uint64_t __attribute__((export_name("TS_Bolt11Invoice_payment_metadata"))) TS_Bolt11Invoice_payment_metadata(uint64_t this_arg) {
68907 LDKBolt11Invoice this_arg_conv;
68908 this_arg_conv.inner = untag_ptr(this_arg);
68909 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68911 this_arg_conv.is_owned = false;
68912 LDKCOption_CVec_u8ZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_u8ZZ), "LDKCOption_CVec_u8ZZ");
68913 *ret_copy = Bolt11Invoice_payment_metadata(&this_arg_conv);
68914 uint64_t ret_ref = tag_ptr(ret_copy, true);
68918 uint64_t __attribute__((export_name("TS_Bolt11Invoice_features"))) TS_Bolt11Invoice_features(uint64_t this_arg) {
68919 LDKBolt11Invoice this_arg_conv;
68920 this_arg_conv.inner = untag_ptr(this_arg);
68921 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68922 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68923 this_arg_conv.is_owned = false;
68924 LDKBolt11InvoiceFeatures ret_var = Bolt11Invoice_features(&this_arg_conv);
68925 uint64_t ret_ref = 0;
68926 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
68927 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
68931 int8_tArray __attribute__((export_name("TS_Bolt11Invoice_recover_payee_pub_key"))) TS_Bolt11Invoice_recover_payee_pub_key(uint64_t this_arg) {
68932 LDKBolt11Invoice this_arg_conv;
68933 this_arg_conv.inner = untag_ptr(this_arg);
68934 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68936 this_arg_conv.is_owned = false;
68937 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
68938 memcpy(ret_arr->elems, Bolt11Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
68942 uint64_t __attribute__((export_name("TS_Bolt11Invoice_expires_at"))) TS_Bolt11Invoice_expires_at(uint64_t this_arg) {
68943 LDKBolt11Invoice this_arg_conv;
68944 this_arg_conv.inner = untag_ptr(this_arg);
68945 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68947 this_arg_conv.is_owned = false;
68948 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
68949 *ret_copy = Bolt11Invoice_expires_at(&this_arg_conv);
68950 uint64_t ret_ref = tag_ptr(ret_copy, true);
68954 int64_t __attribute__((export_name("TS_Bolt11Invoice_expiry_time"))) TS_Bolt11Invoice_expiry_time(uint64_t this_arg) {
68955 LDKBolt11Invoice this_arg_conv;
68956 this_arg_conv.inner = untag_ptr(this_arg);
68957 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68959 this_arg_conv.is_owned = false;
68960 int64_t ret_conv = Bolt11Invoice_expiry_time(&this_arg_conv);
68964 int64_t __attribute__((export_name("TS_Bolt11Invoice_expiration_remaining_from_epoch"))) TS_Bolt11Invoice_expiration_remaining_from_epoch(uint64_t this_arg, int64_t time) {
68965 LDKBolt11Invoice this_arg_conv;
68966 this_arg_conv.inner = untag_ptr(this_arg);
68967 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68969 this_arg_conv.is_owned = false;
68970 int64_t ret_conv = Bolt11Invoice_expiration_remaining_from_epoch(&this_arg_conv, time);
68974 jboolean __attribute__((export_name("TS_Bolt11Invoice_would_expire"))) TS_Bolt11Invoice_would_expire(uint64_t this_arg, int64_t at_time) {
68975 LDKBolt11Invoice this_arg_conv;
68976 this_arg_conv.inner = untag_ptr(this_arg);
68977 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68979 this_arg_conv.is_owned = false;
68980 jboolean ret_conv = Bolt11Invoice_would_expire(&this_arg_conv, at_time);
68984 int64_t __attribute__((export_name("TS_Bolt11Invoice_min_final_cltv_expiry_delta"))) TS_Bolt11Invoice_min_final_cltv_expiry_delta(uint64_t this_arg) {
68985 LDKBolt11Invoice this_arg_conv;
68986 this_arg_conv.inner = untag_ptr(this_arg);
68987 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68988 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68989 this_arg_conv.is_owned = false;
68990 int64_t ret_conv = Bolt11Invoice_min_final_cltv_expiry_delta(&this_arg_conv);
68994 ptrArray __attribute__((export_name("TS_Bolt11Invoice_fallback_addresses"))) TS_Bolt11Invoice_fallback_addresses(uint64_t this_arg) {
68995 LDKBolt11Invoice this_arg_conv;
68996 this_arg_conv.inner = untag_ptr(this_arg);
68997 this_arg_conv.is_owned = ptr_is_owned(this_arg);
68998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
68999 this_arg_conv.is_owned = false;
69000 LDKCVec_StrZ ret_var = Bolt11Invoice_fallback_addresses(&this_arg_conv);
69001 ptrArray ret_arr = NULL;
69002 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
69003 jstring *ret_arr_ptr = (jstring*)(((uint8_t*)ret_arr) + 8);
69004 for (size_t i = 0; i < ret_var.datalen; i++) {
69005 LDKStr ret_conv_8_str = ret_var.data[i];
69006 jstring ret_conv_8_conv = str_ref_to_ts(ret_conv_8_str.chars, ret_conv_8_str.len);
69007 Str_free(ret_conv_8_str);
69008 ret_arr_ptr[i] = ret_conv_8_conv;
69011 FREE(ret_var.data);
69015 uint64_tArray __attribute__((export_name("TS_Bolt11Invoice_private_routes"))) TS_Bolt11Invoice_private_routes(uint64_t this_arg) {
69016 LDKBolt11Invoice this_arg_conv;
69017 this_arg_conv.inner = untag_ptr(this_arg);
69018 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69020 this_arg_conv.is_owned = false;
69021 LDKCVec_PrivateRouteZ ret_var = Bolt11Invoice_private_routes(&this_arg_conv);
69022 uint64_tArray ret_arr = NULL;
69023 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
69024 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
69025 for (size_t o = 0; o < ret_var.datalen; o++) {
69026 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
69027 uint64_t ret_conv_14_ref = 0;
69028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
69029 ret_conv_14_ref = tag_ptr(ret_conv_14_var.inner, ret_conv_14_var.is_owned);
69030 ret_arr_ptr[o] = ret_conv_14_ref;
69033 FREE(ret_var.data);
69037 uint64_tArray __attribute__((export_name("TS_Bolt11Invoice_route_hints"))) TS_Bolt11Invoice_route_hints(uint64_t this_arg) {
69038 LDKBolt11Invoice this_arg_conv;
69039 this_arg_conv.inner = untag_ptr(this_arg);
69040 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69042 this_arg_conv.is_owned = false;
69043 LDKCVec_RouteHintZ ret_var = Bolt11Invoice_route_hints(&this_arg_conv);
69044 uint64_tArray ret_arr = NULL;
69045 ret_arr = init_uint64_tArray(ret_var.datalen, __LINE__);
69046 uint64_t *ret_arr_ptr = (uint64_t*)(((uint8_t*)ret_arr) + 8);
69047 for (size_t l = 0; l < ret_var.datalen; l++) {
69048 LDKRouteHint ret_conv_11_var = ret_var.data[l];
69049 uint64_t ret_conv_11_ref = 0;
69050 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
69051 ret_conv_11_ref = tag_ptr(ret_conv_11_var.inner, ret_conv_11_var.is_owned);
69052 ret_arr_ptr[l] = ret_conv_11_ref;
69055 FREE(ret_var.data);
69059 uint32_t __attribute__((export_name("TS_Bolt11Invoice_currency"))) TS_Bolt11Invoice_currency(uint64_t this_arg) {
69060 LDKBolt11Invoice this_arg_conv;
69061 this_arg_conv.inner = untag_ptr(this_arg);
69062 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69064 this_arg_conv.is_owned = false;
69065 uint32_t ret_conv = LDKCurrency_to_js(Bolt11Invoice_currency(&this_arg_conv));
69069 uint64_t __attribute__((export_name("TS_Bolt11Invoice_amount_milli_satoshis"))) TS_Bolt11Invoice_amount_milli_satoshis(uint64_t this_arg) {
69070 LDKBolt11Invoice this_arg_conv;
69071 this_arg_conv.inner = untag_ptr(this_arg);
69072 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69073 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69074 this_arg_conv.is_owned = false;
69075 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
69076 *ret_copy = Bolt11Invoice_amount_milli_satoshis(&this_arg_conv);
69077 uint64_t ret_ref = tag_ptr(ret_copy, true);
69081 uint64_t __attribute__((export_name("TS_Description_new"))) TS_Description_new(jstring description) {
69082 LDKStr description_conv = str_ref_to_owned_c(description);
69083 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
69084 *ret_conv = Description_new(description_conv);
69085 return tag_ptr(ret_conv, true);
69088 jstring __attribute__((export_name("TS_Description_into_inner"))) TS_Description_into_inner(uint64_t this_arg) {
69089 LDKDescription this_arg_conv;
69090 this_arg_conv.inner = untag_ptr(this_arg);
69091 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69093 this_arg_conv = Description_clone(&this_arg_conv);
69094 LDKStr ret_str = Description_into_inner(this_arg_conv);
69095 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69100 uint64_t __attribute__((export_name("TS_ExpiryTime_from_seconds"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
69101 LDKExpiryTime ret_var = ExpiryTime_from_seconds(seconds);
69102 uint64_t ret_ref = 0;
69103 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
69104 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
69108 uint64_t __attribute__((export_name("TS_ExpiryTime_from_duration"))) TS_ExpiryTime_from_duration(int64_t duration) {
69109 LDKExpiryTime ret_var = ExpiryTime_from_duration(duration);
69110 uint64_t ret_ref = 0;
69111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
69112 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
69116 int64_t __attribute__((export_name("TS_ExpiryTime_as_seconds"))) TS_ExpiryTime_as_seconds(uint64_t this_arg) {
69117 LDKExpiryTime this_arg_conv;
69118 this_arg_conv.inner = untag_ptr(this_arg);
69119 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69121 this_arg_conv.is_owned = false;
69122 int64_t ret_conv = ExpiryTime_as_seconds(&this_arg_conv);
69126 int64_t __attribute__((export_name("TS_ExpiryTime_as_duration"))) TS_ExpiryTime_as_duration(uint64_t this_arg) {
69127 LDKExpiryTime this_arg_conv;
69128 this_arg_conv.inner = untag_ptr(this_arg);
69129 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69131 this_arg_conv.is_owned = false;
69132 int64_t ret_conv = ExpiryTime_as_duration(&this_arg_conv);
69136 uint64_t __attribute__((export_name("TS_PrivateRoute_new"))) TS_PrivateRoute_new(uint64_t hops) {
69137 LDKRouteHint hops_conv;
69138 hops_conv.inner = untag_ptr(hops);
69139 hops_conv.is_owned = ptr_is_owned(hops);
69140 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
69141 hops_conv = RouteHint_clone(&hops_conv);
69142 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
69143 *ret_conv = PrivateRoute_new(hops_conv);
69144 return tag_ptr(ret_conv, true);
69147 uint64_t __attribute__((export_name("TS_PrivateRoute_into_inner"))) TS_PrivateRoute_into_inner(uint64_t this_arg) {
69148 LDKPrivateRoute this_arg_conv;
69149 this_arg_conv.inner = untag_ptr(this_arg);
69150 this_arg_conv.is_owned = ptr_is_owned(this_arg);
69151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
69152 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
69153 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
69154 uint64_t ret_ref = 0;
69155 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
69156 ret_ref = tag_ptr(ret_var.inner, ret_var.is_owned);
69160 uint32_t __attribute__((export_name("TS_CreationError_clone"))) TS_CreationError_clone(uint64_t orig) {
69161 LDKCreationError* orig_conv = (LDKCreationError*)untag_ptr(orig);
69162 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
69166 uint32_t __attribute__((export_name("TS_CreationError_description_too_long"))) TS_CreationError_description_too_long() {
69167 uint32_t ret_conv = LDKCreationError_to_js(CreationError_description_too_long());
69171 uint32_t __attribute__((export_name("TS_CreationError_route_too_long"))) TS_CreationError_route_too_long() {
69172 uint32_t ret_conv = LDKCreationError_to_js(CreationError_route_too_long());
69176 uint32_t __attribute__((export_name("TS_CreationError_timestamp_out_of_bounds"))) TS_CreationError_timestamp_out_of_bounds() {
69177 uint32_t ret_conv = LDKCreationError_to_js(CreationError_timestamp_out_of_bounds());
69181 uint32_t __attribute__((export_name("TS_CreationError_invalid_amount"))) TS_CreationError_invalid_amount() {
69182 uint32_t ret_conv = LDKCreationError_to_js(CreationError_invalid_amount());
69186 uint32_t __attribute__((export_name("TS_CreationError_missing_route_hints"))) TS_CreationError_missing_route_hints() {
69187 uint32_t ret_conv = LDKCreationError_to_js(CreationError_missing_route_hints());
69191 uint32_t __attribute__((export_name("TS_CreationError_min_final_cltv_expiry_delta_too_short"))) TS_CreationError_min_final_cltv_expiry_delta_too_short() {
69192 uint32_t ret_conv = LDKCreationError_to_js(CreationError_min_final_cltv_expiry_delta_too_short());
69196 jboolean __attribute__((export_name("TS_CreationError_eq"))) TS_CreationError_eq(uint64_t a, uint64_t b) {
69197 LDKCreationError* a_conv = (LDKCreationError*)untag_ptr(a);
69198 LDKCreationError* b_conv = (LDKCreationError*)untag_ptr(b);
69199 jboolean ret_conv = CreationError_eq(a_conv, b_conv);
69203 jstring __attribute__((export_name("TS_CreationError_to_str"))) TS_CreationError_to_str(uint64_t o) {
69204 LDKCreationError* o_conv = (LDKCreationError*)untag_ptr(o);
69205 LDKStr ret_str = CreationError_to_str(o_conv);
69206 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69211 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_clone"))) TS_Bolt11SemanticError_clone(uint64_t orig) {
69212 LDKBolt11SemanticError* orig_conv = (LDKBolt11SemanticError*)untag_ptr(orig);
69213 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_clone(orig_conv));
69217 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_no_payment_hash"))) TS_Bolt11SemanticError_no_payment_hash() {
69218 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_no_payment_hash());
69222 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_multiple_payment_hashes"))) TS_Bolt11SemanticError_multiple_payment_hashes() {
69223 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_multiple_payment_hashes());
69227 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_no_description"))) TS_Bolt11SemanticError_no_description() {
69228 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_no_description());
69232 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_multiple_descriptions"))) TS_Bolt11SemanticError_multiple_descriptions() {
69233 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_multiple_descriptions());
69237 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_no_payment_secret"))) TS_Bolt11SemanticError_no_payment_secret() {
69238 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_no_payment_secret());
69242 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_multiple_payment_secrets"))) TS_Bolt11SemanticError_multiple_payment_secrets() {
69243 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_multiple_payment_secrets());
69247 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_invalid_features"))) TS_Bolt11SemanticError_invalid_features() {
69248 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_invalid_features());
69252 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_invalid_recovery_id"))) TS_Bolt11SemanticError_invalid_recovery_id() {
69253 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_invalid_recovery_id());
69257 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_invalid_signature"))) TS_Bolt11SemanticError_invalid_signature() {
69258 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_invalid_signature());
69262 uint32_t __attribute__((export_name("TS_Bolt11SemanticError_imprecise_amount"))) TS_Bolt11SemanticError_imprecise_amount() {
69263 uint32_t ret_conv = LDKBolt11SemanticError_to_js(Bolt11SemanticError_imprecise_amount());
69267 jboolean __attribute__((export_name("TS_Bolt11SemanticError_eq"))) TS_Bolt11SemanticError_eq(uint64_t a, uint64_t b) {
69268 LDKBolt11SemanticError* a_conv = (LDKBolt11SemanticError*)untag_ptr(a);
69269 LDKBolt11SemanticError* b_conv = (LDKBolt11SemanticError*)untag_ptr(b);
69270 jboolean ret_conv = Bolt11SemanticError_eq(a_conv, b_conv);
69274 jstring __attribute__((export_name("TS_Bolt11SemanticError_to_str"))) TS_Bolt11SemanticError_to_str(uint64_t o) {
69275 LDKBolt11SemanticError* o_conv = (LDKBolt11SemanticError*)untag_ptr(o);
69276 LDKStr ret_str = Bolt11SemanticError_to_str(o_conv);
69277 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69282 void __attribute__((export_name("TS_SignOrCreationError_free"))) TS_SignOrCreationError_free(uint64_t this_ptr) {
69283 if (!ptr_is_owned(this_ptr)) return;
69284 void* this_ptr_ptr = untag_ptr(this_ptr);
69285 CHECK_ACCESS(this_ptr_ptr);
69286 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(this_ptr_ptr);
69287 FREE(untag_ptr(this_ptr));
69288 SignOrCreationError_free(this_ptr_conv);
69291 static inline uint64_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
69292 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
69293 *ret_copy = SignOrCreationError_clone(arg);
69294 uint64_t ret_ref = tag_ptr(ret_copy, true);
69297 int64_t __attribute__((export_name("TS_SignOrCreationError_clone_ptr"))) TS_SignOrCreationError_clone_ptr(uint64_t arg) {
69298 LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)untag_ptr(arg);
69299 int64_t ret_conv = SignOrCreationError_clone_ptr(arg_conv);
69303 uint64_t __attribute__((export_name("TS_SignOrCreationError_clone"))) TS_SignOrCreationError_clone(uint64_t orig) {
69304 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)untag_ptr(orig);
69305 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
69306 *ret_copy = SignOrCreationError_clone(orig_conv);
69307 uint64_t ret_ref = tag_ptr(ret_copy, true);
69311 uint64_t __attribute__((export_name("TS_SignOrCreationError_sign_error"))) TS_SignOrCreationError_sign_error() {
69312 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
69313 *ret_copy = SignOrCreationError_sign_error();
69314 uint64_t ret_ref = tag_ptr(ret_copy, true);
69318 uint64_t __attribute__((export_name("TS_SignOrCreationError_creation_error"))) TS_SignOrCreationError_creation_error(uint32_t a) {
69319 LDKCreationError a_conv = LDKCreationError_from_js(a);
69320 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
69321 *ret_copy = SignOrCreationError_creation_error(a_conv);
69322 uint64_t ret_ref = tag_ptr(ret_copy, true);
69326 jboolean __attribute__((export_name("TS_SignOrCreationError_eq"))) TS_SignOrCreationError_eq(uint64_t a, uint64_t b) {
69327 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)untag_ptr(a);
69328 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)untag_ptr(b);
69329 jboolean ret_conv = SignOrCreationError_eq(a_conv, b_conv);
69333 jstring __attribute__((export_name("TS_SignOrCreationError_to_str"))) TS_SignOrCreationError_to_str(uint64_t o) {
69334 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)untag_ptr(o);
69335 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
69336 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69341 uint64_t __attribute__((export_name("TS_pay_invoice"))) TS_pay_invoice(uint64_t invoice, uint64_t retry_strategy, uint64_t channelmanager) {
69342 LDKBolt11Invoice invoice_conv;
69343 invoice_conv.inner = untag_ptr(invoice);
69344 invoice_conv.is_owned = ptr_is_owned(invoice);
69345 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69346 invoice_conv.is_owned = false;
69347 void* retry_strategy_ptr = untag_ptr(retry_strategy);
69348 CHECK_ACCESS(retry_strategy_ptr);
69349 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
69350 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
69351 LDKChannelManager channelmanager_conv;
69352 channelmanager_conv.inner = untag_ptr(channelmanager);
69353 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69354 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69355 channelmanager_conv.is_owned = false;
69356 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
69357 *ret_conv = pay_invoice(&invoice_conv, retry_strategy_conv, &channelmanager_conv);
69358 return tag_ptr(ret_conv, true);
69361 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) {
69362 LDKBolt11Invoice invoice_conv;
69363 invoice_conv.inner = untag_ptr(invoice);
69364 invoice_conv.is_owned = ptr_is_owned(invoice);
69365 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69366 invoice_conv.is_owned = false;
69367 LDKThirtyTwoBytes payment_id_ref;
69368 CHECK(payment_id->arr_len == 32);
69369 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
69370 void* retry_strategy_ptr = untag_ptr(retry_strategy);
69371 CHECK_ACCESS(retry_strategy_ptr);
69372 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
69373 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
69374 LDKChannelManager channelmanager_conv;
69375 channelmanager_conv.inner = untag_ptr(channelmanager);
69376 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69377 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69378 channelmanager_conv.is_owned = false;
69379 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
69380 *ret_conv = pay_invoice_with_id(&invoice_conv, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
69381 return tag_ptr(ret_conv, true);
69384 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) {
69385 LDKBolt11Invoice invoice_conv;
69386 invoice_conv.inner = untag_ptr(invoice);
69387 invoice_conv.is_owned = ptr_is_owned(invoice);
69388 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69389 invoice_conv.is_owned = false;
69390 void* retry_strategy_ptr = untag_ptr(retry_strategy);
69391 CHECK_ACCESS(retry_strategy_ptr);
69392 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
69393 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
69394 LDKChannelManager channelmanager_conv;
69395 channelmanager_conv.inner = untag_ptr(channelmanager);
69396 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69397 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69398 channelmanager_conv.is_owned = false;
69399 LDKCResult_ThirtyTwoBytesPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ThirtyTwoBytesPaymentErrorZ), "LDKCResult_ThirtyTwoBytesPaymentErrorZ");
69400 *ret_conv = pay_zero_value_invoice(&invoice_conv, amount_msats, retry_strategy_conv, &channelmanager_conv);
69401 return tag_ptr(ret_conv, true);
69404 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) {
69405 LDKBolt11Invoice invoice_conv;
69406 invoice_conv.inner = untag_ptr(invoice);
69407 invoice_conv.is_owned = ptr_is_owned(invoice);
69408 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69409 invoice_conv.is_owned = false;
69410 LDKThirtyTwoBytes payment_id_ref;
69411 CHECK(payment_id->arr_len == 32);
69412 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
69413 void* retry_strategy_ptr = untag_ptr(retry_strategy);
69414 CHECK_ACCESS(retry_strategy_ptr);
69415 LDKRetry retry_strategy_conv = *(LDKRetry*)(retry_strategy_ptr);
69416 retry_strategy_conv = Retry_clone((LDKRetry*)untag_ptr(retry_strategy));
69417 LDKChannelManager channelmanager_conv;
69418 channelmanager_conv.inner = untag_ptr(channelmanager);
69419 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69420 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69421 channelmanager_conv.is_owned = false;
69422 LDKCResult_NonePaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentErrorZ), "LDKCResult_NonePaymentErrorZ");
69423 *ret_conv = pay_zero_value_invoice_with_id(&invoice_conv, amount_msats, payment_id_ref, retry_strategy_conv, &channelmanager_conv);
69424 return tag_ptr(ret_conv, true);
69427 uint64_t __attribute__((export_name("TS_preflight_probe_invoice"))) TS_preflight_probe_invoice(uint64_t invoice, uint64_t channelmanager, uint64_t liquidity_limit_multiplier) {
69428 LDKBolt11Invoice invoice_conv;
69429 invoice_conv.inner = untag_ptr(invoice);
69430 invoice_conv.is_owned = ptr_is_owned(invoice);
69431 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69432 invoice_conv.is_owned = false;
69433 LDKChannelManager channelmanager_conv;
69434 channelmanager_conv.inner = untag_ptr(channelmanager);
69435 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69436 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69437 channelmanager_conv.is_owned = false;
69438 void* liquidity_limit_multiplier_ptr = untag_ptr(liquidity_limit_multiplier);
69439 CHECK_ACCESS(liquidity_limit_multiplier_ptr);
69440 LDKCOption_u64Z liquidity_limit_multiplier_conv = *(LDKCOption_u64Z*)(liquidity_limit_multiplier_ptr);
69441 liquidity_limit_multiplier_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(liquidity_limit_multiplier));
69442 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
69443 *ret_conv = preflight_probe_invoice(&invoice_conv, &channelmanager_conv, liquidity_limit_multiplier_conv);
69444 return tag_ptr(ret_conv, true);
69447 uint64_t __attribute__((export_name("TS_preflight_probe_zero_value_invoice"))) TS_preflight_probe_zero_value_invoice(uint64_t invoice, int64_t amount_msat, uint64_t channelmanager, uint64_t liquidity_limit_multiplier) {
69448 LDKBolt11Invoice invoice_conv;
69449 invoice_conv.inner = untag_ptr(invoice);
69450 invoice_conv.is_owned = ptr_is_owned(invoice);
69451 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
69452 invoice_conv.is_owned = false;
69453 LDKChannelManager channelmanager_conv;
69454 channelmanager_conv.inner = untag_ptr(channelmanager);
69455 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69456 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69457 channelmanager_conv.is_owned = false;
69458 void* liquidity_limit_multiplier_ptr = untag_ptr(liquidity_limit_multiplier);
69459 CHECK_ACCESS(liquidity_limit_multiplier_ptr);
69460 LDKCOption_u64Z liquidity_limit_multiplier_conv = *(LDKCOption_u64Z*)(liquidity_limit_multiplier_ptr);
69461 liquidity_limit_multiplier_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(liquidity_limit_multiplier));
69462 LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ), "LDKCResult_CVec_C2Tuple_ThirtyTwoBytesThirtyTwoBytesZZProbingErrorZ");
69463 *ret_conv = preflight_probe_zero_value_invoice(&invoice_conv, amount_msat, &channelmanager_conv, liquidity_limit_multiplier_conv);
69464 return tag_ptr(ret_conv, true);
69467 void __attribute__((export_name("TS_PaymentError_free"))) TS_PaymentError_free(uint64_t this_ptr) {
69468 if (!ptr_is_owned(this_ptr)) return;
69469 void* this_ptr_ptr = untag_ptr(this_ptr);
69470 CHECK_ACCESS(this_ptr_ptr);
69471 LDKPaymentError this_ptr_conv = *(LDKPaymentError*)(this_ptr_ptr);
69472 FREE(untag_ptr(this_ptr));
69473 PaymentError_free(this_ptr_conv);
69476 static inline uint64_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
69477 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
69478 *ret_copy = PaymentError_clone(arg);
69479 uint64_t ret_ref = tag_ptr(ret_copy, true);
69482 int64_t __attribute__((export_name("TS_PaymentError_clone_ptr"))) TS_PaymentError_clone_ptr(uint64_t arg) {
69483 LDKPaymentError* arg_conv = (LDKPaymentError*)untag_ptr(arg);
69484 int64_t ret_conv = PaymentError_clone_ptr(arg_conv);
69488 uint64_t __attribute__((export_name("TS_PaymentError_clone"))) TS_PaymentError_clone(uint64_t orig) {
69489 LDKPaymentError* orig_conv = (LDKPaymentError*)untag_ptr(orig);
69490 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
69491 *ret_copy = PaymentError_clone(orig_conv);
69492 uint64_t ret_ref = tag_ptr(ret_copy, true);
69496 uint64_t __attribute__((export_name("TS_PaymentError_invoice"))) TS_PaymentError_invoice(jstring a) {
69497 LDKStr a_conv = str_ref_to_owned_c(a);
69498 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
69499 *ret_copy = PaymentError_invoice(a_conv);
69500 uint64_t ret_ref = tag_ptr(ret_copy, true);
69504 uint64_t __attribute__((export_name("TS_PaymentError_sending"))) TS_PaymentError_sending(uint32_t a) {
69505 LDKRetryableSendFailure a_conv = LDKRetryableSendFailure_from_js(a);
69506 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
69507 *ret_copy = PaymentError_sending(a_conv);
69508 uint64_t ret_ref = tag_ptr(ret_copy, true);
69512 jboolean __attribute__((export_name("TS_PaymentError_eq"))) TS_PaymentError_eq(uint64_t a, uint64_t b) {
69513 LDKPaymentError* a_conv = (LDKPaymentError*)untag_ptr(a);
69514 LDKPaymentError* b_conv = (LDKPaymentError*)untag_ptr(b);
69515 jboolean ret_conv = PaymentError_eq(a_conv, b_conv);
69519 void __attribute__((export_name("TS_ProbingError_free"))) TS_ProbingError_free(uint64_t this_ptr) {
69520 if (!ptr_is_owned(this_ptr)) return;
69521 void* this_ptr_ptr = untag_ptr(this_ptr);
69522 CHECK_ACCESS(this_ptr_ptr);
69523 LDKProbingError this_ptr_conv = *(LDKProbingError*)(this_ptr_ptr);
69524 FREE(untag_ptr(this_ptr));
69525 ProbingError_free(this_ptr_conv);
69528 static inline uint64_t ProbingError_clone_ptr(LDKProbingError *NONNULL_PTR arg) {
69529 LDKProbingError *ret_copy = MALLOC(sizeof(LDKProbingError), "LDKProbingError");
69530 *ret_copy = ProbingError_clone(arg);
69531 uint64_t ret_ref = tag_ptr(ret_copy, true);
69534 int64_t __attribute__((export_name("TS_ProbingError_clone_ptr"))) TS_ProbingError_clone_ptr(uint64_t arg) {
69535 LDKProbingError* arg_conv = (LDKProbingError*)untag_ptr(arg);
69536 int64_t ret_conv = ProbingError_clone_ptr(arg_conv);
69540 uint64_t __attribute__((export_name("TS_ProbingError_clone"))) TS_ProbingError_clone(uint64_t orig) {
69541 LDKProbingError* orig_conv = (LDKProbingError*)untag_ptr(orig);
69542 LDKProbingError *ret_copy = MALLOC(sizeof(LDKProbingError), "LDKProbingError");
69543 *ret_copy = ProbingError_clone(orig_conv);
69544 uint64_t ret_ref = tag_ptr(ret_copy, true);
69548 uint64_t __attribute__((export_name("TS_ProbingError_invoice"))) TS_ProbingError_invoice(jstring a) {
69549 LDKStr a_conv = str_ref_to_owned_c(a);
69550 LDKProbingError *ret_copy = MALLOC(sizeof(LDKProbingError), "LDKProbingError");
69551 *ret_copy = ProbingError_invoice(a_conv);
69552 uint64_t ret_ref = tag_ptr(ret_copy, true);
69556 uint64_t __attribute__((export_name("TS_ProbingError_sending"))) TS_ProbingError_sending(uint64_t a) {
69557 void* a_ptr = untag_ptr(a);
69558 CHECK_ACCESS(a_ptr);
69559 LDKProbeSendFailure a_conv = *(LDKProbeSendFailure*)(a_ptr);
69560 a_conv = ProbeSendFailure_clone((LDKProbeSendFailure*)untag_ptr(a));
69561 LDKProbingError *ret_copy = MALLOC(sizeof(LDKProbingError), "LDKProbingError");
69562 *ret_copy = ProbingError_sending(a_conv);
69563 uint64_t ret_ref = tag_ptr(ret_copy, true);
69567 jboolean __attribute__((export_name("TS_ProbingError_eq"))) TS_ProbingError_eq(uint64_t a, uint64_t b) {
69568 LDKProbingError* a_conv = (LDKProbingError*)untag_ptr(a);
69569 LDKProbingError* b_conv = (LDKProbingError*)untag_ptr(b);
69570 jboolean ret_conv = ProbingError_eq(a_conv, b_conv);
69574 uint64_t __attribute__((export_name("TS_create_phantom_invoice"))) TS_create_phantom_invoice(uint64_t amt_msat, uint64_t 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) {
69575 void* amt_msat_ptr = untag_ptr(amt_msat);
69576 CHECK_ACCESS(amt_msat_ptr);
69577 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
69578 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
69579 void* payment_hash_ptr = untag_ptr(payment_hash);
69580 CHECK_ACCESS(payment_hash_ptr);
69581 LDKCOption_ThirtyTwoBytesZ payment_hash_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_hash_ptr);
69582 payment_hash_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_hash));
69583 LDKStr description_conv = str_ref_to_owned_c(description);
69584 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
69585 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
69586 if (phantom_route_hints_constr.datalen > 0)
69587 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
69589 phantom_route_hints_constr.data = NULL;
69590 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
69591 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
69592 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
69593 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
69594 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
69595 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
69596 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
69597 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
69598 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
69600 FREE(phantom_route_hints);
69601 void* entropy_source_ptr = untag_ptr(entropy_source);
69602 CHECK_ACCESS(entropy_source_ptr);
69603 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
69604 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
69605 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69606 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
69608 void* node_signer_ptr = untag_ptr(node_signer);
69609 CHECK_ACCESS(node_signer_ptr);
69610 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
69611 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
69612 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69613 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
69615 void* logger_ptr = untag_ptr(logger);
69616 CHECK_ACCESS(logger_ptr);
69617 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
69618 if (logger_conv.free == LDKLogger_JCalls_free) {
69619 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69620 LDKLogger_JCalls_cloned(&logger_conv);
69622 LDKCurrency network_conv = LDKCurrency_from_js(network);
69623 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
69624 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
69625 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
69626 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
69627 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
69628 *ret_conv = create_phantom_invoice(amt_msat_conv, payment_hash_conv, 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);
69629 return tag_ptr(ret_conv, true);
69632 uint64_t __attribute__((export_name("TS_create_phantom_invoice_with_description_hash"))) TS_create_phantom_invoice_with_description_hash(uint64_t amt_msat, uint64_t 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) {
69633 void* amt_msat_ptr = untag_ptr(amt_msat);
69634 CHECK_ACCESS(amt_msat_ptr);
69635 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
69636 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
69637 void* payment_hash_ptr = untag_ptr(payment_hash);
69638 CHECK_ACCESS(payment_hash_ptr);
69639 LDKCOption_ThirtyTwoBytesZ payment_hash_conv = *(LDKCOption_ThirtyTwoBytesZ*)(payment_hash_ptr);
69640 payment_hash_conv = COption_ThirtyTwoBytesZ_clone((LDKCOption_ThirtyTwoBytesZ*)untag_ptr(payment_hash));
69641 LDKSha256 description_hash_conv;
69642 description_hash_conv.inner = untag_ptr(description_hash);
69643 description_hash_conv.is_owned = ptr_is_owned(description_hash);
69644 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
69645 description_hash_conv = Sha256_clone(&description_hash_conv);
69646 LDKCVec_PhantomRouteHintsZ phantom_route_hints_constr;
69647 phantom_route_hints_constr.datalen = phantom_route_hints->arr_len;
69648 if (phantom_route_hints_constr.datalen > 0)
69649 phantom_route_hints_constr.data = MALLOC(phantom_route_hints_constr.datalen * sizeof(LDKPhantomRouteHints), "LDKCVec_PhantomRouteHintsZ Elements");
69651 phantom_route_hints_constr.data = NULL;
69652 uint64_t* phantom_route_hints_vals = phantom_route_hints->elems;
69653 for (size_t t = 0; t < phantom_route_hints_constr.datalen; t++) {
69654 uint64_t phantom_route_hints_conv_19 = phantom_route_hints_vals[t];
69655 LDKPhantomRouteHints phantom_route_hints_conv_19_conv;
69656 phantom_route_hints_conv_19_conv.inner = untag_ptr(phantom_route_hints_conv_19);
69657 phantom_route_hints_conv_19_conv.is_owned = ptr_is_owned(phantom_route_hints_conv_19);
69658 CHECK_INNER_FIELD_ACCESS_OR_NULL(phantom_route_hints_conv_19_conv);
69659 phantom_route_hints_conv_19_conv = PhantomRouteHints_clone(&phantom_route_hints_conv_19_conv);
69660 phantom_route_hints_constr.data[t] = phantom_route_hints_conv_19_conv;
69662 FREE(phantom_route_hints);
69663 void* entropy_source_ptr = untag_ptr(entropy_source);
69664 CHECK_ACCESS(entropy_source_ptr);
69665 LDKEntropySource entropy_source_conv = *(LDKEntropySource*)(entropy_source_ptr);
69666 if (entropy_source_conv.free == LDKEntropySource_JCalls_free) {
69667 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69668 LDKEntropySource_JCalls_cloned(&entropy_source_conv);
69670 void* node_signer_ptr = untag_ptr(node_signer);
69671 CHECK_ACCESS(node_signer_ptr);
69672 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
69673 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
69674 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69675 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
69677 void* logger_ptr = untag_ptr(logger);
69678 CHECK_ACCESS(logger_ptr);
69679 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
69680 if (logger_conv.free == LDKLogger_JCalls_free) {
69681 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69682 LDKLogger_JCalls_cloned(&logger_conv);
69684 LDKCurrency network_conv = LDKCurrency_from_js(network);
69685 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
69686 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
69687 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
69688 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
69689 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
69690 *ret_conv = create_phantom_invoice_with_description_hash(amt_msat_conv, payment_hash_conv, 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);
69691 return tag_ptr(ret_conv, true);
69694 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) {
69695 LDKChannelManager channelmanager_conv;
69696 channelmanager_conv.inner = untag_ptr(channelmanager);
69697 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69698 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69699 channelmanager_conv.is_owned = false;
69700 void* node_signer_ptr = untag_ptr(node_signer);
69701 CHECK_ACCESS(node_signer_ptr);
69702 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
69703 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
69704 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69705 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
69707 void* logger_ptr = untag_ptr(logger);
69708 CHECK_ACCESS(logger_ptr);
69709 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
69710 if (logger_conv.free == LDKLogger_JCalls_free) {
69711 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69712 LDKLogger_JCalls_cloned(&logger_conv);
69714 LDKCurrency network_conv = LDKCurrency_from_js(network);
69715 void* amt_msat_ptr = untag_ptr(amt_msat);
69716 CHECK_ACCESS(amt_msat_ptr);
69717 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
69718 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
69719 LDKSha256 description_hash_conv;
69720 description_hash_conv.inner = untag_ptr(description_hash);
69721 description_hash_conv.is_owned = ptr_is_owned(description_hash);
69722 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
69723 description_hash_conv = Sha256_clone(&description_hash_conv);
69724 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
69725 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
69726 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
69727 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
69728 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
69729 *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);
69730 return tag_ptr(ret_conv, true);
69733 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) {
69734 LDKChannelManager channelmanager_conv;
69735 channelmanager_conv.inner = untag_ptr(channelmanager);
69736 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69737 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69738 channelmanager_conv.is_owned = false;
69739 void* node_signer_ptr = untag_ptr(node_signer);
69740 CHECK_ACCESS(node_signer_ptr);
69741 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
69742 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
69743 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69744 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
69746 void* logger_ptr = untag_ptr(logger);
69747 CHECK_ACCESS(logger_ptr);
69748 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
69749 if (logger_conv.free == LDKLogger_JCalls_free) {
69750 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69751 LDKLogger_JCalls_cloned(&logger_conv);
69753 LDKCurrency network_conv = LDKCurrency_from_js(network);
69754 void* amt_msat_ptr = untag_ptr(amt_msat);
69755 CHECK_ACCESS(amt_msat_ptr);
69756 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
69757 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
69758 LDKStr description_conv = str_ref_to_owned_c(description);
69759 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
69760 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
69761 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
69762 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
69763 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
69764 *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);
69765 return tag_ptr(ret_conv, true);
69768 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) {
69769 LDKChannelManager channelmanager_conv;
69770 channelmanager_conv.inner = untag_ptr(channelmanager);
69771 channelmanager_conv.is_owned = ptr_is_owned(channelmanager);
69772 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
69773 channelmanager_conv.is_owned = false;
69774 void* node_signer_ptr = untag_ptr(node_signer);
69775 CHECK_ACCESS(node_signer_ptr);
69776 LDKNodeSigner node_signer_conv = *(LDKNodeSigner*)(node_signer_ptr);
69777 if (node_signer_conv.free == LDKNodeSigner_JCalls_free) {
69778 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69779 LDKNodeSigner_JCalls_cloned(&node_signer_conv);
69781 void* logger_ptr = untag_ptr(logger);
69782 CHECK_ACCESS(logger_ptr);
69783 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
69784 if (logger_conv.free == LDKLogger_JCalls_free) {
69785 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
69786 LDKLogger_JCalls_cloned(&logger_conv);
69788 LDKCurrency network_conv = LDKCurrency_from_js(network);
69789 void* amt_msat_ptr = untag_ptr(amt_msat);
69790 CHECK_ACCESS(amt_msat_ptr);
69791 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
69792 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)untag_ptr(amt_msat));
69793 LDKStr description_conv = str_ref_to_owned_c(description);
69794 LDKThirtyTwoBytes payment_hash_ref;
69795 CHECK(payment_hash->arr_len == 32);
69796 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
69797 void* min_final_cltv_expiry_delta_ptr = untag_ptr(min_final_cltv_expiry_delta);
69798 CHECK_ACCESS(min_final_cltv_expiry_delta_ptr);
69799 LDKCOption_u16Z min_final_cltv_expiry_delta_conv = *(LDKCOption_u16Z*)(min_final_cltv_expiry_delta_ptr);
69800 min_final_cltv_expiry_delta_conv = COption_u16Z_clone((LDKCOption_u16Z*)untag_ptr(min_final_cltv_expiry_delta));
69801 LDKCResult_Bolt11InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceSignOrCreationErrorZ), "LDKCResult_Bolt11InvoiceSignOrCreationErrorZ");
69802 *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);
69803 return tag_ptr(ret_conv, true);
69806 uint64_t __attribute__((export_name("TS_SiPrefix_from_str"))) TS_SiPrefix_from_str(jstring s) {
69807 LDKStr s_conv = str_ref_to_owned_c(s);
69808 LDKCResult_SiPrefixBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixBolt11ParseErrorZ), "LDKCResult_SiPrefixBolt11ParseErrorZ");
69809 *ret_conv = SiPrefix_from_str(s_conv);
69810 return tag_ptr(ret_conv, true);
69813 uint64_t __attribute__((export_name("TS_Bolt11Invoice_from_str"))) TS_Bolt11Invoice_from_str(jstring s) {
69814 LDKStr s_conv = str_ref_to_owned_c(s);
69815 LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ), "LDKCResult_Bolt11InvoiceParseOrSemanticErrorZ");
69816 *ret_conv = Bolt11Invoice_from_str(s_conv);
69817 return tag_ptr(ret_conv, true);
69820 uint64_t __attribute__((export_name("TS_SignedRawBolt11Invoice_from_str"))) TS_SignedRawBolt11Invoice_from_str(jstring s) {
69821 LDKStr s_conv = str_ref_to_owned_c(s);
69822 LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ), "LDKCResult_SignedRawBolt11InvoiceBolt11ParseErrorZ");
69823 *ret_conv = SignedRawBolt11Invoice_from_str(s_conv);
69824 return tag_ptr(ret_conv, true);
69827 jstring __attribute__((export_name("TS_Bolt11ParseError_to_str"))) TS_Bolt11ParseError_to_str(uint64_t o) {
69828 LDKBolt11ParseError* o_conv = (LDKBolt11ParseError*)untag_ptr(o);
69829 LDKStr ret_str = Bolt11ParseError_to_str(o_conv);
69830 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69835 jstring __attribute__((export_name("TS_ParseOrSemanticError_to_str"))) TS_ParseOrSemanticError_to_str(uint64_t o) {
69836 LDKParseOrSemanticError* o_conv = (LDKParseOrSemanticError*)untag_ptr(o);
69837 LDKStr ret_str = ParseOrSemanticError_to_str(o_conv);
69838 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69843 jstring __attribute__((export_name("TS_Bolt11Invoice_to_str"))) TS_Bolt11Invoice_to_str(uint64_t o) {
69844 LDKBolt11Invoice o_conv;
69845 o_conv.inner = untag_ptr(o);
69846 o_conv.is_owned = ptr_is_owned(o);
69847 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
69848 o_conv.is_owned = false;
69849 LDKStr ret_str = Bolt11Invoice_to_str(&o_conv);
69850 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69855 jstring __attribute__((export_name("TS_SignedRawBolt11Invoice_to_str"))) TS_SignedRawBolt11Invoice_to_str(uint64_t o) {
69856 LDKSignedRawBolt11Invoice o_conv;
69857 o_conv.inner = untag_ptr(o);
69858 o_conv.is_owned = ptr_is_owned(o);
69859 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
69860 o_conv.is_owned = false;
69861 LDKStr ret_str = SignedRawBolt11Invoice_to_str(&o_conv);
69862 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69867 jstring __attribute__((export_name("TS_Currency_to_str"))) TS_Currency_to_str(uint64_t o) {
69868 LDKCurrency* o_conv = (LDKCurrency*)untag_ptr(o);
69869 LDKStr ret_str = Currency_to_str(o_conv);
69870 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
69875 jstring __attribute__((export_name("TS_SiPrefix_to_str"))) TS_SiPrefix_to_str(uint64_t o) {
69876 LDKSiPrefix* o_conv = (LDKSiPrefix*)untag_ptr(o);
69877 LDKStr ret_str = SiPrefix_to_str(o_conv);
69878 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);