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 { \
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(uint32_t), #name" array init", lineno); \
46 arr->arr_len = arr_len; \
50 DECL_ARR_TYPE(int64_t, int64_t);
51 DECL_ARR_TYPE(int8_t, int8_t);
52 DECL_ARR_TYPE(uint32_t, uint32_t);
53 DECL_ARR_TYPE(void*, ptr);
54 DECL_ARR_TYPE(char, char);
55 typedef charArray jstring;
57 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
58 charArray arr = init_charArray(len, __LINE__);
59 memcpy(arr->elems, chars, len);
62 static inline LDKStr str_ref_to_owned_c(const jstring str) {
63 char* newchars = MALLOC(str->arr_len + 1, "String chars");
64 memcpy(newchars, str->elems, str->arr_len);
65 newchars[str->arr_len] = 0;
69 .chars_is_owned = true
74 typedef bool jboolean;
76 uint32_t __attribute__((export_name("TS_malloc"))) TS_malloc(uint32_t size) {
77 return (uint32_t)MALLOC(size, "JS-Called malloc");
79 void __attribute__((export_name("TS_free"))) TS_free(uint32_t ptr) {
83 jstring __attribute__((export_name("TS_get_ldk_c_bindings_version"))) TS_get_ldk_c_bindings_version() {
84 const char *res = check_get_ldk_bindings_version();
85 if (res == NULL) return NULL;
86 return str_ref_to_ts(res, strlen(res));
88 jstring __attribute__((export_name("TS_get_ldk_version"))) get_ldk_version() {
89 const char *res = check_get_ldk_version();
90 if (res == NULL) return NULL;
91 return str_ref_to_ts(res, strlen(res));
94 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
95 static inline LDKAccessError LDKAccessError_from_js(int32_t ord) {
97 case 0: return LDKAccessError_UnknownChain;
98 case 1: return LDKAccessError_UnknownTx;
102 static inline int32_t LDKAccessError_to_js(LDKAccessError val) {
104 case LDKAccessError_UnknownChain: return 0;
105 case LDKAccessError_UnknownTx: return 1;
109 static inline LDKCOption_NoneZ LDKCOption_NoneZ_from_js(int32_t ord) {
111 case 0: return LDKCOption_NoneZ_Some;
112 case 1: return LDKCOption_NoneZ_None;
116 static inline int32_t LDKCOption_NoneZ_to_js(LDKCOption_NoneZ val) {
118 case LDKCOption_NoneZ_Some: return 0;
119 case LDKCOption_NoneZ_None: return 1;
123 static inline LDKChannelMonitorUpdateErr LDKChannelMonitorUpdateErr_from_js(int32_t ord) {
125 case 0: return LDKChannelMonitorUpdateErr_TemporaryFailure;
126 case 1: return LDKChannelMonitorUpdateErr_PermanentFailure;
130 static inline int32_t LDKChannelMonitorUpdateErr_to_js(LDKChannelMonitorUpdateErr val) {
132 case LDKChannelMonitorUpdateErr_TemporaryFailure: return 0;
133 case LDKChannelMonitorUpdateErr_PermanentFailure: return 1;
137 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
139 case 0: return LDKConfirmationTarget_Background;
140 case 1: return LDKConfirmationTarget_Normal;
141 case 2: return LDKConfirmationTarget_HighPriority;
145 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
147 case LDKConfirmationTarget_Background: return 0;
148 case LDKConfirmationTarget_Normal: return 1;
149 case LDKConfirmationTarget_HighPriority: return 2;
153 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
155 case 0: return LDKCreationError_DescriptionTooLong;
156 case 1: return LDKCreationError_RouteTooLong;
157 case 2: return LDKCreationError_TimestampOutOfBounds;
158 case 3: return LDKCreationError_InvalidAmount;
159 case 4: return LDKCreationError_MissingRouteHints;
163 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
165 case LDKCreationError_DescriptionTooLong: return 0;
166 case LDKCreationError_RouteTooLong: return 1;
167 case LDKCreationError_TimestampOutOfBounds: return 2;
168 case LDKCreationError_InvalidAmount: return 3;
169 case LDKCreationError_MissingRouteHints: return 4;
173 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
175 case 0: return LDKCurrency_Bitcoin;
176 case 1: return LDKCurrency_BitcoinTestnet;
177 case 2: return LDKCurrency_Regtest;
178 case 3: return LDKCurrency_Simnet;
179 case 4: return LDKCurrency_Signet;
183 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
185 case LDKCurrency_Bitcoin: return 0;
186 case LDKCurrency_BitcoinTestnet: return 1;
187 case LDKCurrency_Regtest: return 2;
188 case LDKCurrency_Simnet: return 3;
189 case LDKCurrency_Signet: return 4;
193 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
195 case 0: return LDKIOError_NotFound;
196 case 1: return LDKIOError_PermissionDenied;
197 case 2: return LDKIOError_ConnectionRefused;
198 case 3: return LDKIOError_ConnectionReset;
199 case 4: return LDKIOError_ConnectionAborted;
200 case 5: return LDKIOError_NotConnected;
201 case 6: return LDKIOError_AddrInUse;
202 case 7: return LDKIOError_AddrNotAvailable;
203 case 8: return LDKIOError_BrokenPipe;
204 case 9: return LDKIOError_AlreadyExists;
205 case 10: return LDKIOError_WouldBlock;
206 case 11: return LDKIOError_InvalidInput;
207 case 12: return LDKIOError_InvalidData;
208 case 13: return LDKIOError_TimedOut;
209 case 14: return LDKIOError_WriteZero;
210 case 15: return LDKIOError_Interrupted;
211 case 16: return LDKIOError_Other;
212 case 17: return LDKIOError_UnexpectedEof;
216 static inline int32_t LDKIOError_to_js(LDKIOError val) {
218 case LDKIOError_NotFound: return 0;
219 case LDKIOError_PermissionDenied: return 1;
220 case LDKIOError_ConnectionRefused: return 2;
221 case LDKIOError_ConnectionReset: return 3;
222 case LDKIOError_ConnectionAborted: return 4;
223 case LDKIOError_NotConnected: return 5;
224 case LDKIOError_AddrInUse: return 6;
225 case LDKIOError_AddrNotAvailable: return 7;
226 case LDKIOError_BrokenPipe: return 8;
227 case LDKIOError_AlreadyExists: return 9;
228 case LDKIOError_WouldBlock: return 10;
229 case LDKIOError_InvalidInput: return 11;
230 case LDKIOError_InvalidData: return 12;
231 case LDKIOError_TimedOut: return 13;
232 case LDKIOError_WriteZero: return 14;
233 case LDKIOError_Interrupted: return 15;
234 case LDKIOError_Other: return 16;
235 case LDKIOError_UnexpectedEof: return 17;
239 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
241 case 0: return LDKLevel_Gossip;
242 case 1: return LDKLevel_Trace;
243 case 2: return LDKLevel_Debug;
244 case 3: return LDKLevel_Info;
245 case 4: return LDKLevel_Warn;
246 case 5: return LDKLevel_Error;
250 static inline int32_t LDKLevel_to_js(LDKLevel val) {
252 case LDKLevel_Gossip: return 0;
253 case LDKLevel_Trace: return 1;
254 case LDKLevel_Debug: return 2;
255 case LDKLevel_Info: return 3;
256 case LDKLevel_Warn: return 4;
257 case LDKLevel_Error: return 5;
261 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
263 case 0: return LDKNetwork_Bitcoin;
264 case 1: return LDKNetwork_Testnet;
265 case 2: return LDKNetwork_Regtest;
266 case 3: return LDKNetwork_Signet;
270 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
272 case LDKNetwork_Bitcoin: return 0;
273 case LDKNetwork_Testnet: return 1;
274 case LDKNetwork_Regtest: return 2;
275 case LDKNetwork_Signet: return 3;
279 static inline LDKRecipient LDKRecipient_from_js(int32_t ord) {
281 case 0: return LDKRecipient_Node;
282 case 1: return LDKRecipient_PhantomNode;
286 static inline int32_t LDKRecipient_to_js(LDKRecipient val) {
288 case LDKRecipient_Node: return 0;
289 case LDKRecipient_PhantomNode: return 1;
293 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
295 case 0: return LDKSecp256k1Error_IncorrectSignature;
296 case 1: return LDKSecp256k1Error_InvalidMessage;
297 case 2: return LDKSecp256k1Error_InvalidPublicKey;
298 case 3: return LDKSecp256k1Error_InvalidSignature;
299 case 4: return LDKSecp256k1Error_InvalidSecretKey;
300 case 5: return LDKSecp256k1Error_InvalidSharedSecret;
301 case 6: return LDKSecp256k1Error_InvalidRecoveryId;
302 case 7: return LDKSecp256k1Error_InvalidTweak;
303 case 8: return LDKSecp256k1Error_NotEnoughMemory;
304 case 9: return LDKSecp256k1Error_InvalidPublicKeySum;
305 case 10: return LDKSecp256k1Error_InvalidParityValue;
309 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
311 case LDKSecp256k1Error_IncorrectSignature: return 0;
312 case LDKSecp256k1Error_InvalidMessage: return 1;
313 case LDKSecp256k1Error_InvalidPublicKey: return 2;
314 case LDKSecp256k1Error_InvalidSignature: return 3;
315 case LDKSecp256k1Error_InvalidSecretKey: return 4;
316 case LDKSecp256k1Error_InvalidSharedSecret: return 5;
317 case LDKSecp256k1Error_InvalidRecoveryId: return 6;
318 case LDKSecp256k1Error_InvalidTweak: return 7;
319 case LDKSecp256k1Error_NotEnoughMemory: return 8;
320 case LDKSecp256k1Error_InvalidPublicKeySum: return 9;
321 case LDKSecp256k1Error_InvalidParityValue: return 10;
325 static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) {
327 case 0: return LDKSemanticError_NoPaymentHash;
328 case 1: return LDKSemanticError_MultiplePaymentHashes;
329 case 2: return LDKSemanticError_NoDescription;
330 case 3: return LDKSemanticError_MultipleDescriptions;
331 case 4: return LDKSemanticError_NoPaymentSecret;
332 case 5: return LDKSemanticError_MultiplePaymentSecrets;
333 case 6: return LDKSemanticError_InvalidFeatures;
334 case 7: return LDKSemanticError_InvalidRecoveryId;
335 case 8: return LDKSemanticError_InvalidSignature;
336 case 9: return LDKSemanticError_ImpreciseAmount;
340 static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) {
342 case LDKSemanticError_NoPaymentHash: return 0;
343 case LDKSemanticError_MultiplePaymentHashes: return 1;
344 case LDKSemanticError_NoDescription: return 2;
345 case LDKSemanticError_MultipleDescriptions: return 3;
346 case LDKSemanticError_NoPaymentSecret: return 4;
347 case LDKSemanticError_MultiplePaymentSecrets: return 5;
348 case LDKSemanticError_InvalidFeatures: return 6;
349 case LDKSemanticError_InvalidRecoveryId: return 7;
350 case LDKSemanticError_InvalidSignature: return 8;
351 case LDKSemanticError_ImpreciseAmount: return 9;
355 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
357 case 0: return LDKSiPrefix_Milli;
358 case 1: return LDKSiPrefix_Micro;
359 case 2: return LDKSiPrefix_Nano;
360 case 3: return LDKSiPrefix_Pico;
364 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
366 case LDKSiPrefix_Milli: return 0;
367 case LDKSiPrefix_Micro: return 1;
368 case LDKSiPrefix_Nano: return 2;
369 case LDKSiPrefix_Pico: return 3;
373 uint32_t __attribute__((export_name("TS_LDKBech32Error_ty_from_ptr"))) TS_LDKBech32Error_ty_from_ptr(uint32_t ptr) {
374 LDKBech32Error *obj = (LDKBech32Error*)(ptr & ~1);
376 case LDKBech32Error_MissingSeparator: return 0;
377 case LDKBech32Error_InvalidChecksum: return 1;
378 case LDKBech32Error_InvalidLength: return 2;
379 case LDKBech32Error_InvalidChar: return 3;
380 case LDKBech32Error_InvalidData: return 4;
381 case LDKBech32Error_InvalidPadding: return 5;
382 case LDKBech32Error_MixedCase: return 6;
386 int32_t __attribute__((export_name("TS_LDKBech32Error_InvalidChar_get_invalid_char"))) TS_LDKBech32Error_InvalidChar_get_invalid_char(uint32_t ptr) {
387 LDKBech32Error *obj = (LDKBech32Error*)(ptr & ~1);
388 assert(obj->tag == LDKBech32Error_InvalidChar);
389 int32_t invalid_char_conv = obj->invalid_char;
390 return invalid_char_conv;
392 int8_t __attribute__((export_name("TS_LDKBech32Error_InvalidData_get_invalid_data"))) TS_LDKBech32Error_InvalidData_get_invalid_data(uint32_t ptr) {
393 LDKBech32Error *obj = (LDKBech32Error*)(ptr & ~1);
394 assert(obj->tag == LDKBech32Error_InvalidData);
395 int8_t invalid_data_conv = obj->invalid_data;
396 return invalid_data_conv;
398 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
399 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
400 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
403 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(uint32_t thing) {
404 LDKTxOut* thing_conv = (LDKTxOut*)(thing & ~1);
405 LDKCVec_u8Z ret_var = TxOut_get_script_pubkey(thing_conv);
406 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
407 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
408 CVec_u8Z_free(ret_var);
412 uint64_t TxOut_get_value (struct LDKTxOut* thing) { return thing->value;}int64_t __attribute__((export_name("TS_TxOut_get_value"))) TS_TxOut_get_value(uint32_t thing) {
413 LDKTxOut* thing_conv = (LDKTxOut*)(thing & ~1);
414 int64_t ret_conv = TxOut_get_value(thing_conv);
418 static inline void CResult_NoneNoneZ_get_ok(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
419 CHECK(owner->result_ok);
420 return *owner->contents.result;
422 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_ok"))) TS_CResult_NoneNoneZ_get_ok(uint32_t owner) {
423 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)(owner & ~1);
424 CResult_NoneNoneZ_get_ok(owner_conv);
427 static inline void CResult_NoneNoneZ_get_err(LDKCResult_NoneNoneZ *NONNULL_PTR owner){
428 CHECK(!owner->result_ok);
429 return *owner->contents.err;
431 void __attribute__((export_name("TS_CResult_NoneNoneZ_get_err"))) TS_CResult_NoneNoneZ_get_err(uint32_t owner) {
432 LDKCResult_NoneNoneZ* owner_conv = (LDKCResult_NoneNoneZ*)(owner & ~1);
433 CResult_NoneNoneZ_get_err(owner_conv);
436 static inline struct LDKCounterpartyCommitmentSecrets CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
437 CHECK(owner->result_ok);
438 return CounterpartyCommitmentSecrets_clone(&*owner->contents.result);
440 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(uint32_t owner) {
441 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(owner & ~1);
442 LDKCounterpartyCommitmentSecrets ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_ok(owner_conv);
443 uint32_t ret_ref = 0;
444 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
445 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
446 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
447 ret_ref = (uintptr_t)ret_var.inner;
448 if (ret_var.is_owned) {
454 static inline struct LDKDecodeError CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR owner){
455 CHECK(!owner->result_ok);
456 return DecodeError_clone(&*owner->contents.err);
458 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(uint32_t owner) {
459 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(owner & ~1);
460 LDKDecodeError ret_var = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_get_err(owner_conv);
461 uint32_t ret_ref = 0;
462 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
463 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
464 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
465 ret_ref = (uintptr_t)ret_var.inner;
466 if (ret_var.is_owned) {
472 static inline struct LDKSecretKey CResult_SecretKeyErrorZ_get_ok(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner){
473 CHECK(owner->result_ok);
474 return *owner->contents.result;
476 int8_tArray __attribute__((export_name("TS_CResult_SecretKeyErrorZ_get_ok"))) TS_CResult_SecretKeyErrorZ_get_ok(uint32_t owner) {
477 LDKCResult_SecretKeyErrorZ* owner_conv = (LDKCResult_SecretKeyErrorZ*)(owner & ~1);
478 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
479 memcpy(ret_arr->elems, CResult_SecretKeyErrorZ_get_ok(owner_conv).bytes, 32);
483 static inline enum LDKSecp256k1Error CResult_SecretKeyErrorZ_get_err(LDKCResult_SecretKeyErrorZ *NONNULL_PTR owner){
484 CHECK(!owner->result_ok);
485 return *owner->contents.err;
487 uint32_t __attribute__((export_name("TS_CResult_SecretKeyErrorZ_get_err"))) TS_CResult_SecretKeyErrorZ_get_err(uint32_t owner) {
488 LDKCResult_SecretKeyErrorZ* owner_conv = (LDKCResult_SecretKeyErrorZ*)(owner & ~1);
489 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_SecretKeyErrorZ_get_err(owner_conv));
493 static inline struct LDKPublicKey CResult_PublicKeyErrorZ_get_ok(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
494 CHECK(owner->result_ok);
495 return *owner->contents.result;
497 int8_tArray __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_ok"))) TS_CResult_PublicKeyErrorZ_get_ok(uint32_t owner) {
498 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)(owner & ~1);
499 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
500 memcpy(ret_arr->elems, CResult_PublicKeyErrorZ_get_ok(owner_conv).compressed_form, 33);
504 static inline enum LDKSecp256k1Error CResult_PublicKeyErrorZ_get_err(LDKCResult_PublicKeyErrorZ *NONNULL_PTR owner){
505 CHECK(!owner->result_ok);
506 return *owner->contents.err;
508 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_get_err"))) TS_CResult_PublicKeyErrorZ_get_err(uint32_t owner) {
509 LDKCResult_PublicKeyErrorZ* owner_conv = (LDKCResult_PublicKeyErrorZ*)(owner & ~1);
510 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PublicKeyErrorZ_get_err(owner_conv));
514 static inline struct LDKTxCreationKeys CResult_TxCreationKeysDecodeErrorZ_get_ok(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
515 CHECK(owner->result_ok);
516 return TxCreationKeys_clone(&*owner->contents.result);
518 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_ok(uint32_t owner) {
519 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(owner & ~1);
520 LDKTxCreationKeys ret_var = CResult_TxCreationKeysDecodeErrorZ_get_ok(owner_conv);
521 uint32_t ret_ref = 0;
522 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
523 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
524 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
525 ret_ref = (uintptr_t)ret_var.inner;
526 if (ret_var.is_owned) {
532 static inline struct LDKDecodeError CResult_TxCreationKeysDecodeErrorZ_get_err(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR owner){
533 CHECK(!owner->result_ok);
534 return DecodeError_clone(&*owner->contents.err);
536 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_get_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_get_err(uint32_t owner) {
537 LDKCResult_TxCreationKeysDecodeErrorZ* owner_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(owner & ~1);
538 LDKDecodeError ret_var = CResult_TxCreationKeysDecodeErrorZ_get_err(owner_conv);
539 uint32_t ret_ref = 0;
540 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
541 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
542 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
543 ret_ref = (uintptr_t)ret_var.inner;
544 if (ret_var.is_owned) {
550 static inline struct LDKChannelPublicKeys CResult_ChannelPublicKeysDecodeErrorZ_get_ok(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
551 CHECK(owner->result_ok);
552 return ChannelPublicKeys_clone(&*owner->contents.result);
554 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint32_t owner) {
555 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(owner & ~1);
556 LDKChannelPublicKeys ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_ok(owner_conv);
557 uint32_t ret_ref = 0;
558 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
559 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
560 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
561 ret_ref = (uintptr_t)ret_var.inner;
562 if (ret_var.is_owned) {
568 static inline struct LDKDecodeError CResult_ChannelPublicKeysDecodeErrorZ_get_err(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR owner){
569 CHECK(!owner->result_ok);
570 return DecodeError_clone(&*owner->contents.err);
572 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_get_err(uint32_t owner) {
573 LDKCResult_ChannelPublicKeysDecodeErrorZ* owner_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(owner & ~1);
574 LDKDecodeError ret_var = CResult_ChannelPublicKeysDecodeErrorZ_get_err(owner_conv);
575 uint32_t ret_ref = 0;
576 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
577 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
578 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
579 ret_ref = (uintptr_t)ret_var.inner;
580 if (ret_var.is_owned) {
586 static inline struct LDKTxCreationKeys CResult_TxCreationKeysErrorZ_get_ok(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner){
587 CHECK(owner->result_ok);
588 return TxCreationKeys_clone(&*owner->contents.result);
590 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_get_ok"))) TS_CResult_TxCreationKeysErrorZ_get_ok(uint32_t owner) {
591 LDKCResult_TxCreationKeysErrorZ* owner_conv = (LDKCResult_TxCreationKeysErrorZ*)(owner & ~1);
592 LDKTxCreationKeys ret_var = CResult_TxCreationKeysErrorZ_get_ok(owner_conv);
593 uint32_t ret_ref = 0;
594 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
595 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
596 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
597 ret_ref = (uintptr_t)ret_var.inner;
598 if (ret_var.is_owned) {
604 static inline enum LDKSecp256k1Error CResult_TxCreationKeysErrorZ_get_err(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR owner){
605 CHECK(!owner->result_ok);
606 return *owner->contents.err;
608 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_get_err"))) TS_CResult_TxCreationKeysErrorZ_get_err(uint32_t owner) {
609 LDKCResult_TxCreationKeysErrorZ* owner_conv = (LDKCResult_TxCreationKeysErrorZ*)(owner & ~1);
610 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_TxCreationKeysErrorZ_get_err(owner_conv));
614 uint32_t __attribute__((export_name("TS_LDKCOption_u32Z_ty_from_ptr"))) TS_LDKCOption_u32Z_ty_from_ptr(uint32_t ptr) {
615 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)(ptr & ~1);
617 case LDKCOption_u32Z_Some: return 0;
618 case LDKCOption_u32Z_None: return 1;
622 int32_t __attribute__((export_name("TS_LDKCOption_u32Z_Some_get_some"))) TS_LDKCOption_u32Z_Some_get_some(uint32_t ptr) {
623 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)(ptr & ~1);
624 assert(obj->tag == LDKCOption_u32Z_Some);
625 int32_t some_conv = obj->some;
628 static inline struct LDKHTLCOutputInCommitment CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
629 CHECK(owner->result_ok);
630 return HTLCOutputInCommitment_clone(&*owner->contents.result);
632 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint32_t owner) {
633 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(owner & ~1);
634 LDKHTLCOutputInCommitment ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(owner_conv);
635 uint32_t ret_ref = 0;
636 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
637 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
638 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
639 ret_ref = (uintptr_t)ret_var.inner;
640 if (ret_var.is_owned) {
646 static inline struct LDKDecodeError CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR owner){
647 CHECK(!owner->result_ok);
648 return DecodeError_clone(&*owner->contents.err);
650 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint32_t owner) {
651 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* owner_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(owner & ~1);
652 LDKDecodeError ret_var = CResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(owner_conv);
653 uint32_t ret_ref = 0;
654 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
655 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
657 ret_ref = (uintptr_t)ret_var.inner;
658 if (ret_var.is_owned) {
664 static inline struct LDKCounterpartyChannelTransactionParameters CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
665 CHECK(owner->result_ok);
666 return CounterpartyChannelTransactionParameters_clone(&*owner->contents.result);
668 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t owner) {
669 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(owner & ~1);
670 LDKCounterpartyChannelTransactionParameters ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
671 uint32_t ret_ref = 0;
672 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
673 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
675 ret_ref = (uintptr_t)ret_var.inner;
676 if (ret_var.is_owned) {
682 static inline struct LDKDecodeError CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
683 CHECK(!owner->result_ok);
684 return DecodeError_clone(&*owner->contents.err);
686 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint32_t owner) {
687 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(owner & ~1);
688 LDKDecodeError ret_var = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
689 uint32_t ret_ref = 0;
690 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
691 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
692 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
693 ret_ref = (uintptr_t)ret_var.inner;
694 if (ret_var.is_owned) {
700 static inline struct LDKChannelTransactionParameters CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
701 CHECK(owner->result_ok);
702 return ChannelTransactionParameters_clone(&*owner->contents.result);
704 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t owner) {
705 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(owner & ~1);
706 LDKChannelTransactionParameters ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_ok(owner_conv);
707 uint32_t ret_ref = 0;
708 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
709 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
710 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
711 ret_ref = (uintptr_t)ret_var.inner;
712 if (ret_var.is_owned) {
718 static inline struct LDKDecodeError CResult_ChannelTransactionParametersDecodeErrorZ_get_err(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR owner){
719 CHECK(!owner->result_ok);
720 return DecodeError_clone(&*owner->contents.err);
722 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint32_t owner) {
723 LDKCResult_ChannelTransactionParametersDecodeErrorZ* owner_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(owner & ~1);
724 LDKDecodeError ret_var = CResult_ChannelTransactionParametersDecodeErrorZ_get_err(owner_conv);
725 uint32_t ret_ref = 0;
726 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
727 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
728 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
729 ret_ref = (uintptr_t)ret_var.inner;
730 if (ret_var.is_owned) {
736 static inline struct LDKHolderCommitmentTransaction CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
737 CHECK(owner->result_ok);
738 return HolderCommitmentTransaction_clone(&*owner->contents.result);
740 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint32_t owner) {
741 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(owner & ~1);
742 LDKHolderCommitmentTransaction ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
743 uint32_t ret_ref = 0;
744 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
745 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
746 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
747 ret_ref = (uintptr_t)ret_var.inner;
748 if (ret_var.is_owned) {
754 static inline struct LDKDecodeError CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
755 CHECK(!owner->result_ok);
756 return DecodeError_clone(&*owner->contents.err);
758 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint32_t owner) {
759 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(owner & ~1);
760 LDKDecodeError ret_var = CResult_HolderCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
761 uint32_t ret_ref = 0;
762 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
763 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
765 ret_ref = (uintptr_t)ret_var.inner;
766 if (ret_var.is_owned) {
772 static inline struct LDKBuiltCommitmentTransaction CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
773 CHECK(owner->result_ok);
774 return BuiltCommitmentTransaction_clone(&*owner->contents.result);
776 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint32_t owner) {
777 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(owner & ~1);
778 LDKBuiltCommitmentTransaction ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
779 uint32_t ret_ref = 0;
780 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
781 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
782 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
783 ret_ref = (uintptr_t)ret_var.inner;
784 if (ret_var.is_owned) {
790 static inline struct LDKDecodeError CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
791 CHECK(!owner->result_ok);
792 return DecodeError_clone(&*owner->contents.err);
794 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint32_t owner) {
795 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(owner & ~1);
796 LDKDecodeError ret_var = CResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(owner_conv);
797 uint32_t ret_ref = 0;
798 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
799 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
800 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
801 ret_ref = (uintptr_t)ret_var.inner;
802 if (ret_var.is_owned) {
808 static inline struct LDKTrustedClosingTransaction *CResult_TrustedClosingTransactionNoneZ_get_ok(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
809 CHECK(owner->result_ok);
810 return &*owner->contents.result;
812 uint32_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_get_ok(uint32_t owner) {
813 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(owner & ~1);
814 LDKTrustedClosingTransaction ret_var = *CResult_TrustedClosingTransactionNoneZ_get_ok(owner_conv);
815 uint32_t ret_ref = 0;
816 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
817 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
819 ret_ref = (uintptr_t)ret_var.inner & ~1;
823 static inline void CResult_TrustedClosingTransactionNoneZ_get_err(LDKCResult_TrustedClosingTransactionNoneZ *NONNULL_PTR owner){
824 CHECK(!owner->result_ok);
825 return *owner->contents.err;
827 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_get_err"))) TS_CResult_TrustedClosingTransactionNoneZ_get_err(uint32_t owner) {
828 LDKCResult_TrustedClosingTransactionNoneZ* owner_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(owner & ~1);
829 CResult_TrustedClosingTransactionNoneZ_get_err(owner_conv);
832 static inline struct LDKCommitmentTransaction CResult_CommitmentTransactionDecodeErrorZ_get_ok(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
833 CHECK(owner->result_ok);
834 return CommitmentTransaction_clone(&*owner->contents.result);
836 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_ok(uint32_t owner) {
837 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(owner & ~1);
838 LDKCommitmentTransaction ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_ok(owner_conv);
839 uint32_t ret_ref = 0;
840 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
841 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
842 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
843 ret_ref = (uintptr_t)ret_var.inner;
844 if (ret_var.is_owned) {
850 static inline struct LDKDecodeError CResult_CommitmentTransactionDecodeErrorZ_get_err(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR owner){
851 CHECK(!owner->result_ok);
852 return DecodeError_clone(&*owner->contents.err);
854 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_get_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_get_err(uint32_t owner) {
855 LDKCResult_CommitmentTransactionDecodeErrorZ* owner_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(owner & ~1);
856 LDKDecodeError ret_var = CResult_CommitmentTransactionDecodeErrorZ_get_err(owner_conv);
857 uint32_t ret_ref = 0;
858 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
859 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
860 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
861 ret_ref = (uintptr_t)ret_var.inner;
862 if (ret_var.is_owned) {
868 static inline struct LDKTrustedCommitmentTransaction *CResult_TrustedCommitmentTransactionNoneZ_get_ok(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
869 CHECK(owner->result_ok);
870 return &*owner->contents.result;
872 uint32_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_ok(uint32_t owner) {
873 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(owner & ~1);
874 LDKTrustedCommitmentTransaction ret_var = *CResult_TrustedCommitmentTransactionNoneZ_get_ok(owner_conv);
875 uint32_t ret_ref = 0;
876 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
877 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
878 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
879 ret_ref = (uintptr_t)ret_var.inner & ~1;
883 static inline void CResult_TrustedCommitmentTransactionNoneZ_get_err(LDKCResult_TrustedCommitmentTransactionNoneZ *NONNULL_PTR owner){
884 CHECK(!owner->result_ok);
885 return *owner->contents.err;
887 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_get_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_get_err(uint32_t owner) {
888 LDKCResult_TrustedCommitmentTransactionNoneZ* owner_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(owner & ~1);
889 CResult_TrustedCommitmentTransactionNoneZ_get_err(owner_conv);
892 static inline struct LDKCVec_SignatureZ CResult_CVec_SignatureZNoneZ_get_ok(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
893 CHECK(owner->result_ok);
894 return *owner->contents.result;
896 ptrArray __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_ok"))) TS_CResult_CVec_SignatureZNoneZ_get_ok(uint32_t owner) {
897 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)(owner & ~1);
898 LDKCVec_SignatureZ ret_var = CResult_CVec_SignatureZNoneZ_get_ok(owner_conv);
899 ptrArray ret_arr = NULL;
900 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
901 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
902 for (size_t m = 0; m < ret_var.datalen; m++) {
903 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
904 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
905 ret_arr_ptr[m] = ret_conv_12_arr;
911 static inline void CResult_CVec_SignatureZNoneZ_get_err(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR owner){
912 CHECK(!owner->result_ok);
913 return *owner->contents.err;
915 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_get_err"))) TS_CResult_CVec_SignatureZNoneZ_get_err(uint32_t owner) {
916 LDKCResult_CVec_SignatureZNoneZ* owner_conv = (LDKCResult_CVec_SignatureZNoneZ*)(owner & ~1);
917 CResult_CVec_SignatureZNoneZ_get_err(owner_conv);
920 static inline struct LDKShutdownScript CResult_ShutdownScriptDecodeErrorZ_get_ok(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
921 CHECK(owner->result_ok);
922 return ShutdownScript_clone(&*owner->contents.result);
924 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_ok(uint32_t owner) {
925 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(owner & ~1);
926 LDKShutdownScript ret_var = CResult_ShutdownScriptDecodeErrorZ_get_ok(owner_conv);
927 uint32_t ret_ref = 0;
928 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
929 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
930 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
931 ret_ref = (uintptr_t)ret_var.inner;
932 if (ret_var.is_owned) {
938 static inline struct LDKDecodeError CResult_ShutdownScriptDecodeErrorZ_get_err(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR owner){
939 CHECK(!owner->result_ok);
940 return DecodeError_clone(&*owner->contents.err);
942 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_get_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_get_err(uint32_t owner) {
943 LDKCResult_ShutdownScriptDecodeErrorZ* owner_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(owner & ~1);
944 LDKDecodeError ret_var = CResult_ShutdownScriptDecodeErrorZ_get_err(owner_conv);
945 uint32_t ret_ref = 0;
946 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
947 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
948 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
949 ret_ref = (uintptr_t)ret_var.inner;
950 if (ret_var.is_owned) {
956 static inline struct LDKShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
957 CHECK(owner->result_ok);
958 return ShutdownScript_clone(&*owner->contents.result);
960 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(uint32_t owner) {
961 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(owner & ~1);
962 LDKShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_ok(owner_conv);
963 uint32_t ret_ref = 0;
964 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
965 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
966 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
967 ret_ref = (uintptr_t)ret_var.inner;
968 if (ret_var.is_owned) {
974 static inline struct LDKInvalidShutdownScript CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR owner){
975 CHECK(!owner->result_ok);
976 return InvalidShutdownScript_clone(&*owner->contents.err);
978 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(uint32_t owner) {
979 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* owner_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(owner & ~1);
980 LDKInvalidShutdownScript ret_var = CResult_ShutdownScriptInvalidShutdownScriptZ_get_err(owner_conv);
981 uint32_t ret_ref = 0;
982 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
983 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
984 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
985 ret_ref = (uintptr_t)ret_var.inner;
986 if (ret_var.is_owned) {
992 static inline struct LDKRouteHop CResult_RouteHopDecodeErrorZ_get_ok(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
993 CHECK(owner->result_ok);
994 return RouteHop_clone(&*owner->contents.result);
996 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHopDecodeErrorZ_get_ok(uint32_t owner) {
997 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)(owner & ~1);
998 LDKRouteHop ret_var = CResult_RouteHopDecodeErrorZ_get_ok(owner_conv);
999 uint32_t ret_ref = 0;
1000 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1001 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1002 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1003 ret_ref = (uintptr_t)ret_var.inner;
1004 if (ret_var.is_owned) {
1010 static inline struct LDKDecodeError CResult_RouteHopDecodeErrorZ_get_err(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR owner){
1011 CHECK(!owner->result_ok);
1012 return DecodeError_clone(&*owner->contents.err);
1014 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_get_err"))) TS_CResult_RouteHopDecodeErrorZ_get_err(uint32_t owner) {
1015 LDKCResult_RouteHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHopDecodeErrorZ*)(owner & ~1);
1016 LDKDecodeError ret_var = CResult_RouteHopDecodeErrorZ_get_err(owner_conv);
1017 uint32_t ret_ref = 0;
1018 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1019 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1020 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1021 ret_ref = (uintptr_t)ret_var.inner;
1022 if (ret_var.is_owned) {
1028 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
1029 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
1030 for (size_t i = 0; i < ret.datalen; i++) {
1031 ret.data[i] = RouteHop_clone(&orig->data[i]);
1035 static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
1036 LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
1037 for (size_t i = 0; i < ret.datalen; i++) {
1038 ret.data[i] = CVec_RouteHopZ_clone(&orig->data[i]);
1042 static inline struct LDKRoute CResult_RouteDecodeErrorZ_get_ok(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1043 CHECK(owner->result_ok);
1044 return Route_clone(&*owner->contents.result);
1046 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_ok"))) TS_CResult_RouteDecodeErrorZ_get_ok(uint32_t owner) {
1047 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)(owner & ~1);
1048 LDKRoute ret_var = CResult_RouteDecodeErrorZ_get_ok(owner_conv);
1049 uint32_t ret_ref = 0;
1050 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1051 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1053 ret_ref = (uintptr_t)ret_var.inner;
1054 if (ret_var.is_owned) {
1060 static inline struct LDKDecodeError CResult_RouteDecodeErrorZ_get_err(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR owner){
1061 CHECK(!owner->result_ok);
1062 return DecodeError_clone(&*owner->contents.err);
1064 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_get_err"))) TS_CResult_RouteDecodeErrorZ_get_err(uint32_t owner) {
1065 LDKCResult_RouteDecodeErrorZ* owner_conv = (LDKCResult_RouteDecodeErrorZ*)(owner & ~1);
1066 LDKDecodeError ret_var = CResult_RouteDecodeErrorZ_get_err(owner_conv);
1067 uint32_t ret_ref = 0;
1068 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1069 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1071 ret_ref = (uintptr_t)ret_var.inner;
1072 if (ret_var.is_owned) {
1078 static inline struct LDKRouteParameters CResult_RouteParametersDecodeErrorZ_get_ok(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1079 CHECK(owner->result_ok);
1080 return RouteParameters_clone(&*owner->contents.result);
1082 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_ok"))) TS_CResult_RouteParametersDecodeErrorZ_get_ok(uint32_t owner) {
1083 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(owner & ~1);
1084 LDKRouteParameters ret_var = CResult_RouteParametersDecodeErrorZ_get_ok(owner_conv);
1085 uint32_t ret_ref = 0;
1086 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1087 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1088 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1089 ret_ref = (uintptr_t)ret_var.inner;
1090 if (ret_var.is_owned) {
1096 static inline struct LDKDecodeError CResult_RouteParametersDecodeErrorZ_get_err(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR owner){
1097 CHECK(!owner->result_ok);
1098 return DecodeError_clone(&*owner->contents.err);
1100 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_get_err"))) TS_CResult_RouteParametersDecodeErrorZ_get_err(uint32_t owner) {
1101 LDKCResult_RouteParametersDecodeErrorZ* owner_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(owner & ~1);
1102 LDKDecodeError ret_var = CResult_RouteParametersDecodeErrorZ_get_err(owner_conv);
1103 uint32_t ret_ref = 0;
1104 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1105 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1106 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1107 ret_ref = (uintptr_t)ret_var.inner;
1108 if (ret_var.is_owned) {
1114 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
1115 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
1116 for (size_t i = 0; i < ret.datalen; i++) {
1117 ret.data[i] = RouteHint_clone(&orig->data[i]);
1121 uint32_t __attribute__((export_name("TS_LDKCOption_u64Z_ty_from_ptr"))) TS_LDKCOption_u64Z_ty_from_ptr(uint32_t ptr) {
1122 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)(ptr & ~1);
1124 case LDKCOption_u64Z_Some: return 0;
1125 case LDKCOption_u64Z_None: return 1;
1129 int64_t __attribute__((export_name("TS_LDKCOption_u64Z_Some_get_some"))) TS_LDKCOption_u64Z_Some_get_some(uint32_t ptr) {
1130 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)(ptr & ~1);
1131 assert(obj->tag == LDKCOption_u64Z_Some);
1132 int64_t some_conv = obj->some;
1135 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
1136 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
1137 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
1140 static inline struct LDKPaymentParameters CResult_PaymentParametersDecodeErrorZ_get_ok(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1141 CHECK(owner->result_ok);
1142 return PaymentParameters_clone(&*owner->contents.result);
1144 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_get_ok(uint32_t owner) {
1145 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)(owner & ~1);
1146 LDKPaymentParameters ret_var = CResult_PaymentParametersDecodeErrorZ_get_ok(owner_conv);
1147 uint32_t ret_ref = 0;
1148 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1149 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1150 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1151 ret_ref = (uintptr_t)ret_var.inner;
1152 if (ret_var.is_owned) {
1158 static inline struct LDKDecodeError CResult_PaymentParametersDecodeErrorZ_get_err(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR owner){
1159 CHECK(!owner->result_ok);
1160 return DecodeError_clone(&*owner->contents.err);
1162 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_get_err"))) TS_CResult_PaymentParametersDecodeErrorZ_get_err(uint32_t owner) {
1163 LDKCResult_PaymentParametersDecodeErrorZ* owner_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)(owner & ~1);
1164 LDKDecodeError ret_var = CResult_PaymentParametersDecodeErrorZ_get_err(owner_conv);
1165 uint32_t ret_ref = 0;
1166 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1167 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1168 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1169 ret_ref = (uintptr_t)ret_var.inner;
1170 if (ret_var.is_owned) {
1176 static inline LDKCVec_RouteHintHopZ CVec_RouteHintHopZ_clone(const LDKCVec_RouteHintHopZ *orig) {
1177 LDKCVec_RouteHintHopZ ret = { .data = MALLOC(sizeof(LDKRouteHintHop) * orig->datalen, "LDKCVec_RouteHintHopZ clone bytes"), .datalen = orig->datalen };
1178 for (size_t i = 0; i < ret.datalen; i++) {
1179 ret.data[i] = RouteHintHop_clone(&orig->data[i]);
1183 static inline struct LDKRouteHint CResult_RouteHintDecodeErrorZ_get_ok(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1184 CHECK(owner->result_ok);
1185 return RouteHint_clone(&*owner->contents.result);
1187 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_ok"))) TS_CResult_RouteHintDecodeErrorZ_get_ok(uint32_t owner) {
1188 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)(owner & ~1);
1189 LDKRouteHint ret_var = CResult_RouteHintDecodeErrorZ_get_ok(owner_conv);
1190 uint32_t ret_ref = 0;
1191 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1192 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1193 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1194 ret_ref = (uintptr_t)ret_var.inner;
1195 if (ret_var.is_owned) {
1201 static inline struct LDKDecodeError CResult_RouteHintDecodeErrorZ_get_err(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR owner){
1202 CHECK(!owner->result_ok);
1203 return DecodeError_clone(&*owner->contents.err);
1205 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_get_err"))) TS_CResult_RouteHintDecodeErrorZ_get_err(uint32_t owner) {
1206 LDKCResult_RouteHintDecodeErrorZ* owner_conv = (LDKCResult_RouteHintDecodeErrorZ*)(owner & ~1);
1207 LDKDecodeError ret_var = CResult_RouteHintDecodeErrorZ_get_err(owner_conv);
1208 uint32_t ret_ref = 0;
1209 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1210 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1211 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1212 ret_ref = (uintptr_t)ret_var.inner;
1213 if (ret_var.is_owned) {
1219 static inline struct LDKRouteHintHop CResult_RouteHintHopDecodeErrorZ_get_ok(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1220 CHECK(owner->result_ok);
1221 return RouteHintHop_clone(&*owner->contents.result);
1223 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_get_ok(uint32_t owner) {
1224 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(owner & ~1);
1225 LDKRouteHintHop ret_var = CResult_RouteHintHopDecodeErrorZ_get_ok(owner_conv);
1226 uint32_t ret_ref = 0;
1227 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1228 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1229 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1230 ret_ref = (uintptr_t)ret_var.inner;
1231 if (ret_var.is_owned) {
1237 static inline struct LDKDecodeError CResult_RouteHintHopDecodeErrorZ_get_err(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR owner){
1238 CHECK(!owner->result_ok);
1239 return DecodeError_clone(&*owner->contents.err);
1241 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_get_err"))) TS_CResult_RouteHintHopDecodeErrorZ_get_err(uint32_t owner) {
1242 LDKCResult_RouteHintHopDecodeErrorZ* owner_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(owner & ~1);
1243 LDKDecodeError ret_var = CResult_RouteHintHopDecodeErrorZ_get_err(owner_conv);
1244 uint32_t ret_ref = 0;
1245 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1246 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1247 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1248 ret_ref = (uintptr_t)ret_var.inner;
1249 if (ret_var.is_owned) {
1255 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
1256 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
1257 for (size_t i = 0; i < ret.datalen; i++) {
1258 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
1262 static inline struct LDKRoute CResult_RouteLightningErrorZ_get_ok(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1263 CHECK(owner->result_ok);
1264 return Route_clone(&*owner->contents.result);
1266 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_ok"))) TS_CResult_RouteLightningErrorZ_get_ok(uint32_t owner) {
1267 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)(owner & ~1);
1268 LDKRoute ret_var = CResult_RouteLightningErrorZ_get_ok(owner_conv);
1269 uint32_t ret_ref = 0;
1270 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1271 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1272 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1273 ret_ref = (uintptr_t)ret_var.inner;
1274 if (ret_var.is_owned) {
1280 static inline struct LDKLightningError CResult_RouteLightningErrorZ_get_err(LDKCResult_RouteLightningErrorZ *NONNULL_PTR owner){
1281 CHECK(!owner->result_ok);
1282 return LightningError_clone(&*owner->contents.err);
1284 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_get_err"))) TS_CResult_RouteLightningErrorZ_get_err(uint32_t owner) {
1285 LDKCResult_RouteLightningErrorZ* owner_conv = (LDKCResult_RouteLightningErrorZ*)(owner & ~1);
1286 LDKLightningError ret_var = CResult_RouteLightningErrorZ_get_err(owner_conv);
1287 uint32_t ret_ref = 0;
1288 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1289 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1290 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1291 ret_ref = (uintptr_t)ret_var.inner;
1292 if (ret_var.is_owned) {
1298 uint32_t __attribute__((export_name("TS_LDKPaymentPurpose_ty_from_ptr"))) TS_LDKPaymentPurpose_ty_from_ptr(uint32_t ptr) {
1299 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
1301 case LDKPaymentPurpose_InvoicePayment: return 0;
1302 case LDKPaymentPurpose_SpontaneousPayment: return 1;
1306 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_preimage(uint32_t ptr) {
1307 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
1308 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
1309 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
1310 memcpy(payment_preimage_arr->elems, obj->invoice_payment.payment_preimage.data, 32);
1311 return payment_preimage_arr;
1313 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret"))) TS_LDKPaymentPurpose_InvoicePayment_get_payment_secret(uint32_t ptr) {
1314 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
1315 assert(obj->tag == LDKPaymentPurpose_InvoicePayment);
1316 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
1317 memcpy(payment_secret_arr->elems, obj->invoice_payment.payment_secret.data, 32);
1318 return payment_secret_arr;
1320 int8_tArray __attribute__((export_name("TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment"))) TS_LDKPaymentPurpose_SpontaneousPayment_get_spontaneous_payment(uint32_t ptr) {
1321 LDKPaymentPurpose *obj = (LDKPaymentPurpose*)(ptr & ~1);
1322 assert(obj->tag == LDKPaymentPurpose_SpontaneousPayment);
1323 int8_tArray spontaneous_payment_arr = init_int8_tArray(32, __LINE__);
1324 memcpy(spontaneous_payment_arr->elems, obj->spontaneous_payment.data, 32);
1325 return spontaneous_payment_arr;
1327 static inline struct LDKPaymentPurpose CResult_PaymentPurposeDecodeErrorZ_get_ok(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
1328 CHECK(owner->result_ok);
1329 return PaymentPurpose_clone(&*owner->contents.result);
1331 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_ok(uint32_t owner) {
1332 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)(owner & ~1);
1333 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
1334 *ret_copy = CResult_PaymentPurposeDecodeErrorZ_get_ok(owner_conv);
1335 uint32_t ret_ref = (uintptr_t)ret_copy;
1339 static inline struct LDKDecodeError CResult_PaymentPurposeDecodeErrorZ_get_err(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR owner){
1340 CHECK(!owner->result_ok);
1341 return DecodeError_clone(&*owner->contents.err);
1343 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_get_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_get_err(uint32_t owner) {
1344 LDKCResult_PaymentPurposeDecodeErrorZ* owner_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)(owner & ~1);
1345 LDKDecodeError ret_var = CResult_PaymentPurposeDecodeErrorZ_get_err(owner_conv);
1346 uint32_t ret_ref = 0;
1347 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1348 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1349 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1350 ret_ref = (uintptr_t)ret_var.inner;
1351 if (ret_var.is_owned) {
1357 uint32_t __attribute__((export_name("TS_LDKClosureReason_ty_from_ptr"))) TS_LDKClosureReason_ty_from_ptr(uint32_t ptr) {
1358 LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
1360 case LDKClosureReason_CounterpartyForceClosed: return 0;
1361 case LDKClosureReason_HolderForceClosed: return 1;
1362 case LDKClosureReason_CooperativeClosure: return 2;
1363 case LDKClosureReason_CommitmentTxConfirmed: return 3;
1364 case LDKClosureReason_FundingTimedOut: return 4;
1365 case LDKClosureReason_ProcessingError: return 5;
1366 case LDKClosureReason_DisconnectedPeer: return 6;
1367 case LDKClosureReason_OutdatedChannelManager: return 7;
1371 jstring __attribute__((export_name("TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg"))) TS_LDKClosureReason_CounterpartyForceClosed_get_peer_msg(uint32_t ptr) {
1372 LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
1373 assert(obj->tag == LDKClosureReason_CounterpartyForceClosed);
1374 LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg;
1375 jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len);
1376 return peer_msg_conv;
1378 jstring __attribute__((export_name("TS_LDKClosureReason_ProcessingError_get_err"))) TS_LDKClosureReason_ProcessingError_get_err(uint32_t ptr) {
1379 LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1);
1380 assert(obj->tag == LDKClosureReason_ProcessingError);
1381 LDKStr err_str = obj->processing_error.err;
1382 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
1385 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_ty_from_ptr"))) TS_LDKCOption_ClosureReasonZ_ty_from_ptr(uint32_t ptr) {
1386 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
1388 case LDKCOption_ClosureReasonZ_Some: return 0;
1389 case LDKCOption_ClosureReasonZ_None: return 1;
1393 uint32_t __attribute__((export_name("TS_LDKCOption_ClosureReasonZ_Some_get_some"))) TS_LDKCOption_ClosureReasonZ_Some_get_some(uint32_t ptr) {
1394 LDKCOption_ClosureReasonZ *obj = (LDKCOption_ClosureReasonZ*)(ptr & ~1);
1395 assert(obj->tag == LDKCOption_ClosureReasonZ_Some);
1396 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
1399 static inline struct LDKCOption_ClosureReasonZ CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
1400 CHECK(owner->result_ok);
1401 return COption_ClosureReasonZ_clone(&*owner->contents.result);
1403 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(uint32_t owner) {
1404 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(owner & ~1);
1405 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
1406 *ret_copy = CResult_COption_ClosureReasonZDecodeErrorZ_get_ok(owner_conv);
1407 uint32_t ret_ref = (uintptr_t)ret_copy;
1411 static inline struct LDKDecodeError CResult_COption_ClosureReasonZDecodeErrorZ_get_err(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR owner){
1412 CHECK(!owner->result_ok);
1413 return DecodeError_clone(&*owner->contents.err);
1415 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_get_err(uint32_t owner) {
1416 LDKCResult_COption_ClosureReasonZDecodeErrorZ* owner_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(owner & ~1);
1417 LDKDecodeError ret_var = CResult_COption_ClosureReasonZDecodeErrorZ_get_err(owner_conv);
1418 uint32_t ret_ref = 0;
1419 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1420 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1421 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1422 ret_ref = (uintptr_t)ret_var.inner;
1423 if (ret_var.is_owned) {
1429 uint32_t __attribute__((export_name("TS_LDKHTLCDestination_ty_from_ptr"))) TS_LDKHTLCDestination_ty_from_ptr(uint32_t ptr) {
1430 LDKHTLCDestination *obj = (LDKHTLCDestination*)(ptr & ~1);
1432 case LDKHTLCDestination_NextHopChannel: return 0;
1433 case LDKHTLCDestination_UnknownNextHop: return 1;
1434 case LDKHTLCDestination_FailedPayment: return 2;
1438 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_node_id"))) TS_LDKHTLCDestination_NextHopChannel_get_node_id(uint32_t ptr) {
1439 LDKHTLCDestination *obj = (LDKHTLCDestination*)(ptr & ~1);
1440 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
1441 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
1442 memcpy(node_id_arr->elems, obj->next_hop_channel.node_id.compressed_form, 33);
1445 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_NextHopChannel_get_channel_id"))) TS_LDKHTLCDestination_NextHopChannel_get_channel_id(uint32_t ptr) {
1446 LDKHTLCDestination *obj = (LDKHTLCDestination*)(ptr & ~1);
1447 assert(obj->tag == LDKHTLCDestination_NextHopChannel);
1448 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
1449 memcpy(channel_id_arr->elems, obj->next_hop_channel.channel_id.data, 32);
1450 return channel_id_arr;
1452 int64_t __attribute__((export_name("TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid"))) TS_LDKHTLCDestination_UnknownNextHop_get_requested_forward_scid(uint32_t ptr) {
1453 LDKHTLCDestination *obj = (LDKHTLCDestination*)(ptr & ~1);
1454 assert(obj->tag == LDKHTLCDestination_UnknownNextHop);
1455 int64_t requested_forward_scid_conv = obj->unknown_next_hop.requested_forward_scid;
1456 return requested_forward_scid_conv;
1458 int8_tArray __attribute__((export_name("TS_LDKHTLCDestination_FailedPayment_get_payment_hash"))) TS_LDKHTLCDestination_FailedPayment_get_payment_hash(uint32_t ptr) {
1459 LDKHTLCDestination *obj = (LDKHTLCDestination*)(ptr & ~1);
1460 assert(obj->tag == LDKHTLCDestination_FailedPayment);
1461 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1462 memcpy(payment_hash_arr->elems, obj->failed_payment.payment_hash.data, 32);
1463 return payment_hash_arr;
1465 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_ty_from_ptr"))) TS_LDKCOption_HTLCDestinationZ_ty_from_ptr(uint32_t ptr) {
1466 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)(ptr & ~1);
1468 case LDKCOption_HTLCDestinationZ_Some: return 0;
1469 case LDKCOption_HTLCDestinationZ_None: return 1;
1473 uint32_t __attribute__((export_name("TS_LDKCOption_HTLCDestinationZ_Some_get_some"))) TS_LDKCOption_HTLCDestinationZ_Some_get_some(uint32_t ptr) {
1474 LDKCOption_HTLCDestinationZ *obj = (LDKCOption_HTLCDestinationZ*)(ptr & ~1);
1475 assert(obj->tag == LDKCOption_HTLCDestinationZ_Some);
1476 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
1479 static inline struct LDKCOption_HTLCDestinationZ CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
1480 CHECK(owner->result_ok);
1481 return COption_HTLCDestinationZ_clone(&*owner->contents.result);
1483 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(uint32_t owner) {
1484 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(owner & ~1);
1485 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
1486 *ret_copy = CResult_COption_HTLCDestinationZDecodeErrorZ_get_ok(owner_conv);
1487 uint32_t ret_ref = (uintptr_t)ret_copy;
1491 static inline struct LDKDecodeError CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR owner){
1492 CHECK(!owner->result_ok);
1493 return DecodeError_clone(&*owner->contents.err);
1495 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(uint32_t owner) {
1496 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* owner_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(owner & ~1);
1497 LDKDecodeError ret_var = CResult_COption_HTLCDestinationZDecodeErrorZ_get_err(owner_conv);
1498 uint32_t ret_ref = 0;
1499 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1500 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1501 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
1502 ret_ref = (uintptr_t)ret_var.inner;
1503 if (ret_var.is_owned) {
1509 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ty_from_ptr"))) TS_LDKNetworkUpdate_ty_from_ptr(uint32_t ptr) {
1510 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1512 case LDKNetworkUpdate_ChannelUpdateMessage: return 0;
1513 case LDKNetworkUpdate_ChannelFailure: return 1;
1514 case LDKNetworkUpdate_NodeFailure: return 2;
1518 uint32_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg"))) TS_LDKNetworkUpdate_ChannelUpdateMessage_get_msg(uint32_t ptr) {
1519 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1520 assert(obj->tag == LDKNetworkUpdate_ChannelUpdateMessage);
1521 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
1522 uint32_t msg_ref = 0;
1523 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1524 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1525 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
1526 msg_ref = (uintptr_t)msg_var.inner & ~1;
1529 int64_t __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id"))) TS_LDKNetworkUpdate_ChannelFailure_get_short_channel_id(uint32_t ptr) {
1530 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1531 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
1532 int64_t short_channel_id_conv = obj->channel_failure.short_channel_id;
1533 return short_channel_id_conv;
1535 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent"))) TS_LDKNetworkUpdate_ChannelFailure_get_is_permanent(uint32_t ptr) {
1536 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1537 assert(obj->tag == LDKNetworkUpdate_ChannelFailure);
1538 jboolean is_permanent_conv = obj->channel_failure.is_permanent;
1539 return is_permanent_conv;
1541 int8_tArray __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_node_id"))) TS_LDKNetworkUpdate_NodeFailure_get_node_id(uint32_t ptr) {
1542 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1543 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
1544 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
1545 memcpy(node_id_arr->elems, obj->node_failure.node_id.compressed_form, 33);
1548 jboolean __attribute__((export_name("TS_LDKNetworkUpdate_NodeFailure_get_is_permanent"))) TS_LDKNetworkUpdate_NodeFailure_get_is_permanent(uint32_t ptr) {
1549 LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1);
1550 assert(obj->tag == LDKNetworkUpdate_NodeFailure);
1551 jboolean is_permanent_conv = obj->node_failure.is_permanent;
1552 return is_permanent_conv;
1554 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_ty_from_ptr"))) TS_LDKCOption_NetworkUpdateZ_ty_from_ptr(uint32_t ptr) {
1555 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)(ptr & ~1);
1557 case LDKCOption_NetworkUpdateZ_Some: return 0;
1558 case LDKCOption_NetworkUpdateZ_None: return 1;
1562 uint32_t __attribute__((export_name("TS_LDKCOption_NetworkUpdateZ_Some_get_some"))) TS_LDKCOption_NetworkUpdateZ_Some_get_some(uint32_t ptr) {
1563 LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)(ptr & ~1);
1564 assert(obj->tag == LDKCOption_NetworkUpdateZ_Some);
1565 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
1568 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_ty_from_ptr"))) TS_LDKSpendableOutputDescriptor_ty_from_ptr(uint32_t ptr) {
1569 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1571 case LDKSpendableOutputDescriptor_StaticOutput: return 0;
1572 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: return 1;
1573 case LDKSpendableOutputDescriptor_StaticPaymentOutput: return 2;
1577 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_outpoint(uint32_t ptr) {
1578 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1579 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1580 LDKOutPoint outpoint_var = obj->static_output.outpoint;
1581 uint32_t outpoint_ref = 0;
1582 CHECK((((uintptr_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1583 CHECK((((uintptr_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1584 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_var);
1585 outpoint_ref = (uintptr_t)outpoint_var.inner & ~1;
1586 return outpoint_ref;
1588 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticOutput_get_output"))) TS_LDKSpendableOutputDescriptor_StaticOutput_get_output(uint32_t ptr) {
1589 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1590 assert(obj->tag == LDKSpendableOutputDescriptor_StaticOutput);
1591 uint32_t output_ref = ((uintptr_t)&obj->static_output.output) | 1;
1592 return (uint32_t)output_ref;
1594 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output"))) TS_LDKSpendableOutputDescriptor_DelayedPaymentOutput_get_delayed_payment_output(uint32_t ptr) {
1595 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1596 assert(obj->tag == LDKSpendableOutputDescriptor_DelayedPaymentOutput);
1597 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
1598 uint32_t delayed_payment_output_ref = 0;
1599 CHECK((((uintptr_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1600 CHECK((((uintptr_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1601 CHECK_INNER_FIELD_ACCESS_OR_NULL(delayed_payment_output_var);
1602 delayed_payment_output_ref = (uintptr_t)delayed_payment_output_var.inner & ~1;
1603 return delayed_payment_output_ref;
1605 uint32_t __attribute__((export_name("TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output"))) TS_LDKSpendableOutputDescriptor_StaticPaymentOutput_get_static_payment_output(uint32_t ptr) {
1606 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
1607 assert(obj->tag == LDKSpendableOutputDescriptor_StaticPaymentOutput);
1608 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
1609 uint32_t static_payment_output_ref = 0;
1610 CHECK((((uintptr_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1611 CHECK((((uintptr_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1612 CHECK_INNER_FIELD_ACCESS_OR_NULL(static_payment_output_var);
1613 static_payment_output_ref = (uintptr_t)static_payment_output_var.inner & ~1;
1614 return static_payment_output_ref;
1616 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
1617 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
1618 for (size_t i = 0; i < ret.datalen; i++) {
1619 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
1623 uint32_t __attribute__((export_name("TS_LDKEvent_ty_from_ptr"))) TS_LDKEvent_ty_from_ptr(uint32_t ptr) {
1624 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1626 case LDKEvent_FundingGenerationReady: return 0;
1627 case LDKEvent_PaymentReceived: return 1;
1628 case LDKEvent_PaymentClaimed: return 2;
1629 case LDKEvent_PaymentSent: return 3;
1630 case LDKEvent_PaymentFailed: return 4;
1631 case LDKEvent_PaymentPathSuccessful: return 5;
1632 case LDKEvent_PaymentPathFailed: return 6;
1633 case LDKEvent_ProbeSuccessful: return 7;
1634 case LDKEvent_ProbeFailed: return 8;
1635 case LDKEvent_PendingHTLCsForwardable: return 9;
1636 case LDKEvent_SpendableOutputs: return 10;
1637 case LDKEvent_PaymentForwarded: return 11;
1638 case LDKEvent_ChannelClosed: return 12;
1639 case LDKEvent_DiscardFunding: return 13;
1640 case LDKEvent_OpenChannelRequest: return 14;
1641 case LDKEvent_HTLCHandlingFailed: return 15;
1645 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_temporary_channel_id(uint32_t ptr) {
1646 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1647 assert(obj->tag == LDKEvent_FundingGenerationReady);
1648 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
1649 memcpy(temporary_channel_id_arr->elems, obj->funding_generation_ready.temporary_channel_id.data, 32);
1650 return temporary_channel_id_arr;
1652 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id"))) TS_LDKEvent_FundingGenerationReady_get_counterparty_node_id(uint32_t ptr) {
1653 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1654 assert(obj->tag == LDKEvent_FundingGenerationReady);
1655 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
1656 memcpy(counterparty_node_id_arr->elems, obj->funding_generation_ready.counterparty_node_id.compressed_form, 33);
1657 return counterparty_node_id_arr;
1659 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis"))) TS_LDKEvent_FundingGenerationReady_get_channel_value_satoshis(uint32_t ptr) {
1660 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1661 assert(obj->tag == LDKEvent_FundingGenerationReady);
1662 int64_t channel_value_satoshis_conv = obj->funding_generation_ready.channel_value_satoshis;
1663 return channel_value_satoshis_conv;
1665 int8_tArray __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_output_script"))) TS_LDKEvent_FundingGenerationReady_get_output_script(uint32_t ptr) {
1666 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1667 assert(obj->tag == LDKEvent_FundingGenerationReady);
1668 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
1669 int8_tArray output_script_arr = init_int8_tArray(output_script_var.datalen, __LINE__);
1670 memcpy(output_script_arr->elems, output_script_var.data, output_script_var.datalen);
1671 return output_script_arr;
1673 int64_t __attribute__((export_name("TS_LDKEvent_FundingGenerationReady_get_user_channel_id"))) TS_LDKEvent_FundingGenerationReady_get_user_channel_id(uint32_t ptr) {
1674 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1675 assert(obj->tag == LDKEvent_FundingGenerationReady);
1676 int64_t user_channel_id_conv = obj->funding_generation_ready.user_channel_id;
1677 return user_channel_id_conv;
1679 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentReceived_get_payment_hash"))) TS_LDKEvent_PaymentReceived_get_payment_hash(uint32_t ptr) {
1680 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1681 assert(obj->tag == LDKEvent_PaymentReceived);
1682 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1683 memcpy(payment_hash_arr->elems, obj->payment_received.payment_hash.data, 32);
1684 return payment_hash_arr;
1686 int64_t __attribute__((export_name("TS_LDKEvent_PaymentReceived_get_amount_msat"))) TS_LDKEvent_PaymentReceived_get_amount_msat(uint32_t ptr) {
1687 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1688 assert(obj->tag == LDKEvent_PaymentReceived);
1689 int64_t amount_msat_conv = obj->payment_received.amount_msat;
1690 return amount_msat_conv;
1692 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentReceived_get_purpose"))) TS_LDKEvent_PaymentReceived_get_purpose(uint32_t ptr) {
1693 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1694 assert(obj->tag == LDKEvent_PaymentReceived);
1695 uint32_t purpose_ref = ((uintptr_t)&obj->payment_received.purpose) | 1;
1698 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_payment_hash"))) TS_LDKEvent_PaymentClaimed_get_payment_hash(uint32_t ptr) {
1699 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1700 assert(obj->tag == LDKEvent_PaymentClaimed);
1701 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1702 memcpy(payment_hash_arr->elems, obj->payment_claimed.payment_hash.data, 32);
1703 return payment_hash_arr;
1705 int64_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_amount_msat"))) TS_LDKEvent_PaymentClaimed_get_amount_msat(uint32_t ptr) {
1706 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1707 assert(obj->tag == LDKEvent_PaymentClaimed);
1708 int64_t amount_msat_conv = obj->payment_claimed.amount_msat;
1709 return amount_msat_conv;
1711 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentClaimed_get_purpose"))) TS_LDKEvent_PaymentClaimed_get_purpose(uint32_t ptr) {
1712 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1713 assert(obj->tag == LDKEvent_PaymentClaimed);
1714 uint32_t purpose_ref = ((uintptr_t)&obj->payment_claimed.purpose) | 1;
1717 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_id"))) TS_LDKEvent_PaymentSent_get_payment_id(uint32_t ptr) {
1718 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1719 assert(obj->tag == LDKEvent_PaymentSent);
1720 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1721 memcpy(payment_id_arr->elems, obj->payment_sent.payment_id.data, 32);
1722 return payment_id_arr;
1724 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_preimage"))) TS_LDKEvent_PaymentSent_get_payment_preimage(uint32_t ptr) {
1725 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1726 assert(obj->tag == LDKEvent_PaymentSent);
1727 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
1728 memcpy(payment_preimage_arr->elems, obj->payment_sent.payment_preimage.data, 32);
1729 return payment_preimage_arr;
1731 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentSent_get_payment_hash"))) TS_LDKEvent_PaymentSent_get_payment_hash(uint32_t ptr) {
1732 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1733 assert(obj->tag == LDKEvent_PaymentSent);
1734 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1735 memcpy(payment_hash_arr->elems, obj->payment_sent.payment_hash.data, 32);
1736 return payment_hash_arr;
1738 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentSent_get_fee_paid_msat"))) TS_LDKEvent_PaymentSent_get_fee_paid_msat(uint32_t ptr) {
1739 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1740 assert(obj->tag == LDKEvent_PaymentSent);
1741 uint32_t fee_paid_msat_ref = ((uintptr_t)&obj->payment_sent.fee_paid_msat) | 1;
1742 return fee_paid_msat_ref;
1744 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_id"))) TS_LDKEvent_PaymentFailed_get_payment_id(uint32_t ptr) {
1745 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1746 assert(obj->tag == LDKEvent_PaymentFailed);
1747 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1748 memcpy(payment_id_arr->elems, obj->payment_failed.payment_id.data, 32);
1749 return payment_id_arr;
1751 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentFailed_get_payment_hash"))) TS_LDKEvent_PaymentFailed_get_payment_hash(uint32_t ptr) {
1752 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1753 assert(obj->tag == LDKEvent_PaymentFailed);
1754 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1755 memcpy(payment_hash_arr->elems, obj->payment_failed.payment_hash.data, 32);
1756 return payment_hash_arr;
1758 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_id"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_id(uint32_t ptr) {
1759 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1760 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1761 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1762 memcpy(payment_id_arr->elems, obj->payment_path_successful.payment_id.data, 32);
1763 return payment_id_arr;
1765 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_payment_hash"))) TS_LDKEvent_PaymentPathSuccessful_get_payment_hash(uint32_t ptr) {
1766 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1767 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1768 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1769 memcpy(payment_hash_arr->elems, obj->payment_path_successful.payment_hash.data, 32);
1770 return payment_hash_arr;
1772 uint32_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathSuccessful_get_path"))) TS_LDKEvent_PaymentPathSuccessful_get_path(uint32_t ptr) {
1773 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1774 assert(obj->tag == LDKEvent_PaymentPathSuccessful);
1775 LDKCVec_RouteHopZ path_var = obj->payment_path_successful.path;
1776 uint32_tArray path_arr = NULL;
1777 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
1778 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
1779 for (size_t k = 0; k < path_var.datalen; k++) {
1780 LDKRouteHop path_conv_10_var = path_var.data[k];
1781 uint32_t path_conv_10_ref = 0;
1782 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1783 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1784 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1785 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner & ~1;
1786 path_arr_ptr[k] = path_conv_10_ref;
1791 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_id"))) TS_LDKEvent_PaymentPathFailed_get_payment_id(uint32_t ptr) {
1792 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1793 assert(obj->tag == LDKEvent_PaymentPathFailed);
1794 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1795 memcpy(payment_id_arr->elems, obj->payment_path_failed.payment_id.data, 32);
1796 return payment_id_arr;
1798 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_payment_hash"))) TS_LDKEvent_PaymentPathFailed_get_payment_hash(uint32_t ptr) {
1799 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1800 assert(obj->tag == LDKEvent_PaymentPathFailed);
1801 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1802 memcpy(payment_hash_arr->elems, obj->payment_path_failed.payment_hash.data, 32);
1803 return payment_hash_arr;
1805 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest"))) TS_LDKEvent_PaymentPathFailed_get_rejected_by_dest(uint32_t ptr) {
1806 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1807 assert(obj->tag == LDKEvent_PaymentPathFailed);
1808 jboolean rejected_by_dest_conv = obj->payment_path_failed.rejected_by_dest;
1809 return rejected_by_dest_conv;
1811 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_network_update"))) TS_LDKEvent_PaymentPathFailed_get_network_update(uint32_t ptr) {
1812 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1813 assert(obj->tag == LDKEvent_PaymentPathFailed);
1814 uint32_t network_update_ref = ((uintptr_t)&obj->payment_path_failed.network_update) | 1;
1815 return network_update_ref;
1817 jboolean __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_all_paths_failed"))) TS_LDKEvent_PaymentPathFailed_get_all_paths_failed(uint32_t ptr) {
1818 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1819 assert(obj->tag == LDKEvent_PaymentPathFailed);
1820 jboolean all_paths_failed_conv = obj->payment_path_failed.all_paths_failed;
1821 return all_paths_failed_conv;
1823 uint32_tArray __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_path"))) TS_LDKEvent_PaymentPathFailed_get_path(uint32_t ptr) {
1824 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1825 assert(obj->tag == LDKEvent_PaymentPathFailed);
1826 LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path;
1827 uint32_tArray path_arr = NULL;
1828 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
1829 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
1830 for (size_t k = 0; k < path_var.datalen; k++) {
1831 LDKRouteHop path_conv_10_var = path_var.data[k];
1832 uint32_t path_conv_10_ref = 0;
1833 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1834 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1835 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1836 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner & ~1;
1837 path_arr_ptr[k] = path_conv_10_ref;
1842 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_short_channel_id"))) TS_LDKEvent_PaymentPathFailed_get_short_channel_id(uint32_t ptr) {
1843 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1844 assert(obj->tag == LDKEvent_PaymentPathFailed);
1845 uint32_t short_channel_id_ref = ((uintptr_t)&obj->payment_path_failed.short_channel_id) | 1;
1846 return short_channel_id_ref;
1848 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentPathFailed_get_retry"))) TS_LDKEvent_PaymentPathFailed_get_retry(uint32_t ptr) {
1849 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1850 assert(obj->tag == LDKEvent_PaymentPathFailed);
1851 LDKRouteParameters retry_var = obj->payment_path_failed.retry;
1852 uint32_t retry_ref = 0;
1853 if ((uintptr_t)retry_var.inner > 4096) {
1854 CHECK((((uintptr_t)retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1855 CHECK((((uintptr_t)&retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1856 CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_var);
1857 retry_ref = (uintptr_t)retry_var.inner & ~1;
1861 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_id"))) TS_LDKEvent_ProbeSuccessful_get_payment_id(uint32_t ptr) {
1862 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1863 assert(obj->tag == LDKEvent_ProbeSuccessful);
1864 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1865 memcpy(payment_id_arr->elems, obj->probe_successful.payment_id.data, 32);
1866 return payment_id_arr;
1868 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_payment_hash"))) TS_LDKEvent_ProbeSuccessful_get_payment_hash(uint32_t ptr) {
1869 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1870 assert(obj->tag == LDKEvent_ProbeSuccessful);
1871 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1872 memcpy(payment_hash_arr->elems, obj->probe_successful.payment_hash.data, 32);
1873 return payment_hash_arr;
1875 uint32_tArray __attribute__((export_name("TS_LDKEvent_ProbeSuccessful_get_path"))) TS_LDKEvent_ProbeSuccessful_get_path(uint32_t ptr) {
1876 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1877 assert(obj->tag == LDKEvent_ProbeSuccessful);
1878 LDKCVec_RouteHopZ path_var = obj->probe_successful.path;
1879 uint32_tArray path_arr = NULL;
1880 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
1881 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
1882 for (size_t k = 0; k < path_var.datalen; k++) {
1883 LDKRouteHop path_conv_10_var = path_var.data[k];
1884 uint32_t path_conv_10_ref = 0;
1885 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1886 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1887 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1888 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner & ~1;
1889 path_arr_ptr[k] = path_conv_10_ref;
1894 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_id"))) TS_LDKEvent_ProbeFailed_get_payment_id(uint32_t ptr) {
1895 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1896 assert(obj->tag == LDKEvent_ProbeFailed);
1897 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
1898 memcpy(payment_id_arr->elems, obj->probe_failed.payment_id.data, 32);
1899 return payment_id_arr;
1901 int8_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_payment_hash"))) TS_LDKEvent_ProbeFailed_get_payment_hash(uint32_t ptr) {
1902 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1903 assert(obj->tag == LDKEvent_ProbeFailed);
1904 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
1905 memcpy(payment_hash_arr->elems, obj->probe_failed.payment_hash.data, 32);
1906 return payment_hash_arr;
1908 uint32_tArray __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_path"))) TS_LDKEvent_ProbeFailed_get_path(uint32_t ptr) {
1909 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1910 assert(obj->tag == LDKEvent_ProbeFailed);
1911 LDKCVec_RouteHopZ path_var = obj->probe_failed.path;
1912 uint32_tArray path_arr = NULL;
1913 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
1914 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
1915 for (size_t k = 0; k < path_var.datalen; k++) {
1916 LDKRouteHop path_conv_10_var = path_var.data[k];
1917 uint32_t path_conv_10_ref = 0;
1918 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1919 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1920 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
1921 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner & ~1;
1922 path_arr_ptr[k] = path_conv_10_ref;
1927 uint32_t __attribute__((export_name("TS_LDKEvent_ProbeFailed_get_short_channel_id"))) TS_LDKEvent_ProbeFailed_get_short_channel_id(uint32_t ptr) {
1928 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1929 assert(obj->tag == LDKEvent_ProbeFailed);
1930 uint32_t short_channel_id_ref = ((uintptr_t)&obj->probe_failed.short_channel_id) | 1;
1931 return short_channel_id_ref;
1933 int64_t __attribute__((export_name("TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable"))) TS_LDKEvent_PendingHTLCsForwardable_get_time_forwardable(uint32_t ptr) {
1934 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1935 assert(obj->tag == LDKEvent_PendingHTLCsForwardable);
1936 int64_t time_forwardable_conv = obj->pending_htl_cs_forwardable.time_forwardable;
1937 return time_forwardable_conv;
1939 uint32_tArray __attribute__((export_name("TS_LDKEvent_SpendableOutputs_get_outputs"))) TS_LDKEvent_SpendableOutputs_get_outputs(uint32_t ptr) {
1940 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1941 assert(obj->tag == LDKEvent_SpendableOutputs);
1942 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
1943 uint32_tArray outputs_arr = NULL;
1944 outputs_arr = init_uint32_tArray(outputs_var.datalen, __LINE__);
1945 uint32_t *outputs_arr_ptr = (uint32_t*)(((uint8_t*)outputs_arr) + 4);
1946 for (size_t b = 0; b < outputs_var.datalen; b++) {
1947 uint32_t outputs_conv_27_ref = ((uintptr_t)&outputs_var.data[b]) | 1;
1948 outputs_arr_ptr[b] = outputs_conv_27_ref;
1953 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_prev_channel_id"))) TS_LDKEvent_PaymentForwarded_get_prev_channel_id(uint32_t ptr) {
1954 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1955 assert(obj->tag == LDKEvent_PaymentForwarded);
1956 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
1957 memcpy(prev_channel_id_arr->elems, obj->payment_forwarded.prev_channel_id.data, 32);
1958 return prev_channel_id_arr;
1960 int8_tArray __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_next_channel_id"))) TS_LDKEvent_PaymentForwarded_get_next_channel_id(uint32_t ptr) {
1961 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1962 assert(obj->tag == LDKEvent_PaymentForwarded);
1963 int8_tArray next_channel_id_arr = init_int8_tArray(32, __LINE__);
1964 memcpy(next_channel_id_arr->elems, obj->payment_forwarded.next_channel_id.data, 32);
1965 return next_channel_id_arr;
1967 uint32_t __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_fee_earned_msat"))) TS_LDKEvent_PaymentForwarded_get_fee_earned_msat(uint32_t ptr) {
1968 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1969 assert(obj->tag == LDKEvent_PaymentForwarded);
1970 uint32_t fee_earned_msat_ref = ((uintptr_t)&obj->payment_forwarded.fee_earned_msat) | 1;
1971 return fee_earned_msat_ref;
1973 jboolean __attribute__((export_name("TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx"))) TS_LDKEvent_PaymentForwarded_get_claim_from_onchain_tx(uint32_t ptr) {
1974 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1975 assert(obj->tag == LDKEvent_PaymentForwarded);
1976 jboolean claim_from_onchain_tx_conv = obj->payment_forwarded.claim_from_onchain_tx;
1977 return claim_from_onchain_tx_conv;
1979 int8_tArray __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_channel_id"))) TS_LDKEvent_ChannelClosed_get_channel_id(uint32_t ptr) {
1980 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1981 assert(obj->tag == LDKEvent_ChannelClosed);
1982 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
1983 memcpy(channel_id_arr->elems, obj->channel_closed.channel_id.data, 32);
1984 return channel_id_arr;
1986 int64_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_user_channel_id"))) TS_LDKEvent_ChannelClosed_get_user_channel_id(uint32_t ptr) {
1987 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1988 assert(obj->tag == LDKEvent_ChannelClosed);
1989 int64_t user_channel_id_conv = obj->channel_closed.user_channel_id;
1990 return user_channel_id_conv;
1992 uint32_t __attribute__((export_name("TS_LDKEvent_ChannelClosed_get_reason"))) TS_LDKEvent_ChannelClosed_get_reason(uint32_t ptr) {
1993 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
1994 assert(obj->tag == LDKEvent_ChannelClosed);
1995 uint32_t reason_ref = ((uintptr_t)&obj->channel_closed.reason) | 1;
1998 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_channel_id"))) TS_LDKEvent_DiscardFunding_get_channel_id(uint32_t ptr) {
1999 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2000 assert(obj->tag == LDKEvent_DiscardFunding);
2001 int8_tArray channel_id_arr = init_int8_tArray(32, __LINE__);
2002 memcpy(channel_id_arr->elems, obj->discard_funding.channel_id.data, 32);
2003 return channel_id_arr;
2005 int8_tArray __attribute__((export_name("TS_LDKEvent_DiscardFunding_get_transaction"))) TS_LDKEvent_DiscardFunding_get_transaction(uint32_t ptr) {
2006 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2007 assert(obj->tag == LDKEvent_DiscardFunding);
2008 LDKTransaction transaction_var = obj->discard_funding.transaction;
2009 int8_tArray transaction_arr = init_int8_tArray(transaction_var.datalen, __LINE__);
2010 memcpy(transaction_arr->elems, transaction_var.data, transaction_var.datalen);
2011 return transaction_arr;
2013 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id"))) TS_LDKEvent_OpenChannelRequest_get_temporary_channel_id(uint32_t ptr) {
2014 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2015 assert(obj->tag == LDKEvent_OpenChannelRequest);
2016 int8_tArray temporary_channel_id_arr = init_int8_tArray(32, __LINE__);
2017 memcpy(temporary_channel_id_arr->elems, obj->open_channel_request.temporary_channel_id.data, 32);
2018 return temporary_channel_id_arr;
2020 int8_tArray __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id"))) TS_LDKEvent_OpenChannelRequest_get_counterparty_node_id(uint32_t ptr) {
2021 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2022 assert(obj->tag == LDKEvent_OpenChannelRequest);
2023 int8_tArray counterparty_node_id_arr = init_int8_tArray(33, __LINE__);
2024 memcpy(counterparty_node_id_arr->elems, obj->open_channel_request.counterparty_node_id.compressed_form, 33);
2025 return counterparty_node_id_arr;
2027 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_funding_satoshis"))) TS_LDKEvent_OpenChannelRequest_get_funding_satoshis(uint32_t ptr) {
2028 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2029 assert(obj->tag == LDKEvent_OpenChannelRequest);
2030 int64_t funding_satoshis_conv = obj->open_channel_request.funding_satoshis;
2031 return funding_satoshis_conv;
2033 int64_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_push_msat"))) TS_LDKEvent_OpenChannelRequest_get_push_msat(uint32_t ptr) {
2034 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2035 assert(obj->tag == LDKEvent_OpenChannelRequest);
2036 int64_t push_msat_conv = obj->open_channel_request.push_msat;
2037 return push_msat_conv;
2039 uint32_t __attribute__((export_name("TS_LDKEvent_OpenChannelRequest_get_channel_type"))) TS_LDKEvent_OpenChannelRequest_get_channel_type(uint32_t ptr) {
2040 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2041 assert(obj->tag == LDKEvent_OpenChannelRequest);
2042 LDKChannelTypeFeatures channel_type_var = obj->open_channel_request.channel_type;
2043 uint32_t channel_type_ref = 0;
2044 CHECK((((uintptr_t)channel_type_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2045 CHECK((((uintptr_t)&channel_type_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2046 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_var);
2047 channel_type_ref = (uintptr_t)channel_type_var.inner & ~1;
2048 return channel_type_ref;
2050 int8_tArray __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id"))) TS_LDKEvent_HTLCHandlingFailed_get_prev_channel_id(uint32_t ptr) {
2051 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2052 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2053 int8_tArray prev_channel_id_arr = init_int8_tArray(32, __LINE__);
2054 memcpy(prev_channel_id_arr->elems, obj->htlc_handling_failed.prev_channel_id.data, 32);
2055 return prev_channel_id_arr;
2057 uint32_t __attribute__((export_name("TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination"))) TS_LDKEvent_HTLCHandlingFailed_get_failed_next_destination(uint32_t ptr) {
2058 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
2059 assert(obj->tag == LDKEvent_HTLCHandlingFailed);
2060 uint32_t failed_next_destination_ref = ((uintptr_t)&obj->htlc_handling_failed.failed_next_destination) | 1;
2061 return failed_next_destination_ref;
2063 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_ty_from_ptr"))) TS_LDKCOption_EventZ_ty_from_ptr(uint32_t ptr) {
2064 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
2066 case LDKCOption_EventZ_Some: return 0;
2067 case LDKCOption_EventZ_None: return 1;
2071 uint32_t __attribute__((export_name("TS_LDKCOption_EventZ_Some_get_some"))) TS_LDKCOption_EventZ_Some_get_some(uint32_t ptr) {
2072 LDKCOption_EventZ *obj = (LDKCOption_EventZ*)(ptr & ~1);
2073 assert(obj->tag == LDKCOption_EventZ_Some);
2074 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
2077 static inline struct LDKCOption_EventZ CResult_COption_EventZDecodeErrorZ_get_ok(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2078 CHECK(owner->result_ok);
2079 return COption_EventZ_clone(&*owner->contents.result);
2081 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_ok"))) TS_CResult_COption_EventZDecodeErrorZ_get_ok(uint32_t owner) {
2082 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(owner & ~1);
2083 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
2084 *ret_copy = CResult_COption_EventZDecodeErrorZ_get_ok(owner_conv);
2085 uint32_t ret_ref = (uintptr_t)ret_copy;
2089 static inline struct LDKDecodeError CResult_COption_EventZDecodeErrorZ_get_err(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR owner){
2090 CHECK(!owner->result_ok);
2091 return DecodeError_clone(&*owner->contents.err);
2093 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_get_err"))) TS_CResult_COption_EventZDecodeErrorZ_get_err(uint32_t owner) {
2094 LDKCResult_COption_EventZDecodeErrorZ* owner_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(owner & ~1);
2095 LDKDecodeError ret_var = CResult_COption_EventZDecodeErrorZ_get_err(owner_conv);
2096 uint32_t ret_ref = 0;
2097 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2098 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2099 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2100 ret_ref = (uintptr_t)ret_var.inner;
2101 if (ret_var.is_owned) {
2107 uint32_t __attribute__((export_name("TS_LDKErrorAction_ty_from_ptr"))) TS_LDKErrorAction_ty_from_ptr(uint32_t ptr) {
2108 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2110 case LDKErrorAction_DisconnectPeer: return 0;
2111 case LDKErrorAction_IgnoreError: return 1;
2112 case LDKErrorAction_IgnoreAndLog: return 2;
2113 case LDKErrorAction_IgnoreDuplicateGossip: return 3;
2114 case LDKErrorAction_SendErrorMessage: return 4;
2115 case LDKErrorAction_SendWarningMessage: return 5;
2119 uint32_t __attribute__((export_name("TS_LDKErrorAction_DisconnectPeer_get_msg"))) TS_LDKErrorAction_DisconnectPeer_get_msg(uint32_t ptr) {
2120 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2121 assert(obj->tag == LDKErrorAction_DisconnectPeer);
2122 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
2123 uint32_t msg_ref = 0;
2124 if ((uintptr_t)msg_var.inner > 4096) {
2125 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2126 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2127 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2128 msg_ref = (uintptr_t)msg_var.inner & ~1;
2132 uint32_t __attribute__((export_name("TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log"))) TS_LDKErrorAction_IgnoreAndLog_get_ignore_and_log(uint32_t ptr) {
2133 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2134 assert(obj->tag == LDKErrorAction_IgnoreAndLog);
2135 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
2136 return ignore_and_log_conv;
2138 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendErrorMessage_get_msg"))) TS_LDKErrorAction_SendErrorMessage_get_msg(uint32_t ptr) {
2139 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2140 assert(obj->tag == LDKErrorAction_SendErrorMessage);
2141 LDKErrorMessage msg_var = obj->send_error_message.msg;
2142 uint32_t msg_ref = 0;
2143 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2144 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2145 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2146 msg_ref = (uintptr_t)msg_var.inner & ~1;
2149 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_msg"))) TS_LDKErrorAction_SendWarningMessage_get_msg(uint32_t ptr) {
2150 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2151 assert(obj->tag == LDKErrorAction_SendWarningMessage);
2152 LDKWarningMessage msg_var = obj->send_warning_message.msg;
2153 uint32_t msg_ref = 0;
2154 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2155 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2156 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2157 msg_ref = (uintptr_t)msg_var.inner & ~1;
2160 uint32_t __attribute__((export_name("TS_LDKErrorAction_SendWarningMessage_get_log_level"))) TS_LDKErrorAction_SendWarningMessage_get_log_level(uint32_t ptr) {
2161 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
2162 assert(obj->tag == LDKErrorAction_SendWarningMessage);
2163 uint32_t log_level_conv = LDKLevel_to_js(obj->send_warning_message.log_level);
2164 return log_level_conv;
2166 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_ty_from_ptr"))) TS_LDKMessageSendEvent_ty_from_ptr(uint32_t ptr) {
2167 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2169 case LDKMessageSendEvent_SendAcceptChannel: return 0;
2170 case LDKMessageSendEvent_SendOpenChannel: return 1;
2171 case LDKMessageSendEvent_SendFundingCreated: return 2;
2172 case LDKMessageSendEvent_SendFundingSigned: return 3;
2173 case LDKMessageSendEvent_SendChannelReady: return 4;
2174 case LDKMessageSendEvent_SendAnnouncementSignatures: return 5;
2175 case LDKMessageSendEvent_UpdateHTLCs: return 6;
2176 case LDKMessageSendEvent_SendRevokeAndACK: return 7;
2177 case LDKMessageSendEvent_SendClosingSigned: return 8;
2178 case LDKMessageSendEvent_SendShutdown: return 9;
2179 case LDKMessageSendEvent_SendChannelReestablish: return 10;
2180 case LDKMessageSendEvent_BroadcastChannelAnnouncement: return 11;
2181 case LDKMessageSendEvent_BroadcastNodeAnnouncement: return 12;
2182 case LDKMessageSendEvent_BroadcastChannelUpdate: return 13;
2183 case LDKMessageSendEvent_SendChannelUpdate: return 14;
2184 case LDKMessageSendEvent_HandleError: return 15;
2185 case LDKMessageSendEvent_SendChannelRangeQuery: return 16;
2186 case LDKMessageSendEvent_SendShortIdsQuery: return 17;
2187 case LDKMessageSendEvent_SendReplyChannelRange: return 18;
2188 case LDKMessageSendEvent_SendGossipTimestampFilter: return 19;
2192 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_node_id(uint32_t ptr) {
2193 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2194 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
2195 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2196 memcpy(node_id_arr->elems, obj->send_accept_channel.node_id.compressed_form, 33);
2199 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAcceptChannel_get_msg"))) TS_LDKMessageSendEvent_SendAcceptChannel_get_msg(uint32_t ptr) {
2200 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2201 assert(obj->tag == LDKMessageSendEvent_SendAcceptChannel);
2202 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
2203 uint32_t msg_ref = 0;
2204 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2205 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2206 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2207 msg_ref = (uintptr_t)msg_var.inner & ~1;
2210 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_node_id"))) TS_LDKMessageSendEvent_SendOpenChannel_get_node_id(uint32_t ptr) {
2211 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2212 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
2213 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2214 memcpy(node_id_arr->elems, obj->send_open_channel.node_id.compressed_form, 33);
2217 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendOpenChannel_get_msg"))) TS_LDKMessageSendEvent_SendOpenChannel_get_msg(uint32_t ptr) {
2218 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2219 assert(obj->tag == LDKMessageSendEvent_SendOpenChannel);
2220 LDKOpenChannel msg_var = obj->send_open_channel.msg;
2221 uint32_t msg_ref = 0;
2222 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2223 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2224 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2225 msg_ref = (uintptr_t)msg_var.inner & ~1;
2228 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_node_id"))) TS_LDKMessageSendEvent_SendFundingCreated_get_node_id(uint32_t ptr) {
2229 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2230 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
2231 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2232 memcpy(node_id_arr->elems, obj->send_funding_created.node_id.compressed_form, 33);
2235 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingCreated_get_msg"))) TS_LDKMessageSendEvent_SendFundingCreated_get_msg(uint32_t ptr) {
2236 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2237 assert(obj->tag == LDKMessageSendEvent_SendFundingCreated);
2238 LDKFundingCreated msg_var = obj->send_funding_created.msg;
2239 uint32_t msg_ref = 0;
2240 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2241 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2242 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2243 msg_ref = (uintptr_t)msg_var.inner & ~1;
2246 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendFundingSigned_get_node_id(uint32_t ptr) {
2247 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2248 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
2249 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2250 memcpy(node_id_arr->elems, obj->send_funding_signed.node_id.compressed_form, 33);
2253 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendFundingSigned_get_msg"))) TS_LDKMessageSendEvent_SendFundingSigned_get_msg(uint32_t ptr) {
2254 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2255 assert(obj->tag == LDKMessageSendEvent_SendFundingSigned);
2256 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
2257 uint32_t msg_ref = 0;
2258 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2259 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2260 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2261 msg_ref = (uintptr_t)msg_var.inner & ~1;
2264 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReady_get_node_id(uint32_t ptr) {
2265 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2266 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
2267 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2268 memcpy(node_id_arr->elems, obj->send_channel_ready.node_id.compressed_form, 33);
2271 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReady_get_msg"))) TS_LDKMessageSendEvent_SendChannelReady_get_msg(uint32_t ptr) {
2272 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2273 assert(obj->tag == LDKMessageSendEvent_SendChannelReady);
2274 LDKChannelReady msg_var = obj->send_channel_ready.msg;
2275 uint32_t msg_ref = 0;
2276 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2277 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2278 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2279 msg_ref = (uintptr_t)msg_var.inner & ~1;
2282 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_node_id(uint32_t ptr) {
2283 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2284 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
2285 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2286 memcpy(node_id_arr->elems, obj->send_announcement_signatures.node_id.compressed_form, 33);
2289 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg"))) TS_LDKMessageSendEvent_SendAnnouncementSignatures_get_msg(uint32_t ptr) {
2290 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2291 assert(obj->tag == LDKMessageSendEvent_SendAnnouncementSignatures);
2292 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
2293 uint32_t msg_ref = 0;
2294 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2295 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2296 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2297 msg_ref = (uintptr_t)msg_var.inner & ~1;
2300 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_node_id(uint32_t ptr) {
2301 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2302 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
2303 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2304 memcpy(node_id_arr->elems, obj->update_htl_cs.node_id.compressed_form, 33);
2307 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_UpdateHTLCs_get_updates"))) TS_LDKMessageSendEvent_UpdateHTLCs_get_updates(uint32_t ptr) {
2308 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2309 assert(obj->tag == LDKMessageSendEvent_UpdateHTLCs);
2310 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
2311 uint32_t updates_ref = 0;
2312 CHECK((((uintptr_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2313 CHECK((((uintptr_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2314 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_var);
2315 updates_ref = (uintptr_t)updates_var.inner & ~1;
2318 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_node_id(uint32_t ptr) {
2319 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2320 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
2321 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2322 memcpy(node_id_arr->elems, obj->send_revoke_and_ack.node_id.compressed_form, 33);
2325 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg"))) TS_LDKMessageSendEvent_SendRevokeAndACK_get_msg(uint32_t ptr) {
2326 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2327 assert(obj->tag == LDKMessageSendEvent_SendRevokeAndACK);
2328 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
2329 uint32_t msg_ref = 0;
2330 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2331 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2332 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2333 msg_ref = (uintptr_t)msg_var.inner & ~1;
2336 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_node_id"))) TS_LDKMessageSendEvent_SendClosingSigned_get_node_id(uint32_t ptr) {
2337 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2338 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
2339 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2340 memcpy(node_id_arr->elems, obj->send_closing_signed.node_id.compressed_form, 33);
2343 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendClosingSigned_get_msg"))) TS_LDKMessageSendEvent_SendClosingSigned_get_msg(uint32_t ptr) {
2344 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2345 assert(obj->tag == LDKMessageSendEvent_SendClosingSigned);
2346 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
2347 uint32_t msg_ref = 0;
2348 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2349 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2350 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2351 msg_ref = (uintptr_t)msg_var.inner & ~1;
2354 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_node_id"))) TS_LDKMessageSendEvent_SendShutdown_get_node_id(uint32_t ptr) {
2355 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2356 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
2357 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2358 memcpy(node_id_arr->elems, obj->send_shutdown.node_id.compressed_form, 33);
2361 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShutdown_get_msg"))) TS_LDKMessageSendEvent_SendShutdown_get_msg(uint32_t ptr) {
2362 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2363 assert(obj->tag == LDKMessageSendEvent_SendShutdown);
2364 LDKShutdown msg_var = obj->send_shutdown.msg;
2365 uint32_t msg_ref = 0;
2366 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2367 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2368 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2369 msg_ref = (uintptr_t)msg_var.inner & ~1;
2372 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_node_id(uint32_t ptr) {
2373 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2374 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
2375 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2376 memcpy(node_id_arr->elems, obj->send_channel_reestablish.node_id.compressed_form, 33);
2379 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelReestablish_get_msg"))) TS_LDKMessageSendEvent_SendChannelReestablish_get_msg(uint32_t ptr) {
2380 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2381 assert(obj->tag == LDKMessageSendEvent_SendChannelReestablish);
2382 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
2383 uint32_t msg_ref = 0;
2384 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2385 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2386 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2387 msg_ref = (uintptr_t)msg_var.inner & ~1;
2390 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_msg(uint32_t ptr) {
2391 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2392 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
2393 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
2394 uint32_t msg_ref = 0;
2395 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2396 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2397 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2398 msg_ref = (uintptr_t)msg_var.inner & ~1;
2401 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg"))) TS_LDKMessageSendEvent_BroadcastChannelAnnouncement_get_update_msg(uint32_t ptr) {
2402 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2403 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelAnnouncement);
2404 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
2405 uint32_t update_msg_ref = 0;
2406 CHECK((((uintptr_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2407 CHECK((((uintptr_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2408 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_var);
2409 update_msg_ref = (uintptr_t)update_msg_var.inner & ~1;
2410 return update_msg_ref;
2412 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg"))) TS_LDKMessageSendEvent_BroadcastNodeAnnouncement_get_msg(uint32_t ptr) {
2413 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2414 assert(obj->tag == LDKMessageSendEvent_BroadcastNodeAnnouncement);
2415 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
2416 uint32_t msg_ref = 0;
2417 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2418 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2419 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2420 msg_ref = (uintptr_t)msg_var.inner & ~1;
2423 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_BroadcastChannelUpdate_get_msg(uint32_t ptr) {
2424 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2425 assert(obj->tag == LDKMessageSendEvent_BroadcastChannelUpdate);
2426 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
2427 uint32_t msg_ref = 0;
2428 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2429 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2430 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2431 msg_ref = (uintptr_t)msg_var.inner & ~1;
2434 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_node_id(uint32_t ptr) {
2435 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2436 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
2437 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2438 memcpy(node_id_arr->elems, obj->send_channel_update.node_id.compressed_form, 33);
2441 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelUpdate_get_msg"))) TS_LDKMessageSendEvent_SendChannelUpdate_get_msg(uint32_t ptr) {
2442 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2443 assert(obj->tag == LDKMessageSendEvent_SendChannelUpdate);
2444 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
2445 uint32_t msg_ref = 0;
2446 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2447 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2448 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2449 msg_ref = (uintptr_t)msg_var.inner & ~1;
2452 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_node_id"))) TS_LDKMessageSendEvent_HandleError_get_node_id(uint32_t ptr) {
2453 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2454 assert(obj->tag == LDKMessageSendEvent_HandleError);
2455 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2456 memcpy(node_id_arr->elems, obj->handle_error.node_id.compressed_form, 33);
2459 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_HandleError_get_action"))) TS_LDKMessageSendEvent_HandleError_get_action(uint32_t ptr) {
2460 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2461 assert(obj->tag == LDKMessageSendEvent_HandleError);
2462 uint32_t action_ref = ((uintptr_t)&obj->handle_error.action) | 1;
2465 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_node_id(uint32_t ptr) {
2466 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2467 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
2468 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2469 memcpy(node_id_arr->elems, obj->send_channel_range_query.node_id.compressed_form, 33);
2472 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg"))) TS_LDKMessageSendEvent_SendChannelRangeQuery_get_msg(uint32_t ptr) {
2473 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2474 assert(obj->tag == LDKMessageSendEvent_SendChannelRangeQuery);
2475 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
2476 uint32_t msg_ref = 0;
2477 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2478 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2479 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2480 msg_ref = (uintptr_t)msg_var.inner & ~1;
2483 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_node_id(uint32_t ptr) {
2484 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2485 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
2486 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2487 memcpy(node_id_arr->elems, obj->send_short_ids_query.node_id.compressed_form, 33);
2490 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg"))) TS_LDKMessageSendEvent_SendShortIdsQuery_get_msg(uint32_t ptr) {
2491 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2492 assert(obj->tag == LDKMessageSendEvent_SendShortIdsQuery);
2493 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
2494 uint32_t msg_ref = 0;
2495 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2496 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2497 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2498 msg_ref = (uintptr_t)msg_var.inner & ~1;
2501 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_node_id(uint32_t ptr) {
2502 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2503 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
2504 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2505 memcpy(node_id_arr->elems, obj->send_reply_channel_range.node_id.compressed_form, 33);
2508 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg"))) TS_LDKMessageSendEvent_SendReplyChannelRange_get_msg(uint32_t ptr) {
2509 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2510 assert(obj->tag == LDKMessageSendEvent_SendReplyChannelRange);
2511 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
2512 uint32_t msg_ref = 0;
2513 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2514 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2515 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2516 msg_ref = (uintptr_t)msg_var.inner & ~1;
2519 int8_tArray __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_node_id(uint32_t ptr) {
2520 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2521 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
2522 int8_tArray node_id_arr = init_int8_tArray(33, __LINE__);
2523 memcpy(node_id_arr->elems, obj->send_gossip_timestamp_filter.node_id.compressed_form, 33);
2526 uint32_t __attribute__((export_name("TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg"))) TS_LDKMessageSendEvent_SendGossipTimestampFilter_get_msg(uint32_t ptr) {
2527 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
2528 assert(obj->tag == LDKMessageSendEvent_SendGossipTimestampFilter);
2529 LDKGossipTimestampFilter msg_var = obj->send_gossip_timestamp_filter.msg;
2530 uint32_t msg_ref = 0;
2531 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2532 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2533 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
2534 msg_ref = (uintptr_t)msg_var.inner & ~1;
2537 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
2538 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
2539 for (size_t i = 0; i < ret.datalen; i++) {
2540 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
2544 static inline struct LDKTxOut CResult_TxOutAccessErrorZ_get_ok(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner){
2545 CHECK(owner->result_ok);
2546 return TxOut_clone(&*owner->contents.result);
2548 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_get_ok"))) TS_CResult_TxOutAccessErrorZ_get_ok(uint32_t owner) {
2549 LDKCResult_TxOutAccessErrorZ* owner_conv = (LDKCResult_TxOutAccessErrorZ*)(owner & ~1);
2550 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
2551 *ret_ref = CResult_TxOutAccessErrorZ_get_ok(owner_conv);
2552 return (uint32_t)ret_ref;
2555 static inline enum LDKAccessError CResult_TxOutAccessErrorZ_get_err(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR owner){
2556 CHECK(!owner->result_ok);
2557 return AccessError_clone(&*owner->contents.err);
2559 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_get_err"))) TS_CResult_TxOutAccessErrorZ_get_err(uint32_t owner) {
2560 LDKCResult_TxOutAccessErrorZ* owner_conv = (LDKCResult_TxOutAccessErrorZ*)(owner & ~1);
2561 uint32_t ret_conv = LDKAccessError_to_js(CResult_TxOutAccessErrorZ_get_err(owner_conv));
2565 static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2568 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_a"))) TS_C2Tuple_usizeTransactionZ_get_a(uint32_t owner) {
2569 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)(owner & ~1);
2570 uint32_t ret_conv = C2Tuple_usizeTransactionZ_get_a(owner_conv);
2574 static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR owner){
2577 int8_tArray __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_get_b"))) TS_C2Tuple_usizeTransactionZ_get_b(uint32_t owner) {
2578 LDKC2Tuple_usizeTransactionZ* owner_conv = (LDKC2Tuple_usizeTransactionZ*)(owner & ~1);
2579 LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(owner_conv);
2580 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
2581 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
2585 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
2586 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
2587 for (size_t i = 0; i < ret.datalen; i++) {
2588 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
2592 static inline LDKCVec_TxidZ CVec_TxidZ_clone(const LDKCVec_TxidZ *orig) {
2593 LDKCVec_TxidZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_TxidZ clone bytes"), .datalen = orig->datalen };
2594 for (size_t i = 0; i < ret.datalen; i++) {
2595 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
2599 static inline void CResult_NoneChannelMonitorUpdateErrZ_get_ok(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner){
2600 CHECK(owner->result_ok);
2601 return *owner->contents.result;
2603 void __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok"))) TS_CResult_NoneChannelMonitorUpdateErrZ_get_ok(uint32_t owner) {
2604 LDKCResult_NoneChannelMonitorUpdateErrZ* owner_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(owner & ~1);
2605 CResult_NoneChannelMonitorUpdateErrZ_get_ok(owner_conv);
2608 static inline enum LDKChannelMonitorUpdateErr CResult_NoneChannelMonitorUpdateErrZ_get_err(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR owner){
2609 CHECK(!owner->result_ok);
2610 return ChannelMonitorUpdateErr_clone(&*owner->contents.err);
2612 uint32_t __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_get_err"))) TS_CResult_NoneChannelMonitorUpdateErrZ_get_err(uint32_t owner) {
2613 LDKCResult_NoneChannelMonitorUpdateErrZ* owner_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(owner & ~1);
2614 uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(CResult_NoneChannelMonitorUpdateErrZ_get_err(owner_conv));
2618 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_ty_from_ptr"))) TS_LDKMonitorEvent_ty_from_ptr(uint32_t ptr) {
2619 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2621 case LDKMonitorEvent_HTLCEvent: return 0;
2622 case LDKMonitorEvent_CommitmentTxConfirmed: return 1;
2623 case LDKMonitorEvent_UpdateCompleted: return 2;
2624 case LDKMonitorEvent_UpdateFailed: return 3;
2628 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_HTLCEvent_get_htlc_event"))) TS_LDKMonitorEvent_HTLCEvent_get_htlc_event(uint32_t ptr) {
2629 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2630 assert(obj->tag == LDKMonitorEvent_HTLCEvent);
2631 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
2632 uint32_t htlc_event_ref = 0;
2633 CHECK((((uintptr_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2634 CHECK((((uintptr_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2635 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_event_var);
2636 htlc_event_ref = (uintptr_t)htlc_event_var.inner & ~1;
2637 return htlc_event_ref;
2639 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed"))) TS_LDKMonitorEvent_CommitmentTxConfirmed_get_commitment_tx_confirmed(uint32_t ptr) {
2640 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2641 assert(obj->tag == LDKMonitorEvent_CommitmentTxConfirmed);
2642 LDKOutPoint commitment_tx_confirmed_var = obj->commitment_tx_confirmed;
2643 uint32_t commitment_tx_confirmed_ref = 0;
2644 CHECK((((uintptr_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2645 CHECK((((uintptr_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2646 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_confirmed_var);
2647 commitment_tx_confirmed_ref = (uintptr_t)commitment_tx_confirmed_var.inner & ~1;
2648 return commitment_tx_confirmed_ref;
2650 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo"))) TS_LDKMonitorEvent_UpdateCompleted_get_funding_txo(uint32_t ptr) {
2651 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2652 assert(obj->tag == LDKMonitorEvent_UpdateCompleted);
2653 LDKOutPoint funding_txo_var = obj->update_completed.funding_txo;
2654 uint32_t funding_txo_ref = 0;
2655 CHECK((((uintptr_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2656 CHECK((((uintptr_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2657 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
2658 funding_txo_ref = (uintptr_t)funding_txo_var.inner & ~1;
2659 return funding_txo_ref;
2661 int64_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id"))) TS_LDKMonitorEvent_UpdateCompleted_get_monitor_update_id(uint32_t ptr) {
2662 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2663 assert(obj->tag == LDKMonitorEvent_UpdateCompleted);
2664 int64_t monitor_update_id_conv = obj->update_completed.monitor_update_id;
2665 return monitor_update_id_conv;
2667 uint32_t __attribute__((export_name("TS_LDKMonitorEvent_UpdateFailed_get_update_failed"))) TS_LDKMonitorEvent_UpdateFailed_get_update_failed(uint32_t ptr) {
2668 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
2669 assert(obj->tag == LDKMonitorEvent_UpdateFailed);
2670 LDKOutPoint update_failed_var = obj->update_failed;
2671 uint32_t update_failed_ref = 0;
2672 CHECK((((uintptr_t)update_failed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2673 CHECK((((uintptr_t)&update_failed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2674 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_failed_var);
2675 update_failed_ref = (uintptr_t)update_failed_var.inner & ~1;
2676 return update_failed_ref;
2678 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
2679 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
2680 for (size_t i = 0; i < ret.datalen; i++) {
2681 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
2685 static inline struct LDKOutPoint C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2686 return OutPoint_clone(&owner->a);
2688 uint32_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(uint32_t owner) {
2689 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(owner & ~1);
2690 LDKOutPoint ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_a(owner_conv);
2691 uint32_t ret_ref = 0;
2692 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2693 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2694 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2695 ret_ref = (uintptr_t)ret_var.inner;
2696 if (ret_var.is_owned) {
2702 static inline struct LDKCVec_MonitorEventZ C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2703 return CVec_MonitorEventZ_clone(&owner->b);
2705 uint32_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(uint32_t owner) {
2706 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(owner & ~1);
2707 LDKCVec_MonitorEventZ ret_var = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_b(owner_conv);
2708 uint32_tArray ret_arr = NULL;
2709 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
2710 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
2711 for (size_t o = 0; o < ret_var.datalen; o++) {
2712 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
2713 *ret_conv_14_copy = ret_var.data[o];
2714 uint32_t ret_conv_14_ref = (uintptr_t)ret_conv_14_copy;
2715 ret_arr_ptr[o] = ret_conv_14_ref;
2722 static inline struct LDKPublicKey C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR owner){
2725 int8_tArray __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(uint32_t owner) {
2726 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* owner_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(owner & ~1);
2727 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
2728 memcpy(ret_arr->elems, C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_get_c(owner_conv).compressed_form, 33);
2732 static inline LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_clone(const LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ *orig) {
2733 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ) * orig->datalen, "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ clone bytes"), .datalen = orig->datalen };
2734 for (size_t i = 0; i < ret.datalen; i++) {
2735 ret.data[i] = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(&orig->data[i]);
2739 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_usizeTransactionZZ_ty_from_ptr(uint32_t ptr) {
2740 LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)(ptr & ~1);
2742 case LDKCOption_C2Tuple_usizeTransactionZZ_Some: return 0;
2743 case LDKCOption_C2Tuple_usizeTransactionZZ_None: return 1;
2747 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_usizeTransactionZZ_Some_get_some(uint32_t ptr) {
2748 LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)(ptr & ~1);
2749 assert(obj->tag == LDKCOption_C2Tuple_usizeTransactionZZ_Some);
2750 LDKC2Tuple_usizeTransactionZ* some_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
2751 *some_conv = obj->some;
2752 *some_conv = C2Tuple_usizeTransactionZ_clone(some_conv);
2753 return ((uint32_t)some_conv);
2755 static inline struct LDKFixedPenaltyScorer CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2756 CHECK(owner->result_ok);
2757 return FixedPenaltyScorer_clone(&*owner->contents.result);
2759 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(uint32_t owner) {
2760 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(owner & ~1);
2761 LDKFixedPenaltyScorer ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_ok(owner_conv);
2762 uint32_t ret_ref = 0;
2763 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2764 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2766 ret_ref = (uintptr_t)ret_var.inner;
2767 if (ret_var.is_owned) {
2773 static inline struct LDKDecodeError CResult_FixedPenaltyScorerDecodeErrorZ_get_err(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR owner){
2774 CHECK(!owner->result_ok);
2775 return DecodeError_clone(&*owner->contents.err);
2777 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_get_err(uint32_t owner) {
2778 LDKCResult_FixedPenaltyScorerDecodeErrorZ* owner_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(owner & ~1);
2779 LDKDecodeError ret_var = CResult_FixedPenaltyScorerDecodeErrorZ_get_err(owner_conv);
2780 uint32_t ret_ref = 0;
2781 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2782 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2783 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2784 ret_ref = (uintptr_t)ret_var.inner;
2785 if (ret_var.is_owned) {
2791 static inline uint64_t C2Tuple_u64u64Z_get_a(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2794 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_a"))) TS_C2Tuple_u64u64Z_get_a(uint32_t owner) {
2795 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)(owner & ~1);
2796 int64_t ret_conv = C2Tuple_u64u64Z_get_a(owner_conv);
2800 static inline uint64_t C2Tuple_u64u64Z_get_b(LDKC2Tuple_u64u64Z *NONNULL_PTR owner){
2803 int64_t __attribute__((export_name("TS_C2Tuple_u64u64Z_get_b"))) TS_C2Tuple_u64u64Z_get_b(uint32_t owner) {
2804 LDKC2Tuple_u64u64Z* owner_conv = (LDKC2Tuple_u64u64Z*)(owner & ~1);
2805 int64_t ret_conv = C2Tuple_u64u64Z_get_b(owner_conv);
2809 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr"))) TS_LDKCOption_C2Tuple_u64u64ZZ_ty_from_ptr(uint32_t ptr) {
2810 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)(ptr & ~1);
2812 case LDKCOption_C2Tuple_u64u64ZZ_Some: return 0;
2813 case LDKCOption_C2Tuple_u64u64ZZ_None: return 1;
2817 uint32_t __attribute__((export_name("TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some"))) TS_LDKCOption_C2Tuple_u64u64ZZ_Some_get_some(uint32_t ptr) {
2818 LDKCOption_C2Tuple_u64u64ZZ *obj = (LDKCOption_C2Tuple_u64u64ZZ*)(ptr & ~1);
2819 assert(obj->tag == LDKCOption_C2Tuple_u64u64ZZ_Some);
2820 LDKC2Tuple_u64u64Z* some_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
2821 *some_conv = obj->some;
2822 *some_conv = C2Tuple_u64u64Z_clone(some_conv);
2823 return ((uint32_t)some_conv);
2825 static inline LDKCVec_NodeIdZ CVec_NodeIdZ_clone(const LDKCVec_NodeIdZ *orig) {
2826 LDKCVec_NodeIdZ ret = { .data = MALLOC(sizeof(LDKNodeId) * orig->datalen, "LDKCVec_NodeIdZ clone bytes"), .datalen = orig->datalen };
2827 for (size_t i = 0; i < ret.datalen; i++) {
2828 ret.data[i] = NodeId_clone(&orig->data[i]);
2832 typedef struct LDKLogger_JCalls {
2833 atomic_size_t refcnt;
2834 uint32_t instance_ptr;
2836 static void LDKLogger_JCalls_free(void* this_arg) {
2837 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2838 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2842 void log_LDKLogger_jcall(const void* this_arg, const LDKRecord * record) {
2843 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2844 LDKRecord record_var = *record;
2845 uint32_t record_ref = 0;
2846 record_var = Record_clone(&record_var);
2847 CHECK((((uintptr_t)record_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2848 CHECK((((uintptr_t)&record_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2849 CHECK_INNER_FIELD_ACCESS_OR_NULL(record_var);
2850 record_ref = (uintptr_t)record_var.inner;
2851 if (record_var.is_owned) {
2854 js_invoke_function_u_u(j_calls->instance_ptr, 0, (uint32_t)record_ref);
2856 static void LDKLogger_JCalls_cloned(LDKLogger* new_obj) {
2857 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) new_obj->this_arg;
2858 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2860 static inline LDKLogger LDKLogger_init (JSValue o) {
2861 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
2862 atomic_init(&calls->refcnt, 1);
2863 calls->instance_ptr = o;
2866 .this_arg = (void*) calls,
2867 .log = log_LDKLogger_jcall,
2868 .free = LDKLogger_JCalls_free,
2872 long __attribute__((export_name("TS_LDKLogger_new"))) TS_LDKLogger_new(JSValue o) {
2873 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
2874 *res_ptr = LDKLogger_init(o);
2875 return (long)res_ptr;
2877 static inline struct LDKProbabilisticScorer *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2878 CHECK(owner->result_ok);
2879 return &*owner->contents.result;
2881 uint32_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_ok(uint32_t owner) {
2882 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)(owner & ~1);
2883 LDKProbabilisticScorer ret_var = *CResult_ProbabilisticScorerDecodeErrorZ_get_ok(owner_conv);
2884 uint32_t ret_ref = 0;
2885 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2886 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2887 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2888 ret_ref = (uintptr_t)ret_var.inner & ~1;
2892 static inline struct LDKDecodeError CResult_ProbabilisticScorerDecodeErrorZ_get_err(LDKCResult_ProbabilisticScorerDecodeErrorZ *NONNULL_PTR owner){
2893 CHECK(!owner->result_ok);
2894 return DecodeError_clone(&*owner->contents.err);
2896 uint32_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_get_err(uint32_t owner) {
2897 LDKCResult_ProbabilisticScorerDecodeErrorZ* owner_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)(owner & ~1);
2898 LDKDecodeError ret_var = CResult_ProbabilisticScorerDecodeErrorZ_get_err(owner_conv);
2899 uint32_t ret_ref = 0;
2900 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2901 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2902 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2903 ret_ref = (uintptr_t)ret_var.inner;
2904 if (ret_var.is_owned) {
2910 static inline struct LDKInitFeatures CResult_InitFeaturesDecodeErrorZ_get_ok(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2911 CHECK(owner->result_ok);
2912 return InitFeatures_clone(&*owner->contents.result);
2914 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t owner) {
2915 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(owner & ~1);
2916 LDKInitFeatures ret_var = CResult_InitFeaturesDecodeErrorZ_get_ok(owner_conv);
2917 uint32_t ret_ref = 0;
2918 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2919 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2921 ret_ref = (uintptr_t)ret_var.inner;
2922 if (ret_var.is_owned) {
2928 static inline struct LDKDecodeError CResult_InitFeaturesDecodeErrorZ_get_err(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR owner){
2929 CHECK(!owner->result_ok);
2930 return DecodeError_clone(&*owner->contents.err);
2932 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_get_err"))) TS_CResult_InitFeaturesDecodeErrorZ_get_err(uint32_t owner) {
2933 LDKCResult_InitFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(owner & ~1);
2934 LDKDecodeError ret_var = CResult_InitFeaturesDecodeErrorZ_get_err(owner_conv);
2935 uint32_t ret_ref = 0;
2936 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2937 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2938 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2939 ret_ref = (uintptr_t)ret_var.inner;
2940 if (ret_var.is_owned) {
2946 static inline struct LDKChannelFeatures CResult_ChannelFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2947 CHECK(owner->result_ok);
2948 return ChannelFeatures_clone(&*owner->contents.result);
2950 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t owner) {
2951 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(owner & ~1);
2952 LDKChannelFeatures ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_ok(owner_conv);
2953 uint32_t ret_ref = 0;
2954 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2955 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2956 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2957 ret_ref = (uintptr_t)ret_var.inner;
2958 if (ret_var.is_owned) {
2964 static inline struct LDKDecodeError CResult_ChannelFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR owner){
2965 CHECK(!owner->result_ok);
2966 return DecodeError_clone(&*owner->contents.err);
2968 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_get_err(uint32_t owner) {
2969 LDKCResult_ChannelFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(owner & ~1);
2970 LDKDecodeError ret_var = CResult_ChannelFeaturesDecodeErrorZ_get_err(owner_conv);
2971 uint32_t ret_ref = 0;
2972 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2973 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2975 ret_ref = (uintptr_t)ret_var.inner;
2976 if (ret_var.is_owned) {
2982 static inline struct LDKNodeFeatures CResult_NodeFeaturesDecodeErrorZ_get_ok(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
2983 CHECK(owner->result_ok);
2984 return NodeFeatures_clone(&*owner->contents.result);
2986 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t owner) {
2987 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(owner & ~1);
2988 LDKNodeFeatures ret_var = CResult_NodeFeaturesDecodeErrorZ_get_ok(owner_conv);
2989 uint32_t ret_ref = 0;
2990 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2991 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2992 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
2993 ret_ref = (uintptr_t)ret_var.inner;
2994 if (ret_var.is_owned) {
3000 static inline struct LDKDecodeError CResult_NodeFeaturesDecodeErrorZ_get_err(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3001 CHECK(!owner->result_ok);
3002 return DecodeError_clone(&*owner->contents.err);
3004 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_get_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_get_err(uint32_t owner) {
3005 LDKCResult_NodeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(owner & ~1);
3006 LDKDecodeError ret_var = CResult_NodeFeaturesDecodeErrorZ_get_err(owner_conv);
3007 uint32_t ret_ref = 0;
3008 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3009 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3010 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3011 ret_ref = (uintptr_t)ret_var.inner;
3012 if (ret_var.is_owned) {
3018 static inline struct LDKInvoiceFeatures CResult_InvoiceFeaturesDecodeErrorZ_get_ok(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3019 CHECK(owner->result_ok);
3020 return InvoiceFeatures_clone(&*owner->contents.result);
3022 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint32_t owner) {
3023 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(owner & ~1);
3024 LDKInvoiceFeatures ret_var = CResult_InvoiceFeaturesDecodeErrorZ_get_ok(owner_conv);
3025 uint32_t ret_ref = 0;
3026 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3027 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3029 ret_ref = (uintptr_t)ret_var.inner;
3030 if (ret_var.is_owned) {
3036 static inline struct LDKDecodeError CResult_InvoiceFeaturesDecodeErrorZ_get_err(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR owner){
3037 CHECK(!owner->result_ok);
3038 return DecodeError_clone(&*owner->contents.err);
3040 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_get_err(uint32_t owner) {
3041 LDKCResult_InvoiceFeaturesDecodeErrorZ* owner_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(owner & ~1);
3042 LDKDecodeError ret_var = CResult_InvoiceFeaturesDecodeErrorZ_get_err(owner_conv);
3043 uint32_t ret_ref = 0;
3044 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3045 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3047 ret_ref = (uintptr_t)ret_var.inner;
3048 if (ret_var.is_owned) {
3054 static inline struct LDKChannelTypeFeatures CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3055 CHECK(owner->result_ok);
3056 return ChannelTypeFeatures_clone(&*owner->contents.result);
3058 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(uint32_t owner) {
3059 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(owner & ~1);
3060 LDKChannelTypeFeatures ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_ok(owner_conv);
3061 uint32_t ret_ref = 0;
3062 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3063 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3064 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3065 ret_ref = (uintptr_t)ret_var.inner;
3066 if (ret_var.is_owned) {
3072 static inline struct LDKDecodeError CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR owner){
3073 CHECK(!owner->result_ok);
3074 return DecodeError_clone(&*owner->contents.err);
3076 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(uint32_t owner) {
3077 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* owner_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(owner & ~1);
3078 LDKDecodeError ret_var = CResult_ChannelTypeFeaturesDecodeErrorZ_get_err(owner_conv);
3079 uint32_t ret_ref = 0;
3080 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3081 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3082 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3083 ret_ref = (uintptr_t)ret_var.inner;
3084 if (ret_var.is_owned) {
3090 static inline struct LDKNodeId CResult_NodeIdDecodeErrorZ_get_ok(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3091 CHECK(owner->result_ok);
3092 return NodeId_clone(&*owner->contents.result);
3094 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_ok"))) TS_CResult_NodeIdDecodeErrorZ_get_ok(uint32_t owner) {
3095 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)(owner & ~1);
3096 LDKNodeId ret_var = CResult_NodeIdDecodeErrorZ_get_ok(owner_conv);
3097 uint32_t ret_ref = 0;
3098 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3099 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3100 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3101 ret_ref = (uintptr_t)ret_var.inner;
3102 if (ret_var.is_owned) {
3108 static inline struct LDKDecodeError CResult_NodeIdDecodeErrorZ_get_err(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR owner){
3109 CHECK(!owner->result_ok);
3110 return DecodeError_clone(&*owner->contents.err);
3112 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_get_err"))) TS_CResult_NodeIdDecodeErrorZ_get_err(uint32_t owner) {
3113 LDKCResult_NodeIdDecodeErrorZ* owner_conv = (LDKCResult_NodeIdDecodeErrorZ*)(owner & ~1);
3114 LDKDecodeError ret_var = CResult_NodeIdDecodeErrorZ_get_err(owner_conv);
3115 uint32_t ret_ref = 0;
3116 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3117 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3119 ret_ref = (uintptr_t)ret_var.inner;
3120 if (ret_var.is_owned) {
3126 static inline struct LDKCOption_NetworkUpdateZ CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3127 CHECK(owner->result_ok);
3128 return COption_NetworkUpdateZ_clone(&*owner->contents.result);
3130 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(uint32_t owner) {
3131 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(owner & ~1);
3132 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
3133 *ret_copy = CResult_COption_NetworkUpdateZDecodeErrorZ_get_ok(owner_conv);
3134 uint32_t ret_ref = (uintptr_t)ret_copy;
3138 static inline struct LDKDecodeError CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR owner){
3139 CHECK(!owner->result_ok);
3140 return DecodeError_clone(&*owner->contents.err);
3142 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(uint32_t owner) {
3143 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* owner_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(owner & ~1);
3144 LDKDecodeError ret_var = CResult_COption_NetworkUpdateZDecodeErrorZ_get_err(owner_conv);
3145 uint32_t ret_ref = 0;
3146 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3147 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3148 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3149 ret_ref = (uintptr_t)ret_var.inner;
3150 if (ret_var.is_owned) {
3156 typedef struct LDKAccess_JCalls {
3157 atomic_size_t refcnt;
3158 uint32_t instance_ptr;
3160 static void LDKAccess_JCalls_free(void* this_arg) {
3161 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
3162 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3166 LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
3167 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
3168 int8_tArray genesis_hash_arr = init_int8_tArray(32, __LINE__);
3169 memcpy(genesis_hash_arr->elems, *genesis_hash, 32);
3170 int64_t short_channel_id_conv = short_channel_id;
3171 uint32_t ret = js_invoke_function_u_bb(j_calls->instance_ptr, 1, (uint32_t)genesis_hash_arr, (uint32_t)short_channel_id_conv);
3172 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
3173 CHECK_ACCESS(ret_ptr);
3174 LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(ret_ptr);
3178 static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) {
3179 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) new_obj->this_arg;
3180 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
3182 static inline LDKAccess LDKAccess_init (JSValue o) {
3183 LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls");
3184 atomic_init(&calls->refcnt, 1);
3185 calls->instance_ptr = o;
3188 .this_arg = (void*) calls,
3189 .get_utxo = get_utxo_LDKAccess_jcall,
3190 .free = LDKAccess_JCalls_free,
3194 long __attribute__((export_name("TS_LDKAccess_new"))) TS_LDKAccess_new(JSValue o) {
3195 LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
3196 *res_ptr = LDKAccess_init(o);
3197 return (long)res_ptr;
3199 uint32_t __attribute__((export_name("TS_Access_get_utxo"))) TS_Access_get_utxo(uint32_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) {
3200 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
3201 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
3202 LDKAccess* this_arg_conv = (LDKAccess*)this_arg_ptr;
3203 unsigned char genesis_hash_arr[32];
3204 CHECK(genesis_hash->arr_len == 32);
3205 memcpy(genesis_hash_arr, genesis_hash->elems, 32); FREE(genesis_hash);
3206 unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr;
3207 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
3208 *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
3209 return (uint32_t)ret_conv;
3212 uint32_t __attribute__((export_name("TS_LDKCOption_AccessZ_ty_from_ptr"))) TS_LDKCOption_AccessZ_ty_from_ptr(uint32_t ptr) {
3213 LDKCOption_AccessZ *obj = (LDKCOption_AccessZ*)(ptr & ~1);
3215 case LDKCOption_AccessZ_Some: return 0;
3216 case LDKCOption_AccessZ_None: return 1;
3220 uint32_t __attribute__((export_name("TS_LDKCOption_AccessZ_Some_get_some"))) TS_LDKCOption_AccessZ_Some_get_some(uint32_t ptr) {
3221 LDKCOption_AccessZ *obj = (LDKCOption_AccessZ*)(ptr & ~1);
3222 assert(obj->tag == LDKCOption_AccessZ_Some);
3223 LDKAccess* some_ret = MALLOC(sizeof(LDKAccess), "LDKAccess");
3224 *some_ret = obj->some;
3225 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
3226 if ((*some_ret).free == LDKAccess_JCalls_free) {
3227 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
3228 LDKAccess_JCalls_cloned(&(*some_ret));
3230 return (uint32_t)some_ret;
3232 static inline bool CResult_boolLightningErrorZ_get_ok(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3233 CHECK(owner->result_ok);
3234 return *owner->contents.result;
3236 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_ok"))) TS_CResult_boolLightningErrorZ_get_ok(uint32_t owner) {
3237 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)(owner & ~1);
3238 jboolean ret_conv = CResult_boolLightningErrorZ_get_ok(owner_conv);
3242 static inline struct LDKLightningError CResult_boolLightningErrorZ_get_err(LDKCResult_boolLightningErrorZ *NONNULL_PTR owner){
3243 CHECK(!owner->result_ok);
3244 return LightningError_clone(&*owner->contents.err);
3246 uint32_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_get_err"))) TS_CResult_boolLightningErrorZ_get_err(uint32_t owner) {
3247 LDKCResult_boolLightningErrorZ* owner_conv = (LDKCResult_boolLightningErrorZ*)(owner & ~1);
3248 LDKLightningError ret_var = CResult_boolLightningErrorZ_get_err(owner_conv);
3249 uint32_t ret_ref = 0;
3250 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3251 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3252 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3253 ret_ref = (uintptr_t)ret_var.inner;
3254 if (ret_var.is_owned) {
3260 static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3261 return ChannelAnnouncement_clone(&owner->a);
3263 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint32_t owner) {
3264 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(owner & ~1);
3265 LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(owner_conv);
3266 uint32_t ret_ref = 0;
3267 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3268 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3269 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3270 ret_ref = (uintptr_t)ret_var.inner;
3271 if (ret_var.is_owned) {
3277 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3278 return ChannelUpdate_clone(&owner->b);
3280 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint32_t owner) {
3281 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(owner & ~1);
3282 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(owner_conv);
3283 uint32_t ret_ref = 0;
3284 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3285 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3286 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3287 ret_ref = (uintptr_t)ret_var.inner;
3288 if (ret_var.is_owned) {
3294 static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR owner){
3295 return ChannelUpdate_clone(&owner->c);
3297 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint32_t owner) {
3298 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* owner_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(owner & ~1);
3299 LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(owner_conv);
3300 uint32_t ret_ref = 0;
3301 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3302 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3303 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3304 ret_ref = (uintptr_t)ret_var.inner;
3305 if (ret_var.is_owned) {
3311 static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
3312 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
3313 for (size_t i = 0; i < ret.datalen; i++) {
3314 ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
3318 static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
3319 LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
3320 for (size_t i = 0; i < ret.datalen; i++) {
3321 ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
3325 static inline void CResult_NoneLightningErrorZ_get_ok(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3326 CHECK(owner->result_ok);
3327 return *owner->contents.result;
3329 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_ok"))) TS_CResult_NoneLightningErrorZ_get_ok(uint32_t owner) {
3330 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)(owner & ~1);
3331 CResult_NoneLightningErrorZ_get_ok(owner_conv);
3334 static inline struct LDKLightningError CResult_NoneLightningErrorZ_get_err(LDKCResult_NoneLightningErrorZ *NONNULL_PTR owner){
3335 CHECK(!owner->result_ok);
3336 return LightningError_clone(&*owner->contents.err);
3338 uint32_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_get_err"))) TS_CResult_NoneLightningErrorZ_get_err(uint32_t owner) {
3339 LDKCResult_NoneLightningErrorZ* owner_conv = (LDKCResult_NoneLightningErrorZ*)(owner & ~1);
3340 LDKLightningError ret_var = CResult_NoneLightningErrorZ_get_err(owner_conv);
3341 uint32_t ret_ref = 0;
3342 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3343 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3345 ret_ref = (uintptr_t)ret_var.inner;
3346 if (ret_var.is_owned) {
3352 static inline struct LDKChannelUpdateInfo CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3353 CHECK(owner->result_ok);
3354 return ChannelUpdateInfo_clone(&*owner->contents.result);
3356 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(uint32_t owner) {
3357 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(owner & ~1);
3358 LDKChannelUpdateInfo ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_ok(owner_conv);
3359 uint32_t ret_ref = 0;
3360 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3361 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3362 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3363 ret_ref = (uintptr_t)ret_var.inner;
3364 if (ret_var.is_owned) {
3370 static inline struct LDKDecodeError CResult_ChannelUpdateInfoDecodeErrorZ_get_err(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR owner){
3371 CHECK(!owner->result_ok);
3372 return DecodeError_clone(&*owner->contents.err);
3374 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_get_err(uint32_t owner) {
3375 LDKCResult_ChannelUpdateInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(owner & ~1);
3376 LDKDecodeError ret_var = CResult_ChannelUpdateInfoDecodeErrorZ_get_err(owner_conv);
3377 uint32_t ret_ref = 0;
3378 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3379 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3380 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3381 ret_ref = (uintptr_t)ret_var.inner;
3382 if (ret_var.is_owned) {
3388 static inline struct LDKChannelInfo CResult_ChannelInfoDecodeErrorZ_get_ok(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3389 CHECK(owner->result_ok);
3390 return ChannelInfo_clone(&*owner->contents.result);
3392 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t owner) {
3393 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(owner & ~1);
3394 LDKChannelInfo ret_var = CResult_ChannelInfoDecodeErrorZ_get_ok(owner_conv);
3395 uint32_t ret_ref = 0;
3396 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3397 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3398 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3399 ret_ref = (uintptr_t)ret_var.inner;
3400 if (ret_var.is_owned) {
3406 static inline struct LDKDecodeError CResult_ChannelInfoDecodeErrorZ_get_err(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR owner){
3407 CHECK(!owner->result_ok);
3408 return DecodeError_clone(&*owner->contents.err);
3410 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_get_err"))) TS_CResult_ChannelInfoDecodeErrorZ_get_err(uint32_t owner) {
3411 LDKCResult_ChannelInfoDecodeErrorZ* owner_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(owner & ~1);
3412 LDKDecodeError ret_var = CResult_ChannelInfoDecodeErrorZ_get_err(owner_conv);
3413 uint32_t ret_ref = 0;
3414 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3415 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3417 ret_ref = (uintptr_t)ret_var.inner;
3418 if (ret_var.is_owned) {
3424 static inline struct LDKRoutingFees CResult_RoutingFeesDecodeErrorZ_get_ok(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3425 CHECK(owner->result_ok);
3426 return RoutingFees_clone(&*owner->contents.result);
3428 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_get_ok(uint32_t owner) {
3429 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(owner & ~1);
3430 LDKRoutingFees ret_var = CResult_RoutingFeesDecodeErrorZ_get_ok(owner_conv);
3431 uint32_t ret_ref = 0;
3432 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3433 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3435 ret_ref = (uintptr_t)ret_var.inner;
3436 if (ret_var.is_owned) {
3442 static inline struct LDKDecodeError CResult_RoutingFeesDecodeErrorZ_get_err(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR owner){
3443 CHECK(!owner->result_ok);
3444 return DecodeError_clone(&*owner->contents.err);
3446 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_get_err"))) TS_CResult_RoutingFeesDecodeErrorZ_get_err(uint32_t owner) {
3447 LDKCResult_RoutingFeesDecodeErrorZ* owner_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(owner & ~1);
3448 LDKDecodeError ret_var = CResult_RoutingFeesDecodeErrorZ_get_err(owner_conv);
3449 uint32_t ret_ref = 0;
3450 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3451 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3453 ret_ref = (uintptr_t)ret_var.inner;
3454 if (ret_var.is_owned) {
3460 uint32_t __attribute__((export_name("TS_LDKNetAddress_ty_from_ptr"))) TS_LDKNetAddress_ty_from_ptr(uint32_t ptr) {
3461 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3463 case LDKNetAddress_IPv4: return 0;
3464 case LDKNetAddress_IPv6: return 1;
3465 case LDKNetAddress_OnionV2: return 2;
3466 case LDKNetAddress_OnionV3: return 3;
3467 case LDKNetAddress_Hostname: return 4;
3471 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv4_get_addr"))) TS_LDKNetAddress_IPv4_get_addr(uint32_t ptr) {
3472 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3473 assert(obj->tag == LDKNetAddress_IPv4);
3474 int8_tArray addr_arr = init_int8_tArray(4, __LINE__);
3475 memcpy(addr_arr->elems, obj->i_pv4.addr.data, 4);
3478 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv4_get_port"))) TS_LDKNetAddress_IPv4_get_port(uint32_t ptr) {
3479 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3480 assert(obj->tag == LDKNetAddress_IPv4);
3481 int16_t port_conv = obj->i_pv4.port;
3484 int8_tArray __attribute__((export_name("TS_LDKNetAddress_IPv6_get_addr"))) TS_LDKNetAddress_IPv6_get_addr(uint32_t ptr) {
3485 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3486 assert(obj->tag == LDKNetAddress_IPv6);
3487 int8_tArray addr_arr = init_int8_tArray(16, __LINE__);
3488 memcpy(addr_arr->elems, obj->i_pv6.addr.data, 16);
3491 int16_t __attribute__((export_name("TS_LDKNetAddress_IPv6_get_port"))) TS_LDKNetAddress_IPv6_get_port(uint32_t ptr) {
3492 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3493 assert(obj->tag == LDKNetAddress_IPv6);
3494 int16_t port_conv = obj->i_pv6.port;
3497 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV2_get_onion_v2"))) TS_LDKNetAddress_OnionV2_get_onion_v2(uint32_t ptr) {
3498 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3499 assert(obj->tag == LDKNetAddress_OnionV2);
3500 int8_tArray onion_v2_arr = init_int8_tArray(12, __LINE__);
3501 memcpy(onion_v2_arr->elems, obj->onion_v2.data, 12);
3502 return onion_v2_arr;
3504 int8_tArray __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_ed25519_pubkey"))) TS_LDKNetAddress_OnionV3_get_ed25519_pubkey(uint32_t ptr) {
3505 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3506 assert(obj->tag == LDKNetAddress_OnionV3);
3507 int8_tArray ed25519_pubkey_arr = init_int8_tArray(32, __LINE__);
3508 memcpy(ed25519_pubkey_arr->elems, obj->onion_v3.ed25519_pubkey.data, 32);
3509 return ed25519_pubkey_arr;
3511 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_checksum"))) TS_LDKNetAddress_OnionV3_get_checksum(uint32_t ptr) {
3512 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3513 assert(obj->tag == LDKNetAddress_OnionV3);
3514 int16_t checksum_conv = obj->onion_v3.checksum;
3515 return checksum_conv;
3517 int8_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_version"))) TS_LDKNetAddress_OnionV3_get_version(uint32_t ptr) {
3518 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3519 assert(obj->tag == LDKNetAddress_OnionV3);
3520 int8_t version_conv = obj->onion_v3.version;
3521 return version_conv;
3523 int16_t __attribute__((export_name("TS_LDKNetAddress_OnionV3_get_port"))) TS_LDKNetAddress_OnionV3_get_port(uint32_t ptr) {
3524 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3525 assert(obj->tag == LDKNetAddress_OnionV3);
3526 int16_t port_conv = obj->onion_v3.port;
3529 uint32_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_hostname"))) TS_LDKNetAddress_Hostname_get_hostname(uint32_t ptr) {
3530 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3531 assert(obj->tag == LDKNetAddress_Hostname);
3532 LDKHostname hostname_var = obj->hostname.hostname;
3533 uint32_t hostname_ref = 0;
3534 CHECK((((uintptr_t)hostname_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3535 CHECK((((uintptr_t)&hostname_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3536 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_var);
3537 hostname_ref = (uintptr_t)hostname_var.inner & ~1;
3538 return hostname_ref;
3540 int16_t __attribute__((export_name("TS_LDKNetAddress_Hostname_get_port"))) TS_LDKNetAddress_Hostname_get_port(uint32_t ptr) {
3541 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
3542 assert(obj->tag == LDKNetAddress_Hostname);
3543 int16_t port_conv = obj->hostname.port;
3546 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
3547 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
3548 for (size_t i = 0; i < ret.datalen; i++) {
3549 ret.data[i] = NetAddress_clone(&orig->data[i]);
3553 static inline struct LDKNodeAnnouncementInfo CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3554 CHECK(owner->result_ok);
3555 return NodeAnnouncementInfo_clone(&*owner->contents.result);
3557 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint32_t owner) {
3558 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(owner & ~1);
3559 LDKNodeAnnouncementInfo ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(owner_conv);
3560 uint32_t ret_ref = 0;
3561 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3562 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3563 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3564 ret_ref = (uintptr_t)ret_var.inner;
3565 if (ret_var.is_owned) {
3571 static inline struct LDKDecodeError CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR owner){
3572 CHECK(!owner->result_ok);
3573 return DecodeError_clone(&*owner->contents.err);
3575 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint32_t owner) {
3576 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(owner & ~1);
3577 LDKDecodeError ret_var = CResult_NodeAnnouncementInfoDecodeErrorZ_get_err(owner_conv);
3578 uint32_t ret_ref = 0;
3579 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3580 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3581 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3582 ret_ref = (uintptr_t)ret_var.inner;
3583 if (ret_var.is_owned) {
3589 static inline struct LDKNodeAlias CResult_NodeAliasDecodeErrorZ_get_ok(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3590 CHECK(owner->result_ok);
3591 return NodeAlias_clone(&*owner->contents.result);
3593 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_ok"))) TS_CResult_NodeAliasDecodeErrorZ_get_ok(uint32_t owner) {
3594 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)(owner & ~1);
3595 LDKNodeAlias ret_var = CResult_NodeAliasDecodeErrorZ_get_ok(owner_conv);
3596 uint32_t ret_ref = 0;
3597 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3598 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3599 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3600 ret_ref = (uintptr_t)ret_var.inner;
3601 if (ret_var.is_owned) {
3607 static inline struct LDKDecodeError CResult_NodeAliasDecodeErrorZ_get_err(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR owner){
3608 CHECK(!owner->result_ok);
3609 return DecodeError_clone(&*owner->contents.err);
3611 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_get_err"))) TS_CResult_NodeAliasDecodeErrorZ_get_err(uint32_t owner) {
3612 LDKCResult_NodeAliasDecodeErrorZ* owner_conv = (LDKCResult_NodeAliasDecodeErrorZ*)(owner & ~1);
3613 LDKDecodeError ret_var = CResult_NodeAliasDecodeErrorZ_get_err(owner_conv);
3614 uint32_t ret_ref = 0;
3615 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3616 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3617 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3618 ret_ref = (uintptr_t)ret_var.inner;
3619 if (ret_var.is_owned) {
3625 static inline struct LDKNodeInfo CResult_NodeInfoDecodeErrorZ_get_ok(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3626 CHECK(owner->result_ok);
3627 return NodeInfo_clone(&*owner->contents.result);
3629 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_ok"))) TS_CResult_NodeInfoDecodeErrorZ_get_ok(uint32_t owner) {
3630 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(owner & ~1);
3631 LDKNodeInfo ret_var = CResult_NodeInfoDecodeErrorZ_get_ok(owner_conv);
3632 uint32_t ret_ref = 0;
3633 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3634 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3636 ret_ref = (uintptr_t)ret_var.inner;
3637 if (ret_var.is_owned) {
3643 static inline struct LDKDecodeError CResult_NodeInfoDecodeErrorZ_get_err(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR owner){
3644 CHECK(!owner->result_ok);
3645 return DecodeError_clone(&*owner->contents.err);
3647 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_get_err"))) TS_CResult_NodeInfoDecodeErrorZ_get_err(uint32_t owner) {
3648 LDKCResult_NodeInfoDecodeErrorZ* owner_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(owner & ~1);
3649 LDKDecodeError ret_var = CResult_NodeInfoDecodeErrorZ_get_err(owner_conv);
3650 uint32_t ret_ref = 0;
3651 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3652 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3653 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3654 ret_ref = (uintptr_t)ret_var.inner;
3655 if (ret_var.is_owned) {
3661 static inline struct LDKNetworkGraph *CResult_NetworkGraphDecodeErrorZ_get_ok(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3662 CHECK(owner->result_ok);
3663 return &*owner->contents.result;
3665 uint32_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_get_ok(uint32_t owner) {
3666 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(owner & ~1);
3667 LDKNetworkGraph ret_var = *CResult_NetworkGraphDecodeErrorZ_get_ok(owner_conv);
3668 uint32_t ret_ref = 0;
3669 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3670 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3671 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3672 ret_ref = (uintptr_t)ret_var.inner & ~1;
3676 static inline struct LDKDecodeError CResult_NetworkGraphDecodeErrorZ_get_err(LDKCResult_NetworkGraphDecodeErrorZ *NONNULL_PTR owner){
3677 CHECK(!owner->result_ok);
3678 return DecodeError_clone(&*owner->contents.err);
3680 uint32_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_get_err"))) TS_CResult_NetworkGraphDecodeErrorZ_get_err(uint32_t owner) {
3681 LDKCResult_NetworkGraphDecodeErrorZ* owner_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(owner & ~1);
3682 LDKDecodeError ret_var = CResult_NetworkGraphDecodeErrorZ_get_err(owner_conv);
3683 uint32_t ret_ref = 0;
3684 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3685 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3686 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3687 ret_ref = (uintptr_t)ret_var.inner;
3688 if (ret_var.is_owned) {
3694 uint32_t __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr"))) TS_LDKCOption_CVec_NetAddressZZ_ty_from_ptr(uint32_t ptr) {
3695 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)(ptr & ~1);
3697 case LDKCOption_CVec_NetAddressZZ_Some: return 0;
3698 case LDKCOption_CVec_NetAddressZZ_None: return 1;
3702 uint32_tArray __attribute__((export_name("TS_LDKCOption_CVec_NetAddressZZ_Some_get_some"))) TS_LDKCOption_CVec_NetAddressZZ_Some_get_some(uint32_t ptr) {
3703 LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)(ptr & ~1);
3704 assert(obj->tag == LDKCOption_CVec_NetAddressZZ_Some);
3705 LDKCVec_NetAddressZ some_var = obj->some;
3706 uint32_tArray some_arr = NULL;
3707 some_arr = init_uint32_tArray(some_var.datalen, __LINE__);
3708 uint32_t *some_arr_ptr = (uint32_t*)(((uint8_t*)some_arr) + 4);
3709 for (size_t m = 0; m < some_var.datalen; m++) {
3710 uint32_t some_conv_12_ref = ((uintptr_t)&some_var.data[m]) | 1;
3711 some_arr_ptr[m] = some_conv_12_ref;
3716 static inline struct LDKDelayedPaymentOutputDescriptor CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3717 CHECK(owner->result_ok);
3718 return DelayedPaymentOutputDescriptor_clone(&*owner->contents.result);
3720 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t owner) {
3721 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(owner & ~1);
3722 LDKDelayedPaymentOutputDescriptor ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3723 uint32_t ret_ref = 0;
3724 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3725 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3726 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3727 ret_ref = (uintptr_t)ret_var.inner;
3728 if (ret_var.is_owned) {
3734 static inline struct LDKDecodeError CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3735 CHECK(!owner->result_ok);
3736 return DecodeError_clone(&*owner->contents.err);
3738 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint32_t owner) {
3739 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(owner & ~1);
3740 LDKDecodeError ret_var = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3741 uint32_t ret_ref = 0;
3742 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3743 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3745 ret_ref = (uintptr_t)ret_var.inner;
3746 if (ret_var.is_owned) {
3752 static inline struct LDKStaticPaymentOutputDescriptor CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3753 CHECK(owner->result_ok);
3754 return StaticPaymentOutputDescriptor_clone(&*owner->contents.result);
3756 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t owner) {
3757 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(owner & ~1);
3758 LDKStaticPaymentOutputDescriptor ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3759 uint32_t ret_ref = 0;
3760 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3761 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3762 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3763 ret_ref = (uintptr_t)ret_var.inner;
3764 if (ret_var.is_owned) {
3770 static inline struct LDKDecodeError CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3771 CHECK(!owner->result_ok);
3772 return DecodeError_clone(&*owner->contents.err);
3774 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint32_t owner) {
3775 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(owner & ~1);
3776 LDKDecodeError ret_var = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3777 uint32_t ret_ref = 0;
3778 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3779 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3780 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3781 ret_ref = (uintptr_t)ret_var.inner;
3782 if (ret_var.is_owned) {
3788 static inline struct LDKSpendableOutputDescriptor CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3789 CHECK(owner->result_ok);
3790 return SpendableOutputDescriptor_clone(&*owner->contents.result);
3792 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint32_t owner) {
3793 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(owner & ~1);
3794 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
3795 *ret_copy = CResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(owner_conv);
3796 uint32_t ret_ref = (uintptr_t)ret_copy;
3800 static inline struct LDKDecodeError CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR owner){
3801 CHECK(!owner->result_ok);
3802 return DecodeError_clone(&*owner->contents.err);
3804 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint32_t owner) {
3805 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* owner_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(owner & ~1);
3806 LDKDecodeError ret_var = CResult_SpendableOutputDescriptorDecodeErrorZ_get_err(owner_conv);
3807 uint32_t ret_ref = 0;
3808 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3809 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3810 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
3811 ret_ref = (uintptr_t)ret_var.inner;
3812 if (ret_var.is_owned) {
3818 static inline LDKCVec_PaymentPreimageZ CVec_PaymentPreimageZ_clone(const LDKCVec_PaymentPreimageZ *orig) {
3819 LDKCVec_PaymentPreimageZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_PaymentPreimageZ clone bytes"), .datalen = orig->datalen };
3820 for (size_t i = 0; i < ret.datalen; i++) {
3821 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
3825 static inline struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
3828 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_a"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(uint32_t owner) {
3829 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(owner & ~1);
3830 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3831 memcpy(ret_arr->elems, C2Tuple_SignatureCVec_SignatureZZ_get_a(owner_conv).compact_form, 64);
3835 static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR owner){
3838 ptrArray __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_get_b"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(uint32_t owner) {
3839 LDKC2Tuple_SignatureCVec_SignatureZZ* owner_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(owner & ~1);
3840 LDKCVec_SignatureZ ret_var = C2Tuple_SignatureCVec_SignatureZZ_get_b(owner_conv);
3841 ptrArray ret_arr = NULL;
3842 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
3843 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
3844 for (size_t m = 0; m < ret_var.datalen; m++) {
3845 int8_tArray ret_conv_12_arr = init_int8_tArray(64, __LINE__);
3846 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compact_form, 64);
3847 ret_arr_ptr[m] = ret_conv_12_arr;
3853 static inline struct LDKC2Tuple_SignatureCVec_SignatureZZ CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
3854 CHECK(owner->result_ok);
3855 return C2Tuple_SignatureCVec_SignatureZZ_clone(&*owner->contents.result);
3857 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint32_t owner) {
3858 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(owner & ~1);
3859 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
3860 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(owner_conv);
3861 return ((uint32_t)ret_conv);
3864 static inline void CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR owner){
3865 CHECK(!owner->result_ok);
3866 return *owner->contents.err;
3868 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint32_t owner) {
3869 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(owner & ~1);
3870 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(owner_conv);
3873 static inline struct LDKSignature CResult_SignatureNoneZ_get_ok(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
3874 CHECK(owner->result_ok);
3875 return *owner->contents.result;
3877 int8_tArray __attribute__((export_name("TS_CResult_SignatureNoneZ_get_ok"))) TS_CResult_SignatureNoneZ_get_ok(uint32_t owner) {
3878 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)(owner & ~1);
3879 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3880 memcpy(ret_arr->elems, CResult_SignatureNoneZ_get_ok(owner_conv).compact_form, 64);
3884 static inline void CResult_SignatureNoneZ_get_err(LDKCResult_SignatureNoneZ *NONNULL_PTR owner){
3885 CHECK(!owner->result_ok);
3886 return *owner->contents.err;
3888 void __attribute__((export_name("TS_CResult_SignatureNoneZ_get_err"))) TS_CResult_SignatureNoneZ_get_err(uint32_t owner) {
3889 LDKCResult_SignatureNoneZ* owner_conv = (LDKCResult_SignatureNoneZ*)(owner & ~1);
3890 CResult_SignatureNoneZ_get_err(owner_conv);
3893 static inline struct LDKSignature C2Tuple_SignatureSignatureZ_get_a(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner){
3896 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_get_a"))) TS_C2Tuple_SignatureSignatureZ_get_a(uint32_t owner) {
3897 LDKC2Tuple_SignatureSignatureZ* owner_conv = (LDKC2Tuple_SignatureSignatureZ*)(owner & ~1);
3898 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3899 memcpy(ret_arr->elems, C2Tuple_SignatureSignatureZ_get_a(owner_conv).compact_form, 64);
3903 static inline struct LDKSignature C2Tuple_SignatureSignatureZ_get_b(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR owner){
3906 int8_tArray __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_get_b"))) TS_C2Tuple_SignatureSignatureZ_get_b(uint32_t owner) {
3907 LDKC2Tuple_SignatureSignatureZ* owner_conv = (LDKC2Tuple_SignatureSignatureZ*)(owner & ~1);
3908 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
3909 memcpy(ret_arr->elems, C2Tuple_SignatureSignatureZ_get_b(owner_conv).compact_form, 64);
3913 static inline struct LDKC2Tuple_SignatureSignatureZ CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner){
3914 CHECK(owner->result_ok);
3915 return C2Tuple_SignatureSignatureZ_clone(&*owner->contents.result);
3917 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(uint32_t owner) {
3918 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(owner & ~1);
3919 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
3920 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_get_ok(owner_conv);
3921 return ((uint32_t)ret_conv);
3924 static inline void CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR owner){
3925 CHECK(!owner->result_ok);
3926 return *owner->contents.err;
3928 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(uint32_t owner) {
3929 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* owner_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(owner & ~1);
3930 CResult_C2Tuple_SignatureSignatureZNoneZ_get_err(owner_conv);
3933 static inline struct LDKSecretKey CResult_SecretKeyNoneZ_get_ok(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner){
3934 CHECK(owner->result_ok);
3935 return *owner->contents.result;
3937 int8_tArray __attribute__((export_name("TS_CResult_SecretKeyNoneZ_get_ok"))) TS_CResult_SecretKeyNoneZ_get_ok(uint32_t owner) {
3938 LDKCResult_SecretKeyNoneZ* owner_conv = (LDKCResult_SecretKeyNoneZ*)(owner & ~1);
3939 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
3940 memcpy(ret_arr->elems, CResult_SecretKeyNoneZ_get_ok(owner_conv).bytes, 32);
3944 static inline void CResult_SecretKeyNoneZ_get_err(LDKCResult_SecretKeyNoneZ *NONNULL_PTR owner){
3945 CHECK(!owner->result_ok);
3946 return *owner->contents.err;
3948 void __attribute__((export_name("TS_CResult_SecretKeyNoneZ_get_err"))) TS_CResult_SecretKeyNoneZ_get_err(uint32_t owner) {
3949 LDKCResult_SecretKeyNoneZ* owner_conv = (LDKCResult_SecretKeyNoneZ*)(owner & ~1);
3950 CResult_SecretKeyNoneZ_get_err(owner_conv);
3953 typedef struct LDKBaseSign_JCalls {
3954 atomic_size_t refcnt;
3955 uint32_t instance_ptr;
3956 } LDKBaseSign_JCalls;
3957 static void LDKBaseSign_JCalls_free(void* this_arg) {
3958 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3959 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
3963 LDKPublicKey get_per_commitment_point_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
3964 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3965 int64_t idx_conv = idx;
3966 int8_tArray ret = (int8_tArray)js_invoke_function_u_b(j_calls->instance_ptr, 2, (uint32_t)idx_conv);
3967 LDKPublicKey ret_ref;
3968 CHECK(ret->arr_len == 33);
3969 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
3972 LDKThirtyTwoBytes release_commitment_secret_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
3973 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3974 int64_t idx_conv = idx;
3975 int8_tArray ret = (int8_tArray)js_invoke_function_u_b(j_calls->instance_ptr, 3, (uint32_t)idx_conv);
3976 LDKThirtyTwoBytes ret_ref;
3977 CHECK(ret->arr_len == 32);
3978 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
3981 LDKCResult_NoneNoneZ validate_holder_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx, LDKCVec_PaymentPreimageZ preimages) {
3982 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
3983 LDKHolderCommitmentTransaction holder_tx_var = *holder_tx;
3984 uint32_t holder_tx_ref = 0;
3985 holder_tx_var = HolderCommitmentTransaction_clone(&holder_tx_var);
3986 CHECK((((uintptr_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3987 CHECK((((uintptr_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3988 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_var);
3989 holder_tx_ref = (uintptr_t)holder_tx_var.inner;
3990 if (holder_tx_var.is_owned) {
3993 LDKCVec_PaymentPreimageZ preimages_var = preimages;
3994 ptrArray preimages_arr = NULL;
3995 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
3996 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 4);
3997 for (size_t m = 0; m < preimages_var.datalen; m++) {
3998 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
3999 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4000 preimages_arr_ptr[m] = preimages_conv_12_arr;
4003 FREE(preimages_var.data);
4004 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 4, (uint32_t)holder_tx_ref, (uint32_t)preimages_arr);
4005 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4006 CHECK_ACCESS(ret_ptr);
4007 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4011 LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
4012 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4013 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 5);
4014 LDKThirtyTwoBytes ret_ref;
4015 CHECK(ret->arr_len == 32);
4016 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
4019 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx, LDKCVec_PaymentPreimageZ preimages) {
4020 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4021 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
4022 uint32_t commitment_tx_ref = 0;
4023 commitment_tx_var = CommitmentTransaction_clone(&commitment_tx_var);
4024 CHECK((((uintptr_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4025 CHECK((((uintptr_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4026 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4027 commitment_tx_ref = (uintptr_t)commitment_tx_var.inner;
4028 if (commitment_tx_var.is_owned) {
4029 commitment_tx_ref |= 1;
4031 LDKCVec_PaymentPreimageZ preimages_var = preimages;
4032 ptrArray preimages_arr = NULL;
4033 preimages_arr = init_ptrArray(preimages_var.datalen, __LINE__);
4034 int8_tArray *preimages_arr_ptr = (int8_tArray*)(((uint8_t*)preimages_arr) + 4);
4035 for (size_t m = 0; m < preimages_var.datalen; m++) {
4036 int8_tArray preimages_conv_12_arr = init_int8_tArray(32, __LINE__);
4037 memcpy(preimages_conv_12_arr->elems, preimages_var.data[m].data, 32);
4038 preimages_arr_ptr[m] = preimages_conv_12_arr;
4041 FREE(preimages_var.data);
4042 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 6, (uint32_t)commitment_tx_ref, (uint32_t)preimages_arr);
4043 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4044 CHECK_ACCESS(ret_ptr);
4045 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4049 LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKBaseSign_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) {
4050 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4051 int64_t idx_conv = idx;
4052 int8_tArray secret_arr = init_int8_tArray(32, __LINE__);
4053 memcpy(secret_arr->elems, *secret, 32);
4054 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 7, (uint32_t)idx_conv, (uint32_t)secret_arr);
4055 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4056 CHECK_ACCESS(ret_ptr);
4057 LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(ret_ptr);
4061 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
4062 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4063 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
4064 uint32_t commitment_tx_ref = 0;
4065 commitment_tx_var = HolderCommitmentTransaction_clone(&commitment_tx_var);
4066 CHECK((((uintptr_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4067 CHECK((((uintptr_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4068 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_var);
4069 commitment_tx_ref = (uintptr_t)commitment_tx_var.inner;
4070 if (commitment_tx_var.is_owned) {
4071 commitment_tx_ref |= 1;
4073 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 8, (uint32_t)commitment_tx_ref);
4074 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4075 CHECK_ACCESS(ret_ptr);
4076 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(ret_ptr);
4080 LDKCResult_SignatureNoneZ sign_justice_revoked_output_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32]) {
4081 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4082 LDKTransaction justice_tx_var = justice_tx;
4083 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4084 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4085 Transaction_free(justice_tx_var);
4086 uint32_t input_conv = input;
4087 int64_t amount_conv = amount;
4088 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4089 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4090 uint32_t ret = js_invoke_function_u_uuuu(j_calls->instance_ptr, 9, (uint32_t)justice_tx_arr, (uint32_t)input_conv, (uint32_t)amount_conv, (uint32_t)per_commitment_key_arr);
4091 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4092 CHECK_ACCESS(ret_ptr);
4093 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4097 LDKCResult_SignatureNoneZ sign_justice_revoked_htlc_LDKBaseSign_jcall(const void* this_arg, LDKTransaction justice_tx, uintptr_t input, uint64_t amount, const uint8_t (* per_commitment_key)[32], const LDKHTLCOutputInCommitment * htlc) {
4098 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4099 LDKTransaction justice_tx_var = justice_tx;
4100 int8_tArray justice_tx_arr = init_int8_tArray(justice_tx_var.datalen, __LINE__);
4101 memcpy(justice_tx_arr->elems, justice_tx_var.data, justice_tx_var.datalen);
4102 Transaction_free(justice_tx_var);
4103 uint32_t input_conv = input;
4104 int64_t amount_conv = amount;
4105 int8_tArray per_commitment_key_arr = init_int8_tArray(32, __LINE__);
4106 memcpy(per_commitment_key_arr->elems, *per_commitment_key, 32);
4107 LDKHTLCOutputInCommitment htlc_var = *htlc;
4108 uint32_t htlc_ref = 0;
4109 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4110 CHECK((((uintptr_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4111 CHECK((((uintptr_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4112 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4113 htlc_ref = (uintptr_t)htlc_var.inner;
4114 if (htlc_var.is_owned) {
4117 uint32_t ret = js_invoke_function_u_uuuuu(j_calls->instance_ptr, 10, (uint32_t)justice_tx_arr, (uint32_t)input_conv, (uint32_t)amount_conv, (uint32_t)per_commitment_key_arr, (uint32_t)htlc_ref);
4118 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4119 CHECK_ACCESS(ret_ptr);
4120 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4124 LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction htlc_tx, uintptr_t input, uint64_t amount, LDKPublicKey per_commitment_point, const LDKHTLCOutputInCommitment * htlc) {
4125 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4126 LDKTransaction htlc_tx_var = htlc_tx;
4127 int8_tArray htlc_tx_arr = init_int8_tArray(htlc_tx_var.datalen, __LINE__);
4128 memcpy(htlc_tx_arr->elems, htlc_tx_var.data, htlc_tx_var.datalen);
4129 Transaction_free(htlc_tx_var);
4130 uint32_t input_conv = input;
4131 int64_t amount_conv = amount;
4132 int8_tArray per_commitment_point_arr = init_int8_tArray(33, __LINE__);
4133 memcpy(per_commitment_point_arr->elems, per_commitment_point.compressed_form, 33);
4134 LDKHTLCOutputInCommitment htlc_var = *htlc;
4135 uint32_t htlc_ref = 0;
4136 htlc_var = HTLCOutputInCommitment_clone(&htlc_var);
4137 CHECK((((uintptr_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4138 CHECK((((uintptr_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4139 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_var);
4140 htlc_ref = (uintptr_t)htlc_var.inner;
4141 if (htlc_var.is_owned) {
4144 uint32_t ret = js_invoke_function_u_uuuuu(j_calls->instance_ptr, 11, (uint32_t)htlc_tx_arr, (uint32_t)input_conv, (uint32_t)amount_conv, (uint32_t)per_commitment_point_arr, (uint32_t)htlc_ref);
4145 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4146 CHECK_ACCESS(ret_ptr);
4147 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4151 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) {
4152 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4153 LDKClosingTransaction closing_tx_var = *closing_tx;
4154 uint32_t closing_tx_ref = 0;
4155 closing_tx_var = ClosingTransaction_clone(&closing_tx_var);
4156 CHECK((((uintptr_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4157 CHECK((((uintptr_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4158 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_var);
4159 closing_tx_ref = (uintptr_t)closing_tx_var.inner;
4160 if (closing_tx_var.is_owned) {
4161 closing_tx_ref |= 1;
4163 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 12, (uint32_t)closing_tx_ref);
4164 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4165 CHECK_ACCESS(ret_ptr);
4166 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(ret_ptr);
4170 LDKCResult_C2Tuple_SignatureSignatureZNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
4171 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4172 LDKUnsignedChannelAnnouncement msg_var = *msg;
4173 uint32_t msg_ref = 0;
4174 msg_var = UnsignedChannelAnnouncement_clone(&msg_var);
4175 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4176 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4177 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
4178 msg_ref = (uintptr_t)msg_var.inner;
4179 if (msg_var.is_owned) {
4182 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 13, (uint32_t)msg_ref);
4183 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
4184 CHECK_ACCESS(ret_ptr);
4185 LDKCResult_C2Tuple_SignatureSignatureZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(ret_ptr);
4189 void ready_channel_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
4190 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
4191 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
4192 uint32_t channel_parameters_ref = 0;
4193 channel_parameters_var = ChannelTransactionParameters_clone(&channel_parameters_var);
4194 CHECK((((uintptr_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4195 CHECK((((uintptr_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4196 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_var);
4197 channel_parameters_ref = (uintptr_t)channel_parameters_var.inner;
4198 if (channel_parameters_var.is_owned) {
4199 channel_parameters_ref |= 1;
4201 js_invoke_function_u_u(j_calls->instance_ptr, 14, (uint32_t)channel_parameters_ref);
4203 static void LDKBaseSign_JCalls_cloned(LDKBaseSign* new_obj) {
4204 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) new_obj->this_arg;
4205 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4207 static inline LDKBaseSign LDKBaseSign_init (JSValue o, uint32_t pubkeys) {
4208 LDKBaseSign_JCalls *calls = MALLOC(sizeof(LDKBaseSign_JCalls), "LDKBaseSign_JCalls");
4209 atomic_init(&calls->refcnt, 1);
4210 calls->instance_ptr = o;
4212 LDKChannelPublicKeys pubkeys_conv;
4213 pubkeys_conv.inner = (void*)(pubkeys & (~1));
4214 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
4215 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4218 .this_arg = (void*) calls,
4219 .get_per_commitment_point = get_per_commitment_point_LDKBaseSign_jcall,
4220 .release_commitment_secret = release_commitment_secret_LDKBaseSign_jcall,
4221 .validate_holder_commitment = validate_holder_commitment_LDKBaseSign_jcall,
4222 .channel_keys_id = channel_keys_id_LDKBaseSign_jcall,
4223 .sign_counterparty_commitment = sign_counterparty_commitment_LDKBaseSign_jcall,
4224 .validate_counterparty_revocation = validate_counterparty_revocation_LDKBaseSign_jcall,
4225 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKBaseSign_jcall,
4226 .sign_justice_revoked_output = sign_justice_revoked_output_LDKBaseSign_jcall,
4227 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKBaseSign_jcall,
4228 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKBaseSign_jcall,
4229 .sign_closing_transaction = sign_closing_transaction_LDKBaseSign_jcall,
4230 .sign_channel_announcement = sign_channel_announcement_LDKBaseSign_jcall,
4231 .ready_channel = ready_channel_LDKBaseSign_jcall,
4232 .free = LDKBaseSign_JCalls_free,
4233 .pubkeys = pubkeys_conv,
4234 .set_pubkeys = NULL,
4238 long __attribute__((export_name("TS_LDKBaseSign_new"))) TS_LDKBaseSign_new(JSValue o, uint32_t pubkeys) {
4239 LDKBaseSign *res_ptr = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
4240 *res_ptr = LDKBaseSign_init(o, pubkeys);
4241 return (long)res_ptr;
4243 int8_tArray __attribute__((export_name("TS_BaseSign_get_per_commitment_point"))) TS_BaseSign_get_per_commitment_point(uint32_t this_arg, int64_t idx) {
4244 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4245 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4246 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4247 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
4248 memcpy(ret_arr->elems, (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
4252 int8_tArray __attribute__((export_name("TS_BaseSign_release_commitment_secret"))) TS_BaseSign_release_commitment_secret(uint32_t this_arg, int64_t idx) {
4253 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4254 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4255 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4256 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4257 memcpy(ret_arr->elems, (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
4261 uint32_t __attribute__((export_name("TS_BaseSign_validate_holder_commitment"))) TS_BaseSign_validate_holder_commitment(uint32_t this_arg, uint32_t holder_tx, ptrArray preimages) {
4262 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4263 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4264 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4265 LDKHolderCommitmentTransaction holder_tx_conv;
4266 holder_tx_conv.inner = (void*)(holder_tx & (~1));
4267 holder_tx_conv.is_owned = false;
4268 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_tx_conv);
4269 LDKCVec_PaymentPreimageZ preimages_constr;
4270 preimages_constr.datalen = preimages->arr_len;
4271 if (preimages_constr.datalen > 0)
4272 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4274 preimages_constr.data = NULL;
4275 int8_tArray* preimages_vals = (void*) preimages->elems;
4276 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4277 int8_tArray preimages_conv_12 = preimages_vals[m];
4278 LDKThirtyTwoBytes preimages_conv_12_ref;
4279 CHECK(preimages_conv_12->arr_len == 32);
4280 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4281 preimages_constr.data[m] = preimages_conv_12_ref;
4284 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4285 *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv, preimages_constr);
4286 return (uint32_t)ret_conv;
4289 int8_tArray __attribute__((export_name("TS_BaseSign_channel_keys_id"))) TS_BaseSign_channel_keys_id(uint32_t this_arg) {
4290 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4291 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4292 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4293 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4294 memcpy(ret_arr->elems, (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
4298 uint32_t __attribute__((export_name("TS_BaseSign_sign_counterparty_commitment"))) TS_BaseSign_sign_counterparty_commitment(uint32_t this_arg, uint32_t commitment_tx, ptrArray preimages) {
4299 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4300 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4301 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4302 LDKCommitmentTransaction commitment_tx_conv;
4303 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
4304 commitment_tx_conv.is_owned = false;
4305 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4306 LDKCVec_PaymentPreimageZ preimages_constr;
4307 preimages_constr.datalen = preimages->arr_len;
4308 if (preimages_constr.datalen > 0)
4309 preimages_constr.data = MALLOC(preimages_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
4311 preimages_constr.data = NULL;
4312 int8_tArray* preimages_vals = (void*) preimages->elems;
4313 for (size_t m = 0; m < preimages_constr.datalen; m++) {
4314 int8_tArray preimages_conv_12 = preimages_vals[m];
4315 LDKThirtyTwoBytes preimages_conv_12_ref;
4316 CHECK(preimages_conv_12->arr_len == 32);
4317 memcpy(preimages_conv_12_ref.data, preimages_conv_12->elems, 32); FREE(preimages_conv_12);
4318 preimages_constr.data[m] = preimages_conv_12_ref;
4321 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4322 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv, preimages_constr);
4323 return (uint32_t)ret_conv;
4326 uint32_t __attribute__((export_name("TS_BaseSign_validate_counterparty_revocation"))) TS_BaseSign_validate_counterparty_revocation(uint32_t this_arg, int64_t idx, int8_tArray secret) {
4327 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4328 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4329 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4330 unsigned char secret_arr[32];
4331 CHECK(secret->arr_len == 32);
4332 memcpy(secret_arr, secret->elems, 32); FREE(secret);
4333 unsigned char (*secret_ref)[32] = &secret_arr;
4334 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
4335 *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref);
4336 return (uint32_t)ret_conv;
4339 uint32_t __attribute__((export_name("TS_BaseSign_sign_holder_commitment_and_htlcs"))) TS_BaseSign_sign_holder_commitment_and_htlcs(uint32_t this_arg, uint32_t commitment_tx) {
4340 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4341 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4342 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4343 LDKHolderCommitmentTransaction commitment_tx_conv;
4344 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
4345 commitment_tx_conv.is_owned = false;
4346 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
4347 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
4348 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
4349 return (uint32_t)ret_conv;
4352 uint32_t __attribute__((export_name("TS_BaseSign_sign_justice_revoked_output"))) TS_BaseSign_sign_justice_revoked_output(uint32_t this_arg, int8_tArray justice_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_key) {
4353 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4354 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4355 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4356 LDKTransaction justice_tx_ref;
4357 justice_tx_ref.datalen = justice_tx->arr_len;
4358 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4359 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4360 justice_tx_ref.data_is_owned = true;
4361 unsigned char per_commitment_key_arr[32];
4362 CHECK(per_commitment_key->arr_len == 32);
4363 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4364 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4365 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4366 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
4367 return (uint32_t)ret_conv;
4370 uint32_t __attribute__((export_name("TS_BaseSign_sign_justice_revoked_htlc"))) TS_BaseSign_sign_justice_revoked_htlc(uint32_t this_arg, int8_tArray justice_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_key, uint32_t htlc) {
4371 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4372 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4373 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4374 LDKTransaction justice_tx_ref;
4375 justice_tx_ref.datalen = justice_tx->arr_len;
4376 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
4377 memcpy(justice_tx_ref.data, justice_tx->elems, justice_tx_ref.datalen); FREE(justice_tx);
4378 justice_tx_ref.data_is_owned = true;
4379 unsigned char per_commitment_key_arr[32];
4380 CHECK(per_commitment_key->arr_len == 32);
4381 memcpy(per_commitment_key_arr, per_commitment_key->elems, 32); FREE(per_commitment_key);
4382 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
4383 LDKHTLCOutputInCommitment htlc_conv;
4384 htlc_conv.inner = (void*)(htlc & (~1));
4385 htlc_conv.is_owned = false;
4386 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4387 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4388 *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);
4389 return (uint32_t)ret_conv;
4392 uint32_t __attribute__((export_name("TS_BaseSign_sign_counterparty_htlc_transaction"))) TS_BaseSign_sign_counterparty_htlc_transaction(uint32_t this_arg, int8_tArray htlc_tx, uint32_t input, int64_t amount, int8_tArray per_commitment_point, uint32_t htlc) {
4393 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4394 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4395 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4396 LDKTransaction htlc_tx_ref;
4397 htlc_tx_ref.datalen = htlc_tx->arr_len;
4398 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
4399 memcpy(htlc_tx_ref.data, htlc_tx->elems, htlc_tx_ref.datalen); FREE(htlc_tx);
4400 htlc_tx_ref.data_is_owned = true;
4401 LDKPublicKey per_commitment_point_ref;
4402 CHECK(per_commitment_point->arr_len == 33);
4403 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
4404 LDKHTLCOutputInCommitment htlc_conv;
4405 htlc_conv.inner = (void*)(htlc & (~1));
4406 htlc_conv.is_owned = false;
4407 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
4408 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4409 *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);
4410 return (uint32_t)ret_conv;
4413 uint32_t __attribute__((export_name("TS_BaseSign_sign_closing_transaction"))) TS_BaseSign_sign_closing_transaction(uint32_t this_arg, uint32_t closing_tx) {
4414 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4415 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4416 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4417 LDKClosingTransaction closing_tx_conv;
4418 closing_tx_conv.inner = (void*)(closing_tx & (~1));
4419 closing_tx_conv.is_owned = false;
4420 CHECK_INNER_FIELD_ACCESS_OR_NULL(closing_tx_conv);
4421 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
4422 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv);
4423 return (uint32_t)ret_conv;
4426 uint32_t __attribute__((export_name("TS_BaseSign_sign_channel_announcement"))) TS_BaseSign_sign_channel_announcement(uint32_t this_arg, uint32_t msg) {
4427 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4428 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4429 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4430 LDKUnsignedChannelAnnouncement msg_conv;
4431 msg_conv.inner = (void*)(msg & (~1));
4432 msg_conv.is_owned = false;
4433 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
4434 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
4435 *ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
4436 return (uint32_t)ret_conv;
4439 void __attribute__((export_name("TS_BaseSign_ready_channel"))) TS_BaseSign_ready_channel(uint32_t this_arg, uint32_t channel_parameters) {
4440 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4441 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4442 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4443 LDKChannelTransactionParameters channel_parameters_conv;
4444 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
4445 channel_parameters_conv.is_owned = false;
4446 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
4447 (this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
4450 LDKChannelPublicKeys LDKBaseSign_set_get_pubkeys(LDKBaseSign* this_arg) {
4451 if (this_arg->set_pubkeys != NULL)
4452 this_arg->set_pubkeys(this_arg);
4453 return this_arg->pubkeys;
4455 uint32_t __attribute__((export_name("TS_BaseSign_get_pubkeys"))) TS_BaseSign_get_pubkeys(uint32_t this_arg) {
4456 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4457 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4458 LDKBaseSign* this_arg_conv = (LDKBaseSign*)this_arg_ptr;
4459 LDKChannelPublicKeys ret_var = LDKBaseSign_set_get_pubkeys(this_arg_conv);
4460 uint32_t ret_ref = 0;
4461 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4462 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4463 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4464 ret_ref = (uintptr_t)ret_var.inner;
4465 if (ret_var.is_owned) {
4471 typedef struct LDKSign_JCalls {
4472 atomic_size_t refcnt;
4473 uint32_t instance_ptr;
4474 LDKBaseSign_JCalls* BaseSign;
4476 static void LDKSign_JCalls_free(void* this_arg) {
4477 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
4478 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4482 LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
4483 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
4484 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 15);
4485 LDKCVec_u8Z ret_ref;
4486 ret_ref.datalen = ret->arr_len;
4487 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
4488 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
4491 static void LDKSign_JCalls_cloned(LDKSign* new_obj) {
4492 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) new_obj->this_arg;
4493 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4494 atomic_fetch_add_explicit(&j_calls->BaseSign->refcnt, 1, memory_order_release);
4496 static inline LDKSign LDKSign_init (JSValue o, JSValue BaseSign, uint32_t pubkeys) {
4497 LDKSign_JCalls *calls = MALLOC(sizeof(LDKSign_JCalls), "LDKSign_JCalls");
4498 atomic_init(&calls->refcnt, 1);
4499 calls->instance_ptr = o;
4501 LDKChannelPublicKeys pubkeys_conv;
4502 pubkeys_conv.inner = (void*)(pubkeys & (~1));
4503 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
4504 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_conv);
4507 .this_arg = (void*) calls,
4508 .write = write_LDKSign_jcall,
4509 .cloned = LDKSign_JCalls_cloned,
4510 .free = LDKSign_JCalls_free,
4511 .BaseSign = LDKBaseSign_init(BaseSign, pubkeys),
4513 calls->BaseSign = ret.BaseSign.this_arg;
4516 long __attribute__((export_name("TS_LDKSign_new"))) TS_LDKSign_new(JSValue o, JSValue BaseSign, uint32_t pubkeys) {
4517 LDKSign *res_ptr = MALLOC(sizeof(LDKSign), "LDKSign");
4518 *res_ptr = LDKSign_init(o, BaseSign, pubkeys);
4519 return (long)res_ptr;
4521 int8_tArray __attribute__((export_name("TS_Sign_write"))) TS_Sign_write(uint32_t this_arg) {
4522 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
4523 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
4524 LDKSign* this_arg_conv = (LDKSign*)this_arg_ptr;
4525 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
4526 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4527 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4528 CVec_u8Z_free(ret_var);
4532 static inline struct LDKSign CResult_SignDecodeErrorZ_get_ok(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner){
4533 CHECK(owner->result_ok);
4534 return Sign_clone(&*owner->contents.result);
4536 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_get_ok"))) TS_CResult_SignDecodeErrorZ_get_ok(uint32_t owner) {
4537 LDKCResult_SignDecodeErrorZ* owner_conv = (LDKCResult_SignDecodeErrorZ*)(owner & ~1);
4538 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
4539 *ret_ret = CResult_SignDecodeErrorZ_get_ok(owner_conv);
4540 return (uint32_t)ret_ret;
4543 static inline struct LDKDecodeError CResult_SignDecodeErrorZ_get_err(LDKCResult_SignDecodeErrorZ *NONNULL_PTR owner){
4544 CHECK(!owner->result_ok);
4545 return DecodeError_clone(&*owner->contents.err);
4547 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_get_err"))) TS_CResult_SignDecodeErrorZ_get_err(uint32_t owner) {
4548 LDKCResult_SignDecodeErrorZ* owner_conv = (LDKCResult_SignDecodeErrorZ*)(owner & ~1);
4549 LDKDecodeError ret_var = CResult_SignDecodeErrorZ_get_err(owner_conv);
4550 uint32_t ret_ref = 0;
4551 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4552 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4553 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4554 ret_ref = (uintptr_t)ret_var.inner;
4555 if (ret_var.is_owned) {
4561 static inline struct LDKRecoverableSignature CResult_RecoverableSignatureNoneZ_get_ok(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4562 CHECK(owner->result_ok);
4563 return *owner->contents.result;
4565 int8_tArray __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_ok"))) TS_CResult_RecoverableSignatureNoneZ_get_ok(uint32_t owner) {
4566 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)(owner & ~1);
4567 int8_tArray ret_arr = init_int8_tArray(68, __LINE__);
4568 memcpy(ret_arr->elems, CResult_RecoverableSignatureNoneZ_get_ok(owner_conv).serialized_form, 68);
4572 static inline void CResult_RecoverableSignatureNoneZ_get_err(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR owner){
4573 CHECK(!owner->result_ok);
4574 return *owner->contents.err;
4576 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_get_err"))) TS_CResult_RecoverableSignatureNoneZ_get_err(uint32_t owner) {
4577 LDKCResult_RecoverableSignatureNoneZ* owner_conv = (LDKCResult_RecoverableSignatureNoneZ*)(owner & ~1);
4578 CResult_RecoverableSignatureNoneZ_get_err(owner_conv);
4581 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
4582 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
4583 for (size_t i = 0; i < ret.datalen; i++) {
4584 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
4588 static inline struct LDKCVec_CVec_u8ZZ CResult_CVec_CVec_u8ZZNoneZ_get_ok(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4589 CHECK(owner->result_ok);
4590 return CVec_CVec_u8ZZ_clone(&*owner->contents.result);
4592 ptrArray __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_ok(uint32_t owner) {
4593 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(owner & ~1);
4594 LDKCVec_CVec_u8ZZ ret_var = CResult_CVec_CVec_u8ZZNoneZ_get_ok(owner_conv);
4595 ptrArray ret_arr = NULL;
4596 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
4597 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
4598 for (size_t m = 0; m < ret_var.datalen; m++) {
4599 LDKCVec_u8Z ret_conv_12_var = ret_var.data[m];
4600 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
4601 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
4602 CVec_u8Z_free(ret_conv_12_var);
4603 ret_arr_ptr[m] = ret_conv_12_arr;
4610 static inline void CResult_CVec_CVec_u8ZZNoneZ_get_err(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR owner){
4611 CHECK(!owner->result_ok);
4612 return *owner->contents.err;
4614 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_get_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_get_err(uint32_t owner) {
4615 LDKCResult_CVec_CVec_u8ZZNoneZ* owner_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(owner & ~1);
4616 CResult_CVec_CVec_u8ZZNoneZ_get_err(owner_conv);
4619 static inline struct LDKInMemorySigner CResult_InMemorySignerDecodeErrorZ_get_ok(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4620 CHECK(owner->result_ok);
4621 return InMemorySigner_clone(&*owner->contents.result);
4623 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_get_ok(uint32_t owner) {
4624 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(owner & ~1);
4625 LDKInMemorySigner ret_var = CResult_InMemorySignerDecodeErrorZ_get_ok(owner_conv);
4626 uint32_t ret_ref = 0;
4627 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4628 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4629 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4630 ret_ref = (uintptr_t)ret_var.inner;
4631 if (ret_var.is_owned) {
4637 static inline struct LDKDecodeError CResult_InMemorySignerDecodeErrorZ_get_err(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR owner){
4638 CHECK(!owner->result_ok);
4639 return DecodeError_clone(&*owner->contents.err);
4641 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_get_err"))) TS_CResult_InMemorySignerDecodeErrorZ_get_err(uint32_t owner) {
4642 LDKCResult_InMemorySignerDecodeErrorZ* owner_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(owner & ~1);
4643 LDKDecodeError ret_var = CResult_InMemorySignerDecodeErrorZ_get_err(owner_conv);
4644 uint32_t ret_ref = 0;
4645 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4646 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4647 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
4648 ret_ref = (uintptr_t)ret_var.inner;
4649 if (ret_var.is_owned) {
4655 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
4656 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
4657 for (size_t i = 0; i < ret.datalen; i++) {
4658 ret.data[i] = TxOut_clone(&orig->data[i]);
4662 static inline struct LDKTransaction CResult_TransactionNoneZ_get_ok(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4663 CHECK(owner->result_ok);
4664 return *owner->contents.result;
4666 int8_tArray __attribute__((export_name("TS_CResult_TransactionNoneZ_get_ok"))) TS_CResult_TransactionNoneZ_get_ok(uint32_t owner) {
4667 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)(owner & ~1);
4668 LDKTransaction ret_var = CResult_TransactionNoneZ_get_ok(owner_conv);
4669 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
4670 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
4674 static inline void CResult_TransactionNoneZ_get_err(LDKCResult_TransactionNoneZ *NONNULL_PTR owner){
4675 CHECK(!owner->result_ok);
4676 return *owner->contents.err;
4678 void __attribute__((export_name("TS_CResult_TransactionNoneZ_get_err"))) TS_CResult_TransactionNoneZ_get_err(uint32_t owner) {
4679 LDKCResult_TransactionNoneZ* owner_conv = (LDKCResult_TransactionNoneZ*)(owner & ~1);
4680 CResult_TransactionNoneZ_get_err(owner_conv);
4683 uint32_t __attribute__((export_name("TS_LDKCOption_u16Z_ty_from_ptr"))) TS_LDKCOption_u16Z_ty_from_ptr(uint32_t ptr) {
4684 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)(ptr & ~1);
4686 case LDKCOption_u16Z_Some: return 0;
4687 case LDKCOption_u16Z_None: return 1;
4691 int16_t __attribute__((export_name("TS_LDKCOption_u16Z_Some_get_some"))) TS_LDKCOption_u16Z_Some_get_some(uint32_t ptr) {
4692 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)(ptr & ~1);
4693 assert(obj->tag == LDKCOption_u16Z_Some);
4694 int16_t some_conv = obj->some;
4697 uint32_t __attribute__((export_name("TS_LDKAPIError_ty_from_ptr"))) TS_LDKAPIError_ty_from_ptr(uint32_t ptr) {
4698 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4700 case LDKAPIError_APIMisuseError: return 0;
4701 case LDKAPIError_FeeRateTooHigh: return 1;
4702 case LDKAPIError_RouteError: return 2;
4703 case LDKAPIError_ChannelUnavailable: return 3;
4704 case LDKAPIError_MonitorUpdateFailed: return 4;
4705 case LDKAPIError_IncompatibleShutdownScript: return 5;
4709 jstring __attribute__((export_name("TS_LDKAPIError_APIMisuseError_get_err"))) TS_LDKAPIError_APIMisuseError_get_err(uint32_t ptr) {
4710 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4711 assert(obj->tag == LDKAPIError_APIMisuseError);
4712 LDKStr err_str = obj->api_misuse_error.err;
4713 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4716 jstring __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_err"))) TS_LDKAPIError_FeeRateTooHigh_get_err(uint32_t ptr) {
4717 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4718 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
4719 LDKStr err_str = obj->fee_rate_too_high.err;
4720 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4723 int32_t __attribute__((export_name("TS_LDKAPIError_FeeRateTooHigh_get_feerate"))) TS_LDKAPIError_FeeRateTooHigh_get_feerate(uint32_t ptr) {
4724 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4725 assert(obj->tag == LDKAPIError_FeeRateTooHigh);
4726 int32_t feerate_conv = obj->fee_rate_too_high.feerate;
4727 return feerate_conv;
4729 jstring __attribute__((export_name("TS_LDKAPIError_RouteError_get_err"))) TS_LDKAPIError_RouteError_get_err(uint32_t ptr) {
4730 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4731 assert(obj->tag == LDKAPIError_RouteError);
4732 LDKStr err_str = obj->route_error.err;
4733 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4736 jstring __attribute__((export_name("TS_LDKAPIError_ChannelUnavailable_get_err"))) TS_LDKAPIError_ChannelUnavailable_get_err(uint32_t ptr) {
4737 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4738 assert(obj->tag == LDKAPIError_ChannelUnavailable);
4739 LDKStr err_str = obj->channel_unavailable.err;
4740 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
4743 uint32_t __attribute__((export_name("TS_LDKAPIError_IncompatibleShutdownScript_get_script"))) TS_LDKAPIError_IncompatibleShutdownScript_get_script(uint32_t ptr) {
4744 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
4745 assert(obj->tag == LDKAPIError_IncompatibleShutdownScript);
4746 LDKShutdownScript script_var = obj->incompatible_shutdown_script.script;
4747 uint32_t script_ref = 0;
4748 CHECK((((uintptr_t)script_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4749 CHECK((((uintptr_t)&script_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4750 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_var);
4751 script_ref = (uintptr_t)script_var.inner & ~1;
4754 static inline void CResult_NoneAPIErrorZ_get_ok(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
4755 CHECK(owner->result_ok);
4756 return *owner->contents.result;
4758 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_ok"))) TS_CResult_NoneAPIErrorZ_get_ok(uint32_t owner) {
4759 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)(owner & ~1);
4760 CResult_NoneAPIErrorZ_get_ok(owner_conv);
4763 static inline struct LDKAPIError CResult_NoneAPIErrorZ_get_err(LDKCResult_NoneAPIErrorZ *NONNULL_PTR owner){
4764 CHECK(!owner->result_ok);
4765 return APIError_clone(&*owner->contents.err);
4767 uint32_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_get_err"))) TS_CResult_NoneAPIErrorZ_get_err(uint32_t owner) {
4768 LDKCResult_NoneAPIErrorZ* owner_conv = (LDKCResult_NoneAPIErrorZ*)(owner & ~1);
4769 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4770 *ret_copy = CResult_NoneAPIErrorZ_get_err(owner_conv);
4771 uint32_t ret_ref = (uintptr_t)ret_copy;
4775 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
4776 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
4777 for (size_t i = 0; i < ret.datalen; i++) {
4778 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
4782 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
4783 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
4784 for (size_t i = 0; i < ret.datalen; i++) {
4785 ret.data[i] = APIError_clone(&orig->data[i]);
4789 static inline struct LDKThirtyTwoBytes CResult__u832APIErrorZ_get_ok(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
4790 CHECK(owner->result_ok);
4791 return ThirtyTwoBytes_clone(&*owner->contents.result);
4793 int8_tArray __attribute__((export_name("TS_CResult__u832APIErrorZ_get_ok"))) TS_CResult__u832APIErrorZ_get_ok(uint32_t owner) {
4794 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)(owner & ~1);
4795 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4796 memcpy(ret_arr->elems, CResult__u832APIErrorZ_get_ok(owner_conv).data, 32);
4800 static inline struct LDKAPIError CResult__u832APIErrorZ_get_err(LDKCResult__u832APIErrorZ *NONNULL_PTR owner){
4801 CHECK(!owner->result_ok);
4802 return APIError_clone(&*owner->contents.err);
4804 uint32_t __attribute__((export_name("TS_CResult__u832APIErrorZ_get_err"))) TS_CResult__u832APIErrorZ_get_err(uint32_t owner) {
4805 LDKCResult__u832APIErrorZ* owner_conv = (LDKCResult__u832APIErrorZ*)(owner & ~1);
4806 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
4807 *ret_copy = CResult__u832APIErrorZ_get_err(owner_conv);
4808 uint32_t ret_ref = (uintptr_t)ret_copy;
4812 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ty_from_ptr"))) TS_LDKPaymentSendFailure_ty_from_ptr(uint32_t ptr) {
4813 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4815 case LDKPaymentSendFailure_ParameterError: return 0;
4816 case LDKPaymentSendFailure_PathParameterError: return 1;
4817 case LDKPaymentSendFailure_AllFailedRetrySafe: return 2;
4818 case LDKPaymentSendFailure_PartialFailure: return 3;
4822 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_ParameterError_get_parameter_error"))) TS_LDKPaymentSendFailure_ParameterError_get_parameter_error(uint32_t ptr) {
4823 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4824 assert(obj->tag == LDKPaymentSendFailure_ParameterError);
4825 uint32_t parameter_error_ref = ((uintptr_t)&obj->parameter_error) | 1;
4826 return parameter_error_ref;
4828 uint32_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error"))) TS_LDKPaymentSendFailure_PathParameterError_get_path_parameter_error(uint32_t ptr) {
4829 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4830 assert(obj->tag == LDKPaymentSendFailure_PathParameterError);
4831 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
4832 uint32_tArray path_parameter_error_arr = NULL;
4833 path_parameter_error_arr = init_uint32_tArray(path_parameter_error_var.datalen, __LINE__);
4834 uint32_t *path_parameter_error_arr_ptr = (uint32_t*)(((uint8_t*)path_parameter_error_arr) + 4);
4835 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
4836 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4837 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
4838 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
4839 path_parameter_error_arr_ptr[w] = (uint32_t)path_parameter_error_conv_22_conv;
4842 return path_parameter_error_arr;
4844 uint32_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe"))) TS_LDKPaymentSendFailure_AllFailedRetrySafe_get_all_failed_retry_safe(uint32_t ptr) {
4845 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4846 assert(obj->tag == LDKPaymentSendFailure_AllFailedRetrySafe);
4847 LDKCVec_APIErrorZ all_failed_retry_safe_var = obj->all_failed_retry_safe;
4848 uint32_tArray all_failed_retry_safe_arr = NULL;
4849 all_failed_retry_safe_arr = init_uint32_tArray(all_failed_retry_safe_var.datalen, __LINE__);
4850 uint32_t *all_failed_retry_safe_arr_ptr = (uint32_t*)(((uint8_t*)all_failed_retry_safe_arr) + 4);
4851 for (size_t k = 0; k < all_failed_retry_safe_var.datalen; k++) {
4852 uint32_t all_failed_retry_safe_conv_10_ref = ((uintptr_t)&all_failed_retry_safe_var.data[k]) | 1;
4853 all_failed_retry_safe_arr_ptr[k] = all_failed_retry_safe_conv_10_ref;
4856 return all_failed_retry_safe_arr;
4858 uint32_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_results"))) TS_LDKPaymentSendFailure_PartialFailure_get_results(uint32_t ptr) {
4859 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4860 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4861 LDKCVec_CResult_NoneAPIErrorZZ results_var = obj->partial_failure.results;
4862 uint32_tArray results_arr = NULL;
4863 results_arr = init_uint32_tArray(results_var.datalen, __LINE__);
4864 uint32_t *results_arr_ptr = (uint32_t*)(((uint8_t*)results_arr) + 4);
4865 for (size_t w = 0; w < results_var.datalen; w++) {
4866 LDKCResult_NoneAPIErrorZ* results_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
4867 *results_conv_22_conv = results_var.data[w];
4868 *results_conv_22_conv = CResult_NoneAPIErrorZ_clone(results_conv_22_conv);
4869 results_arr_ptr[w] = (uint32_t)results_conv_22_conv;
4874 uint32_t __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry"))) TS_LDKPaymentSendFailure_PartialFailure_get_failed_paths_retry(uint32_t ptr) {
4875 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4876 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4877 LDKRouteParameters failed_paths_retry_var = obj->partial_failure.failed_paths_retry;
4878 uint32_t failed_paths_retry_ref = 0;
4879 if ((uintptr_t)failed_paths_retry_var.inner > 4096) {
4880 CHECK((((uintptr_t)failed_paths_retry_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4881 CHECK((((uintptr_t)&failed_paths_retry_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4882 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_var);
4883 failed_paths_retry_ref = (uintptr_t)failed_paths_retry_var.inner & ~1;
4885 return failed_paths_retry_ref;
4887 int8_tArray __attribute__((export_name("TS_LDKPaymentSendFailure_PartialFailure_get_payment_id"))) TS_LDKPaymentSendFailure_PartialFailure_get_payment_id(uint32_t ptr) {
4888 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
4889 assert(obj->tag == LDKPaymentSendFailure_PartialFailure);
4890 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
4891 memcpy(payment_id_arr->elems, obj->partial_failure.payment_id.data, 32);
4892 return payment_id_arr;
4894 static inline struct LDKThirtyTwoBytes CResult_PaymentIdPaymentSendFailureZ_get_ok(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner){
4895 CHECK(owner->result_ok);
4896 return ThirtyTwoBytes_clone(&*owner->contents.result);
4898 int8_tArray __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_get_ok"))) TS_CResult_PaymentIdPaymentSendFailureZ_get_ok(uint32_t owner) {
4899 LDKCResult_PaymentIdPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(owner & ~1);
4900 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4901 memcpy(ret_arr->elems, CResult_PaymentIdPaymentSendFailureZ_get_ok(owner_conv).data, 32);
4905 static inline struct LDKPaymentSendFailure CResult_PaymentIdPaymentSendFailureZ_get_err(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR owner){
4906 CHECK(!owner->result_ok);
4907 return PaymentSendFailure_clone(&*owner->contents.err);
4909 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_get_err"))) TS_CResult_PaymentIdPaymentSendFailureZ_get_err(uint32_t owner) {
4910 LDKCResult_PaymentIdPaymentSendFailureZ* owner_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(owner & ~1);
4911 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4912 *ret_copy = CResult_PaymentIdPaymentSendFailureZ_get_err(owner_conv);
4913 uint32_t ret_ref = (uintptr_t)ret_copy;
4917 static inline void CResult_NonePaymentSendFailureZ_get_ok(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4918 CHECK(owner->result_ok);
4919 return *owner->contents.result;
4921 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_ok"))) TS_CResult_NonePaymentSendFailureZ_get_ok(uint32_t owner) {
4922 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)(owner & ~1);
4923 CResult_NonePaymentSendFailureZ_get_ok(owner_conv);
4926 static inline struct LDKPaymentSendFailure CResult_NonePaymentSendFailureZ_get_err(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR owner){
4927 CHECK(!owner->result_ok);
4928 return PaymentSendFailure_clone(&*owner->contents.err);
4930 uint32_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_get_err"))) TS_CResult_NonePaymentSendFailureZ_get_err(uint32_t owner) {
4931 LDKCResult_NonePaymentSendFailureZ* owner_conv = (LDKCResult_NonePaymentSendFailureZ*)(owner & ~1);
4932 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4933 *ret_copy = CResult_NonePaymentSendFailureZ_get_err(owner_conv);
4934 uint32_t ret_ref = (uintptr_t)ret_copy;
4938 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
4939 return ThirtyTwoBytes_clone(&owner->a);
4941 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_a"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_a(uint32_t owner) {
4942 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(owner & ~1);
4943 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4944 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_a(owner_conv).data, 32);
4948 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR owner){
4949 return ThirtyTwoBytes_clone(&owner->b);
4951 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_get_b"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_b(uint32_t owner) {
4952 LDKC2Tuple_PaymentHashPaymentIdZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(owner & ~1);
4953 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4954 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentIdZ_get_b(owner_conv).data, 32);
4958 static inline struct LDKC2Tuple_PaymentHashPaymentIdZ CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
4959 CHECK(owner->result_ok);
4960 return C2Tuple_PaymentHashPaymentIdZ_clone(&*owner->contents.result);
4962 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint32_t owner) {
4963 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(owner & ~1);
4964 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
4965 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(owner_conv);
4966 return ((uint32_t)ret_conv);
4969 static inline struct LDKPaymentSendFailure CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR owner){
4970 CHECK(!owner->result_ok);
4971 return PaymentSendFailure_clone(&*owner->contents.err);
4973 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(uint32_t owner) {
4974 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(owner & ~1);
4975 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
4976 *ret_copy = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(owner_conv);
4977 uint32_t ret_ref = (uintptr_t)ret_copy;
4981 static inline LDKCVec_ThirtyTwoBytesZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_ThirtyTwoBytesZ *orig) {
4982 LDKCVec_ThirtyTwoBytesZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_ThirtyTwoBytesZ clone bytes"), .datalen = orig->datalen };
4983 for (size_t i = 0; i < ret.datalen; i++) {
4984 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
4988 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
4989 return ThirtyTwoBytes_clone(&owner->a);
4991 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_a"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(uint32_t owner) {
4992 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(owner & ~1);
4993 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
4994 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_a(owner_conv).data, 32);
4998 static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR owner){
4999 return ThirtyTwoBytes_clone(&owner->b);
5001 int8_tArray __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_get_b"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(uint32_t owner) {
5002 LDKC2Tuple_PaymentHashPaymentSecretZ* owner_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(owner & ~1);
5003 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5004 memcpy(ret_arr->elems, C2Tuple_PaymentHashPaymentSecretZ_get_b(owner_conv).data, 32);
5008 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5009 CHECK(owner->result_ok);
5010 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5012 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(uint32_t owner) {
5013 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(owner & ~1);
5014 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5015 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_ok(owner_conv);
5016 return ((uint32_t)ret_conv);
5019 static inline void CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR owner){
5020 CHECK(!owner->result_ok);
5021 return *owner->contents.err;
5023 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(uint32_t owner) {
5024 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(owner & ~1);
5025 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_get_err(owner_conv);
5028 static inline struct LDKC2Tuple_PaymentHashPaymentSecretZ CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5029 CHECK(owner->result_ok);
5030 return C2Tuple_PaymentHashPaymentSecretZ_clone(&*owner->contents.result);
5032 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(uint32_t owner) {
5033 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(owner & ~1);
5034 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
5035 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_ok(owner_conv);
5036 return ((uint32_t)ret_conv);
5039 static inline struct LDKAPIError CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR owner){
5040 CHECK(!owner->result_ok);
5041 return APIError_clone(&*owner->contents.err);
5043 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(uint32_t owner) {
5044 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* owner_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(owner & ~1);
5045 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5046 *ret_copy = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_get_err(owner_conv);
5047 uint32_t ret_ref = (uintptr_t)ret_copy;
5051 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretNoneZ_get_ok(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5052 CHECK(owner->result_ok);
5053 return ThirtyTwoBytes_clone(&*owner->contents.result);
5055 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_ok"))) TS_CResult_PaymentSecretNoneZ_get_ok(uint32_t owner) {
5056 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)(owner & ~1);
5057 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5058 memcpy(ret_arr->elems, CResult_PaymentSecretNoneZ_get_ok(owner_conv).data, 32);
5062 static inline void CResult_PaymentSecretNoneZ_get_err(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR owner){
5063 CHECK(!owner->result_ok);
5064 return *owner->contents.err;
5066 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_get_err"))) TS_CResult_PaymentSecretNoneZ_get_err(uint32_t owner) {
5067 LDKCResult_PaymentSecretNoneZ* owner_conv = (LDKCResult_PaymentSecretNoneZ*)(owner & ~1);
5068 CResult_PaymentSecretNoneZ_get_err(owner_conv);
5071 static inline struct LDKThirtyTwoBytes CResult_PaymentSecretAPIErrorZ_get_ok(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5072 CHECK(owner->result_ok);
5073 return ThirtyTwoBytes_clone(&*owner->contents.result);
5075 int8_tArray __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_ok"))) TS_CResult_PaymentSecretAPIErrorZ_get_ok(uint32_t owner) {
5076 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(owner & ~1);
5077 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5078 memcpy(ret_arr->elems, CResult_PaymentSecretAPIErrorZ_get_ok(owner_conv).data, 32);
5082 static inline struct LDKAPIError CResult_PaymentSecretAPIErrorZ_get_err(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR owner){
5083 CHECK(!owner->result_ok);
5084 return APIError_clone(&*owner->contents.err);
5086 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_get_err"))) TS_CResult_PaymentSecretAPIErrorZ_get_err(uint32_t owner) {
5087 LDKCResult_PaymentSecretAPIErrorZ* owner_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(owner & ~1);
5088 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5089 *ret_copy = CResult_PaymentSecretAPIErrorZ_get_err(owner_conv);
5090 uint32_t ret_ref = (uintptr_t)ret_copy;
5094 static inline struct LDKThirtyTwoBytes CResult_PaymentPreimageAPIErrorZ_get_ok(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5095 CHECK(owner->result_ok);
5096 return ThirtyTwoBytes_clone(&*owner->contents.result);
5098 int8_tArray __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_get_ok(uint32_t owner) {
5099 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)(owner & ~1);
5100 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5101 memcpy(ret_arr->elems, CResult_PaymentPreimageAPIErrorZ_get_ok(owner_conv).data, 32);
5105 static inline struct LDKAPIError CResult_PaymentPreimageAPIErrorZ_get_err(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR owner){
5106 CHECK(!owner->result_ok);
5107 return APIError_clone(&*owner->contents.err);
5109 uint32_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_get_err"))) TS_CResult_PaymentPreimageAPIErrorZ_get_err(uint32_t owner) {
5110 LDKCResult_PaymentPreimageAPIErrorZ* owner_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)(owner & ~1);
5111 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
5112 *ret_copy = CResult_PaymentPreimageAPIErrorZ_get_err(owner_conv);
5113 uint32_t ret_ref = (uintptr_t)ret_copy;
5117 static inline struct LDKCounterpartyForwardingInfo CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5118 CHECK(owner->result_ok);
5119 return CounterpartyForwardingInfo_clone(&*owner->contents.result);
5121 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(uint32_t owner) {
5122 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(owner & ~1);
5123 LDKCounterpartyForwardingInfo ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_ok(owner_conv);
5124 uint32_t ret_ref = 0;
5125 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5126 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5127 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5128 ret_ref = (uintptr_t)ret_var.inner;
5129 if (ret_var.is_owned) {
5135 static inline struct LDKDecodeError CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR owner){
5136 CHECK(!owner->result_ok);
5137 return DecodeError_clone(&*owner->contents.err);
5139 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(uint32_t owner) {
5140 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* owner_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(owner & ~1);
5141 LDKDecodeError ret_var = CResult_CounterpartyForwardingInfoDecodeErrorZ_get_err(owner_conv);
5142 uint32_t ret_ref = 0;
5143 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5144 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5145 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5146 ret_ref = (uintptr_t)ret_var.inner;
5147 if (ret_var.is_owned) {
5153 static inline struct LDKChannelCounterparty CResult_ChannelCounterpartyDecodeErrorZ_get_ok(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5154 CHECK(owner->result_ok);
5155 return ChannelCounterparty_clone(&*owner->contents.result);
5157 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_ok(uint32_t owner) {
5158 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)(owner & ~1);
5159 LDKChannelCounterparty ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_ok(owner_conv);
5160 uint32_t ret_ref = 0;
5161 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5162 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5163 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5164 ret_ref = (uintptr_t)ret_var.inner;
5165 if (ret_var.is_owned) {
5171 static inline struct LDKDecodeError CResult_ChannelCounterpartyDecodeErrorZ_get_err(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR owner){
5172 CHECK(!owner->result_ok);
5173 return DecodeError_clone(&*owner->contents.err);
5175 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_get_err(uint32_t owner) {
5176 LDKCResult_ChannelCounterpartyDecodeErrorZ* owner_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)(owner & ~1);
5177 LDKDecodeError ret_var = CResult_ChannelCounterpartyDecodeErrorZ_get_err(owner_conv);
5178 uint32_t ret_ref = 0;
5179 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5180 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5181 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5182 ret_ref = (uintptr_t)ret_var.inner;
5183 if (ret_var.is_owned) {
5189 static inline struct LDKChannelDetails CResult_ChannelDetailsDecodeErrorZ_get_ok(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5190 CHECK(owner->result_ok);
5191 return ChannelDetails_clone(&*owner->contents.result);
5193 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_ok(uint32_t owner) {
5194 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)(owner & ~1);
5195 LDKChannelDetails ret_var = CResult_ChannelDetailsDecodeErrorZ_get_ok(owner_conv);
5196 uint32_t ret_ref = 0;
5197 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5198 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5199 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5200 ret_ref = (uintptr_t)ret_var.inner;
5201 if (ret_var.is_owned) {
5207 static inline struct LDKDecodeError CResult_ChannelDetailsDecodeErrorZ_get_err(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR owner){
5208 CHECK(!owner->result_ok);
5209 return DecodeError_clone(&*owner->contents.err);
5211 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_get_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_get_err(uint32_t owner) {
5212 LDKCResult_ChannelDetailsDecodeErrorZ* owner_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)(owner & ~1);
5213 LDKDecodeError ret_var = CResult_ChannelDetailsDecodeErrorZ_get_err(owner_conv);
5214 uint32_t ret_ref = 0;
5215 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5216 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5217 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5218 ret_ref = (uintptr_t)ret_var.inner;
5219 if (ret_var.is_owned) {
5225 static inline struct LDKPhantomRouteHints CResult_PhantomRouteHintsDecodeErrorZ_get_ok(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5226 CHECK(owner->result_ok);
5227 return PhantomRouteHints_clone(&*owner->contents.result);
5229 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_ok(uint32_t owner) {
5230 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)(owner & ~1);
5231 LDKPhantomRouteHints ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_ok(owner_conv);
5232 uint32_t ret_ref = 0;
5233 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5234 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5235 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5236 ret_ref = (uintptr_t)ret_var.inner;
5237 if (ret_var.is_owned) {
5243 static inline struct LDKDecodeError CResult_PhantomRouteHintsDecodeErrorZ_get_err(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR owner){
5244 CHECK(!owner->result_ok);
5245 return DecodeError_clone(&*owner->contents.err);
5247 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_get_err(uint32_t owner) {
5248 LDKCResult_PhantomRouteHintsDecodeErrorZ* owner_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)(owner & ~1);
5249 LDKDecodeError ret_var = CResult_PhantomRouteHintsDecodeErrorZ_get_err(owner_conv);
5250 uint32_t ret_ref = 0;
5251 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5252 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5253 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5254 ret_ref = (uintptr_t)ret_var.inner;
5255 if (ret_var.is_owned) {
5261 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
5262 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
5263 for (size_t i = 0; i < ret.datalen; i++) {
5264 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
5268 typedef struct LDKWatch_JCalls {
5269 atomic_size_t refcnt;
5270 uint32_t instance_ptr;
5272 static void LDKWatch_JCalls_free(void* this_arg) {
5273 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5274 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5278 LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
5279 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5280 LDKOutPoint funding_txo_var = funding_txo;
5281 uint32_t funding_txo_ref = 0;
5282 CHECK((((uintptr_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5283 CHECK((((uintptr_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5284 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5285 funding_txo_ref = (uintptr_t)funding_txo_var.inner;
5286 if (funding_txo_var.is_owned) {
5287 funding_txo_ref |= 1;
5289 LDKChannelMonitor monitor_var = monitor;
5290 uint32_t monitor_ref = 0;
5291 CHECK((((uintptr_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5292 CHECK((((uintptr_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5293 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_var);
5294 monitor_ref = (uintptr_t)monitor_var.inner;
5295 if (monitor_var.is_owned) {
5298 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 16, (uint32_t)funding_txo_ref, (uint32_t)monitor_ref);
5299 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5300 CHECK_ACCESS(ret_ptr);
5301 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
5305 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
5306 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5307 LDKOutPoint funding_txo_var = funding_txo;
5308 uint32_t funding_txo_ref = 0;
5309 CHECK((((uintptr_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5310 CHECK((((uintptr_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5311 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_var);
5312 funding_txo_ref = (uintptr_t)funding_txo_var.inner;
5313 if (funding_txo_var.is_owned) {
5314 funding_txo_ref |= 1;
5316 LDKChannelMonitorUpdate update_var = update;
5317 uint32_t update_ref = 0;
5318 CHECK((((uintptr_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5319 CHECK((((uintptr_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5320 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
5321 update_ref = (uintptr_t)update_var.inner;
5322 if (update_var.is_owned) {
5325 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 17, (uint32_t)funding_txo_ref, (uint32_t)update_ref);
5326 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5327 CHECK_ACCESS(ret_ptr);
5328 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
5332 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
5333 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
5334 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_(j_calls->instance_ptr, 18);
5335 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_constr;
5336 ret_constr.datalen = ret->arr_len;
5337 if (ret_constr.datalen > 0)
5338 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
5340 ret_constr.data = NULL;
5341 uint32_t* ret_vals = ret->elems;
5342 for (size_t x = 0; x < ret_constr.datalen; x++) {
5343 uint32_t ret_conv_49 = ret_vals[x];
5344 void* ret_conv_49_ptr = (void*)(((uintptr_t)ret_conv_49) & ~1);
5345 CHECK_ACCESS(ret_conv_49_ptr);
5346 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ ret_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(ret_conv_49_ptr);
5347 FREE((void*)ret_conv_49);
5348 ret_constr.data[x] = ret_conv_49_conv;
5353 static void LDKWatch_JCalls_cloned(LDKWatch* new_obj) {
5354 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) new_obj->this_arg;
5355 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5357 static inline LDKWatch LDKWatch_init (JSValue o) {
5358 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
5359 atomic_init(&calls->refcnt, 1);
5360 calls->instance_ptr = o;
5363 .this_arg = (void*) calls,
5364 .watch_channel = watch_channel_LDKWatch_jcall,
5365 .update_channel = update_channel_LDKWatch_jcall,
5366 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
5367 .free = LDKWatch_JCalls_free,
5371 long __attribute__((export_name("TS_LDKWatch_new"))) TS_LDKWatch_new(JSValue o) {
5372 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
5373 *res_ptr = LDKWatch_init(o);
5374 return (long)res_ptr;
5376 uint32_t __attribute__((export_name("TS_Watch_watch_channel"))) TS_Watch_watch_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t monitor) {
5377 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5378 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5379 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5380 LDKOutPoint funding_txo_conv;
5381 funding_txo_conv.inner = (void*)(funding_txo & (~1));
5382 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
5383 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5384 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5385 LDKChannelMonitor monitor_conv;
5386 monitor_conv.inner = (void*)(monitor & (~1));
5387 monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
5388 CHECK_INNER_FIELD_ACCESS_OR_NULL(monitor_conv);
5389 monitor_conv = ChannelMonitor_clone(&monitor_conv);
5390 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5391 *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
5392 return (uint32_t)ret_conv;
5395 uint32_t __attribute__((export_name("TS_Watch_update_channel"))) TS_Watch_update_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t update) {
5396 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5397 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5398 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5399 LDKOutPoint funding_txo_conv;
5400 funding_txo_conv.inner = (void*)(funding_txo & (~1));
5401 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
5402 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
5403 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
5404 LDKChannelMonitorUpdate update_conv;
5405 update_conv.inner = (void*)(update & (~1));
5406 update_conv.is_owned = (update & 1) || (update == 0);
5407 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
5408 update_conv = ChannelMonitorUpdate_clone(&update_conv);
5409 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5410 *ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
5411 return (uint32_t)ret_conv;
5414 uint32_tArray __attribute__((export_name("TS_Watch_release_pending_monitor_events"))) TS_Watch_release_pending_monitor_events(uint32_t this_arg) {
5415 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5416 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5417 LDKWatch* this_arg_conv = (LDKWatch*)this_arg_ptr;
5418 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
5419 uint32_tArray ret_arr = NULL;
5420 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
5421 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
5422 for (size_t x = 0; x < ret_var.datalen; x++) {
5423 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv_49_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
5424 *ret_conv_49_conv = ret_var.data[x];
5425 ret_arr_ptr[x] = ((uint32_t)ret_conv_49_conv);
5432 typedef struct LDKBroadcasterInterface_JCalls {
5433 atomic_size_t refcnt;
5434 uint32_t instance_ptr;
5435 } LDKBroadcasterInterface_JCalls;
5436 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
5437 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5438 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5442 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
5443 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
5444 LDKTransaction tx_var = tx;
5445 int8_tArray tx_arr = init_int8_tArray(tx_var.datalen, __LINE__);
5446 memcpy(tx_arr->elems, tx_var.data, tx_var.datalen);
5447 Transaction_free(tx_var);
5448 js_invoke_function_u_u(j_calls->instance_ptr, 19, (uint32_t)tx_arr);
5450 static void LDKBroadcasterInterface_JCalls_cloned(LDKBroadcasterInterface* new_obj) {
5451 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) new_obj->this_arg;
5452 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5454 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (JSValue o) {
5455 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
5456 atomic_init(&calls->refcnt, 1);
5457 calls->instance_ptr = o;
5459 LDKBroadcasterInterface ret = {
5460 .this_arg = (void*) calls,
5461 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
5462 .free = LDKBroadcasterInterface_JCalls_free,
5466 long __attribute__((export_name("TS_LDKBroadcasterInterface_new"))) TS_LDKBroadcasterInterface_new(JSValue o) {
5467 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
5468 *res_ptr = LDKBroadcasterInterface_init(o);
5469 return (long)res_ptr;
5471 void __attribute__((export_name("TS_BroadcasterInterface_broadcast_transaction"))) TS_BroadcasterInterface_broadcast_transaction(uint32_t this_arg, int8_tArray tx) {
5472 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5473 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5474 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)this_arg_ptr;
5475 LDKTransaction tx_ref;
5476 tx_ref.datalen = tx->arr_len;
5477 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
5478 memcpy(tx_ref.data, tx->elems, tx_ref.datalen); FREE(tx);
5479 tx_ref.data_is_owned = true;
5480 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
5483 typedef struct LDKKeysInterface_JCalls {
5484 atomic_size_t refcnt;
5485 uint32_t instance_ptr;
5486 } LDKKeysInterface_JCalls;
5487 static void LDKKeysInterface_JCalls_free(void* this_arg) {
5488 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5489 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5493 LDKCResult_SecretKeyNoneZ get_node_secret_LDKKeysInterface_jcall(const void* this_arg, LDKRecipient recipient) {
5494 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5495 uint32_t recipient_conv = LDKRecipient_to_js(recipient);
5496 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 20, (uint32_t)recipient_conv);
5497 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5498 CHECK_ACCESS(ret_ptr);
5499 LDKCResult_SecretKeyNoneZ ret_conv = *(LDKCResult_SecretKeyNoneZ*)(ret_ptr);
5503 LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
5504 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5505 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 21);
5506 LDKCVec_u8Z ret_ref;
5507 ret_ref.datalen = ret->arr_len;
5508 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
5509 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
5512 LDKShutdownScript get_shutdown_scriptpubkey_LDKKeysInterface_jcall(const void* this_arg) {
5513 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5514 uint32_t ret = js_invoke_function_u_(j_calls->instance_ptr, 22);
5515 LDKShutdownScript ret_conv;
5516 ret_conv.inner = (void*)(ret & (~1));
5517 ret_conv.is_owned = (ret & 1) || (ret == 0);
5518 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv);
5521 LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
5522 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5523 jboolean inbound_conv = inbound;
5524 int64_t channel_value_satoshis_conv = channel_value_satoshis;
5525 uint32_t ret = js_invoke_function_u_bb(j_calls->instance_ptr, 23, (uint32_t)inbound_conv, (uint32_t)channel_value_satoshis_conv);
5526 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5527 CHECK_ACCESS(ret_ptr);
5528 LDKSign ret_conv = *(LDKSign*)(ret_ptr);
5532 LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
5533 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5534 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 24);
5535 LDKThirtyTwoBytes ret_ref;
5536 CHECK(ret->arr_len == 32);
5537 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5540 LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
5541 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5542 LDKu8slice reader_var = reader;
5543 int8_tArray reader_arr = init_int8_tArray(reader_var.datalen, __LINE__);
5544 memcpy(reader_arr->elems, reader_var.data, reader_var.datalen);
5545 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 25, (uint32_t)reader_arr);
5546 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5547 CHECK_ACCESS(ret_ptr);
5548 LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(ret_ptr);
5552 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice hrp_bytes, LDKCVec_u5Z invoice_data, LDKRecipient receipient) {
5553 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5554 LDKu8slice hrp_bytes_var = hrp_bytes;
5555 int8_tArray hrp_bytes_arr = init_int8_tArray(hrp_bytes_var.datalen, __LINE__);
5556 memcpy(hrp_bytes_arr->elems, hrp_bytes_var.data, hrp_bytes_var.datalen);
5557 LDKCVec_u5Z invoice_data_var = invoice_data;
5558 ptrArray invoice_data_arr = NULL;
5559 invoice_data_arr = init_ptrArray(invoice_data_var.datalen, __LINE__);
5560 int8_t *invoice_data_arr_ptr = (int8_t*)(((uint8_t*)invoice_data_arr) + 4);
5561 for (size_t h = 0; h < invoice_data_var.datalen; h++) {
5562 uint8_t invoice_data_conv_7_val = invoice_data_var.data[h]._0;
5563 invoice_data_arr_ptr[h] = invoice_data_conv_7_val;
5566 FREE(invoice_data_var.data);
5567 uint32_t receipient_conv = LDKRecipient_to_js(receipient);
5568 uint32_t ret = js_invoke_function_u_uuu(j_calls->instance_ptr, 26, (uint32_t)hrp_bytes_arr, (uint32_t)invoice_data_arr, (uint32_t)receipient_conv);
5569 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
5570 CHECK_ACCESS(ret_ptr);
5571 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(ret_ptr);
5575 LDKThirtyTwoBytes get_inbound_payment_key_material_LDKKeysInterface_jcall(const void* this_arg) {
5576 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
5577 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 27);
5578 LDKThirtyTwoBytes ret_ref;
5579 CHECK(ret->arr_len == 32);
5580 memcpy(ret_ref.data, ret->elems, 32); FREE(ret);
5583 static void LDKKeysInterface_JCalls_cloned(LDKKeysInterface* new_obj) {
5584 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) new_obj->this_arg;
5585 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5587 static inline LDKKeysInterface LDKKeysInterface_init (JSValue o) {
5588 LDKKeysInterface_JCalls *calls = MALLOC(sizeof(LDKKeysInterface_JCalls), "LDKKeysInterface_JCalls");
5589 atomic_init(&calls->refcnt, 1);
5590 calls->instance_ptr = o;
5592 LDKKeysInterface ret = {
5593 .this_arg = (void*) calls,
5594 .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
5595 .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
5596 .get_shutdown_scriptpubkey = get_shutdown_scriptpubkey_LDKKeysInterface_jcall,
5597 .get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
5598 .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
5599 .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
5600 .sign_invoice = sign_invoice_LDKKeysInterface_jcall,
5601 .get_inbound_payment_key_material = get_inbound_payment_key_material_LDKKeysInterface_jcall,
5602 .free = LDKKeysInterface_JCalls_free,
5606 long __attribute__((export_name("TS_LDKKeysInterface_new"))) TS_LDKKeysInterface_new(JSValue o) {
5607 LDKKeysInterface *res_ptr = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
5608 *res_ptr = LDKKeysInterface_init(o);
5609 return (long)res_ptr;
5611 uint32_t __attribute__((export_name("TS_KeysInterface_get_node_secret"))) TS_KeysInterface_get_node_secret(uint32_t this_arg, uint32_t recipient) {
5612 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5613 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5614 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5615 LDKRecipient recipient_conv = LDKRecipient_from_js(recipient);
5616 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
5617 *ret_conv = (this_arg_conv->get_node_secret)(this_arg_conv->this_arg, recipient_conv);
5618 return (uint32_t)ret_conv;
5621 int8_tArray __attribute__((export_name("TS_KeysInterface_get_destination_script"))) TS_KeysInterface_get_destination_script(uint32_t this_arg) {
5622 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5623 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5624 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5625 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
5626 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
5627 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
5628 CVec_u8Z_free(ret_var);
5632 uint32_t __attribute__((export_name("TS_KeysInterface_get_shutdown_scriptpubkey"))) TS_KeysInterface_get_shutdown_scriptpubkey(uint32_t this_arg) {
5633 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5634 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5635 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5636 LDKShutdownScript ret_var = (this_arg_conv->get_shutdown_scriptpubkey)(this_arg_conv->this_arg);
5637 uint32_t ret_ref = 0;
5638 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5639 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5640 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5641 ret_ref = (uintptr_t)ret_var.inner;
5642 if (ret_var.is_owned) {
5648 uint32_t __attribute__((export_name("TS_KeysInterface_get_channel_signer"))) TS_KeysInterface_get_channel_signer(uint32_t this_arg, jboolean inbound, int64_t channel_value_satoshis) {
5649 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5650 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5651 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5652 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
5653 *ret_ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis);
5654 return (uint32_t)ret_ret;
5657 int8_tArray __attribute__((export_name("TS_KeysInterface_get_secure_random_bytes"))) TS_KeysInterface_get_secure_random_bytes(uint32_t this_arg) {
5658 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5659 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5660 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5661 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5662 memcpy(ret_arr->elems, (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
5666 uint32_t __attribute__((export_name("TS_KeysInterface_read_chan_signer"))) TS_KeysInterface_read_chan_signer(uint32_t this_arg, int8_tArray reader) {
5667 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5668 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5669 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5670 LDKu8slice reader_ref;
5671 reader_ref.datalen = reader->arr_len;
5672 reader_ref.data = reader->elems;
5673 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
5674 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
5676 return (uint32_t)ret_conv;
5679 uint32_t __attribute__((export_name("TS_KeysInterface_sign_invoice"))) TS_KeysInterface_sign_invoice(uint32_t this_arg, int8_tArray hrp_bytes, ptrArray invoice_data, uint32_t receipient) {
5680 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5681 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5682 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5683 LDKu8slice hrp_bytes_ref;
5684 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
5685 hrp_bytes_ref.data = hrp_bytes->elems;
5686 LDKCVec_u5Z invoice_data_constr;
5687 invoice_data_constr.datalen = invoice_data->arr_len;
5688 if (invoice_data_constr.datalen > 0)
5689 invoice_data_constr.data = MALLOC(invoice_data_constr.datalen * sizeof(LDKu5), "LDKCVec_u5Z Elements");
5691 invoice_data_constr.data = NULL;
5692 int8_t* invoice_data_vals = (void*) invoice_data->elems;
5693 for (size_t h = 0; h < invoice_data_constr.datalen; h++) {
5694 int8_t invoice_data_conv_7 = invoice_data_vals[h];
5696 invoice_data_constr.data[h] = (LDKu5){ ._0 = invoice_data_conv_7 };
5699 LDKRecipient receipient_conv = LDKRecipient_from_js(receipient);
5700 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
5701 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, hrp_bytes_ref, invoice_data_constr, receipient_conv);
5703 return (uint32_t)ret_conv;
5706 int8_tArray __attribute__((export_name("TS_KeysInterface_get_inbound_payment_key_material"))) TS_KeysInterface_get_inbound_payment_key_material(uint32_t this_arg) {
5707 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5708 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5709 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)this_arg_ptr;
5710 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5711 memcpy(ret_arr->elems, (this_arg_conv->get_inbound_payment_key_material)(this_arg_conv->this_arg).data, 32);
5715 typedef struct LDKFeeEstimator_JCalls {
5716 atomic_size_t refcnt;
5717 uint32_t instance_ptr;
5718 } LDKFeeEstimator_JCalls;
5719 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
5720 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5721 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5725 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
5726 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
5727 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
5728 return js_invoke_function_u_u(j_calls->instance_ptr, 28, (uint32_t)confirmation_target_conv);
5730 static void LDKFeeEstimator_JCalls_cloned(LDKFeeEstimator* new_obj) {
5731 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) new_obj->this_arg;
5732 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5734 static inline LDKFeeEstimator LDKFeeEstimator_init (JSValue o) {
5735 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
5736 atomic_init(&calls->refcnt, 1);
5737 calls->instance_ptr = o;
5739 LDKFeeEstimator ret = {
5740 .this_arg = (void*) calls,
5741 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
5742 .free = LDKFeeEstimator_JCalls_free,
5746 long __attribute__((export_name("TS_LDKFeeEstimator_new"))) TS_LDKFeeEstimator_new(JSValue o) {
5747 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
5748 *res_ptr = LDKFeeEstimator_init(o);
5749 return (long)res_ptr;
5751 int32_t __attribute__((export_name("TS_FeeEstimator_get_est_sat_per_1000_weight"))) TS_FeeEstimator_get_est_sat_per_1000_weight(uint32_t this_arg, uint32_t confirmation_target) {
5752 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5753 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5754 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)this_arg_ptr;
5755 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
5756 int32_t ret_conv = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
5760 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
5761 return ThirtyTwoBytes_clone(&owner->a);
5763 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_a"))) TS_C2Tuple_BlockHashChannelManagerZ_get_a(uint32_t owner) {
5764 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)(owner & ~1);
5765 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
5766 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelManagerZ_get_a(owner_conv).data, 32);
5770 static inline struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR owner){
5773 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_get_b"))) TS_C2Tuple_BlockHashChannelManagerZ_get_b(uint32_t owner) {
5774 LDKC2Tuple_BlockHashChannelManagerZ* owner_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)(owner & ~1);
5775 LDKChannelManager ret_var = *C2Tuple_BlockHashChannelManagerZ_get_b(owner_conv);
5776 uint32_t ret_ref = 0;
5777 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5778 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5779 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5780 ret_ref = (uintptr_t)ret_var.inner & ~1;
5784 static inline struct LDKC2Tuple_BlockHashChannelManagerZ *CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
5785 CHECK(owner->result_ok);
5786 return &*owner->contents.result;
5788 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint32_t owner) {
5789 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(owner & ~1);
5790 uint32_t ret_ret = (uintptr_t)CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(owner_conv) | 1;
5794 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *NONNULL_PTR owner){
5795 CHECK(!owner->result_ok);
5796 return DecodeError_clone(&*owner->contents.err);
5798 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint32_t owner) {
5799 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(owner & ~1);
5800 LDKDecodeError ret_var = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(owner_conv);
5801 uint32_t ret_ref = 0;
5802 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5803 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5804 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5805 ret_ref = (uintptr_t)ret_var.inner;
5806 if (ret_var.is_owned) {
5812 static inline struct LDKChannelConfig CResult_ChannelConfigDecodeErrorZ_get_ok(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
5813 CHECK(owner->result_ok);
5814 return ChannelConfig_clone(&*owner->contents.result);
5816 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t owner) {
5817 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(owner & ~1);
5818 LDKChannelConfig ret_var = CResult_ChannelConfigDecodeErrorZ_get_ok(owner_conv);
5819 uint32_t ret_ref = 0;
5820 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5821 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5822 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5823 ret_ref = (uintptr_t)ret_var.inner;
5824 if (ret_var.is_owned) {
5830 static inline struct LDKDecodeError CResult_ChannelConfigDecodeErrorZ_get_err(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR owner){
5831 CHECK(!owner->result_ok);
5832 return DecodeError_clone(&*owner->contents.err);
5834 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_get_err"))) TS_CResult_ChannelConfigDecodeErrorZ_get_err(uint32_t owner) {
5835 LDKCResult_ChannelConfigDecodeErrorZ* owner_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(owner & ~1);
5836 LDKDecodeError ret_var = CResult_ChannelConfigDecodeErrorZ_get_err(owner_conv);
5837 uint32_t ret_ref = 0;
5838 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5839 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5840 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5841 ret_ref = (uintptr_t)ret_var.inner;
5842 if (ret_var.is_owned) {
5848 static inline struct LDKOutPoint CResult_OutPointDecodeErrorZ_get_ok(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
5849 CHECK(owner->result_ok);
5850 return OutPoint_clone(&*owner->contents.result);
5852 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_ok"))) TS_CResult_OutPointDecodeErrorZ_get_ok(uint32_t owner) {
5853 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)(owner & ~1);
5854 LDKOutPoint ret_var = CResult_OutPointDecodeErrorZ_get_ok(owner_conv);
5855 uint32_t ret_ref = 0;
5856 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5857 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5858 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5859 ret_ref = (uintptr_t)ret_var.inner;
5860 if (ret_var.is_owned) {
5866 static inline struct LDKDecodeError CResult_OutPointDecodeErrorZ_get_err(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR owner){
5867 CHECK(!owner->result_ok);
5868 return DecodeError_clone(&*owner->contents.err);
5870 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_get_err"))) TS_CResult_OutPointDecodeErrorZ_get_err(uint32_t owner) {
5871 LDKCResult_OutPointDecodeErrorZ* owner_conv = (LDKCResult_OutPointDecodeErrorZ*)(owner & ~1);
5872 LDKDecodeError ret_var = CResult_OutPointDecodeErrorZ_get_err(owner_conv);
5873 uint32_t ret_ref = 0;
5874 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5875 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5876 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
5877 ret_ref = (uintptr_t)ret_var.inner;
5878 if (ret_var.is_owned) {
5884 typedef struct LDKType_JCalls {
5885 atomic_size_t refcnt;
5886 uint32_t instance_ptr;
5888 static void LDKType_JCalls_free(void* this_arg) {
5889 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5890 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5894 uint16_t type_id_LDKType_jcall(const void* this_arg) {
5895 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5896 return js_invoke_function_u_(j_calls->instance_ptr, 29);
5898 LDKStr debug_str_LDKType_jcall(const void* this_arg) {
5899 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5900 jstring ret = (jstring)js_invoke_function_u_(j_calls->instance_ptr, 30);
5901 LDKStr ret_conv = str_ref_to_owned_c(ret);
5904 LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) {
5905 LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg;
5906 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 31);
5907 LDKCVec_u8Z ret_ref;
5908 ret_ref.datalen = ret->arr_len;
5909 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
5910 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
5913 static void LDKType_JCalls_cloned(LDKType* new_obj) {
5914 LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg;
5915 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5917 static inline LDKType LDKType_init (JSValue o) {
5918 LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls");
5919 atomic_init(&calls->refcnt, 1);
5920 calls->instance_ptr = o;
5923 .this_arg = (void*) calls,
5924 .type_id = type_id_LDKType_jcall,
5925 .debug_str = debug_str_LDKType_jcall,
5926 .write = write_LDKType_jcall,
5927 .cloned = LDKType_JCalls_cloned,
5928 .free = LDKType_JCalls_free,
5932 long __attribute__((export_name("TS_LDKType_new"))) TS_LDKType_new(JSValue o) {
5933 LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType");
5934 *res_ptr = LDKType_init(o);
5935 return (long)res_ptr;
5937 int16_t __attribute__((export_name("TS_Type_type_id"))) TS_Type_type_id(uint32_t this_arg) {
5938 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5939 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5940 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5941 int16_t ret_conv = (this_arg_conv->type_id)(this_arg_conv->this_arg);
5945 jstring __attribute__((export_name("TS_Type_debug_str"))) TS_Type_debug_str(uint32_t this_arg) {
5946 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5947 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5948 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5949 LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg);
5950 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
5955 int8_tArray __attribute__((export_name("TS_Type_write"))) TS_Type_write(uint32_t this_arg) {
5956 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
5957 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
5958 LDKType* this_arg_conv = (LDKType*)this_arg_ptr;
5959 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
5960 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
5961 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
5962 CVec_u8Z_free(ret_var);
5966 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_ty_from_ptr"))) TS_LDKCOption_TypeZ_ty_from_ptr(uint32_t ptr) {
5967 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)(ptr & ~1);
5969 case LDKCOption_TypeZ_Some: return 0;
5970 case LDKCOption_TypeZ_None: return 1;
5974 uint32_t __attribute__((export_name("TS_LDKCOption_TypeZ_Some_get_some"))) TS_LDKCOption_TypeZ_Some_get_some(uint32_t ptr) {
5975 LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)(ptr & ~1);
5976 assert(obj->tag == LDKCOption_TypeZ_Some);
5977 LDKType* some_ret = MALLOC(sizeof(LDKType), "LDKType");
5978 *some_ret = Type_clone(&obj->some);
5979 return (uint32_t)some_ret;
5981 static inline struct LDKCOption_TypeZ CResult_COption_TypeZDecodeErrorZ_get_ok(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
5982 CHECK(owner->result_ok);
5983 return COption_TypeZ_clone(&*owner->contents.result);
5985 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_get_ok(uint32_t owner) {
5986 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(owner & ~1);
5987 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
5988 *ret_copy = CResult_COption_TypeZDecodeErrorZ_get_ok(owner_conv);
5989 uint32_t ret_ref = (uintptr_t)ret_copy;
5993 static inline struct LDKDecodeError CResult_COption_TypeZDecodeErrorZ_get_err(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR owner){
5994 CHECK(!owner->result_ok);
5995 return DecodeError_clone(&*owner->contents.err);
5997 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_get_err"))) TS_CResult_COption_TypeZDecodeErrorZ_get_err(uint32_t owner) {
5998 LDKCResult_COption_TypeZDecodeErrorZ* owner_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(owner & ~1);
5999 LDKDecodeError ret_var = CResult_COption_TypeZDecodeErrorZ_get_err(owner_conv);
6000 uint32_t ret_ref = 0;
6001 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6002 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6003 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6004 ret_ref = (uintptr_t)ret_var.inner;
6005 if (ret_var.is_owned) {
6011 uint32_t __attribute__((export_name("TS_LDKPaymentError_ty_from_ptr"))) TS_LDKPaymentError_ty_from_ptr(uint32_t ptr) {
6012 LDKPaymentError *obj = (LDKPaymentError*)(ptr & ~1);
6014 case LDKPaymentError_Invoice: return 0;
6015 case LDKPaymentError_Routing: return 1;
6016 case LDKPaymentError_Sending: return 2;
6020 jstring __attribute__((export_name("TS_LDKPaymentError_Invoice_get_invoice"))) TS_LDKPaymentError_Invoice_get_invoice(uint32_t ptr) {
6021 LDKPaymentError *obj = (LDKPaymentError*)(ptr & ~1);
6022 assert(obj->tag == LDKPaymentError_Invoice);
6023 LDKStr invoice_str = obj->invoice;
6024 jstring invoice_conv = str_ref_to_ts(invoice_str.chars, invoice_str.len);
6025 return invoice_conv;
6027 uint32_t __attribute__((export_name("TS_LDKPaymentError_Routing_get_routing"))) TS_LDKPaymentError_Routing_get_routing(uint32_t ptr) {
6028 LDKPaymentError *obj = (LDKPaymentError*)(ptr & ~1);
6029 assert(obj->tag == LDKPaymentError_Routing);
6030 LDKLightningError routing_var = obj->routing;
6031 uint32_t routing_ref = 0;
6032 CHECK((((uintptr_t)routing_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6033 CHECK((((uintptr_t)&routing_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6034 CHECK_INNER_FIELD_ACCESS_OR_NULL(routing_var);
6035 routing_ref = (uintptr_t)routing_var.inner & ~1;
6038 uint32_t __attribute__((export_name("TS_LDKPaymentError_Sending_get_sending"))) TS_LDKPaymentError_Sending_get_sending(uint32_t ptr) {
6039 LDKPaymentError *obj = (LDKPaymentError*)(ptr & ~1);
6040 assert(obj->tag == LDKPaymentError_Sending);
6041 uint32_t sending_ref = ((uintptr_t)&obj->sending) | 1;
6044 static inline struct LDKThirtyTwoBytes CResult_PaymentIdPaymentErrorZ_get_ok(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6045 CHECK(owner->result_ok);
6046 return ThirtyTwoBytes_clone(&*owner->contents.result);
6048 int8_tArray __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_ok"))) TS_CResult_PaymentIdPaymentErrorZ_get_ok(uint32_t owner) {
6049 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(owner & ~1);
6050 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6051 memcpy(ret_arr->elems, CResult_PaymentIdPaymentErrorZ_get_ok(owner_conv).data, 32);
6055 static inline struct LDKPaymentError CResult_PaymentIdPaymentErrorZ_get_err(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR owner){
6056 CHECK(!owner->result_ok);
6057 return PaymentError_clone(&*owner->contents.err);
6059 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_get_err"))) TS_CResult_PaymentIdPaymentErrorZ_get_err(uint32_t owner) {
6060 LDKCResult_PaymentIdPaymentErrorZ* owner_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(owner & ~1);
6061 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
6062 *ret_copy = CResult_PaymentIdPaymentErrorZ_get_err(owner_conv);
6063 uint32_t ret_ref = (uintptr_t)ret_copy;
6067 uint32_t __attribute__((export_name("TS_LDKParseError_ty_from_ptr"))) TS_LDKParseError_ty_from_ptr(uint32_t ptr) {
6068 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6070 case LDKParseError_Bech32Error: return 0;
6071 case LDKParseError_ParseAmountError: return 1;
6072 case LDKParseError_MalformedSignature: return 2;
6073 case LDKParseError_BadPrefix: return 3;
6074 case LDKParseError_UnknownCurrency: return 4;
6075 case LDKParseError_UnknownSiPrefix: return 5;
6076 case LDKParseError_MalformedHRP: return 6;
6077 case LDKParseError_TooShortDataPart: return 7;
6078 case LDKParseError_UnexpectedEndOfTaggedFields: return 8;
6079 case LDKParseError_DescriptionDecodeError: return 9;
6080 case LDKParseError_PaddingError: return 10;
6081 case LDKParseError_IntegerOverflowError: return 11;
6082 case LDKParseError_InvalidSegWitProgramLength: return 12;
6083 case LDKParseError_InvalidPubKeyHashLength: return 13;
6084 case LDKParseError_InvalidScriptHashLength: return 14;
6085 case LDKParseError_InvalidRecoveryId: return 15;
6086 case LDKParseError_InvalidSliceLength: return 16;
6087 case LDKParseError_Skip: return 17;
6091 uint32_t __attribute__((export_name("TS_LDKParseError_Bech32Error_get_bech32_error"))) TS_LDKParseError_Bech32Error_get_bech32_error(uint32_t ptr) {
6092 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6093 assert(obj->tag == LDKParseError_Bech32Error);
6094 uint32_t bech32_error_ref = ((uintptr_t)&obj->bech32_error) | 1;
6095 return bech32_error_ref;
6097 int32_t __attribute__((export_name("TS_LDKParseError_ParseAmountError_get_parse_amount_error"))) TS_LDKParseError_ParseAmountError_get_parse_amount_error(uint32_t ptr) {
6098 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6099 assert(obj->tag == LDKParseError_ParseAmountError);
6100 /*obj->parse_amount_error*/
6103 uint32_t __attribute__((export_name("TS_LDKParseError_MalformedSignature_get_malformed_signature"))) TS_LDKParseError_MalformedSignature_get_malformed_signature(uint32_t ptr) {
6104 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6105 assert(obj->tag == LDKParseError_MalformedSignature);
6106 uint32_t malformed_signature_conv = LDKSecp256k1Error_to_js(obj->malformed_signature);
6107 return malformed_signature_conv;
6109 int32_t __attribute__((export_name("TS_LDKParseError_DescriptionDecodeError_get_description_decode_error"))) TS_LDKParseError_DescriptionDecodeError_get_description_decode_error(uint32_t ptr) {
6110 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6111 assert(obj->tag == LDKParseError_DescriptionDecodeError);
6112 /*obj->description_decode_error*/
6115 jstring __attribute__((export_name("TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length"))) TS_LDKParseError_InvalidSliceLength_get_invalid_slice_length(uint32_t ptr) {
6116 LDKParseError *obj = (LDKParseError*)(ptr & ~1);
6117 assert(obj->tag == LDKParseError_InvalidSliceLength);
6118 LDKStr invalid_slice_length_str = obj->invalid_slice_length;
6119 jstring invalid_slice_length_conv = str_ref_to_ts(invalid_slice_length_str.chars, invalid_slice_length_str.len);
6120 return invalid_slice_length_conv;
6122 static inline enum LDKSiPrefix CResult_SiPrefixParseErrorZ_get_ok(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
6123 CHECK(owner->result_ok);
6124 return SiPrefix_clone(&*owner->contents.result);
6126 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_ok"))) TS_CResult_SiPrefixParseErrorZ_get_ok(uint32_t owner) {
6127 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)(owner & ~1);
6128 uint32_t ret_conv = LDKSiPrefix_to_js(CResult_SiPrefixParseErrorZ_get_ok(owner_conv));
6132 static inline struct LDKParseError CResult_SiPrefixParseErrorZ_get_err(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR owner){
6133 CHECK(!owner->result_ok);
6134 return ParseError_clone(&*owner->contents.err);
6136 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_get_err"))) TS_CResult_SiPrefixParseErrorZ_get_err(uint32_t owner) {
6137 LDKCResult_SiPrefixParseErrorZ* owner_conv = (LDKCResult_SiPrefixParseErrorZ*)(owner & ~1);
6138 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
6139 *ret_copy = CResult_SiPrefixParseErrorZ_get_err(owner_conv);
6140 uint32_t ret_ref = (uintptr_t)ret_copy;
6144 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ty_from_ptr"))) TS_LDKParseOrSemanticError_ty_from_ptr(uint32_t ptr) {
6145 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)(ptr & ~1);
6147 case LDKParseOrSemanticError_ParseError: return 0;
6148 case LDKParseOrSemanticError_SemanticError: return 1;
6152 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_ParseError_get_parse_error"))) TS_LDKParseOrSemanticError_ParseError_get_parse_error(uint32_t ptr) {
6153 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)(ptr & ~1);
6154 assert(obj->tag == LDKParseOrSemanticError_ParseError);
6155 uint32_t parse_error_ref = ((uintptr_t)&obj->parse_error) | 1;
6156 return parse_error_ref;
6158 uint32_t __attribute__((export_name("TS_LDKParseOrSemanticError_SemanticError_get_semantic_error"))) TS_LDKParseOrSemanticError_SemanticError_get_semantic_error(uint32_t ptr) {
6159 LDKParseOrSemanticError *obj = (LDKParseOrSemanticError*)(ptr & ~1);
6160 assert(obj->tag == LDKParseOrSemanticError_SemanticError);
6161 uint32_t semantic_error_conv = LDKSemanticError_to_js(obj->semantic_error);
6162 return semantic_error_conv;
6164 static inline struct LDKInvoice CResult_InvoiceParseOrSemanticErrorZ_get_ok(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
6165 CHECK(owner->result_ok);
6166 return Invoice_clone(&*owner->contents.result);
6168 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_ok(uint32_t owner) {
6169 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)(owner & ~1);
6170 LDKInvoice ret_var = CResult_InvoiceParseOrSemanticErrorZ_get_ok(owner_conv);
6171 uint32_t ret_ref = 0;
6172 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6173 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6175 ret_ref = (uintptr_t)ret_var.inner;
6176 if (ret_var.is_owned) {
6182 static inline struct LDKParseOrSemanticError CResult_InvoiceParseOrSemanticErrorZ_get_err(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR owner){
6183 CHECK(!owner->result_ok);
6184 return ParseOrSemanticError_clone(&*owner->contents.err);
6186 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_get_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_get_err(uint32_t owner) {
6187 LDKCResult_InvoiceParseOrSemanticErrorZ* owner_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)(owner & ~1);
6188 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
6189 *ret_copy = CResult_InvoiceParseOrSemanticErrorZ_get_err(owner_conv);
6190 uint32_t ret_ref = (uintptr_t)ret_copy;
6194 static inline struct LDKSignedRawInvoice CResult_SignedRawInvoiceParseErrorZ_get_ok(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
6195 CHECK(owner->result_ok);
6196 return SignedRawInvoice_clone(&*owner->contents.result);
6198 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_ok(uint32_t owner) {
6199 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)(owner & ~1);
6200 LDKSignedRawInvoice ret_var = CResult_SignedRawInvoiceParseErrorZ_get_ok(owner_conv);
6201 uint32_t ret_ref = 0;
6202 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6203 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6204 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6205 ret_ref = (uintptr_t)ret_var.inner;
6206 if (ret_var.is_owned) {
6212 static inline struct LDKParseError CResult_SignedRawInvoiceParseErrorZ_get_err(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR owner){
6213 CHECK(!owner->result_ok);
6214 return ParseError_clone(&*owner->contents.err);
6216 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_get_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_get_err(uint32_t owner) {
6217 LDKCResult_SignedRawInvoiceParseErrorZ* owner_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)(owner & ~1);
6218 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
6219 *ret_copy = CResult_SignedRawInvoiceParseErrorZ_get_err(owner_conv);
6220 uint32_t ret_ref = (uintptr_t)ret_copy;
6224 static inline struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6225 return RawInvoice_clone(&owner->a);
6227 uint32_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint32_t owner) {
6228 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(owner & ~1);
6229 LDKRawInvoice ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(owner_conv);
6230 uint32_t ret_ref = 0;
6231 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6232 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6233 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6234 ret_ref = (uintptr_t)ret_var.inner;
6235 if (ret_var.is_owned) {
6241 static inline struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6242 return ThirtyTwoBytes_clone(&owner->b);
6244 int8_tArray __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint32_t owner) {
6245 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(owner & ~1);
6246 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6247 memcpy(ret_arr->elems, C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(owner_conv).data, 32);
6251 static inline struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR owner){
6252 return InvoiceSignature_clone(&owner->c);
6254 uint32_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint32_t owner) {
6255 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* owner_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(owner & ~1);
6256 LDKInvoiceSignature ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(owner_conv);
6257 uint32_t ret_ref = 0;
6258 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6259 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6260 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6261 ret_ref = (uintptr_t)ret_var.inner;
6262 if (ret_var.is_owned) {
6268 static inline struct LDKPayeePubKey CResult_PayeePubKeyErrorZ_get_ok(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
6269 CHECK(owner->result_ok);
6270 return PayeePubKey_clone(&*owner->contents.result);
6272 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_ok"))) TS_CResult_PayeePubKeyErrorZ_get_ok(uint32_t owner) {
6273 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)(owner & ~1);
6274 LDKPayeePubKey ret_var = CResult_PayeePubKeyErrorZ_get_ok(owner_conv);
6275 uint32_t ret_ref = 0;
6276 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6277 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6279 ret_ref = (uintptr_t)ret_var.inner;
6280 if (ret_var.is_owned) {
6286 static inline enum LDKSecp256k1Error CResult_PayeePubKeyErrorZ_get_err(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR owner){
6287 CHECK(!owner->result_ok);
6288 return *owner->contents.err;
6290 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_get_err"))) TS_CResult_PayeePubKeyErrorZ_get_err(uint32_t owner) {
6291 LDKCResult_PayeePubKeyErrorZ* owner_conv = (LDKCResult_PayeePubKeyErrorZ*)(owner & ~1);
6292 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_PayeePubKeyErrorZ_get_err(owner_conv));
6296 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
6297 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
6298 for (size_t i = 0; i < ret.datalen; i++) {
6299 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
6303 static inline struct LDKPositiveTimestamp CResult_PositiveTimestampCreationErrorZ_get_ok(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
6304 CHECK(owner->result_ok);
6305 return PositiveTimestamp_clone(&*owner->contents.result);
6307 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_get_ok(uint32_t owner) {
6308 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(owner & ~1);
6309 LDKPositiveTimestamp ret_var = CResult_PositiveTimestampCreationErrorZ_get_ok(owner_conv);
6310 uint32_t ret_ref = 0;
6311 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6312 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6313 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6314 ret_ref = (uintptr_t)ret_var.inner;
6315 if (ret_var.is_owned) {
6321 static inline enum LDKCreationError CResult_PositiveTimestampCreationErrorZ_get_err(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR owner){
6322 CHECK(!owner->result_ok);
6323 return CreationError_clone(&*owner->contents.err);
6325 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_get_err"))) TS_CResult_PositiveTimestampCreationErrorZ_get_err(uint32_t owner) {
6326 LDKCResult_PositiveTimestampCreationErrorZ* owner_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(owner & ~1);
6327 uint32_t ret_conv = LDKCreationError_to_js(CResult_PositiveTimestampCreationErrorZ_get_err(owner_conv));
6331 static inline void CResult_NoneSemanticErrorZ_get_ok(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
6332 CHECK(owner->result_ok);
6333 return *owner->contents.result;
6335 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_ok"))) TS_CResult_NoneSemanticErrorZ_get_ok(uint32_t owner) {
6336 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)(owner & ~1);
6337 CResult_NoneSemanticErrorZ_get_ok(owner_conv);
6340 static inline enum LDKSemanticError CResult_NoneSemanticErrorZ_get_err(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR owner){
6341 CHECK(!owner->result_ok);
6342 return SemanticError_clone(&*owner->contents.err);
6344 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_get_err"))) TS_CResult_NoneSemanticErrorZ_get_err(uint32_t owner) {
6345 LDKCResult_NoneSemanticErrorZ* owner_conv = (LDKCResult_NoneSemanticErrorZ*)(owner & ~1);
6346 uint32_t ret_conv = LDKSemanticError_to_js(CResult_NoneSemanticErrorZ_get_err(owner_conv));
6350 static inline struct LDKInvoice CResult_InvoiceSemanticErrorZ_get_ok(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
6351 CHECK(owner->result_ok);
6352 return Invoice_clone(&*owner->contents.result);
6354 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_ok"))) TS_CResult_InvoiceSemanticErrorZ_get_ok(uint32_t owner) {
6355 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)(owner & ~1);
6356 LDKInvoice ret_var = CResult_InvoiceSemanticErrorZ_get_ok(owner_conv);
6357 uint32_t ret_ref = 0;
6358 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6359 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6360 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6361 ret_ref = (uintptr_t)ret_var.inner;
6362 if (ret_var.is_owned) {
6368 static inline enum LDKSemanticError CResult_InvoiceSemanticErrorZ_get_err(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR owner){
6369 CHECK(!owner->result_ok);
6370 return SemanticError_clone(&*owner->contents.err);
6372 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_get_err"))) TS_CResult_InvoiceSemanticErrorZ_get_err(uint32_t owner) {
6373 LDKCResult_InvoiceSemanticErrorZ* owner_conv = (LDKCResult_InvoiceSemanticErrorZ*)(owner & ~1);
6374 uint32_t ret_conv = LDKSemanticError_to_js(CResult_InvoiceSemanticErrorZ_get_err(owner_conv));
6378 static inline struct LDKDescription CResult_DescriptionCreationErrorZ_get_ok(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
6379 CHECK(owner->result_ok);
6380 return Description_clone(&*owner->contents.result);
6382 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_ok"))) TS_CResult_DescriptionCreationErrorZ_get_ok(uint32_t owner) {
6383 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)(owner & ~1);
6384 LDKDescription ret_var = CResult_DescriptionCreationErrorZ_get_ok(owner_conv);
6385 uint32_t ret_ref = 0;
6386 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6387 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6388 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6389 ret_ref = (uintptr_t)ret_var.inner;
6390 if (ret_var.is_owned) {
6396 static inline enum LDKCreationError CResult_DescriptionCreationErrorZ_get_err(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR owner){
6397 CHECK(!owner->result_ok);
6398 return CreationError_clone(&*owner->contents.err);
6400 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_get_err"))) TS_CResult_DescriptionCreationErrorZ_get_err(uint32_t owner) {
6401 LDKCResult_DescriptionCreationErrorZ* owner_conv = (LDKCResult_DescriptionCreationErrorZ*)(owner & ~1);
6402 uint32_t ret_conv = LDKCreationError_to_js(CResult_DescriptionCreationErrorZ_get_err(owner_conv));
6406 static inline struct LDKPrivateRoute CResult_PrivateRouteCreationErrorZ_get_ok(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
6407 CHECK(owner->result_ok);
6408 return PrivateRoute_clone(&*owner->contents.result);
6410 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_ok"))) TS_CResult_PrivateRouteCreationErrorZ_get_ok(uint32_t owner) {
6411 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(owner & ~1);
6412 LDKPrivateRoute ret_var = CResult_PrivateRouteCreationErrorZ_get_ok(owner_conv);
6413 uint32_t ret_ref = 0;
6414 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6415 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6417 ret_ref = (uintptr_t)ret_var.inner;
6418 if (ret_var.is_owned) {
6424 static inline enum LDKCreationError CResult_PrivateRouteCreationErrorZ_get_err(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR owner){
6425 CHECK(!owner->result_ok);
6426 return CreationError_clone(&*owner->contents.err);
6428 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_get_err"))) TS_CResult_PrivateRouteCreationErrorZ_get_err(uint32_t owner) {
6429 LDKCResult_PrivateRouteCreationErrorZ* owner_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(owner & ~1);
6430 uint32_t ret_conv = LDKCreationError_to_js(CResult_PrivateRouteCreationErrorZ_get_err(owner_conv));
6434 static inline struct LDKStr CResult_StringErrorZ_get_ok(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6435 CHECK(owner->result_ok);
6436 return *owner->contents.result;
6438 jstring __attribute__((export_name("TS_CResult_StringErrorZ_get_ok"))) TS_CResult_StringErrorZ_get_ok(uint32_t owner) {
6439 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)(owner & ~1);
6440 LDKStr ret_str = CResult_StringErrorZ_get_ok(owner_conv);
6441 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6445 static inline enum LDKSecp256k1Error CResult_StringErrorZ_get_err(LDKCResult_StringErrorZ *NONNULL_PTR owner){
6446 CHECK(!owner->result_ok);
6447 return *owner->contents.err;
6449 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_get_err"))) TS_CResult_StringErrorZ_get_err(uint32_t owner) {
6450 LDKCResult_StringErrorZ* owner_conv = (LDKCResult_StringErrorZ*)(owner & ~1);
6451 uint32_t ret_conv = LDKSecp256k1Error_to_js(CResult_StringErrorZ_get_err(owner_conv));
6455 static inline struct LDKChannelMonitorUpdate CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6456 CHECK(owner->result_ok);
6457 return ChannelMonitorUpdate_clone(&*owner->contents.result);
6459 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint32_t owner) {
6460 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(owner & ~1);
6461 LDKChannelMonitorUpdate ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(owner_conv);
6462 uint32_t ret_ref = 0;
6463 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6464 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6465 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6466 ret_ref = (uintptr_t)ret_var.inner;
6467 if (ret_var.is_owned) {
6473 static inline struct LDKDecodeError CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR owner){
6474 CHECK(!owner->result_ok);
6475 return DecodeError_clone(&*owner->contents.err);
6477 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint32_t owner) {
6478 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(owner & ~1);
6479 LDKDecodeError ret_var = CResult_ChannelMonitorUpdateDecodeErrorZ_get_err(owner_conv);
6480 uint32_t ret_ref = 0;
6481 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6482 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6483 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6484 ret_ref = (uintptr_t)ret_var.inner;
6485 if (ret_var.is_owned) {
6491 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_ty_from_ptr"))) TS_LDKCOption_MonitorEventZ_ty_from_ptr(uint32_t ptr) {
6492 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
6494 case LDKCOption_MonitorEventZ_Some: return 0;
6495 case LDKCOption_MonitorEventZ_None: return 1;
6499 uint32_t __attribute__((export_name("TS_LDKCOption_MonitorEventZ_Some_get_some"))) TS_LDKCOption_MonitorEventZ_Some_get_some(uint32_t ptr) {
6500 LDKCOption_MonitorEventZ *obj = (LDKCOption_MonitorEventZ*)(ptr & ~1);
6501 assert(obj->tag == LDKCOption_MonitorEventZ_Some);
6502 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
6505 static inline struct LDKCOption_MonitorEventZ CResult_COption_MonitorEventZDecodeErrorZ_get_ok(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6506 CHECK(owner->result_ok);
6507 return COption_MonitorEventZ_clone(&*owner->contents.result);
6509 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_ok(uint32_t owner) {
6510 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(owner & ~1);
6511 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
6512 *ret_copy = CResult_COption_MonitorEventZDecodeErrorZ_get_ok(owner_conv);
6513 uint32_t ret_ref = (uintptr_t)ret_copy;
6517 static inline struct LDKDecodeError CResult_COption_MonitorEventZDecodeErrorZ_get_err(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR owner){
6518 CHECK(!owner->result_ok);
6519 return DecodeError_clone(&*owner->contents.err);
6521 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_get_err(uint32_t owner) {
6522 LDKCResult_COption_MonitorEventZDecodeErrorZ* owner_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(owner & ~1);
6523 LDKDecodeError ret_var = CResult_COption_MonitorEventZDecodeErrorZ_get_err(owner_conv);
6524 uint32_t ret_ref = 0;
6525 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6526 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6527 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6528 ret_ref = (uintptr_t)ret_var.inner;
6529 if (ret_var.is_owned) {
6535 static inline struct LDKHTLCUpdate CResult_HTLCUpdateDecodeErrorZ_get_ok(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6536 CHECK(owner->result_ok);
6537 return HTLCUpdate_clone(&*owner->contents.result);
6539 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_ok(uint32_t owner) {
6540 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(owner & ~1);
6541 LDKHTLCUpdate ret_var = CResult_HTLCUpdateDecodeErrorZ_get_ok(owner_conv);
6542 uint32_t ret_ref = 0;
6543 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6544 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6546 ret_ref = (uintptr_t)ret_var.inner;
6547 if (ret_var.is_owned) {
6553 static inline struct LDKDecodeError CResult_HTLCUpdateDecodeErrorZ_get_err(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR owner){
6554 CHECK(!owner->result_ok);
6555 return DecodeError_clone(&*owner->contents.err);
6557 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_get_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_get_err(uint32_t owner) {
6558 LDKCResult_HTLCUpdateDecodeErrorZ* owner_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(owner & ~1);
6559 LDKDecodeError ret_var = CResult_HTLCUpdateDecodeErrorZ_get_err(owner_conv);
6560 uint32_t ret_ref = 0;
6561 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6562 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6563 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6564 ret_ref = (uintptr_t)ret_var.inner;
6565 if (ret_var.is_owned) {
6571 static inline struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6572 return OutPoint_clone(&owner->a);
6574 uint32_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_a"))) TS_C2Tuple_OutPointScriptZ_get_a(uint32_t owner) {
6575 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)(owner & ~1);
6576 LDKOutPoint ret_var = C2Tuple_OutPointScriptZ_get_a(owner_conv);
6577 uint32_t ret_ref = 0;
6578 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6579 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6580 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6581 ret_ref = (uintptr_t)ret_var.inner;
6582 if (ret_var.is_owned) {
6588 static inline struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR owner){
6589 return CVec_u8Z_clone(&owner->b);
6591 int8_tArray __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_get_b"))) TS_C2Tuple_OutPointScriptZ_get_b(uint32_t owner) {
6592 LDKC2Tuple_OutPointScriptZ* owner_conv = (LDKC2Tuple_OutPointScriptZ*)(owner & ~1);
6593 LDKCVec_u8Z ret_var = C2Tuple_OutPointScriptZ_get_b(owner_conv);
6594 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6595 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6596 CVec_u8Z_free(ret_var);
6600 static inline uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6603 int32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_a"))) TS_C2Tuple_u32ScriptZ_get_a(uint32_t owner) {
6604 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)(owner & ~1);
6605 int32_t ret_conv = C2Tuple_u32ScriptZ_get_a(owner_conv);
6609 static inline struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR owner){
6610 return CVec_u8Z_clone(&owner->b);
6612 int8_tArray __attribute__((export_name("TS_C2Tuple_u32ScriptZ_get_b"))) TS_C2Tuple_u32ScriptZ_get_b(uint32_t owner) {
6613 LDKC2Tuple_u32ScriptZ* owner_conv = (LDKC2Tuple_u32ScriptZ*)(owner & ~1);
6614 LDKCVec_u8Z ret_var = C2Tuple_u32ScriptZ_get_b(owner_conv);
6615 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6616 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6617 CVec_u8Z_free(ret_var);
6621 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
6622 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
6623 for (size_t i = 0; i < ret.datalen; i++) {
6624 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
6628 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6629 return ThirtyTwoBytes_clone(&owner->a);
6631 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint32_t owner) {
6632 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(owner & ~1);
6633 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6634 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(owner_conv).data, 32);
6638 static inline struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR owner){
6639 return CVec_C2Tuple_u32ScriptZZ_clone(&owner->b);
6641 uint32_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint32_t owner) {
6642 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(owner & ~1);
6643 LDKCVec_C2Tuple_u32ScriptZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(owner_conv);
6644 uint32_tArray ret_arr = NULL;
6645 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
6646 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
6647 for (size_t v = 0; v < ret_var.datalen; v++) {
6648 LDKC2Tuple_u32ScriptZ* ret_conv_21_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
6649 *ret_conv_21_conv = ret_var.data[v];
6650 ret_arr_ptr[v] = ((uint32_t)ret_conv_21_conv);
6657 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
6658 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ clone bytes"), .datalen = orig->datalen };
6659 for (size_t i = 0; i < ret.datalen; i++) {
6660 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
6664 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
6665 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
6666 for (size_t i = 0; i < ret.datalen; i++) {
6667 ret.data[i] = Event_clone(&orig->data[i]);
6671 static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6674 int32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_a"))) TS_C2Tuple_u32TxOutZ_get_a(uint32_t owner) {
6675 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)(owner & ~1);
6676 int32_t ret_conv = C2Tuple_u32TxOutZ_get_a(owner_conv);
6680 static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR owner){
6681 return TxOut_clone(&owner->b);
6683 uint32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_get_b"))) TS_C2Tuple_u32TxOutZ_get_b(uint32_t owner) {
6684 LDKC2Tuple_u32TxOutZ* owner_conv = (LDKC2Tuple_u32TxOutZ*)(owner & ~1);
6685 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6686 *ret_ref = C2Tuple_u32TxOutZ_get_b(owner_conv);
6687 return (uint32_t)ret_ref;
6690 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
6691 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
6692 for (size_t i = 0; i < ret.datalen; i++) {
6693 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
6697 static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6698 return ThirtyTwoBytes_clone(&owner->a);
6700 int8_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint32_t owner) {
6701 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(owner & ~1);
6702 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6703 memcpy(ret_arr->elems, C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(owner_conv).data, 32);
6707 static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR owner){
6708 return CVec_C2Tuple_u32TxOutZZ_clone(&owner->b);
6710 uint32_tArray __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint32_t owner) {
6711 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* owner_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(owner & ~1);
6712 LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(owner_conv);
6713 uint32_tArray ret_arr = NULL;
6714 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
6715 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
6716 for (size_t u = 0; u < ret_var.datalen; u++) {
6717 LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
6718 *ret_conv_20_conv = ret_var.data[u];
6719 ret_arr_ptr[u] = ((uint32_t)ret_conv_20_conv);
6726 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
6727 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * orig->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ clone bytes"), .datalen = orig->datalen };
6728 for (size_t i = 0; i < ret.datalen; i++) {
6729 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
6733 uint32_t __attribute__((export_name("TS_LDKBalance_ty_from_ptr"))) TS_LDKBalance_ty_from_ptr(uint32_t ptr) {
6734 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6736 case LDKBalance_ClaimableOnChannelClose: return 0;
6737 case LDKBalance_ClaimableAwaitingConfirmations: return 1;
6738 case LDKBalance_ContentiousClaimable: return 2;
6739 case LDKBalance_MaybeClaimableHTLCAwaitingTimeout: return 3;
6743 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableOnChannelClose_get_claimable_amount_satoshis(uint32_t ptr) {
6744 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6745 assert(obj->tag == LDKBalance_ClaimableOnChannelClose);
6746 int64_t claimable_amount_satoshis_conv = obj->claimable_on_channel_close.claimable_amount_satoshis;
6747 return claimable_amount_satoshis_conv;
6749 int64_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_claimable_amount_satoshis(uint32_t ptr) {
6750 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6751 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6752 int64_t claimable_amount_satoshis_conv = obj->claimable_awaiting_confirmations.claimable_amount_satoshis;
6753 return claimable_amount_satoshis_conv;
6755 int32_t __attribute__((export_name("TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height"))) TS_LDKBalance_ClaimableAwaitingConfirmations_get_confirmation_height(uint32_t ptr) {
6756 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6757 assert(obj->tag == LDKBalance_ClaimableAwaitingConfirmations);
6758 int32_t confirmation_height_conv = obj->claimable_awaiting_confirmations.confirmation_height;
6759 return confirmation_height_conv;
6761 int64_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis"))) TS_LDKBalance_ContentiousClaimable_get_claimable_amount_satoshis(uint32_t ptr) {
6762 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6763 assert(obj->tag == LDKBalance_ContentiousClaimable);
6764 int64_t claimable_amount_satoshis_conv = obj->contentious_claimable.claimable_amount_satoshis;
6765 return claimable_amount_satoshis_conv;
6767 int32_t __attribute__((export_name("TS_LDKBalance_ContentiousClaimable_get_timeout_height"))) TS_LDKBalance_ContentiousClaimable_get_timeout_height(uint32_t ptr) {
6768 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6769 assert(obj->tag == LDKBalance_ContentiousClaimable);
6770 int32_t timeout_height_conv = obj->contentious_claimable.timeout_height;
6771 return timeout_height_conv;
6773 int64_t __attribute__((export_name("TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis"))) TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_amount_satoshis(uint32_t ptr) {
6774 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6775 assert(obj->tag == LDKBalance_MaybeClaimableHTLCAwaitingTimeout);
6776 int64_t claimable_amount_satoshis_conv = obj->maybe_claimable_htlc_awaiting_timeout.claimable_amount_satoshis;
6777 return claimable_amount_satoshis_conv;
6779 int32_t __attribute__((export_name("TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height"))) TS_LDKBalance_MaybeClaimableHTLCAwaitingTimeout_get_claimable_height(uint32_t ptr) {
6780 LDKBalance *obj = (LDKBalance*)(ptr & ~1);
6781 assert(obj->tag == LDKBalance_MaybeClaimableHTLCAwaitingTimeout);
6782 int32_t claimable_height_conv = obj->maybe_claimable_htlc_awaiting_timeout.claimable_height;
6783 return claimable_height_conv;
6785 static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) {
6786 LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen };
6787 for (size_t i = 0; i < ret.datalen; i++) {
6788 ret.data[i] = Balance_clone(&orig->data[i]);
6792 static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
6793 return ThirtyTwoBytes_clone(&owner->a);
6795 int8_tArray __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_a"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_a(uint32_t owner) {
6796 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(owner & ~1);
6797 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
6798 memcpy(ret_arr->elems, C2Tuple_BlockHashChannelMonitorZ_get_a(owner_conv).data, 32);
6802 static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR owner){
6803 return ChannelMonitor_clone(&owner->b);
6805 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_get_b"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_b(uint32_t owner) {
6806 LDKC2Tuple_BlockHashChannelMonitorZ* owner_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(owner & ~1);
6807 LDKChannelMonitor ret_var = C2Tuple_BlockHashChannelMonitorZ_get_b(owner_conv);
6808 uint32_t ret_ref = 0;
6809 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6810 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6811 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6812 ret_ref = (uintptr_t)ret_var.inner;
6813 if (ret_var.is_owned) {
6819 static inline struct LDKC2Tuple_BlockHashChannelMonitorZ CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6820 CHECK(owner->result_ok);
6821 return C2Tuple_BlockHashChannelMonitorZ_clone(&*owner->contents.result);
6823 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint32_t owner) {
6824 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(owner & ~1);
6825 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
6826 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(owner_conv);
6827 return ((uint32_t)ret_conv);
6830 static inline struct LDKDecodeError CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR owner){
6831 CHECK(!owner->result_ok);
6832 return DecodeError_clone(&*owner->contents.err);
6834 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint32_t owner) {
6835 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* owner_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(owner & ~1);
6836 LDKDecodeError ret_var = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(owner_conv);
6837 uint32_t ret_ref = 0;
6838 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6839 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6840 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6841 ret_ref = (uintptr_t)ret_var.inner;
6842 if (ret_var.is_owned) {
6848 static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6851 int8_tArray __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_a"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint32_t owner) {
6852 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)(owner & ~1);
6853 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
6854 memcpy(ret_arr->elems, C2Tuple_PublicKeyTypeZ_get_a(owner_conv).compressed_form, 33);
6858 static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR owner){
6859 return Type_clone(&owner->b);
6861 uint32_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_get_b"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint32_t owner) {
6862 LDKC2Tuple_PublicKeyTypeZ* owner_conv = (LDKC2Tuple_PublicKeyTypeZ*)(owner & ~1);
6863 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
6864 *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(owner_conv);
6865 return (uint32_t)ret_ret;
6868 static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) {
6869 LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen };
6870 for (size_t i = 0; i < ret.datalen; i++) {
6871 ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]);
6875 uint32_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_ty_from_ptr"))) TS_LDKCOption_NetAddressZ_ty_from_ptr(uint32_t ptr) {
6876 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)(ptr & ~1);
6878 case LDKCOption_NetAddressZ_Some: return 0;
6879 case LDKCOption_NetAddressZ_None: return 1;
6883 uint32_t __attribute__((export_name("TS_LDKCOption_NetAddressZ_Some_get_some"))) TS_LDKCOption_NetAddressZ_Some_get_some(uint32_t ptr) {
6884 LDKCOption_NetAddressZ *obj = (LDKCOption_NetAddressZ*)(ptr & ~1);
6885 assert(obj->tag == LDKCOption_NetAddressZ_Some);
6886 uint32_t some_ref = ((uintptr_t)&obj->some) | 1;
6889 static inline struct LDKCVec_u8Z CResult_CVec_u8ZPeerHandleErrorZ_get_ok(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
6890 CHECK(owner->result_ok);
6891 return CVec_u8Z_clone(&*owner->contents.result);
6893 int8_tArray __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t owner) {
6894 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(owner & ~1);
6895 LDKCVec_u8Z ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_ok(owner_conv);
6896 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
6897 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
6898 CVec_u8Z_free(ret_var);
6902 static inline struct LDKPeerHandleError CResult_CVec_u8ZPeerHandleErrorZ_get_err(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR owner){
6903 CHECK(!owner->result_ok);
6904 return PeerHandleError_clone(&*owner->contents.err);
6906 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_get_err(uint32_t owner) {
6907 LDKCResult_CVec_u8ZPeerHandleErrorZ* owner_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(owner & ~1);
6908 LDKPeerHandleError ret_var = CResult_CVec_u8ZPeerHandleErrorZ_get_err(owner_conv);
6909 uint32_t ret_ref = 0;
6910 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6911 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6912 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6913 ret_ref = (uintptr_t)ret_var.inner;
6914 if (ret_var.is_owned) {
6920 static inline void CResult_NonePeerHandleErrorZ_get_ok(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
6921 CHECK(owner->result_ok);
6922 return *owner->contents.result;
6924 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_ok"))) TS_CResult_NonePeerHandleErrorZ_get_ok(uint32_t owner) {
6925 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)(owner & ~1);
6926 CResult_NonePeerHandleErrorZ_get_ok(owner_conv);
6929 static inline struct LDKPeerHandleError CResult_NonePeerHandleErrorZ_get_err(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR owner){
6930 CHECK(!owner->result_ok);
6931 return PeerHandleError_clone(&*owner->contents.err);
6933 uint32_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_get_err"))) TS_CResult_NonePeerHandleErrorZ_get_err(uint32_t owner) {
6934 LDKCResult_NonePeerHandleErrorZ* owner_conv = (LDKCResult_NonePeerHandleErrorZ*)(owner & ~1);
6935 LDKPeerHandleError ret_var = CResult_NonePeerHandleErrorZ_get_err(owner_conv);
6936 uint32_t ret_ref = 0;
6937 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6938 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6939 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6940 ret_ref = (uintptr_t)ret_var.inner;
6941 if (ret_var.is_owned) {
6947 static inline bool CResult_boolPeerHandleErrorZ_get_ok(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
6948 CHECK(owner->result_ok);
6949 return *owner->contents.result;
6951 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_ok"))) TS_CResult_boolPeerHandleErrorZ_get_ok(uint32_t owner) {
6952 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)(owner & ~1);
6953 jboolean ret_conv = CResult_boolPeerHandleErrorZ_get_ok(owner_conv);
6957 static inline struct LDKPeerHandleError CResult_boolPeerHandleErrorZ_get_err(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR owner){
6958 CHECK(!owner->result_ok);
6959 return PeerHandleError_clone(&*owner->contents.err);
6961 uint32_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_get_err"))) TS_CResult_boolPeerHandleErrorZ_get_err(uint32_t owner) {
6962 LDKCResult_boolPeerHandleErrorZ* owner_conv = (LDKCResult_boolPeerHandleErrorZ*)(owner & ~1);
6963 LDKPeerHandleError ret_var = CResult_boolPeerHandleErrorZ_get_err(owner_conv);
6964 uint32_t ret_ref = 0;
6965 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6966 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6967 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
6968 ret_ref = (uintptr_t)ret_var.inner;
6969 if (ret_var.is_owned) {
6975 static inline void CResult_NoneErrorZ_get_ok(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
6976 CHECK(owner->result_ok);
6977 return *owner->contents.result;
6979 void __attribute__((export_name("TS_CResult_NoneErrorZ_get_ok"))) TS_CResult_NoneErrorZ_get_ok(uint32_t owner) {
6980 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)(owner & ~1);
6981 CResult_NoneErrorZ_get_ok(owner_conv);
6984 static inline enum LDKIOError CResult_NoneErrorZ_get_err(LDKCResult_NoneErrorZ *NONNULL_PTR owner){
6985 CHECK(!owner->result_ok);
6986 return *owner->contents.err;
6988 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_get_err"))) TS_CResult_NoneErrorZ_get_err(uint32_t owner) {
6989 LDKCResult_NoneErrorZ* owner_conv = (LDKCResult_NoneErrorZ*)(owner & ~1);
6990 uint32_t ret_conv = LDKIOError_to_js(CResult_NoneErrorZ_get_err(owner_conv));
6994 static inline struct LDKNetAddress CResult_NetAddressDecodeErrorZ_get_ok(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
6995 CHECK(owner->result_ok);
6996 return NetAddress_clone(&*owner->contents.result);
6998 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_ok"))) TS_CResult_NetAddressDecodeErrorZ_get_ok(uint32_t owner) {
6999 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)(owner & ~1);
7000 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
7001 *ret_copy = CResult_NetAddressDecodeErrorZ_get_ok(owner_conv);
7002 uint32_t ret_ref = (uintptr_t)ret_copy;
7006 static inline struct LDKDecodeError CResult_NetAddressDecodeErrorZ_get_err(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR owner){
7007 CHECK(!owner->result_ok);
7008 return DecodeError_clone(&*owner->contents.err);
7010 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_get_err"))) TS_CResult_NetAddressDecodeErrorZ_get_err(uint32_t owner) {
7011 LDKCResult_NetAddressDecodeErrorZ* owner_conv = (LDKCResult_NetAddressDecodeErrorZ*)(owner & ~1);
7012 LDKDecodeError ret_var = CResult_NetAddressDecodeErrorZ_get_err(owner_conv);
7013 uint32_t ret_ref = 0;
7014 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7015 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7016 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7017 ret_ref = (uintptr_t)ret_var.inner;
7018 if (ret_var.is_owned) {
7024 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
7025 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
7026 for (size_t i = 0; i < ret.datalen; i++) {
7027 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
7031 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
7032 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
7033 for (size_t i = 0; i < ret.datalen; i++) {
7034 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
7038 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
7039 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
7040 for (size_t i = 0; i < ret.datalen; i++) {
7041 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
7045 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
7046 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
7047 for (size_t i = 0; i < ret.datalen; i++) {
7048 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
7052 static inline struct LDKAcceptChannel CResult_AcceptChannelDecodeErrorZ_get_ok(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7053 CHECK(owner->result_ok);
7054 return AcceptChannel_clone(&*owner->contents.result);
7056 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_get_ok(uint32_t owner) {
7057 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(owner & ~1);
7058 LDKAcceptChannel ret_var = CResult_AcceptChannelDecodeErrorZ_get_ok(owner_conv);
7059 uint32_t ret_ref = 0;
7060 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7061 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7062 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7063 ret_ref = (uintptr_t)ret_var.inner;
7064 if (ret_var.is_owned) {
7070 static inline struct LDKDecodeError CResult_AcceptChannelDecodeErrorZ_get_err(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR owner){
7071 CHECK(!owner->result_ok);
7072 return DecodeError_clone(&*owner->contents.err);
7074 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_get_err"))) TS_CResult_AcceptChannelDecodeErrorZ_get_err(uint32_t owner) {
7075 LDKCResult_AcceptChannelDecodeErrorZ* owner_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(owner & ~1);
7076 LDKDecodeError ret_var = CResult_AcceptChannelDecodeErrorZ_get_err(owner_conv);
7077 uint32_t ret_ref = 0;
7078 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7079 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7080 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7081 ret_ref = (uintptr_t)ret_var.inner;
7082 if (ret_var.is_owned) {
7088 static inline struct LDKAnnouncementSignatures CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7089 CHECK(owner->result_ok);
7090 return AnnouncementSignatures_clone(&*owner->contents.result);
7092 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint32_t owner) {
7093 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(owner & ~1);
7094 LDKAnnouncementSignatures ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_ok(owner_conv);
7095 uint32_t ret_ref = 0;
7096 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7097 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7098 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7099 ret_ref = (uintptr_t)ret_var.inner;
7100 if (ret_var.is_owned) {
7106 static inline struct LDKDecodeError CResult_AnnouncementSignaturesDecodeErrorZ_get_err(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR owner){
7107 CHECK(!owner->result_ok);
7108 return DecodeError_clone(&*owner->contents.err);
7110 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint32_t owner) {
7111 LDKCResult_AnnouncementSignaturesDecodeErrorZ* owner_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(owner & ~1);
7112 LDKDecodeError ret_var = CResult_AnnouncementSignaturesDecodeErrorZ_get_err(owner_conv);
7113 uint32_t ret_ref = 0;
7114 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7115 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7116 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7117 ret_ref = (uintptr_t)ret_var.inner;
7118 if (ret_var.is_owned) {
7124 static inline struct LDKChannelReestablish CResult_ChannelReestablishDecodeErrorZ_get_ok(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7125 CHECK(owner->result_ok);
7126 return ChannelReestablish_clone(&*owner->contents.result);
7128 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_ok(uint32_t owner) {
7129 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(owner & ~1);
7130 LDKChannelReestablish ret_var = CResult_ChannelReestablishDecodeErrorZ_get_ok(owner_conv);
7131 uint32_t ret_ref = 0;
7132 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7133 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7134 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7135 ret_ref = (uintptr_t)ret_var.inner;
7136 if (ret_var.is_owned) {
7142 static inline struct LDKDecodeError CResult_ChannelReestablishDecodeErrorZ_get_err(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR owner){
7143 CHECK(!owner->result_ok);
7144 return DecodeError_clone(&*owner->contents.err);
7146 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_get_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_get_err(uint32_t owner) {
7147 LDKCResult_ChannelReestablishDecodeErrorZ* owner_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(owner & ~1);
7148 LDKDecodeError ret_var = CResult_ChannelReestablishDecodeErrorZ_get_err(owner_conv);
7149 uint32_t ret_ref = 0;
7150 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7151 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7153 ret_ref = (uintptr_t)ret_var.inner;
7154 if (ret_var.is_owned) {
7160 static inline struct LDKClosingSigned CResult_ClosingSignedDecodeErrorZ_get_ok(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7161 CHECK(owner->result_ok);
7162 return ClosingSigned_clone(&*owner->contents.result);
7164 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_get_ok(uint32_t owner) {
7165 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(owner & ~1);
7166 LDKClosingSigned ret_var = CResult_ClosingSignedDecodeErrorZ_get_ok(owner_conv);
7167 uint32_t ret_ref = 0;
7168 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7169 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7170 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7171 ret_ref = (uintptr_t)ret_var.inner;
7172 if (ret_var.is_owned) {
7178 static inline struct LDKDecodeError CResult_ClosingSignedDecodeErrorZ_get_err(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR owner){
7179 CHECK(!owner->result_ok);
7180 return DecodeError_clone(&*owner->contents.err);
7182 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedDecodeErrorZ_get_err(uint32_t owner) {
7183 LDKCResult_ClosingSignedDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(owner & ~1);
7184 LDKDecodeError ret_var = CResult_ClosingSignedDecodeErrorZ_get_err(owner_conv);
7185 uint32_t ret_ref = 0;
7186 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7187 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7188 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7189 ret_ref = (uintptr_t)ret_var.inner;
7190 if (ret_var.is_owned) {
7196 static inline struct LDKClosingSignedFeeRange CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7197 CHECK(owner->result_ok);
7198 return ClosingSignedFeeRange_clone(&*owner->contents.result);
7200 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(uint32_t owner) {
7201 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(owner & ~1);
7202 LDKClosingSignedFeeRange ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_ok(owner_conv);
7203 uint32_t ret_ref = 0;
7204 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7205 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7206 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7207 ret_ref = (uintptr_t)ret_var.inner;
7208 if (ret_var.is_owned) {
7214 static inline struct LDKDecodeError CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR owner){
7215 CHECK(!owner->result_ok);
7216 return DecodeError_clone(&*owner->contents.err);
7218 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(uint32_t owner) {
7219 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* owner_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(owner & ~1);
7220 LDKDecodeError ret_var = CResult_ClosingSignedFeeRangeDecodeErrorZ_get_err(owner_conv);
7221 uint32_t ret_ref = 0;
7222 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7223 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7224 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7225 ret_ref = (uintptr_t)ret_var.inner;
7226 if (ret_var.is_owned) {
7232 static inline struct LDKCommitmentSigned CResult_CommitmentSignedDecodeErrorZ_get_ok(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7233 CHECK(owner->result_ok);
7234 return CommitmentSigned_clone(&*owner->contents.result);
7236 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_ok(uint32_t owner) {
7237 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(owner & ~1);
7238 LDKCommitmentSigned ret_var = CResult_CommitmentSignedDecodeErrorZ_get_ok(owner_conv);
7239 uint32_t ret_ref = 0;
7240 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7241 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7242 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7243 ret_ref = (uintptr_t)ret_var.inner;
7244 if (ret_var.is_owned) {
7250 static inline struct LDKDecodeError CResult_CommitmentSignedDecodeErrorZ_get_err(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR owner){
7251 CHECK(!owner->result_ok);
7252 return DecodeError_clone(&*owner->contents.err);
7254 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_get_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_get_err(uint32_t owner) {
7255 LDKCResult_CommitmentSignedDecodeErrorZ* owner_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(owner & ~1);
7256 LDKDecodeError ret_var = CResult_CommitmentSignedDecodeErrorZ_get_err(owner_conv);
7257 uint32_t ret_ref = 0;
7258 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7259 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7260 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7261 ret_ref = (uintptr_t)ret_var.inner;
7262 if (ret_var.is_owned) {
7268 static inline struct LDKFundingCreated CResult_FundingCreatedDecodeErrorZ_get_ok(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7269 CHECK(owner->result_ok);
7270 return FundingCreated_clone(&*owner->contents.result);
7272 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_get_ok(uint32_t owner) {
7273 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(owner & ~1);
7274 LDKFundingCreated ret_var = CResult_FundingCreatedDecodeErrorZ_get_ok(owner_conv);
7275 uint32_t ret_ref = 0;
7276 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7277 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7279 ret_ref = (uintptr_t)ret_var.inner;
7280 if (ret_var.is_owned) {
7286 static inline struct LDKDecodeError CResult_FundingCreatedDecodeErrorZ_get_err(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR owner){
7287 CHECK(!owner->result_ok);
7288 return DecodeError_clone(&*owner->contents.err);
7290 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_get_err"))) TS_CResult_FundingCreatedDecodeErrorZ_get_err(uint32_t owner) {
7291 LDKCResult_FundingCreatedDecodeErrorZ* owner_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(owner & ~1);
7292 LDKDecodeError ret_var = CResult_FundingCreatedDecodeErrorZ_get_err(owner_conv);
7293 uint32_t ret_ref = 0;
7294 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7295 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7296 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7297 ret_ref = (uintptr_t)ret_var.inner;
7298 if (ret_var.is_owned) {
7304 static inline struct LDKFundingSigned CResult_FundingSignedDecodeErrorZ_get_ok(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7305 CHECK(owner->result_ok);
7306 return FundingSigned_clone(&*owner->contents.result);
7308 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_ok"))) TS_CResult_FundingSignedDecodeErrorZ_get_ok(uint32_t owner) {
7309 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(owner & ~1);
7310 LDKFundingSigned ret_var = CResult_FundingSignedDecodeErrorZ_get_ok(owner_conv);
7311 uint32_t ret_ref = 0;
7312 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7313 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7314 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7315 ret_ref = (uintptr_t)ret_var.inner;
7316 if (ret_var.is_owned) {
7322 static inline struct LDKDecodeError CResult_FundingSignedDecodeErrorZ_get_err(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR owner){
7323 CHECK(!owner->result_ok);
7324 return DecodeError_clone(&*owner->contents.err);
7326 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_get_err"))) TS_CResult_FundingSignedDecodeErrorZ_get_err(uint32_t owner) {
7327 LDKCResult_FundingSignedDecodeErrorZ* owner_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(owner & ~1);
7328 LDKDecodeError ret_var = CResult_FundingSignedDecodeErrorZ_get_err(owner_conv);
7329 uint32_t ret_ref = 0;
7330 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7331 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7332 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7333 ret_ref = (uintptr_t)ret_var.inner;
7334 if (ret_var.is_owned) {
7340 static inline struct LDKChannelReady CResult_ChannelReadyDecodeErrorZ_get_ok(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7341 CHECK(owner->result_ok);
7342 return ChannelReady_clone(&*owner->contents.result);
7344 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_get_ok(uint32_t owner) {
7345 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)(owner & ~1);
7346 LDKChannelReady ret_var = CResult_ChannelReadyDecodeErrorZ_get_ok(owner_conv);
7347 uint32_t ret_ref = 0;
7348 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7349 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7350 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7351 ret_ref = (uintptr_t)ret_var.inner;
7352 if (ret_var.is_owned) {
7358 static inline struct LDKDecodeError CResult_ChannelReadyDecodeErrorZ_get_err(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR owner){
7359 CHECK(!owner->result_ok);
7360 return DecodeError_clone(&*owner->contents.err);
7362 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_get_err"))) TS_CResult_ChannelReadyDecodeErrorZ_get_err(uint32_t owner) {
7363 LDKCResult_ChannelReadyDecodeErrorZ* owner_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)(owner & ~1);
7364 LDKDecodeError ret_var = CResult_ChannelReadyDecodeErrorZ_get_err(owner_conv);
7365 uint32_t ret_ref = 0;
7366 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7367 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7368 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7369 ret_ref = (uintptr_t)ret_var.inner;
7370 if (ret_var.is_owned) {
7376 static inline struct LDKInit CResult_InitDecodeErrorZ_get_ok(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7377 CHECK(owner->result_ok);
7378 return Init_clone(&*owner->contents.result);
7380 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_ok"))) TS_CResult_InitDecodeErrorZ_get_ok(uint32_t owner) {
7381 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)(owner & ~1);
7382 LDKInit ret_var = CResult_InitDecodeErrorZ_get_ok(owner_conv);
7383 uint32_t ret_ref = 0;
7384 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7385 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7386 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7387 ret_ref = (uintptr_t)ret_var.inner;
7388 if (ret_var.is_owned) {
7394 static inline struct LDKDecodeError CResult_InitDecodeErrorZ_get_err(LDKCResult_InitDecodeErrorZ *NONNULL_PTR owner){
7395 CHECK(!owner->result_ok);
7396 return DecodeError_clone(&*owner->contents.err);
7398 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_get_err"))) TS_CResult_InitDecodeErrorZ_get_err(uint32_t owner) {
7399 LDKCResult_InitDecodeErrorZ* owner_conv = (LDKCResult_InitDecodeErrorZ*)(owner & ~1);
7400 LDKDecodeError ret_var = CResult_InitDecodeErrorZ_get_err(owner_conv);
7401 uint32_t ret_ref = 0;
7402 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7403 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7404 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7405 ret_ref = (uintptr_t)ret_var.inner;
7406 if (ret_var.is_owned) {
7412 static inline struct LDKOpenChannel CResult_OpenChannelDecodeErrorZ_get_ok(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7413 CHECK(owner->result_ok);
7414 return OpenChannel_clone(&*owner->contents.result);
7416 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_ok"))) TS_CResult_OpenChannelDecodeErrorZ_get_ok(uint32_t owner) {
7417 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(owner & ~1);
7418 LDKOpenChannel ret_var = CResult_OpenChannelDecodeErrorZ_get_ok(owner_conv);
7419 uint32_t ret_ref = 0;
7420 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7421 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7422 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7423 ret_ref = (uintptr_t)ret_var.inner;
7424 if (ret_var.is_owned) {
7430 static inline struct LDKDecodeError CResult_OpenChannelDecodeErrorZ_get_err(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR owner){
7431 CHECK(!owner->result_ok);
7432 return DecodeError_clone(&*owner->contents.err);
7434 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_get_err"))) TS_CResult_OpenChannelDecodeErrorZ_get_err(uint32_t owner) {
7435 LDKCResult_OpenChannelDecodeErrorZ* owner_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(owner & ~1);
7436 LDKDecodeError ret_var = CResult_OpenChannelDecodeErrorZ_get_err(owner_conv);
7437 uint32_t ret_ref = 0;
7438 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7439 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7441 ret_ref = (uintptr_t)ret_var.inner;
7442 if (ret_var.is_owned) {
7448 static inline struct LDKRevokeAndACK CResult_RevokeAndACKDecodeErrorZ_get_ok(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7449 CHECK(owner->result_ok);
7450 return RevokeAndACK_clone(&*owner->contents.result);
7452 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_ok(uint32_t owner) {
7453 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(owner & ~1);
7454 LDKRevokeAndACK ret_var = CResult_RevokeAndACKDecodeErrorZ_get_ok(owner_conv);
7455 uint32_t ret_ref = 0;
7456 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7457 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7458 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7459 ret_ref = (uintptr_t)ret_var.inner;
7460 if (ret_var.is_owned) {
7466 static inline struct LDKDecodeError CResult_RevokeAndACKDecodeErrorZ_get_err(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR owner){
7467 CHECK(!owner->result_ok);
7468 return DecodeError_clone(&*owner->contents.err);
7470 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_get_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_get_err(uint32_t owner) {
7471 LDKCResult_RevokeAndACKDecodeErrorZ* owner_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(owner & ~1);
7472 LDKDecodeError ret_var = CResult_RevokeAndACKDecodeErrorZ_get_err(owner_conv);
7473 uint32_t ret_ref = 0;
7474 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7475 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7476 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7477 ret_ref = (uintptr_t)ret_var.inner;
7478 if (ret_var.is_owned) {
7484 static inline struct LDKShutdown CResult_ShutdownDecodeErrorZ_get_ok(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7485 CHECK(owner->result_ok);
7486 return Shutdown_clone(&*owner->contents.result);
7488 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_ok"))) TS_CResult_ShutdownDecodeErrorZ_get_ok(uint32_t owner) {
7489 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)(owner & ~1);
7490 LDKShutdown ret_var = CResult_ShutdownDecodeErrorZ_get_ok(owner_conv);
7491 uint32_t ret_ref = 0;
7492 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7493 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7494 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7495 ret_ref = (uintptr_t)ret_var.inner;
7496 if (ret_var.is_owned) {
7502 static inline struct LDKDecodeError CResult_ShutdownDecodeErrorZ_get_err(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR owner){
7503 CHECK(!owner->result_ok);
7504 return DecodeError_clone(&*owner->contents.err);
7506 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_get_err"))) TS_CResult_ShutdownDecodeErrorZ_get_err(uint32_t owner) {
7507 LDKCResult_ShutdownDecodeErrorZ* owner_conv = (LDKCResult_ShutdownDecodeErrorZ*)(owner & ~1);
7508 LDKDecodeError ret_var = CResult_ShutdownDecodeErrorZ_get_err(owner_conv);
7509 uint32_t ret_ref = 0;
7510 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7511 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7512 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7513 ret_ref = (uintptr_t)ret_var.inner;
7514 if (ret_var.is_owned) {
7520 static inline struct LDKUpdateFailHTLC CResult_UpdateFailHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7521 CHECK(owner->result_ok);
7522 return UpdateFailHTLC_clone(&*owner->contents.result);
7524 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint32_t owner) {
7525 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(owner & ~1);
7526 LDKUpdateFailHTLC ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_ok(owner_conv);
7527 uint32_t ret_ref = 0;
7528 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7529 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7531 ret_ref = (uintptr_t)ret_var.inner;
7532 if (ret_var.is_owned) {
7538 static inline struct LDKDecodeError CResult_UpdateFailHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR owner){
7539 CHECK(!owner->result_ok);
7540 return DecodeError_clone(&*owner->contents.err);
7542 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_get_err(uint32_t owner) {
7543 LDKCResult_UpdateFailHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(owner & ~1);
7544 LDKDecodeError ret_var = CResult_UpdateFailHTLCDecodeErrorZ_get_err(owner_conv);
7545 uint32_t ret_ref = 0;
7546 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7547 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7548 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7549 ret_ref = (uintptr_t)ret_var.inner;
7550 if (ret_var.is_owned) {
7556 static inline struct LDKUpdateFailMalformedHTLC CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7557 CHECK(owner->result_ok);
7558 return UpdateFailMalformedHTLC_clone(&*owner->contents.result);
7560 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint32_t owner) {
7561 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(owner & ~1);
7562 LDKUpdateFailMalformedHTLC ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(owner_conv);
7563 uint32_t ret_ref = 0;
7564 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7565 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7566 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7567 ret_ref = (uintptr_t)ret_var.inner;
7568 if (ret_var.is_owned) {
7574 static inline struct LDKDecodeError CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR owner){
7575 CHECK(!owner->result_ok);
7576 return DecodeError_clone(&*owner->contents.err);
7578 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint32_t owner) {
7579 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(owner & ~1);
7580 LDKDecodeError ret_var = CResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(owner_conv);
7581 uint32_t ret_ref = 0;
7582 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7583 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7584 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7585 ret_ref = (uintptr_t)ret_var.inner;
7586 if (ret_var.is_owned) {
7592 static inline struct LDKUpdateFee CResult_UpdateFeeDecodeErrorZ_get_ok(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7593 CHECK(owner->result_ok);
7594 return UpdateFee_clone(&*owner->contents.result);
7596 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_get_ok(uint32_t owner) {
7597 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(owner & ~1);
7598 LDKUpdateFee ret_var = CResult_UpdateFeeDecodeErrorZ_get_ok(owner_conv);
7599 uint32_t ret_ref = 0;
7600 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7601 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7602 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7603 ret_ref = (uintptr_t)ret_var.inner;
7604 if (ret_var.is_owned) {
7610 static inline struct LDKDecodeError CResult_UpdateFeeDecodeErrorZ_get_err(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR owner){
7611 CHECK(!owner->result_ok);
7612 return DecodeError_clone(&*owner->contents.err);
7614 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_get_err"))) TS_CResult_UpdateFeeDecodeErrorZ_get_err(uint32_t owner) {
7615 LDKCResult_UpdateFeeDecodeErrorZ* owner_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(owner & ~1);
7616 LDKDecodeError ret_var = CResult_UpdateFeeDecodeErrorZ_get_err(owner_conv);
7617 uint32_t ret_ref = 0;
7618 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7619 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7621 ret_ref = (uintptr_t)ret_var.inner;
7622 if (ret_var.is_owned) {
7628 static inline struct LDKUpdateFulfillHTLC CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
7629 CHECK(owner->result_ok);
7630 return UpdateFulfillHTLC_clone(&*owner->contents.result);
7632 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint32_t owner) {
7633 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(owner & ~1);
7634 LDKUpdateFulfillHTLC ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(owner_conv);
7635 uint32_t ret_ref = 0;
7636 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7637 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7638 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7639 ret_ref = (uintptr_t)ret_var.inner;
7640 if (ret_var.is_owned) {
7646 static inline struct LDKDecodeError CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR owner){
7647 CHECK(!owner->result_ok);
7648 return DecodeError_clone(&*owner->contents.err);
7650 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint32_t owner) {
7651 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(owner & ~1);
7652 LDKDecodeError ret_var = CResult_UpdateFulfillHTLCDecodeErrorZ_get_err(owner_conv);
7653 uint32_t ret_ref = 0;
7654 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7655 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7657 ret_ref = (uintptr_t)ret_var.inner;
7658 if (ret_var.is_owned) {
7664 static inline struct LDKUpdateAddHTLC CResult_UpdateAddHTLCDecodeErrorZ_get_ok(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
7665 CHECK(owner->result_ok);
7666 return UpdateAddHTLC_clone(&*owner->contents.result);
7668 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint32_t owner) {
7669 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(owner & ~1);
7670 LDKUpdateAddHTLC ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_ok(owner_conv);
7671 uint32_t ret_ref = 0;
7672 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7673 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7675 ret_ref = (uintptr_t)ret_var.inner;
7676 if (ret_var.is_owned) {
7682 static inline struct LDKDecodeError CResult_UpdateAddHTLCDecodeErrorZ_get_err(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR owner){
7683 CHECK(!owner->result_ok);
7684 return DecodeError_clone(&*owner->contents.err);
7686 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_get_err(uint32_t owner) {
7687 LDKCResult_UpdateAddHTLCDecodeErrorZ* owner_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(owner & ~1);
7688 LDKDecodeError ret_var = CResult_UpdateAddHTLCDecodeErrorZ_get_err(owner_conv);
7689 uint32_t ret_ref = 0;
7690 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7691 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7692 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7693 ret_ref = (uintptr_t)ret_var.inner;
7694 if (ret_var.is_owned) {
7700 static inline struct LDKPing CResult_PingDecodeErrorZ_get_ok(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
7701 CHECK(owner->result_ok);
7702 return Ping_clone(&*owner->contents.result);
7704 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_ok"))) TS_CResult_PingDecodeErrorZ_get_ok(uint32_t owner) {
7705 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)(owner & ~1);
7706 LDKPing ret_var = CResult_PingDecodeErrorZ_get_ok(owner_conv);
7707 uint32_t ret_ref = 0;
7708 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7709 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7710 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7711 ret_ref = (uintptr_t)ret_var.inner;
7712 if (ret_var.is_owned) {
7718 static inline struct LDKDecodeError CResult_PingDecodeErrorZ_get_err(LDKCResult_PingDecodeErrorZ *NONNULL_PTR owner){
7719 CHECK(!owner->result_ok);
7720 return DecodeError_clone(&*owner->contents.err);
7722 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_get_err"))) TS_CResult_PingDecodeErrorZ_get_err(uint32_t owner) {
7723 LDKCResult_PingDecodeErrorZ* owner_conv = (LDKCResult_PingDecodeErrorZ*)(owner & ~1);
7724 LDKDecodeError ret_var = CResult_PingDecodeErrorZ_get_err(owner_conv);
7725 uint32_t ret_ref = 0;
7726 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7727 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7728 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7729 ret_ref = (uintptr_t)ret_var.inner;
7730 if (ret_var.is_owned) {
7736 static inline struct LDKPong CResult_PongDecodeErrorZ_get_ok(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
7737 CHECK(owner->result_ok);
7738 return Pong_clone(&*owner->contents.result);
7740 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_ok"))) TS_CResult_PongDecodeErrorZ_get_ok(uint32_t owner) {
7741 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)(owner & ~1);
7742 LDKPong ret_var = CResult_PongDecodeErrorZ_get_ok(owner_conv);
7743 uint32_t ret_ref = 0;
7744 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7745 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7746 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7747 ret_ref = (uintptr_t)ret_var.inner;
7748 if (ret_var.is_owned) {
7754 static inline struct LDKDecodeError CResult_PongDecodeErrorZ_get_err(LDKCResult_PongDecodeErrorZ *NONNULL_PTR owner){
7755 CHECK(!owner->result_ok);
7756 return DecodeError_clone(&*owner->contents.err);
7758 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_get_err"))) TS_CResult_PongDecodeErrorZ_get_err(uint32_t owner) {
7759 LDKCResult_PongDecodeErrorZ* owner_conv = (LDKCResult_PongDecodeErrorZ*)(owner & ~1);
7760 LDKDecodeError ret_var = CResult_PongDecodeErrorZ_get_err(owner_conv);
7761 uint32_t ret_ref = 0;
7762 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7763 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7765 ret_ref = (uintptr_t)ret_var.inner;
7766 if (ret_var.is_owned) {
7772 static inline struct LDKUnsignedChannelAnnouncement CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7773 CHECK(owner->result_ok);
7774 return UnsignedChannelAnnouncement_clone(&*owner->contents.result);
7776 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint32_t owner) {
7777 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(owner & ~1);
7778 LDKUnsignedChannelAnnouncement ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
7779 uint32_t ret_ref = 0;
7780 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7781 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7782 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7783 ret_ref = (uintptr_t)ret_var.inner;
7784 if (ret_var.is_owned) {
7790 static inline struct LDKDecodeError CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7791 CHECK(!owner->result_ok);
7792 return DecodeError_clone(&*owner->contents.err);
7794 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint32_t owner) {
7795 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(owner & ~1);
7796 LDKDecodeError ret_var = CResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
7797 uint32_t ret_ref = 0;
7798 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7799 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7800 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7801 ret_ref = (uintptr_t)ret_var.inner;
7802 if (ret_var.is_owned) {
7808 static inline struct LDKChannelAnnouncement CResult_ChannelAnnouncementDecodeErrorZ_get_ok(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7809 CHECK(owner->result_ok);
7810 return ChannelAnnouncement_clone(&*owner->contents.result);
7812 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint32_t owner) {
7813 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(owner & ~1);
7814 LDKChannelAnnouncement ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_ok(owner_conv);
7815 uint32_t ret_ref = 0;
7816 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7817 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7819 ret_ref = (uintptr_t)ret_var.inner;
7820 if (ret_var.is_owned) {
7826 static inline struct LDKDecodeError CResult_ChannelAnnouncementDecodeErrorZ_get_err(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7827 CHECK(!owner->result_ok);
7828 return DecodeError_clone(&*owner->contents.err);
7830 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_get_err(uint32_t owner) {
7831 LDKCResult_ChannelAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(owner & ~1);
7832 LDKDecodeError ret_var = CResult_ChannelAnnouncementDecodeErrorZ_get_err(owner_conv);
7833 uint32_t ret_ref = 0;
7834 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7835 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7836 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7837 ret_ref = (uintptr_t)ret_var.inner;
7838 if (ret_var.is_owned) {
7844 static inline struct LDKUnsignedChannelUpdate CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7845 CHECK(owner->result_ok);
7846 return UnsignedChannelUpdate_clone(&*owner->contents.result);
7848 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint32_t owner) {
7849 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(owner & ~1);
7850 LDKUnsignedChannelUpdate ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(owner_conv);
7851 uint32_t ret_ref = 0;
7852 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7853 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7854 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7855 ret_ref = (uintptr_t)ret_var.inner;
7856 if (ret_var.is_owned) {
7862 static inline struct LDKDecodeError CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7863 CHECK(!owner->result_ok);
7864 return DecodeError_clone(&*owner->contents.err);
7866 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint32_t owner) {
7867 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(owner & ~1);
7868 LDKDecodeError ret_var = CResult_UnsignedChannelUpdateDecodeErrorZ_get_err(owner_conv);
7869 uint32_t ret_ref = 0;
7870 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7871 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7872 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7873 ret_ref = (uintptr_t)ret_var.inner;
7874 if (ret_var.is_owned) {
7880 static inline struct LDKChannelUpdate CResult_ChannelUpdateDecodeErrorZ_get_ok(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7881 CHECK(owner->result_ok);
7882 return ChannelUpdate_clone(&*owner->contents.result);
7884 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_ok(uint32_t owner) {
7885 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(owner & ~1);
7886 LDKChannelUpdate ret_var = CResult_ChannelUpdateDecodeErrorZ_get_ok(owner_conv);
7887 uint32_t ret_ref = 0;
7888 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7889 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7890 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7891 ret_ref = (uintptr_t)ret_var.inner;
7892 if (ret_var.is_owned) {
7898 static inline struct LDKDecodeError CResult_ChannelUpdateDecodeErrorZ_get_err(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR owner){
7899 CHECK(!owner->result_ok);
7900 return DecodeError_clone(&*owner->contents.err);
7902 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_get_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_get_err(uint32_t owner) {
7903 LDKCResult_ChannelUpdateDecodeErrorZ* owner_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(owner & ~1);
7904 LDKDecodeError ret_var = CResult_ChannelUpdateDecodeErrorZ_get_err(owner_conv);
7905 uint32_t ret_ref = 0;
7906 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7907 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7908 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7909 ret_ref = (uintptr_t)ret_var.inner;
7910 if (ret_var.is_owned) {
7916 static inline struct LDKErrorMessage CResult_ErrorMessageDecodeErrorZ_get_ok(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
7917 CHECK(owner->result_ok);
7918 return ErrorMessage_clone(&*owner->contents.result);
7920 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_get_ok(uint32_t owner) {
7921 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(owner & ~1);
7922 LDKErrorMessage ret_var = CResult_ErrorMessageDecodeErrorZ_get_ok(owner_conv);
7923 uint32_t ret_ref = 0;
7924 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7925 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7926 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7927 ret_ref = (uintptr_t)ret_var.inner;
7928 if (ret_var.is_owned) {
7934 static inline struct LDKDecodeError CResult_ErrorMessageDecodeErrorZ_get_err(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR owner){
7935 CHECK(!owner->result_ok);
7936 return DecodeError_clone(&*owner->contents.err);
7938 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_get_err"))) TS_CResult_ErrorMessageDecodeErrorZ_get_err(uint32_t owner) {
7939 LDKCResult_ErrorMessageDecodeErrorZ* owner_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(owner & ~1);
7940 LDKDecodeError ret_var = CResult_ErrorMessageDecodeErrorZ_get_err(owner_conv);
7941 uint32_t ret_ref = 0;
7942 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7943 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7944 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7945 ret_ref = (uintptr_t)ret_var.inner;
7946 if (ret_var.is_owned) {
7952 static inline struct LDKWarningMessage CResult_WarningMessageDecodeErrorZ_get_ok(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
7953 CHECK(owner->result_ok);
7954 return WarningMessage_clone(&*owner->contents.result);
7956 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_ok"))) TS_CResult_WarningMessageDecodeErrorZ_get_ok(uint32_t owner) {
7957 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)(owner & ~1);
7958 LDKWarningMessage ret_var = CResult_WarningMessageDecodeErrorZ_get_ok(owner_conv);
7959 uint32_t ret_ref = 0;
7960 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7961 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7963 ret_ref = (uintptr_t)ret_var.inner;
7964 if (ret_var.is_owned) {
7970 static inline struct LDKDecodeError CResult_WarningMessageDecodeErrorZ_get_err(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR owner){
7971 CHECK(!owner->result_ok);
7972 return DecodeError_clone(&*owner->contents.err);
7974 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_get_err"))) TS_CResult_WarningMessageDecodeErrorZ_get_err(uint32_t owner) {
7975 LDKCResult_WarningMessageDecodeErrorZ* owner_conv = (LDKCResult_WarningMessageDecodeErrorZ*)(owner & ~1);
7976 LDKDecodeError ret_var = CResult_WarningMessageDecodeErrorZ_get_err(owner_conv);
7977 uint32_t ret_ref = 0;
7978 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7979 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7980 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7981 ret_ref = (uintptr_t)ret_var.inner;
7982 if (ret_var.is_owned) {
7988 static inline struct LDKUnsignedNodeAnnouncement CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
7989 CHECK(owner->result_ok);
7990 return UnsignedNodeAnnouncement_clone(&*owner->contents.result);
7992 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint32_t owner) {
7993 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(owner & ~1);
7994 LDKUnsignedNodeAnnouncement ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
7995 uint32_t ret_ref = 0;
7996 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
7997 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
7998 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
7999 ret_ref = (uintptr_t)ret_var.inner;
8000 if (ret_var.is_owned) {
8006 static inline struct LDKDecodeError CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8007 CHECK(!owner->result_ok);
8008 return DecodeError_clone(&*owner->contents.err);
8010 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint32_t owner) {
8011 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(owner & ~1);
8012 LDKDecodeError ret_var = CResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8013 uint32_t ret_ref = 0;
8014 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8015 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8016 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8017 ret_ref = (uintptr_t)ret_var.inner;
8018 if (ret_var.is_owned) {
8024 static inline struct LDKNodeAnnouncement CResult_NodeAnnouncementDecodeErrorZ_get_ok(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8025 CHECK(owner->result_ok);
8026 return NodeAnnouncement_clone(&*owner->contents.result);
8028 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_ok(uint32_t owner) {
8029 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(owner & ~1);
8030 LDKNodeAnnouncement ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_ok(owner_conv);
8031 uint32_t ret_ref = 0;
8032 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8033 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8034 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8035 ret_ref = (uintptr_t)ret_var.inner;
8036 if (ret_var.is_owned) {
8042 static inline struct LDKDecodeError CResult_NodeAnnouncementDecodeErrorZ_get_err(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR owner){
8043 CHECK(!owner->result_ok);
8044 return DecodeError_clone(&*owner->contents.err);
8046 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_get_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_get_err(uint32_t owner) {
8047 LDKCResult_NodeAnnouncementDecodeErrorZ* owner_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(owner & ~1);
8048 LDKDecodeError ret_var = CResult_NodeAnnouncementDecodeErrorZ_get_err(owner_conv);
8049 uint32_t ret_ref = 0;
8050 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8051 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8052 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8053 ret_ref = (uintptr_t)ret_var.inner;
8054 if (ret_var.is_owned) {
8060 static inline struct LDKQueryShortChannelIds CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8061 CHECK(owner->result_ok);
8062 return QueryShortChannelIds_clone(&*owner->contents.result);
8064 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint32_t owner) {
8065 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(owner & ~1);
8066 LDKQueryShortChannelIds ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_ok(owner_conv);
8067 uint32_t ret_ref = 0;
8068 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8069 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8071 ret_ref = (uintptr_t)ret_var.inner;
8072 if (ret_var.is_owned) {
8078 static inline struct LDKDecodeError CResult_QueryShortChannelIdsDecodeErrorZ_get_err(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR owner){
8079 CHECK(!owner->result_ok);
8080 return DecodeError_clone(&*owner->contents.err);
8082 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint32_t owner) {
8083 LDKCResult_QueryShortChannelIdsDecodeErrorZ* owner_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(owner & ~1);
8084 LDKDecodeError ret_var = CResult_QueryShortChannelIdsDecodeErrorZ_get_err(owner_conv);
8085 uint32_t ret_ref = 0;
8086 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8087 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8088 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8089 ret_ref = (uintptr_t)ret_var.inner;
8090 if (ret_var.is_owned) {
8096 static inline struct LDKReplyShortChannelIdsEnd CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8097 CHECK(owner->result_ok);
8098 return ReplyShortChannelIdsEnd_clone(&*owner->contents.result);
8100 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint32_t owner) {
8101 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(owner & ~1);
8102 LDKReplyShortChannelIdsEnd ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(owner_conv);
8103 uint32_t ret_ref = 0;
8104 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8105 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8106 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8107 ret_ref = (uintptr_t)ret_var.inner;
8108 if (ret_var.is_owned) {
8114 static inline struct LDKDecodeError CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR owner){
8115 CHECK(!owner->result_ok);
8116 return DecodeError_clone(&*owner->contents.err);
8118 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint32_t owner) {
8119 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* owner_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(owner & ~1);
8120 LDKDecodeError ret_var = CResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(owner_conv);
8121 uint32_t ret_ref = 0;
8122 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8123 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8124 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8125 ret_ref = (uintptr_t)ret_var.inner;
8126 if (ret_var.is_owned) {
8132 static inline struct LDKQueryChannelRange CResult_QueryChannelRangeDecodeErrorZ_get_ok(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8133 CHECK(owner->result_ok);
8134 return QueryChannelRange_clone(&*owner->contents.result);
8136 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_ok(uint32_t owner) {
8137 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(owner & ~1);
8138 LDKQueryChannelRange ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_ok(owner_conv);
8139 uint32_t ret_ref = 0;
8140 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8141 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8142 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8143 ret_ref = (uintptr_t)ret_var.inner;
8144 if (ret_var.is_owned) {
8150 static inline struct LDKDecodeError CResult_QueryChannelRangeDecodeErrorZ_get_err(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8151 CHECK(!owner->result_ok);
8152 return DecodeError_clone(&*owner->contents.err);
8154 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_get_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_get_err(uint32_t owner) {
8155 LDKCResult_QueryChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(owner & ~1);
8156 LDKDecodeError ret_var = CResult_QueryChannelRangeDecodeErrorZ_get_err(owner_conv);
8157 uint32_t ret_ref = 0;
8158 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8159 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8160 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8161 ret_ref = (uintptr_t)ret_var.inner;
8162 if (ret_var.is_owned) {
8168 static inline struct LDKReplyChannelRange CResult_ReplyChannelRangeDecodeErrorZ_get_ok(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8169 CHECK(owner->result_ok);
8170 return ReplyChannelRange_clone(&*owner->contents.result);
8172 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint32_t owner) {
8173 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(owner & ~1);
8174 LDKReplyChannelRange ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_ok(owner_conv);
8175 uint32_t ret_ref = 0;
8176 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8177 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8178 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8179 ret_ref = (uintptr_t)ret_var.inner;
8180 if (ret_var.is_owned) {
8186 static inline struct LDKDecodeError CResult_ReplyChannelRangeDecodeErrorZ_get_err(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR owner){
8187 CHECK(!owner->result_ok);
8188 return DecodeError_clone(&*owner->contents.err);
8190 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_get_err(uint32_t owner) {
8191 LDKCResult_ReplyChannelRangeDecodeErrorZ* owner_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(owner & ~1);
8192 LDKDecodeError ret_var = CResult_ReplyChannelRangeDecodeErrorZ_get_err(owner_conv);
8193 uint32_t ret_ref = 0;
8194 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8195 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8196 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8197 ret_ref = (uintptr_t)ret_var.inner;
8198 if (ret_var.is_owned) {
8204 static inline struct LDKGossipTimestampFilter CResult_GossipTimestampFilterDecodeErrorZ_get_ok(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8205 CHECK(owner->result_ok);
8206 return GossipTimestampFilter_clone(&*owner->contents.result);
8208 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint32_t owner) {
8209 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(owner & ~1);
8210 LDKGossipTimestampFilter ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_ok(owner_conv);
8211 uint32_t ret_ref = 0;
8212 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8213 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8214 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8215 ret_ref = (uintptr_t)ret_var.inner;
8216 if (ret_var.is_owned) {
8222 static inline struct LDKDecodeError CResult_GossipTimestampFilterDecodeErrorZ_get_err(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR owner){
8223 CHECK(!owner->result_ok);
8224 return DecodeError_clone(&*owner->contents.err);
8226 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_get_err(uint32_t owner) {
8227 LDKCResult_GossipTimestampFilterDecodeErrorZ* owner_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(owner & ~1);
8228 LDKDecodeError ret_var = CResult_GossipTimestampFilterDecodeErrorZ_get_err(owner_conv);
8229 uint32_t ret_ref = 0;
8230 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8231 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8233 ret_ref = (uintptr_t)ret_var.inner;
8234 if (ret_var.is_owned) {
8240 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_ty_from_ptr"))) TS_LDKSignOrCreationError_ty_from_ptr(uint32_t ptr) {
8241 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)(ptr & ~1);
8243 case LDKSignOrCreationError_SignError: return 0;
8244 case LDKSignOrCreationError_CreationError: return 1;
8248 uint32_t __attribute__((export_name("TS_LDKSignOrCreationError_CreationError_get_creation_error"))) TS_LDKSignOrCreationError_CreationError_get_creation_error(uint32_t ptr) {
8249 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)(ptr & ~1);
8250 assert(obj->tag == LDKSignOrCreationError_CreationError);
8251 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
8252 return creation_error_conv;
8254 static inline struct LDKInvoice CResult_InvoiceSignOrCreationErrorZ_get_ok(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8255 CHECK(owner->result_ok);
8256 return Invoice_clone(&*owner->contents.result);
8258 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_ok(uint32_t owner) {
8259 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(owner & ~1);
8260 LDKInvoice ret_var = CResult_InvoiceSignOrCreationErrorZ_get_ok(owner_conv);
8261 uint32_t ret_ref = 0;
8262 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8263 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8264 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8265 ret_ref = (uintptr_t)ret_var.inner;
8266 if (ret_var.is_owned) {
8272 static inline struct LDKSignOrCreationError CResult_InvoiceSignOrCreationErrorZ_get_err(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR owner){
8273 CHECK(!owner->result_ok);
8274 return SignOrCreationError_clone(&*owner->contents.err);
8276 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_get_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_get_err(uint32_t owner) {
8277 LDKCResult_InvoiceSignOrCreationErrorZ* owner_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(owner & ~1);
8278 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
8279 *ret_copy = CResult_InvoiceSignOrCreationErrorZ_get_err(owner_conv);
8280 uint32_t ret_ref = (uintptr_t)ret_copy;
8284 typedef struct LDKFilter_JCalls {
8285 atomic_size_t refcnt;
8286 uint32_t instance_ptr;
8288 static void LDKFilter_JCalls_free(void* this_arg) {
8289 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8290 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8294 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
8295 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8296 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
8297 memcpy(txid_arr->elems, *txid, 32);
8298 LDKu8slice script_pubkey_var = script_pubkey;
8299 int8_tArray script_pubkey_arr = init_int8_tArray(script_pubkey_var.datalen, __LINE__);
8300 memcpy(script_pubkey_arr->elems, script_pubkey_var.data, script_pubkey_var.datalen);
8301 js_invoke_function_u_uu(j_calls->instance_ptr, 32, (uint32_t)txid_arr, (uint32_t)script_pubkey_arr);
8303 LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
8304 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
8305 LDKWatchedOutput output_var = output;
8306 uint32_t output_ref = 0;
8307 CHECK((((uintptr_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8308 CHECK((((uintptr_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8309 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_var);
8310 output_ref = (uintptr_t)output_var.inner;
8311 if (output_var.is_owned) {
8314 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 33, (uint32_t)output_ref);
8315 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
8316 CHECK_ACCESS(ret_ptr);
8317 LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(ret_ptr);
8321 static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) {
8322 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg;
8323 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8325 static inline LDKFilter LDKFilter_init (JSValue o) {
8326 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
8327 atomic_init(&calls->refcnt, 1);
8328 calls->instance_ptr = o;
8331 .this_arg = (void*) calls,
8332 .register_tx = register_tx_LDKFilter_jcall,
8333 .register_output = register_output_LDKFilter_jcall,
8334 .free = LDKFilter_JCalls_free,
8338 long __attribute__((export_name("TS_LDKFilter_new"))) TS_LDKFilter_new(JSValue o) {
8339 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
8340 *res_ptr = LDKFilter_init(o);
8341 return (long)res_ptr;
8343 void __attribute__((export_name("TS_Filter_register_tx"))) TS_Filter_register_tx(uint32_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
8344 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8345 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8346 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8347 unsigned char txid_arr[32];
8348 CHECK(txid->arr_len == 32);
8349 memcpy(txid_arr, txid->elems, 32); FREE(txid);
8350 unsigned char (*txid_ref)[32] = &txid_arr;
8351 LDKu8slice script_pubkey_ref;
8352 script_pubkey_ref.datalen = script_pubkey->arr_len;
8353 script_pubkey_ref.data = script_pubkey->elems;
8354 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
8355 FREE(script_pubkey);
8358 uint32_t __attribute__((export_name("TS_Filter_register_output"))) TS_Filter_register_output(uint32_t this_arg, uint32_t output) {
8359 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8360 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8361 LDKFilter* this_arg_conv = (LDKFilter*)this_arg_ptr;
8362 LDKWatchedOutput output_conv;
8363 output_conv.inner = (void*)(output & (~1));
8364 output_conv.is_owned = (output & 1) || (output == 0);
8365 CHECK_INNER_FIELD_ACCESS_OR_NULL(output_conv);
8366 output_conv = WatchedOutput_clone(&output_conv);
8367 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
8368 *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
8369 uint32_t ret_ref = (uintptr_t)ret_copy;
8373 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_ty_from_ptr"))) TS_LDKCOption_FilterZ_ty_from_ptr(uint32_t ptr) {
8374 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)(ptr & ~1);
8376 case LDKCOption_FilterZ_Some: return 0;
8377 case LDKCOption_FilterZ_None: return 1;
8381 uint32_t __attribute__((export_name("TS_LDKCOption_FilterZ_Some_get_some"))) TS_LDKCOption_FilterZ_Some_get_some(uint32_t ptr) {
8382 LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)(ptr & ~1);
8383 assert(obj->tag == LDKCOption_FilterZ_Some);
8384 LDKFilter* some_ret = MALLOC(sizeof(LDKFilter), "LDKFilter");
8385 *some_ret = obj->some;
8386 // WARNING: We likely need to clone here, but no clone is available, so we just do it for Java instances
8387 if ((*some_ret).free == LDKFilter_JCalls_free) {
8388 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8389 LDKFilter_JCalls_cloned(&(*some_ret));
8391 return (uint32_t)some_ret;
8393 static inline struct LDKLockedChannelMonitor *CResult_LockedChannelMonitorNoneZ_get_ok(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8394 CHECK(owner->result_ok);
8395 return &*owner->contents.result;
8397 uint32_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_ok"))) TS_CResult_LockedChannelMonitorNoneZ_get_ok(uint32_t owner) {
8398 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(owner & ~1);
8399 LDKLockedChannelMonitor ret_var = *CResult_LockedChannelMonitorNoneZ_get_ok(owner_conv);
8400 uint32_t ret_ref = 0;
8401 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8402 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8403 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
8404 ret_ref = (uintptr_t)ret_var.inner & ~1;
8408 static inline void CResult_LockedChannelMonitorNoneZ_get_err(LDKCResult_LockedChannelMonitorNoneZ *NONNULL_PTR owner){
8409 CHECK(!owner->result_ok);
8410 return *owner->contents.err;
8412 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_get_err"))) TS_CResult_LockedChannelMonitorNoneZ_get_err(uint32_t owner) {
8413 LDKCResult_LockedChannelMonitorNoneZ* owner_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(owner & ~1);
8414 CResult_LockedChannelMonitorNoneZ_get_err(owner_conv);
8417 static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) {
8418 LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen };
8419 for (size_t i = 0; i < ret.datalen; i++) {
8420 ret.data[i] = OutPoint_clone(&orig->data[i]);
8424 typedef struct LDKMessageSendEventsProvider_JCalls {
8425 atomic_size_t refcnt;
8426 uint32_t instance_ptr;
8427 } LDKMessageSendEventsProvider_JCalls;
8428 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
8429 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
8430 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8434 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
8435 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
8436 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_(j_calls->instance_ptr, 34);
8437 LDKCVec_MessageSendEventZ ret_constr;
8438 ret_constr.datalen = ret->arr_len;
8439 if (ret_constr.datalen > 0)
8440 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
8442 ret_constr.data = NULL;
8443 uint32_t* ret_vals = ret->elems;
8444 for (size_t s = 0; s < ret_constr.datalen; s++) {
8445 uint32_t ret_conv_18 = ret_vals[s];
8446 void* ret_conv_18_ptr = (void*)(((uintptr_t)ret_conv_18) & ~1);
8447 CHECK_ACCESS(ret_conv_18_ptr);
8448 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(ret_conv_18_ptr);
8449 FREE((void*)ret_conv_18);
8450 ret_constr.data[s] = ret_conv_18_conv;
8455 static void LDKMessageSendEventsProvider_JCalls_cloned(LDKMessageSendEventsProvider* new_obj) {
8456 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) new_obj->this_arg;
8457 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8459 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (JSValue o) {
8460 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
8461 atomic_init(&calls->refcnt, 1);
8462 calls->instance_ptr = o;
8464 LDKMessageSendEventsProvider ret = {
8465 .this_arg = (void*) calls,
8466 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
8467 .free = LDKMessageSendEventsProvider_JCalls_free,
8471 long __attribute__((export_name("TS_LDKMessageSendEventsProvider_new"))) TS_LDKMessageSendEventsProvider_new(JSValue o) {
8472 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
8473 *res_ptr = LDKMessageSendEventsProvider_init(o);
8474 return (long)res_ptr;
8476 uint32_tArray __attribute__((export_name("TS_MessageSendEventsProvider_get_and_clear_pending_msg_events"))) TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(uint32_t this_arg) {
8477 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8478 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8479 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)this_arg_ptr;
8480 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
8481 uint32_tArray ret_arr = NULL;
8482 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
8483 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
8484 for (size_t s = 0; s < ret_var.datalen; s++) {
8485 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
8486 *ret_conv_18_copy = ret_var.data[s];
8487 uint32_t ret_conv_18_ref = (uintptr_t)ret_conv_18_copy;
8488 ret_arr_ptr[s] = ret_conv_18_ref;
8495 typedef struct LDKEventHandler_JCalls {
8496 atomic_size_t refcnt;
8497 uint32_t instance_ptr;
8498 } LDKEventHandler_JCalls;
8499 static void LDKEventHandler_JCalls_free(void* this_arg) {
8500 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
8501 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8505 void handle_event_LDKEventHandler_jcall(const void* this_arg, const LDKEvent * event) {
8506 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
8507 LDKEvent *ret_event = MALLOC(sizeof(LDKEvent), "LDKEvent ret conversion");
8508 *ret_event = Event_clone(event);
8509 js_invoke_function_u_u(j_calls->instance_ptr, 35, (uint32_t)(uint32_t)ret_event);
8511 static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) {
8512 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg;
8513 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8515 static inline LDKEventHandler LDKEventHandler_init (JSValue o) {
8516 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
8517 atomic_init(&calls->refcnt, 1);
8518 calls->instance_ptr = o;
8520 LDKEventHandler ret = {
8521 .this_arg = (void*) calls,
8522 .handle_event = handle_event_LDKEventHandler_jcall,
8523 .free = LDKEventHandler_JCalls_free,
8527 long __attribute__((export_name("TS_LDKEventHandler_new"))) TS_LDKEventHandler_new(JSValue o) {
8528 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
8529 *res_ptr = LDKEventHandler_init(o);
8530 return (long)res_ptr;
8532 void __attribute__((export_name("TS_EventHandler_handle_event"))) TS_EventHandler_handle_event(uint32_t this_arg, uint32_t event) {
8533 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8534 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8535 LDKEventHandler* this_arg_conv = (LDKEventHandler*)this_arg_ptr;
8536 LDKEvent* event_conv = (LDKEvent*)event;
8537 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
8540 typedef struct LDKEventsProvider_JCalls {
8541 atomic_size_t refcnt;
8542 uint32_t instance_ptr;
8543 } LDKEventsProvider_JCalls;
8544 static void LDKEventsProvider_JCalls_free(void* this_arg) {
8545 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
8546 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8550 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
8551 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
8552 LDKEventHandler* handler_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
8553 *handler_ret = handler;
8554 js_invoke_function_u_u(j_calls->instance_ptr, 36, (uint32_t)(uint32_t)handler_ret);
8556 static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) {
8557 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg;
8558 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8560 static inline LDKEventsProvider LDKEventsProvider_init (JSValue o) {
8561 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
8562 atomic_init(&calls->refcnt, 1);
8563 calls->instance_ptr = o;
8565 LDKEventsProvider ret = {
8566 .this_arg = (void*) calls,
8567 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
8568 .free = LDKEventsProvider_JCalls_free,
8572 long __attribute__((export_name("TS_LDKEventsProvider_new"))) TS_LDKEventsProvider_new(JSValue o) {
8573 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
8574 *res_ptr = LDKEventsProvider_init(o);
8575 return (long)res_ptr;
8577 void __attribute__((export_name("TS_EventsProvider_process_pending_events"))) TS_EventsProvider_process_pending_events(uint32_t this_arg, uint32_t handler) {
8578 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8579 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8580 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)this_arg_ptr;
8581 void* handler_ptr = (void*)(((uintptr_t)handler) & ~1);
8582 CHECK_ACCESS(handler_ptr);
8583 LDKEventHandler handler_conv = *(LDKEventHandler*)(handler_ptr);
8584 if (handler_conv.free == LDKEventHandler_JCalls_free) {
8585 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
8586 LDKEventHandler_JCalls_cloned(&handler_conv);
8588 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
8591 typedef struct LDKScore_JCalls {
8592 atomic_size_t refcnt;
8593 uint32_t instance_ptr;
8595 static void LDKScore_JCalls_free(void* this_arg) {
8596 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8597 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8601 uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id, const LDKNodeId * source, const LDKNodeId * target, LDKChannelUsage usage) {
8602 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8603 int64_t short_channel_id_conv = short_channel_id;
8604 LDKNodeId source_var = *source;
8605 uint32_t source_ref = 0;
8606 source_var = NodeId_clone(&source_var);
8607 CHECK((((uintptr_t)source_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8608 CHECK((((uintptr_t)&source_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8609 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_var);
8610 source_ref = (uintptr_t)source_var.inner;
8611 if (source_var.is_owned) {
8614 LDKNodeId target_var = *target;
8615 uint32_t target_ref = 0;
8616 target_var = NodeId_clone(&target_var);
8617 CHECK((((uintptr_t)target_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8618 CHECK((((uintptr_t)&target_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8619 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_var);
8620 target_ref = (uintptr_t)target_var.inner;
8621 if (target_var.is_owned) {
8624 LDKChannelUsage usage_var = usage;
8625 uint32_t usage_ref = 0;
8626 CHECK((((uintptr_t)usage_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8627 CHECK((((uintptr_t)&usage_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8628 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_var);
8629 usage_ref = (uintptr_t)usage_var.inner;
8630 if (usage_var.is_owned) {
8633 return js_invoke_function_b_uuuu(j_calls->instance_ptr, 37, (uint32_t)short_channel_id_conv, (uint32_t)source_ref, (uint32_t)target_ref, (uint32_t)usage_ref);
8635 void payment_path_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
8636 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8637 LDKCVec_RouteHopZ path_var = path;
8638 uint32_tArray path_arr = NULL;
8639 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
8640 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
8641 for (size_t k = 0; k < path_var.datalen; k++) {
8642 LDKRouteHop path_conv_10_var = path_var.data[k];
8643 uint32_t path_conv_10_ref = 0;
8644 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8645 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8646 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8647 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner;
8648 if (path_conv_10_var.is_owned) {
8649 path_conv_10_ref |= 1;
8651 path_arr_ptr[k] = path_conv_10_ref;
8654 FREE(path_var.data);
8655 int64_t short_channel_id_conv = short_channel_id;
8656 js_invoke_function_u_bb(j_calls->instance_ptr, 38, (uint32_t)path_arr, (uint32_t)short_channel_id_conv);
8658 void payment_path_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
8659 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8660 LDKCVec_RouteHopZ path_var = path;
8661 uint32_tArray path_arr = NULL;
8662 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
8663 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
8664 for (size_t k = 0; k < path_var.datalen; k++) {
8665 LDKRouteHop path_conv_10_var = path_var.data[k];
8666 uint32_t path_conv_10_ref = 0;
8667 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8668 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8669 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8670 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner;
8671 if (path_conv_10_var.is_owned) {
8672 path_conv_10_ref |= 1;
8674 path_arr_ptr[k] = path_conv_10_ref;
8677 FREE(path_var.data);
8678 js_invoke_function_u_u(j_calls->instance_ptr, 39, (uint32_t)path_arr);
8680 void probe_failed_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path, uint64_t short_channel_id) {
8681 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8682 LDKCVec_RouteHopZ path_var = path;
8683 uint32_tArray path_arr = NULL;
8684 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
8685 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
8686 for (size_t k = 0; k < path_var.datalen; k++) {
8687 LDKRouteHop path_conv_10_var = path_var.data[k];
8688 uint32_t path_conv_10_ref = 0;
8689 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8690 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8691 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8692 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner;
8693 if (path_conv_10_var.is_owned) {
8694 path_conv_10_ref |= 1;
8696 path_arr_ptr[k] = path_conv_10_ref;
8699 FREE(path_var.data);
8700 int64_t short_channel_id_conv = short_channel_id;
8701 js_invoke_function_u_bb(j_calls->instance_ptr, 40, (uint32_t)path_arr, (uint32_t)short_channel_id_conv);
8703 void probe_successful_LDKScore_jcall(void* this_arg, LDKCVec_RouteHopZ path) {
8704 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8705 LDKCVec_RouteHopZ path_var = path;
8706 uint32_tArray path_arr = NULL;
8707 path_arr = init_uint32_tArray(path_var.datalen, __LINE__);
8708 uint32_t *path_arr_ptr = (uint32_t*)(((uint8_t*)path_arr) + 4);
8709 for (size_t k = 0; k < path_var.datalen; k++) {
8710 LDKRouteHop path_conv_10_var = path_var.data[k];
8711 uint32_t path_conv_10_ref = 0;
8712 CHECK((((uintptr_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8713 CHECK((((uintptr_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8714 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_var);
8715 path_conv_10_ref = (uintptr_t)path_conv_10_var.inner;
8716 if (path_conv_10_var.is_owned) {
8717 path_conv_10_ref |= 1;
8719 path_arr_ptr[k] = path_conv_10_ref;
8722 FREE(path_var.data);
8723 js_invoke_function_u_u(j_calls->instance_ptr, 41, (uint32_t)path_arr);
8725 LDKCVec_u8Z write_LDKScore_jcall(const void* this_arg) {
8726 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg;
8727 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 42);
8728 LDKCVec_u8Z ret_ref;
8729 ret_ref.datalen = ret->arr_len;
8730 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
8731 memcpy(ret_ref.data, ret->elems, ret_ref.datalen); FREE(ret);
8734 static void LDKScore_JCalls_cloned(LDKScore* new_obj) {
8735 LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg;
8736 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8738 static inline LDKScore LDKScore_init (JSValue o) {
8739 LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls");
8740 atomic_init(&calls->refcnt, 1);
8741 calls->instance_ptr = o;
8744 .this_arg = (void*) calls,
8745 .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall,
8746 .payment_path_failed = payment_path_failed_LDKScore_jcall,
8747 .payment_path_successful = payment_path_successful_LDKScore_jcall,
8748 .probe_failed = probe_failed_LDKScore_jcall,
8749 .probe_successful = probe_successful_LDKScore_jcall,
8750 .write = write_LDKScore_jcall,
8751 .free = LDKScore_JCalls_free,
8755 long __attribute__((export_name("TS_LDKScore_new"))) TS_LDKScore_new(JSValue o) {
8756 LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore");
8757 *res_ptr = LDKScore_init(o);
8758 return (long)res_ptr;
8760 int64_t __attribute__((export_name("TS_Score_channel_penalty_msat"))) TS_Score_channel_penalty_msat(uint32_t this_arg, int64_t short_channel_id, uint32_t source, uint32_t target, uint32_t usage) {
8761 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8762 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8763 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8764 LDKNodeId source_conv;
8765 source_conv.inner = (void*)(source & (~1));
8766 source_conv.is_owned = false;
8767 CHECK_INNER_FIELD_ACCESS_OR_NULL(source_conv);
8768 LDKNodeId target_conv;
8769 target_conv.inner = (void*)(target & (~1));
8770 target_conv.is_owned = false;
8771 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
8772 LDKChannelUsage usage_conv;
8773 usage_conv.inner = (void*)(usage & (~1));
8774 usage_conv.is_owned = (usage & 1) || (usage == 0);
8775 CHECK_INNER_FIELD_ACCESS_OR_NULL(usage_conv);
8776 usage_conv = ChannelUsage_clone(&usage_conv);
8777 int64_t ret_conv = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id, &source_conv, &target_conv, usage_conv);
8781 void __attribute__((export_name("TS_Score_payment_path_failed"))) TS_Score_payment_path_failed(uint32_t this_arg, uint32_tArray path, int64_t short_channel_id) {
8782 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8783 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8784 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8785 LDKCVec_RouteHopZ path_constr;
8786 path_constr.datalen = path->arr_len;
8787 if (path_constr.datalen > 0)
8788 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8790 path_constr.data = NULL;
8791 uint32_t* path_vals = path->elems;
8792 for (size_t k = 0; k < path_constr.datalen; k++) {
8793 uint32_t path_conv_10 = path_vals[k];
8794 LDKRouteHop path_conv_10_conv;
8795 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
8796 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
8797 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8798 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8799 path_constr.data[k] = path_conv_10_conv;
8802 (this_arg_conv->payment_path_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
8805 void __attribute__((export_name("TS_Score_payment_path_successful"))) TS_Score_payment_path_successful(uint32_t this_arg, uint32_tArray path) {
8806 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8807 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8808 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8809 LDKCVec_RouteHopZ path_constr;
8810 path_constr.datalen = path->arr_len;
8811 if (path_constr.datalen > 0)
8812 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8814 path_constr.data = NULL;
8815 uint32_t* path_vals = path->elems;
8816 for (size_t k = 0; k < path_constr.datalen; k++) {
8817 uint32_t path_conv_10 = path_vals[k];
8818 LDKRouteHop path_conv_10_conv;
8819 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
8820 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
8821 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8822 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8823 path_constr.data[k] = path_conv_10_conv;
8826 (this_arg_conv->payment_path_successful)(this_arg_conv->this_arg, path_constr);
8829 void __attribute__((export_name("TS_Score_probe_failed"))) TS_Score_probe_failed(uint32_t this_arg, uint32_tArray path, int64_t short_channel_id) {
8830 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8831 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8832 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8833 LDKCVec_RouteHopZ path_constr;
8834 path_constr.datalen = path->arr_len;
8835 if (path_constr.datalen > 0)
8836 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8838 path_constr.data = NULL;
8839 uint32_t* path_vals = path->elems;
8840 for (size_t k = 0; k < path_constr.datalen; k++) {
8841 uint32_t path_conv_10 = path_vals[k];
8842 LDKRouteHop path_conv_10_conv;
8843 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
8844 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
8845 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8846 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8847 path_constr.data[k] = path_conv_10_conv;
8850 (this_arg_conv->probe_failed)(this_arg_conv->this_arg, path_constr, short_channel_id);
8853 void __attribute__((export_name("TS_Score_probe_successful"))) TS_Score_probe_successful(uint32_t this_arg, uint32_tArray path) {
8854 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8855 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8856 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8857 LDKCVec_RouteHopZ path_constr;
8858 path_constr.datalen = path->arr_len;
8859 if (path_constr.datalen > 0)
8860 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
8862 path_constr.data = NULL;
8863 uint32_t* path_vals = path->elems;
8864 for (size_t k = 0; k < path_constr.datalen; k++) {
8865 uint32_t path_conv_10 = path_vals[k];
8866 LDKRouteHop path_conv_10_conv;
8867 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
8868 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
8869 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
8870 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
8871 path_constr.data[k] = path_conv_10_conv;
8874 (this_arg_conv->probe_successful)(this_arg_conv->this_arg, path_constr);
8877 int8_tArray __attribute__((export_name("TS_Score_write"))) TS_Score_write(uint32_t this_arg) {
8878 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8879 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8880 LDKScore* this_arg_conv = (LDKScore*)this_arg_ptr;
8881 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
8882 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
8883 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
8884 CVec_u8Z_free(ret_var);
8888 typedef struct LDKPersister_JCalls {
8889 atomic_size_t refcnt;
8890 uint32_t instance_ptr;
8891 } LDKPersister_JCalls;
8892 static void LDKPersister_JCalls_free(void* this_arg) {
8893 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8894 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
8898 LDKCResult_NoneErrorZ persist_manager_LDKPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
8899 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8900 LDKChannelManager channel_manager_var = *channel_manager;
8901 uint32_t channel_manager_ref = 0;
8902 // WARNING: we may need a move here but no clone is available for LDKChannelManager
8903 CHECK((((uintptr_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8904 CHECK((((uintptr_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8905 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_var);
8906 channel_manager_ref = (uintptr_t)channel_manager_var.inner;
8907 if (channel_manager_var.is_owned) {
8908 channel_manager_ref |= 1;
8910 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 43, (uint32_t)channel_manager_ref);
8911 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
8912 CHECK_ACCESS(ret_ptr);
8913 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8917 LDKCResult_NoneErrorZ persist_graph_LDKPersister_jcall(const void* this_arg, const LDKNetworkGraph * network_graph) {
8918 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8919 LDKNetworkGraph network_graph_var = *network_graph;
8920 uint32_t network_graph_ref = 0;
8921 // WARNING: we may need a move here but no clone is available for LDKNetworkGraph
8922 CHECK((((uintptr_t)network_graph_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8923 CHECK((((uintptr_t)&network_graph_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8924 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_var);
8925 network_graph_ref = (uintptr_t)network_graph_var.inner;
8926 if (network_graph_var.is_owned) {
8927 network_graph_ref |= 1;
8929 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 44, (uint32_t)network_graph_ref);
8930 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
8931 CHECK_ACCESS(ret_ptr);
8932 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8936 LDKCResult_NoneErrorZ persist_scorer_LDKPersister_jcall(const void* this_arg, const LDKMultiThreadedLockableScore * scorer) {
8937 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) this_arg;
8938 LDKMultiThreadedLockableScore scorer_var = *scorer;
8939 uint32_t scorer_ref = 0;
8940 // WARNING: we may need a move here but no clone is available for LDKMultiThreadedLockableScore
8941 CHECK((((uintptr_t)scorer_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
8942 CHECK((((uintptr_t)&scorer_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
8943 CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_var);
8944 scorer_ref = (uintptr_t)scorer_var.inner;
8945 if (scorer_var.is_owned) {
8948 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 45, (uint32_t)scorer_ref);
8949 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
8950 CHECK_ACCESS(ret_ptr);
8951 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(ret_ptr);
8955 static void LDKPersister_JCalls_cloned(LDKPersister* new_obj) {
8956 LDKPersister_JCalls *j_calls = (LDKPersister_JCalls*) new_obj->this_arg;
8957 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
8959 static inline LDKPersister LDKPersister_init (JSValue o) {
8960 LDKPersister_JCalls *calls = MALLOC(sizeof(LDKPersister_JCalls), "LDKPersister_JCalls");
8961 atomic_init(&calls->refcnt, 1);
8962 calls->instance_ptr = o;
8964 LDKPersister ret = {
8965 .this_arg = (void*) calls,
8966 .persist_manager = persist_manager_LDKPersister_jcall,
8967 .persist_graph = persist_graph_LDKPersister_jcall,
8968 .persist_scorer = persist_scorer_LDKPersister_jcall,
8969 .free = LDKPersister_JCalls_free,
8973 long __attribute__((export_name("TS_LDKPersister_new"))) TS_LDKPersister_new(JSValue o) {
8974 LDKPersister *res_ptr = MALLOC(sizeof(LDKPersister), "LDKPersister");
8975 *res_ptr = LDKPersister_init(o);
8976 return (long)res_ptr;
8978 uint32_t __attribute__((export_name("TS_Persister_persist_manager"))) TS_Persister_persist_manager(uint32_t this_arg, uint32_t channel_manager) {
8979 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8980 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8981 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
8982 LDKChannelManager channel_manager_conv;
8983 channel_manager_conv.inner = (void*)(channel_manager & (~1));
8984 channel_manager_conv.is_owned = false;
8985 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_manager_conv);
8986 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
8987 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
8988 return (uint32_t)ret_conv;
8991 uint32_t __attribute__((export_name("TS_Persister_persist_graph"))) TS_Persister_persist_graph(uint32_t this_arg, uint32_t network_graph) {
8992 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
8993 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
8994 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
8995 LDKNetworkGraph network_graph_conv;
8996 network_graph_conv.inner = (void*)(network_graph & (~1));
8997 network_graph_conv.is_owned = false;
8998 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
8999 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9000 *ret_conv = (this_arg_conv->persist_graph)(this_arg_conv->this_arg, &network_graph_conv);
9001 return (uint32_t)ret_conv;
9004 uint32_t __attribute__((export_name("TS_Persister_persist_scorer"))) TS_Persister_persist_scorer(uint32_t this_arg, uint32_t scorer) {
9005 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9006 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9007 LDKPersister* this_arg_conv = (LDKPersister*)this_arg_ptr;
9008 LDKMultiThreadedLockableScore scorer_conv;
9009 scorer_conv.inner = (void*)(scorer & (~1));
9010 scorer_conv.is_owned = false;
9011 CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
9012 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
9013 *ret_conv = (this_arg_conv->persist_scorer)(this_arg_conv->this_arg, &scorer_conv);
9014 return (uint32_t)ret_conv;
9017 typedef struct LDKListen_JCalls {
9018 atomic_size_t refcnt;
9019 uint32_t instance_ptr;
9021 static void LDKListen_JCalls_free(void* this_arg) {
9022 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9023 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9027 void filtered_block_connected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9028 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9029 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9030 memcpy(header_arr->elems, *header, 80);
9031 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9032 uint32_tArray txdata_arr = NULL;
9033 txdata_arr = init_uint32_tArray(txdata_var.datalen, __LINE__);
9034 uint32_t *txdata_arr_ptr = (uint32_t*)(((uint8_t*)txdata_arr) + 4);
9035 for (size_t c = 0; c < txdata_var.datalen; c++) {
9036 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9037 *txdata_conv_28_conv = txdata_var.data[c];
9038 txdata_arr_ptr[c] = ((uint32_t)txdata_conv_28_conv);
9041 FREE(txdata_var.data);
9042 int32_t height_conv = height;
9043 js_invoke_function_u_uuu(j_calls->instance_ptr, 46, (uint32_t)header_arr, (uint32_t)txdata_arr, (uint32_t)height_conv);
9045 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
9046 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9047 LDKu8slice block_var = block;
9048 int8_tArray block_arr = init_int8_tArray(block_var.datalen, __LINE__);
9049 memcpy(block_arr->elems, block_var.data, block_var.datalen);
9050 int32_t height_conv = height;
9051 js_invoke_function_u_uu(j_calls->instance_ptr, 47, (uint32_t)block_arr, (uint32_t)height_conv);
9053 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9054 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
9055 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9056 memcpy(header_arr->elems, *header, 80);
9057 int32_t height_conv = height;
9058 js_invoke_function_u_uu(j_calls->instance_ptr, 48, (uint32_t)header_arr, (uint32_t)height_conv);
9060 static void LDKListen_JCalls_cloned(LDKListen* new_obj) {
9061 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) new_obj->this_arg;
9062 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9064 static inline LDKListen LDKListen_init (JSValue o) {
9065 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
9066 atomic_init(&calls->refcnt, 1);
9067 calls->instance_ptr = o;
9070 .this_arg = (void*) calls,
9071 .filtered_block_connected = filtered_block_connected_LDKListen_jcall,
9072 .block_connected = block_connected_LDKListen_jcall,
9073 .block_disconnected = block_disconnected_LDKListen_jcall,
9074 .free = LDKListen_JCalls_free,
9078 long __attribute__((export_name("TS_LDKListen_new"))) TS_LDKListen_new(JSValue o) {
9079 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
9080 *res_ptr = LDKListen_init(o);
9081 return (long)res_ptr;
9083 void __attribute__((export_name("TS_Listen_filtered_block_connected"))) TS_Listen_filtered_block_connected(uint32_t this_arg, int8_tArray header, uint32_tArray txdata, int32_t height) {
9084 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9085 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9086 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9087 unsigned char header_arr[80];
9088 CHECK(header->arr_len == 80);
9089 memcpy(header_arr, header->elems, 80); FREE(header);
9090 unsigned char (*header_ref)[80] = &header_arr;
9091 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9092 txdata_constr.datalen = txdata->arr_len;
9093 if (txdata_constr.datalen > 0)
9094 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9096 txdata_constr.data = NULL;
9097 uint32_t* txdata_vals = txdata->elems;
9098 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9099 uint32_t txdata_conv_28 = txdata_vals[c];
9100 void* txdata_conv_28_ptr = (void*)(((uintptr_t)txdata_conv_28) & ~1);
9101 CHECK_ACCESS(txdata_conv_28_ptr);
9102 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9103 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uintptr_t)txdata_conv_28) & ~1));
9104 txdata_constr.data[c] = txdata_conv_28_conv;
9107 (this_arg_conv->filtered_block_connected)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9110 void __attribute__((export_name("TS_Listen_block_connected"))) TS_Listen_block_connected(uint32_t this_arg, int8_tArray block, int32_t height) {
9111 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9112 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9113 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9114 LDKu8slice block_ref;
9115 block_ref.datalen = block->arr_len;
9116 block_ref.data = block->elems;
9117 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
9121 void __attribute__((export_name("TS_Listen_block_disconnected"))) TS_Listen_block_disconnected(uint32_t this_arg, int8_tArray header, int32_t height) {
9122 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9123 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9124 LDKListen* this_arg_conv = (LDKListen*)this_arg_ptr;
9125 unsigned char header_arr[80];
9126 CHECK(header->arr_len == 80);
9127 memcpy(header_arr, header->elems, 80); FREE(header);
9128 unsigned char (*header_ref)[80] = &header_arr;
9129 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
9132 typedef struct LDKConfirm_JCalls {
9133 atomic_size_t refcnt;
9134 uint32_t instance_ptr;
9135 } LDKConfirm_JCalls;
9136 static void LDKConfirm_JCalls_free(void* this_arg) {
9137 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9138 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9142 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
9143 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9144 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9145 memcpy(header_arr->elems, *header, 80);
9146 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
9147 uint32_tArray txdata_arr = NULL;
9148 txdata_arr = init_uint32_tArray(txdata_var.datalen, __LINE__);
9149 uint32_t *txdata_arr_ptr = (uint32_t*)(((uint8_t*)txdata_arr) + 4);
9150 for (size_t c = 0; c < txdata_var.datalen; c++) {
9151 LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
9152 *txdata_conv_28_conv = txdata_var.data[c];
9153 txdata_arr_ptr[c] = ((uint32_t)txdata_conv_28_conv);
9156 FREE(txdata_var.data);
9157 int32_t height_conv = height;
9158 js_invoke_function_u_uuu(j_calls->instance_ptr, 49, (uint32_t)header_arr, (uint32_t)txdata_arr, (uint32_t)height_conv);
9160 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
9161 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9162 int8_tArray txid_arr = init_int8_tArray(32, __LINE__);
9163 memcpy(txid_arr->elems, *txid, 32);
9164 js_invoke_function_u_u(j_calls->instance_ptr, 50, (uint32_t)txid_arr);
9166 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
9167 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9168 int8_tArray header_arr = init_int8_tArray(80, __LINE__);
9169 memcpy(header_arr->elems, *header, 80);
9170 int32_t height_conv = height;
9171 js_invoke_function_u_uu(j_calls->instance_ptr, 51, (uint32_t)header_arr, (uint32_t)height_conv);
9173 LDKCVec_TxidZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
9174 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
9175 ptrArray ret = (ptrArray)js_invoke_function_u_(j_calls->instance_ptr, 52);
9176 LDKCVec_TxidZ ret_constr;
9177 ret_constr.datalen = ret->arr_len;
9178 if (ret_constr.datalen > 0)
9179 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
9181 ret_constr.data = NULL;
9182 int8_tArray* ret_vals = (void*) ret->elems;
9183 for (size_t m = 0; m < ret_constr.datalen; m++) {
9184 int8_tArray ret_conv_12 = ret_vals[m];
9185 LDKThirtyTwoBytes ret_conv_12_ref;
9186 CHECK(ret_conv_12->arr_len == 32);
9187 memcpy(ret_conv_12_ref.data, ret_conv_12->elems, 32); FREE(ret_conv_12);
9188 ret_constr.data[m] = ret_conv_12_ref;
9193 static void LDKConfirm_JCalls_cloned(LDKConfirm* new_obj) {
9194 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) new_obj->this_arg;
9195 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9197 static inline LDKConfirm LDKConfirm_init (JSValue o) {
9198 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
9199 atomic_init(&calls->refcnt, 1);
9200 calls->instance_ptr = o;
9203 .this_arg = (void*) calls,
9204 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
9205 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
9206 .best_block_updated = best_block_updated_LDKConfirm_jcall,
9207 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
9208 .free = LDKConfirm_JCalls_free,
9212 long __attribute__((export_name("TS_LDKConfirm_new"))) TS_LDKConfirm_new(JSValue o) {
9213 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
9214 *res_ptr = LDKConfirm_init(o);
9215 return (long)res_ptr;
9217 void __attribute__((export_name("TS_Confirm_transactions_confirmed"))) TS_Confirm_transactions_confirmed(uint32_t this_arg, int8_tArray header, uint32_tArray txdata, int32_t height) {
9218 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9219 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9220 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9221 unsigned char header_arr[80];
9222 CHECK(header->arr_len == 80);
9223 memcpy(header_arr, header->elems, 80); FREE(header);
9224 unsigned char (*header_ref)[80] = &header_arr;
9225 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
9226 txdata_constr.datalen = txdata->arr_len;
9227 if (txdata_constr.datalen > 0)
9228 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
9230 txdata_constr.data = NULL;
9231 uint32_t* txdata_vals = txdata->elems;
9232 for (size_t c = 0; c < txdata_constr.datalen; c++) {
9233 uint32_t txdata_conv_28 = txdata_vals[c];
9234 void* txdata_conv_28_ptr = (void*)(((uintptr_t)txdata_conv_28) & ~1);
9235 CHECK_ACCESS(txdata_conv_28_ptr);
9236 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
9237 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uintptr_t)txdata_conv_28) & ~1));
9238 txdata_constr.data[c] = txdata_conv_28_conv;
9241 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
9244 void __attribute__((export_name("TS_Confirm_transaction_unconfirmed"))) TS_Confirm_transaction_unconfirmed(uint32_t this_arg, int8_tArray txid) {
9245 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9246 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9247 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9248 unsigned char txid_arr[32];
9249 CHECK(txid->arr_len == 32);
9250 memcpy(txid_arr, txid->elems, 32); FREE(txid);
9251 unsigned char (*txid_ref)[32] = &txid_arr;
9252 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
9255 void __attribute__((export_name("TS_Confirm_best_block_updated"))) TS_Confirm_best_block_updated(uint32_t this_arg, int8_tArray header, int32_t height) {
9256 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9257 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9258 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9259 unsigned char header_arr[80];
9260 CHECK(header->arr_len == 80);
9261 memcpy(header_arr, header->elems, 80); FREE(header);
9262 unsigned char (*header_ref)[80] = &header_arr;
9263 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
9266 ptrArray __attribute__((export_name("TS_Confirm_get_relevant_txids"))) TS_Confirm_get_relevant_txids(uint32_t this_arg) {
9267 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9268 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9269 LDKConfirm* this_arg_conv = (LDKConfirm*)this_arg_ptr;
9270 LDKCVec_TxidZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
9271 ptrArray ret_arr = NULL;
9272 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
9273 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
9274 for (size_t m = 0; m < ret_var.datalen; m++) {
9275 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
9276 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
9277 ret_arr_ptr[m] = ret_conv_12_arr;
9284 typedef struct LDKPersist_JCalls {
9285 atomic_size_t refcnt;
9286 uint32_t instance_ptr;
9287 } LDKPersist_JCalls;
9288 static void LDKPersist_JCalls_free(void* this_arg) {
9289 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9290 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9294 LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9295 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9296 LDKOutPoint channel_id_var = channel_id;
9297 uint32_t channel_id_ref = 0;
9298 CHECK((((uintptr_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9299 CHECK((((uintptr_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9300 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9301 channel_id_ref = (uintptr_t)channel_id_var.inner;
9302 if (channel_id_var.is_owned) {
9303 channel_id_ref |= 1;
9305 LDKChannelMonitor data_var = *data;
9306 uint32_t data_ref = 0;
9307 data_var = ChannelMonitor_clone(&data_var);
9308 CHECK((((uintptr_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9309 CHECK((((uintptr_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9310 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9311 data_ref = (uintptr_t)data_var.inner;
9312 if (data_var.is_owned) {
9315 LDKMonitorUpdateId update_id_var = update_id;
9316 uint32_t update_id_ref = 0;
9317 CHECK((((uintptr_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9318 CHECK((((uintptr_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9319 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9320 update_id_ref = (uintptr_t)update_id_var.inner;
9321 if (update_id_var.is_owned) {
9324 uint32_t ret = js_invoke_function_u_uuu(j_calls->instance_ptr, 53, (uint32_t)channel_id_ref, (uint32_t)data_ref, (uint32_t)update_id_ref);
9325 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
9326 CHECK_ACCESS(ret_ptr);
9327 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
9331 LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint channel_id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data, LDKMonitorUpdateId update_id) {
9332 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
9333 LDKOutPoint channel_id_var = channel_id;
9334 uint32_t channel_id_ref = 0;
9335 CHECK((((uintptr_t)channel_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9336 CHECK((((uintptr_t)&channel_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9337 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_var);
9338 channel_id_ref = (uintptr_t)channel_id_var.inner;
9339 if (channel_id_var.is_owned) {
9340 channel_id_ref |= 1;
9342 LDKChannelMonitorUpdate update_var = *update;
9343 uint32_t update_ref = 0;
9344 if ((uintptr_t)update_var.inner > 4096) {
9345 update_var = ChannelMonitorUpdate_clone(&update_var);
9346 CHECK((((uintptr_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9347 CHECK((((uintptr_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9348 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_var);
9349 update_ref = (uintptr_t)update_var.inner;
9350 if (update_var.is_owned) {
9354 LDKChannelMonitor data_var = *data;
9355 uint32_t data_ref = 0;
9356 data_var = ChannelMonitor_clone(&data_var);
9357 CHECK((((uintptr_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9358 CHECK((((uintptr_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9359 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_var);
9360 data_ref = (uintptr_t)data_var.inner;
9361 if (data_var.is_owned) {
9364 LDKMonitorUpdateId update_id_var = update_id;
9365 uint32_t update_id_ref = 0;
9366 CHECK((((uintptr_t)update_id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9367 CHECK((((uintptr_t)&update_id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9368 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_var);
9369 update_id_ref = (uintptr_t)update_id_var.inner;
9370 if (update_id_var.is_owned) {
9373 uint32_t ret = js_invoke_function_u_uuuu(j_calls->instance_ptr, 54, (uint32_t)channel_id_ref, (uint32_t)update_ref, (uint32_t)data_ref, (uint32_t)update_id_ref);
9374 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
9375 CHECK_ACCESS(ret_ptr);
9376 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(ret_ptr);
9380 static void LDKPersist_JCalls_cloned(LDKPersist* new_obj) {
9381 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) new_obj->this_arg;
9382 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9384 static inline LDKPersist LDKPersist_init (JSValue o) {
9385 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
9386 atomic_init(&calls->refcnt, 1);
9387 calls->instance_ptr = o;
9390 .this_arg = (void*) calls,
9391 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
9392 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
9393 .free = LDKPersist_JCalls_free,
9397 long __attribute__((export_name("TS_LDKPersist_new"))) TS_LDKPersist_new(JSValue o) {
9398 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
9399 *res_ptr = LDKPersist_init(o);
9400 return (long)res_ptr;
9402 uint32_t __attribute__((export_name("TS_Persist_persist_new_channel"))) TS_Persist_persist_new_channel(uint32_t this_arg, uint32_t channel_id, uint32_t data, uint32_t update_id) {
9403 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9404 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9405 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9406 LDKOutPoint channel_id_conv;
9407 channel_id_conv.inner = (void*)(channel_id & (~1));
9408 channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
9409 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9410 channel_id_conv = OutPoint_clone(&channel_id_conv);
9411 LDKChannelMonitor data_conv;
9412 data_conv.inner = (void*)(data & (~1));
9413 data_conv.is_owned = false;
9414 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9415 LDKMonitorUpdateId update_id_conv;
9416 update_id_conv.inner = (void*)(update_id & (~1));
9417 update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
9418 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9419 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9420 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
9421 *ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, channel_id_conv, &data_conv, update_id_conv);
9422 return (uint32_t)ret_conv;
9425 uint32_t __attribute__((export_name("TS_Persist_update_persisted_channel"))) TS_Persist_update_persisted_channel(uint32_t this_arg, uint32_t channel_id, uint32_t update, uint32_t data, uint32_t update_id) {
9426 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9427 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9428 LDKPersist* this_arg_conv = (LDKPersist*)this_arg_ptr;
9429 LDKOutPoint channel_id_conv;
9430 channel_id_conv.inner = (void*)(channel_id & (~1));
9431 channel_id_conv.is_owned = (channel_id & 1) || (channel_id == 0);
9432 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_id_conv);
9433 channel_id_conv = OutPoint_clone(&channel_id_conv);
9434 LDKChannelMonitorUpdate update_conv;
9435 update_conv.inner = (void*)(update & (~1));
9436 update_conv.is_owned = false;
9437 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_conv);
9438 LDKChannelMonitor data_conv;
9439 data_conv.inner = (void*)(data & (~1));
9440 data_conv.is_owned = false;
9441 CHECK_INNER_FIELD_ACCESS_OR_NULL(data_conv);
9442 LDKMonitorUpdateId update_id_conv;
9443 update_id_conv.inner = (void*)(update_id & (~1));
9444 update_id_conv.is_owned = (update_id & 1) || (update_id == 0);
9445 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_id_conv);
9446 update_id_conv = MonitorUpdateId_clone(&update_id_conv);
9447 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
9448 *ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, channel_id_conv, &update_conv, &data_conv, update_id_conv);
9449 return (uint32_t)ret_conv;
9452 typedef struct LDKChannelMessageHandler_JCalls {
9453 atomic_size_t refcnt;
9454 uint32_t instance_ptr;
9455 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
9456 } LDKChannelMessageHandler_JCalls;
9457 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
9458 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9459 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
9463 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
9464 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9465 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9466 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9467 LDKInitFeatures their_features_var = their_features;
9468 uint32_t their_features_ref = 0;
9469 CHECK((((uintptr_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9470 CHECK((((uintptr_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9471 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9472 their_features_ref = (uintptr_t)their_features_var.inner;
9473 if (their_features_var.is_owned) {
9474 their_features_ref |= 1;
9476 LDKOpenChannel msg_var = *msg;
9477 uint32_t msg_ref = 0;
9478 msg_var = OpenChannel_clone(&msg_var);
9479 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9480 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9481 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9482 msg_ref = (uintptr_t)msg_var.inner;
9483 if (msg_var.is_owned) {
9486 js_invoke_function_u_uuu(j_calls->instance_ptr, 55, (uint32_t)their_node_id_arr, (uint32_t)their_features_ref, (uint32_t)msg_ref);
9488 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
9489 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9490 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9491 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9492 LDKInitFeatures their_features_var = their_features;
9493 uint32_t their_features_ref = 0;
9494 CHECK((((uintptr_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9495 CHECK((((uintptr_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9496 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9497 their_features_ref = (uintptr_t)their_features_var.inner;
9498 if (their_features_var.is_owned) {
9499 their_features_ref |= 1;
9501 LDKAcceptChannel msg_var = *msg;
9502 uint32_t msg_ref = 0;
9503 msg_var = AcceptChannel_clone(&msg_var);
9504 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9505 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9506 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9507 msg_ref = (uintptr_t)msg_var.inner;
9508 if (msg_var.is_owned) {
9511 js_invoke_function_u_uuu(j_calls->instance_ptr, 56, (uint32_t)their_node_id_arr, (uint32_t)their_features_ref, (uint32_t)msg_ref);
9513 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
9514 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9515 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9516 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9517 LDKFundingCreated msg_var = *msg;
9518 uint32_t msg_ref = 0;
9519 msg_var = FundingCreated_clone(&msg_var);
9520 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9521 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9522 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9523 msg_ref = (uintptr_t)msg_var.inner;
9524 if (msg_var.is_owned) {
9527 js_invoke_function_u_uu(j_calls->instance_ptr, 57, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9529 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
9530 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9531 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9532 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9533 LDKFundingSigned msg_var = *msg;
9534 uint32_t msg_ref = 0;
9535 msg_var = FundingSigned_clone(&msg_var);
9536 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9537 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9538 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9539 msg_ref = (uintptr_t)msg_var.inner;
9540 if (msg_var.is_owned) {
9543 js_invoke_function_u_uu(j_calls->instance_ptr, 58, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9545 void handle_channel_ready_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReady * msg) {
9546 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9547 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9548 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9549 LDKChannelReady msg_var = *msg;
9550 uint32_t msg_ref = 0;
9551 msg_var = ChannelReady_clone(&msg_var);
9552 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9553 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9554 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9555 msg_ref = (uintptr_t)msg_var.inner;
9556 if (msg_var.is_owned) {
9559 js_invoke_function_u_uu(j_calls->instance_ptr, 59, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9561 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
9562 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9563 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9564 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9565 LDKInitFeatures their_features_var = *their_features;
9566 uint32_t their_features_ref = 0;
9567 their_features_var = InitFeatures_clone(&their_features_var);
9568 CHECK((((uintptr_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9569 CHECK((((uintptr_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9570 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_var);
9571 their_features_ref = (uintptr_t)their_features_var.inner;
9572 if (their_features_var.is_owned) {
9573 their_features_ref |= 1;
9575 LDKShutdown msg_var = *msg;
9576 uint32_t msg_ref = 0;
9577 msg_var = Shutdown_clone(&msg_var);
9578 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9579 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9580 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9581 msg_ref = (uintptr_t)msg_var.inner;
9582 if (msg_var.is_owned) {
9585 js_invoke_function_u_uuu(j_calls->instance_ptr, 60, (uint32_t)their_node_id_arr, (uint32_t)their_features_ref, (uint32_t)msg_ref);
9587 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
9588 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9589 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9590 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9591 LDKClosingSigned msg_var = *msg;
9592 uint32_t msg_ref = 0;
9593 msg_var = ClosingSigned_clone(&msg_var);
9594 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9595 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9596 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9597 msg_ref = (uintptr_t)msg_var.inner;
9598 if (msg_var.is_owned) {
9601 js_invoke_function_u_uu(j_calls->instance_ptr, 61, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9603 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
9604 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9605 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9606 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9607 LDKUpdateAddHTLC msg_var = *msg;
9608 uint32_t msg_ref = 0;
9609 msg_var = UpdateAddHTLC_clone(&msg_var);
9610 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9611 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9612 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9613 msg_ref = (uintptr_t)msg_var.inner;
9614 if (msg_var.is_owned) {
9617 js_invoke_function_u_uu(j_calls->instance_ptr, 62, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9619 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
9620 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9621 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9622 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9623 LDKUpdateFulfillHTLC msg_var = *msg;
9624 uint32_t msg_ref = 0;
9625 msg_var = UpdateFulfillHTLC_clone(&msg_var);
9626 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9627 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9628 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9629 msg_ref = (uintptr_t)msg_var.inner;
9630 if (msg_var.is_owned) {
9633 js_invoke_function_u_uu(j_calls->instance_ptr, 63, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9635 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
9636 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9637 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9638 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9639 LDKUpdateFailHTLC msg_var = *msg;
9640 uint32_t msg_ref = 0;
9641 msg_var = UpdateFailHTLC_clone(&msg_var);
9642 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9643 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9644 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9645 msg_ref = (uintptr_t)msg_var.inner;
9646 if (msg_var.is_owned) {
9649 js_invoke_function_u_uu(j_calls->instance_ptr, 64, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9651 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
9652 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9653 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9654 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9655 LDKUpdateFailMalformedHTLC msg_var = *msg;
9656 uint32_t msg_ref = 0;
9657 msg_var = UpdateFailMalformedHTLC_clone(&msg_var);
9658 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9659 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9660 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9661 msg_ref = (uintptr_t)msg_var.inner;
9662 if (msg_var.is_owned) {
9665 js_invoke_function_u_uu(j_calls->instance_ptr, 65, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9667 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
9668 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9669 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9670 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9671 LDKCommitmentSigned msg_var = *msg;
9672 uint32_t msg_ref = 0;
9673 msg_var = CommitmentSigned_clone(&msg_var);
9674 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9675 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9676 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9677 msg_ref = (uintptr_t)msg_var.inner;
9678 if (msg_var.is_owned) {
9681 js_invoke_function_u_uu(j_calls->instance_ptr, 66, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9683 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
9684 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9685 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9686 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9687 LDKRevokeAndACK msg_var = *msg;
9688 uint32_t msg_ref = 0;
9689 msg_var = RevokeAndACK_clone(&msg_var);
9690 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9691 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9692 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9693 msg_ref = (uintptr_t)msg_var.inner;
9694 if (msg_var.is_owned) {
9697 js_invoke_function_u_uu(j_calls->instance_ptr, 67, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9699 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
9700 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9701 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9702 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9703 LDKUpdateFee msg_var = *msg;
9704 uint32_t msg_ref = 0;
9705 msg_var = UpdateFee_clone(&msg_var);
9706 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9707 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9708 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9709 msg_ref = (uintptr_t)msg_var.inner;
9710 if (msg_var.is_owned) {
9713 js_invoke_function_u_uu(j_calls->instance_ptr, 68, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9715 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
9716 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9717 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9718 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9719 LDKAnnouncementSignatures msg_var = *msg;
9720 uint32_t msg_ref = 0;
9721 msg_var = AnnouncementSignatures_clone(&msg_var);
9722 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9723 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9724 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9725 msg_ref = (uintptr_t)msg_var.inner;
9726 if (msg_var.is_owned) {
9729 js_invoke_function_u_uu(j_calls->instance_ptr, 69, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9731 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
9732 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9733 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9734 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9735 jboolean no_connection_possible_conv = no_connection_possible;
9736 js_invoke_function_u_uu(j_calls->instance_ptr, 70, (uint32_t)their_node_id_arr, (uint32_t)no_connection_possible_conv);
9738 void peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
9739 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9740 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9741 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9742 LDKInit msg_var = *msg;
9743 uint32_t msg_ref = 0;
9744 msg_var = Init_clone(&msg_var);
9745 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9746 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9747 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9748 msg_ref = (uintptr_t)msg_var.inner;
9749 if (msg_var.is_owned) {
9752 js_invoke_function_u_uu(j_calls->instance_ptr, 71, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9754 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
9755 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9756 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9757 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9758 LDKChannelReestablish msg_var = *msg;
9759 uint32_t msg_ref = 0;
9760 msg_var = ChannelReestablish_clone(&msg_var);
9761 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9762 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9763 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9764 msg_ref = (uintptr_t)msg_var.inner;
9765 if (msg_var.is_owned) {
9768 js_invoke_function_u_uu(j_calls->instance_ptr, 72, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9770 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
9771 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9772 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9773 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9774 LDKChannelUpdate msg_var = *msg;
9775 uint32_t msg_ref = 0;
9776 msg_var = ChannelUpdate_clone(&msg_var);
9777 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9778 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9779 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9780 msg_ref = (uintptr_t)msg_var.inner;
9781 if (msg_var.is_owned) {
9784 js_invoke_function_u_uu(j_calls->instance_ptr, 73, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9786 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
9787 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
9788 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
9789 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
9790 LDKErrorMessage msg_var = *msg;
9791 uint32_t msg_ref = 0;
9792 msg_var = ErrorMessage_clone(&msg_var);
9793 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
9794 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
9795 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
9796 msg_ref = (uintptr_t)msg_var.inner;
9797 if (msg_var.is_owned) {
9800 js_invoke_function_u_uu(j_calls->instance_ptr, 74, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
9802 static void LDKChannelMessageHandler_JCalls_cloned(LDKChannelMessageHandler* new_obj) {
9803 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) new_obj->this_arg;
9804 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
9805 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
9807 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
9808 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
9809 atomic_init(&calls->refcnt, 1);
9810 calls->instance_ptr = o;
9812 LDKChannelMessageHandler ret = {
9813 .this_arg = (void*) calls,
9814 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
9815 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
9816 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
9817 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
9818 .handle_channel_ready = handle_channel_ready_LDKChannelMessageHandler_jcall,
9819 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
9820 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
9821 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
9822 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
9823 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
9824 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
9825 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
9826 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
9827 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
9828 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
9829 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
9830 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
9831 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
9832 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
9833 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
9834 .free = LDKChannelMessageHandler_JCalls_free,
9835 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
9837 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
9840 long __attribute__((export_name("TS_LDKChannelMessageHandler_new"))) TS_LDKChannelMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
9841 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
9842 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
9843 return (long)res_ptr;
9845 void __attribute__((export_name("TS_ChannelMessageHandler_handle_open_channel"))) TS_ChannelMessageHandler_handle_open_channel(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
9846 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9847 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9848 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9849 LDKPublicKey their_node_id_ref;
9850 CHECK(their_node_id->arr_len == 33);
9851 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9852 LDKInitFeatures their_features_conv;
9853 their_features_conv.inner = (void*)(their_features & (~1));
9854 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
9855 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9856 their_features_conv = InitFeatures_clone(&their_features_conv);
9857 LDKOpenChannel msg_conv;
9858 msg_conv.inner = (void*)(msg & (~1));
9859 msg_conv.is_owned = false;
9860 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9861 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
9864 void __attribute__((export_name("TS_ChannelMessageHandler_handle_accept_channel"))) TS_ChannelMessageHandler_handle_accept_channel(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
9865 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9866 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9867 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9868 LDKPublicKey their_node_id_ref;
9869 CHECK(their_node_id->arr_len == 33);
9870 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9871 LDKInitFeatures their_features_conv;
9872 their_features_conv.inner = (void*)(their_features & (~1));
9873 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
9874 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9875 their_features_conv = InitFeatures_clone(&their_features_conv);
9876 LDKAcceptChannel msg_conv;
9877 msg_conv.inner = (void*)(msg & (~1));
9878 msg_conv.is_owned = false;
9879 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9880 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
9883 void __attribute__((export_name("TS_ChannelMessageHandler_handle_funding_created"))) TS_ChannelMessageHandler_handle_funding_created(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9884 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9885 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9886 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9887 LDKPublicKey their_node_id_ref;
9888 CHECK(their_node_id->arr_len == 33);
9889 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9890 LDKFundingCreated msg_conv;
9891 msg_conv.inner = (void*)(msg & (~1));
9892 msg_conv.is_owned = false;
9893 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9894 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9897 void __attribute__((export_name("TS_ChannelMessageHandler_handle_funding_signed"))) TS_ChannelMessageHandler_handle_funding_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9898 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9899 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9900 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9901 LDKPublicKey their_node_id_ref;
9902 CHECK(their_node_id->arr_len == 33);
9903 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9904 LDKFundingSigned msg_conv;
9905 msg_conv.inner = (void*)(msg & (~1));
9906 msg_conv.is_owned = false;
9907 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9908 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9911 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_ready"))) TS_ChannelMessageHandler_handle_channel_ready(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9912 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9913 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9914 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9915 LDKPublicKey their_node_id_ref;
9916 CHECK(their_node_id->arr_len == 33);
9917 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9918 LDKChannelReady msg_conv;
9919 msg_conv.inner = (void*)(msg & (~1));
9920 msg_conv.is_owned = false;
9921 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9922 (this_arg_conv->handle_channel_ready)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9925 void __attribute__((export_name("TS_ChannelMessageHandler_handle_shutdown"))) TS_ChannelMessageHandler_handle_shutdown(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
9926 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9927 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9928 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9929 LDKPublicKey their_node_id_ref;
9930 CHECK(their_node_id->arr_len == 33);
9931 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9932 LDKInitFeatures their_features_conv;
9933 their_features_conv.inner = (void*)(their_features & (~1));
9934 their_features_conv.is_owned = false;
9935 CHECK_INNER_FIELD_ACCESS_OR_NULL(their_features_conv);
9936 LDKShutdown msg_conv;
9937 msg_conv.inner = (void*)(msg & (~1));
9938 msg_conv.is_owned = false;
9939 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9940 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
9943 void __attribute__((export_name("TS_ChannelMessageHandler_handle_closing_signed"))) TS_ChannelMessageHandler_handle_closing_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9944 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9945 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9946 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9947 LDKPublicKey their_node_id_ref;
9948 CHECK(their_node_id->arr_len == 33);
9949 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9950 LDKClosingSigned msg_conv;
9951 msg_conv.inner = (void*)(msg & (~1));
9952 msg_conv.is_owned = false;
9953 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9954 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9957 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_add_htlc"))) TS_ChannelMessageHandler_handle_update_add_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9958 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9959 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9960 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9961 LDKPublicKey their_node_id_ref;
9962 CHECK(their_node_id->arr_len == 33);
9963 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9964 LDKUpdateAddHTLC msg_conv;
9965 msg_conv.inner = (void*)(msg & (~1));
9966 msg_conv.is_owned = false;
9967 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9968 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9971 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fulfill_htlc"))) TS_ChannelMessageHandler_handle_update_fulfill_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9972 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9973 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9974 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9975 LDKPublicKey their_node_id_ref;
9976 CHECK(their_node_id->arr_len == 33);
9977 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9978 LDKUpdateFulfillHTLC msg_conv;
9979 msg_conv.inner = (void*)(msg & (~1));
9980 msg_conv.is_owned = false;
9981 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9982 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9985 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fail_htlc"))) TS_ChannelMessageHandler_handle_update_fail_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
9986 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
9987 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
9988 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
9989 LDKPublicKey their_node_id_ref;
9990 CHECK(their_node_id->arr_len == 33);
9991 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
9992 LDKUpdateFailHTLC msg_conv;
9993 msg_conv.inner = (void*)(msg & (~1));
9994 msg_conv.is_owned = false;
9995 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
9996 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
9999 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fail_malformed_htlc"))) TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10000 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10001 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10002 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10003 LDKPublicKey their_node_id_ref;
10004 CHECK(their_node_id->arr_len == 33);
10005 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10006 LDKUpdateFailMalformedHTLC msg_conv;
10007 msg_conv.inner = (void*)(msg & (~1));
10008 msg_conv.is_owned = false;
10009 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10010 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10013 void __attribute__((export_name("TS_ChannelMessageHandler_handle_commitment_signed"))) TS_ChannelMessageHandler_handle_commitment_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10014 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10015 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10016 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10017 LDKPublicKey their_node_id_ref;
10018 CHECK(their_node_id->arr_len == 33);
10019 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10020 LDKCommitmentSigned msg_conv;
10021 msg_conv.inner = (void*)(msg & (~1));
10022 msg_conv.is_owned = false;
10023 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10024 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10027 void __attribute__((export_name("TS_ChannelMessageHandler_handle_revoke_and_ack"))) TS_ChannelMessageHandler_handle_revoke_and_ack(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10028 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10029 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10030 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10031 LDKPublicKey their_node_id_ref;
10032 CHECK(their_node_id->arr_len == 33);
10033 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10034 LDKRevokeAndACK msg_conv;
10035 msg_conv.inner = (void*)(msg & (~1));
10036 msg_conv.is_owned = false;
10037 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10038 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10041 void __attribute__((export_name("TS_ChannelMessageHandler_handle_update_fee"))) TS_ChannelMessageHandler_handle_update_fee(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10042 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10043 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10044 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10045 LDKPublicKey their_node_id_ref;
10046 CHECK(their_node_id->arr_len == 33);
10047 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10048 LDKUpdateFee msg_conv;
10049 msg_conv.inner = (void*)(msg & (~1));
10050 msg_conv.is_owned = false;
10051 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10052 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10055 void __attribute__((export_name("TS_ChannelMessageHandler_handle_announcement_signatures"))) TS_ChannelMessageHandler_handle_announcement_signatures(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10056 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10057 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10058 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10059 LDKPublicKey their_node_id_ref;
10060 CHECK(their_node_id->arr_len == 33);
10061 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10062 LDKAnnouncementSignatures msg_conv;
10063 msg_conv.inner = (void*)(msg & (~1));
10064 msg_conv.is_owned = false;
10065 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10066 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10069 void __attribute__((export_name("TS_ChannelMessageHandler_peer_disconnected"))) TS_ChannelMessageHandler_peer_disconnected(uint32_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
10070 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10071 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10072 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10073 LDKPublicKey their_node_id_ref;
10074 CHECK(their_node_id->arr_len == 33);
10075 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10076 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
10079 void __attribute__((export_name("TS_ChannelMessageHandler_peer_connected"))) TS_ChannelMessageHandler_peer_connected(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10080 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10081 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10082 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10083 LDKPublicKey their_node_id_ref;
10084 CHECK(their_node_id->arr_len == 33);
10085 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10087 msg_conv.inner = (void*)(msg & (~1));
10088 msg_conv.is_owned = false;
10089 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10090 (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10093 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_reestablish"))) TS_ChannelMessageHandler_handle_channel_reestablish(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10094 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10095 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10096 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10097 LDKPublicKey their_node_id_ref;
10098 CHECK(their_node_id->arr_len == 33);
10099 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10100 LDKChannelReestablish msg_conv;
10101 msg_conv.inner = (void*)(msg & (~1));
10102 msg_conv.is_owned = false;
10103 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10104 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10107 void __attribute__((export_name("TS_ChannelMessageHandler_handle_channel_update"))) TS_ChannelMessageHandler_handle_channel_update(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10108 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10109 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10110 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10111 LDKPublicKey their_node_id_ref;
10112 CHECK(their_node_id->arr_len == 33);
10113 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10114 LDKChannelUpdate msg_conv;
10115 msg_conv.inner = (void*)(msg & (~1));
10116 msg_conv.is_owned = false;
10117 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10118 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10121 void __attribute__((export_name("TS_ChannelMessageHandler_handle_error"))) TS_ChannelMessageHandler_handle_error(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10122 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10123 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10124 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)this_arg_ptr;
10125 LDKPublicKey their_node_id_ref;
10126 CHECK(their_node_id->arr_len == 33);
10127 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10128 LDKErrorMessage msg_conv;
10129 msg_conv.inner = (void*)(msg & (~1));
10130 msg_conv.is_owned = false;
10131 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10132 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
10135 typedef struct LDKRoutingMessageHandler_JCalls {
10136 atomic_size_t refcnt;
10137 uint32_t instance_ptr;
10138 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
10139 } LDKRoutingMessageHandler_JCalls;
10140 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
10141 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10142 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10146 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
10147 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10148 LDKNodeAnnouncement msg_var = *msg;
10149 uint32_t msg_ref = 0;
10150 msg_var = NodeAnnouncement_clone(&msg_var);
10151 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10152 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10153 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10154 msg_ref = (uintptr_t)msg_var.inner;
10155 if (msg_var.is_owned) {
10158 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 75, (uint32_t)msg_ref);
10159 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10160 CHECK_ACCESS(ret_ptr);
10161 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10165 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
10166 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10167 LDKChannelAnnouncement msg_var = *msg;
10168 uint32_t msg_ref = 0;
10169 msg_var = ChannelAnnouncement_clone(&msg_var);
10170 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10171 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10172 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10173 msg_ref = (uintptr_t)msg_var.inner;
10174 if (msg_var.is_owned) {
10177 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 76, (uint32_t)msg_ref);
10178 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10179 CHECK_ACCESS(ret_ptr);
10180 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10184 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
10185 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10186 LDKChannelUpdate msg_var = *msg;
10187 uint32_t msg_ref = 0;
10188 msg_var = ChannelUpdate_clone(&msg_var);
10189 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10190 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10191 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10192 msg_ref = (uintptr_t)msg_var.inner;
10193 if (msg_var.is_owned) {
10196 uint32_t ret = js_invoke_function_u_u(j_calls->instance_ptr, 77, (uint32_t)msg_ref);
10197 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10198 CHECK_ACCESS(ret_ptr);
10199 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(ret_ptr);
10203 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
10204 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10205 int64_t starting_point_conv = starting_point;
10206 int8_t batch_amount_conv = batch_amount;
10207 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_uu(j_calls->instance_ptr, 78, (uint32_t)starting_point_conv, (uint32_t)batch_amount_conv);
10208 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
10209 ret_constr.datalen = ret->arr_len;
10210 if (ret_constr.datalen > 0)
10211 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
10213 ret_constr.data = NULL;
10214 uint32_t* ret_vals = ret->elems;
10215 for (size_t h = 0; h < ret_constr.datalen; h++) {
10216 uint32_t ret_conv_59 = ret_vals[h];
10217 void* ret_conv_59_ptr = (void*)(((uintptr_t)ret_conv_59) & ~1);
10218 CHECK_ACCESS(ret_conv_59_ptr);
10219 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ret_conv_59_ptr);
10220 FREE((void*)ret_conv_59);
10221 ret_constr.data[h] = ret_conv_59_conv;
10226 LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
10227 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10228 int8_tArray starting_point_arr = init_int8_tArray(33, __LINE__);
10229 memcpy(starting_point_arr->elems, starting_point.compressed_form, 33);
10230 int8_t batch_amount_conv = batch_amount;
10231 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_uu(j_calls->instance_ptr, 79, (uint32_t)starting_point_arr, (uint32_t)batch_amount_conv);
10232 LDKCVec_NodeAnnouncementZ ret_constr;
10233 ret_constr.datalen = ret->arr_len;
10234 if (ret_constr.datalen > 0)
10235 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
10237 ret_constr.data = NULL;
10238 uint32_t* ret_vals = ret->elems;
10239 for (size_t s = 0; s < ret_constr.datalen; s++) {
10240 uint32_t ret_conv_18 = ret_vals[s];
10241 LDKNodeAnnouncement ret_conv_18_conv;
10242 ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
10243 ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
10244 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_conv);
10245 ret_constr.data[s] = ret_conv_18_conv;
10250 void peer_connected_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
10251 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10252 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10253 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10254 LDKInit init_var = *init;
10255 uint32_t init_ref = 0;
10256 init_var = Init_clone(&init_var);
10257 CHECK((((uintptr_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10258 CHECK((((uintptr_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10259 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_var);
10260 init_ref = (uintptr_t)init_var.inner;
10261 if (init_var.is_owned) {
10264 js_invoke_function_u_uu(j_calls->instance_ptr, 80, (uint32_t)their_node_id_arr, (uint32_t)init_ref);
10266 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
10267 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10268 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10269 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10270 LDKReplyChannelRange msg_var = msg;
10271 uint32_t msg_ref = 0;
10272 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10273 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10274 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10275 msg_ref = (uintptr_t)msg_var.inner;
10276 if (msg_var.is_owned) {
10279 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 81, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
10280 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10281 CHECK_ACCESS(ret_ptr);
10282 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10286 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
10287 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10288 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10289 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10290 LDKReplyShortChannelIdsEnd msg_var = msg;
10291 uint32_t msg_ref = 0;
10292 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10293 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10294 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10295 msg_ref = (uintptr_t)msg_var.inner;
10296 if (msg_var.is_owned) {
10299 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 82, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
10300 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10301 CHECK_ACCESS(ret_ptr);
10302 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10306 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
10307 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10308 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10309 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10310 LDKQueryChannelRange msg_var = msg;
10311 uint32_t msg_ref = 0;
10312 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10313 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10314 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10315 msg_ref = (uintptr_t)msg_var.inner;
10316 if (msg_var.is_owned) {
10319 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 83, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
10320 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10321 CHECK_ACCESS(ret_ptr);
10322 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10326 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
10327 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
10328 int8_tArray their_node_id_arr = init_int8_tArray(33, __LINE__);
10329 memcpy(their_node_id_arr->elems, their_node_id.compressed_form, 33);
10330 LDKQueryShortChannelIds msg_var = msg;
10331 uint32_t msg_ref = 0;
10332 CHECK((((uintptr_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10333 CHECK((((uintptr_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10334 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_var);
10335 msg_ref = (uintptr_t)msg_var.inner;
10336 if (msg_var.is_owned) {
10339 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 84, (uint32_t)their_node_id_arr, (uint32_t)msg_ref);
10340 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10341 CHECK_ACCESS(ret_ptr);
10342 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10346 static void LDKRoutingMessageHandler_JCalls_cloned(LDKRoutingMessageHandler* new_obj) {
10347 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) new_obj->this_arg;
10348 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10349 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
10351 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (JSValue o, JSValue MessageSendEventsProvider) {
10352 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
10353 atomic_init(&calls->refcnt, 1);
10354 calls->instance_ptr = o;
10356 LDKRoutingMessageHandler ret = {
10357 .this_arg = (void*) calls,
10358 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
10359 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
10360 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
10361 .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
10362 .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
10363 .peer_connected = peer_connected_LDKRoutingMessageHandler_jcall,
10364 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
10365 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
10366 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
10367 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
10368 .free = LDKRoutingMessageHandler_JCalls_free,
10369 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
10371 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
10374 long __attribute__((export_name("TS_LDKRoutingMessageHandler_new"))) TS_LDKRoutingMessageHandler_new(JSValue o, JSValue MessageSendEventsProvider) {
10375 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
10376 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
10377 return (long)res_ptr;
10379 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_node_announcement"))) TS_RoutingMessageHandler_handle_node_announcement(uint32_t this_arg, uint32_t msg) {
10380 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10381 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10382 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10383 LDKNodeAnnouncement msg_conv;
10384 msg_conv.inner = (void*)(msg & (~1));
10385 msg_conv.is_owned = false;
10386 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10387 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10388 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
10389 return (uint32_t)ret_conv;
10392 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_announcement"))) TS_RoutingMessageHandler_handle_channel_announcement(uint32_t this_arg, uint32_t msg) {
10393 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10394 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10395 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10396 LDKChannelAnnouncement msg_conv;
10397 msg_conv.inner = (void*)(msg & (~1));
10398 msg_conv.is_owned = false;
10399 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10400 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10401 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
10402 return (uint32_t)ret_conv;
10405 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_channel_update"))) TS_RoutingMessageHandler_handle_channel_update(uint32_t this_arg, uint32_t msg) {
10406 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10407 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10408 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10409 LDKChannelUpdate msg_conv;
10410 msg_conv.inner = (void*)(msg & (~1));
10411 msg_conv.is_owned = false;
10412 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10413 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
10414 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
10415 return (uint32_t)ret_conv;
10418 uint32_tArray __attribute__((export_name("TS_RoutingMessageHandler_get_next_channel_announcements"))) TS_RoutingMessageHandler_get_next_channel_announcements(uint32_t this_arg, int64_t starting_point, int8_t batch_amount) {
10419 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10420 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10421 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10422 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount);
10423 uint32_tArray ret_arr = NULL;
10424 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
10425 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
10426 for (size_t h = 0; h < ret_var.datalen; h++) {
10427 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_59_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
10428 *ret_conv_59_conv = ret_var.data[h];
10429 ret_arr_ptr[h] = ((uint32_t)ret_conv_59_conv);
10432 FREE(ret_var.data);
10436 uint32_tArray __attribute__((export_name("TS_RoutingMessageHandler_get_next_node_announcements"))) TS_RoutingMessageHandler_get_next_node_announcements(uint32_t this_arg, int8_tArray starting_point, int8_t batch_amount) {
10437 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10438 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10439 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10440 LDKPublicKey starting_point_ref;
10441 CHECK(starting_point->arr_len == 33);
10442 memcpy(starting_point_ref.compressed_form, starting_point->elems, 33); FREE(starting_point);
10443 LDKCVec_NodeAnnouncementZ ret_var = (this_arg_conv->get_next_node_announcements)(this_arg_conv->this_arg, starting_point_ref, batch_amount);
10444 uint32_tArray ret_arr = NULL;
10445 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
10446 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
10447 for (size_t s = 0; s < ret_var.datalen; s++) {
10448 LDKNodeAnnouncement ret_conv_18_var = ret_var.data[s];
10449 uint32_t ret_conv_18_ref = 0;
10450 CHECK((((uintptr_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10451 CHECK((((uintptr_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_18_var);
10453 ret_conv_18_ref = (uintptr_t)ret_conv_18_var.inner;
10454 if (ret_conv_18_var.is_owned) {
10455 ret_conv_18_ref |= 1;
10457 ret_arr_ptr[s] = ret_conv_18_ref;
10460 FREE(ret_var.data);
10464 void __attribute__((export_name("TS_RoutingMessageHandler_peer_connected"))) TS_RoutingMessageHandler_peer_connected(uint32_t this_arg, int8_tArray their_node_id, uint32_t init) {
10465 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10466 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10467 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10468 LDKPublicKey their_node_id_ref;
10469 CHECK(their_node_id->arr_len == 33);
10470 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10472 init_conv.inner = (void*)(init & (~1));
10473 init_conv.is_owned = false;
10474 CHECK_INNER_FIELD_ACCESS_OR_NULL(init_conv);
10475 (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
10478 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_reply_channel_range"))) TS_RoutingMessageHandler_handle_reply_channel_range(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10479 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10480 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10481 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10482 LDKPublicKey their_node_id_ref;
10483 CHECK(their_node_id->arr_len == 33);
10484 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10485 LDKReplyChannelRange msg_conv;
10486 msg_conv.inner = (void*)(msg & (~1));
10487 msg_conv.is_owned = (msg & 1) || (msg == 0);
10488 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10489 msg_conv = ReplyChannelRange_clone(&msg_conv);
10490 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10491 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10492 return (uint32_t)ret_conv;
10495 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_reply_short_channel_ids_end"))) TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10496 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10497 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10498 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10499 LDKPublicKey their_node_id_ref;
10500 CHECK(their_node_id->arr_len == 33);
10501 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10502 LDKReplyShortChannelIdsEnd msg_conv;
10503 msg_conv.inner = (void*)(msg & (~1));
10504 msg_conv.is_owned = (msg & 1) || (msg == 0);
10505 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10506 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
10507 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10508 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10509 return (uint32_t)ret_conv;
10512 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_query_channel_range"))) TS_RoutingMessageHandler_handle_query_channel_range(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10513 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10514 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10515 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10516 LDKPublicKey their_node_id_ref;
10517 CHECK(their_node_id->arr_len == 33);
10518 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10519 LDKQueryChannelRange msg_conv;
10520 msg_conv.inner = (void*)(msg & (~1));
10521 msg_conv.is_owned = (msg & 1) || (msg == 0);
10522 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10523 msg_conv = QueryChannelRange_clone(&msg_conv);
10524 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10525 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10526 return (uint32_t)ret_conv;
10529 uint32_t __attribute__((export_name("TS_RoutingMessageHandler_handle_query_short_channel_ids"))) TS_RoutingMessageHandler_handle_query_short_channel_ids(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
10530 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10531 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10532 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)this_arg_ptr;
10533 LDKPublicKey their_node_id_ref;
10534 CHECK(their_node_id->arr_len == 33);
10535 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
10536 LDKQueryShortChannelIds msg_conv;
10537 msg_conv.inner = (void*)(msg & (~1));
10538 msg_conv.is_owned = (msg & 1) || (msg == 0);
10539 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
10540 msg_conv = QueryShortChannelIds_clone(&msg_conv);
10541 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10542 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
10543 return (uint32_t)ret_conv;
10546 typedef struct LDKCustomMessageReader_JCalls {
10547 atomic_size_t refcnt;
10548 uint32_t instance_ptr;
10549 } LDKCustomMessageReader_JCalls;
10550 static void LDKCustomMessageReader_JCalls_free(void* this_arg) {
10551 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
10552 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10556 LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) {
10557 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg;
10558 int16_t message_type_conv = message_type;
10559 LDKu8slice buffer_var = buffer;
10560 int8_tArray buffer_arr = init_int8_tArray(buffer_var.datalen, __LINE__);
10561 memcpy(buffer_arr->elems, buffer_var.data, buffer_var.datalen);
10562 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 85, (uint32_t)message_type_conv, (uint32_t)buffer_arr);
10563 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10564 CHECK_ACCESS(ret_ptr);
10565 LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(ret_ptr);
10569 static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) {
10570 LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg;
10571 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10573 static inline LDKCustomMessageReader LDKCustomMessageReader_init (JSValue o) {
10574 LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls");
10575 atomic_init(&calls->refcnt, 1);
10576 calls->instance_ptr = o;
10578 LDKCustomMessageReader ret = {
10579 .this_arg = (void*) calls,
10580 .read = read_LDKCustomMessageReader_jcall,
10581 .free = LDKCustomMessageReader_JCalls_free,
10585 long __attribute__((export_name("TS_LDKCustomMessageReader_new"))) TS_LDKCustomMessageReader_new(JSValue o) {
10586 LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
10587 *res_ptr = LDKCustomMessageReader_init(o);
10588 return (long)res_ptr;
10590 uint32_t __attribute__((export_name("TS_CustomMessageReader_read"))) TS_CustomMessageReader_read(uint32_t this_arg, int16_t message_type, int8_tArray buffer) {
10591 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10592 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10593 LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)this_arg_ptr;
10594 LDKu8slice buffer_ref;
10595 buffer_ref.datalen = buffer->arr_len;
10596 buffer_ref.data = buffer->elems;
10597 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
10598 *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref);
10600 return (uint32_t)ret_conv;
10603 typedef struct LDKCustomMessageHandler_JCalls {
10604 atomic_size_t refcnt;
10605 uint32_t instance_ptr;
10606 LDKCustomMessageReader_JCalls* CustomMessageReader;
10607 } LDKCustomMessageHandler_JCalls;
10608 static void LDKCustomMessageHandler_JCalls_free(void* this_arg) {
10609 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10610 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10614 LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) {
10615 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10616 LDKType* msg_ret = MALLOC(sizeof(LDKType), "LDKType");
10618 int8_tArray sender_node_id_arr = init_int8_tArray(33, __LINE__);
10619 memcpy(sender_node_id_arr->elems, sender_node_id.compressed_form, 33);
10620 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 86, (uint32_t)(uint32_t)msg_ret, (uint32_t)sender_node_id_arr);
10621 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10622 CHECK_ACCESS(ret_ptr);
10623 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(ret_ptr);
10627 LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) {
10628 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg;
10629 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_(j_calls->instance_ptr, 87);
10630 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr;
10631 ret_constr.datalen = ret->arr_len;
10632 if (ret_constr.datalen > 0)
10633 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
10635 ret_constr.data = NULL;
10636 uint32_t* ret_vals = ret->elems;
10637 for (size_t z = 0; z < ret_constr.datalen; z++) {
10638 uint32_t ret_conv_25 = ret_vals[z];
10639 void* ret_conv_25_ptr = (void*)(((uintptr_t)ret_conv_25) & ~1);
10640 CHECK_ACCESS(ret_conv_25_ptr);
10641 LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(ret_conv_25_ptr);
10642 FREE((void*)ret_conv_25);
10643 ret_constr.data[z] = ret_conv_25_conv;
10648 static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) {
10649 LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg;
10650 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10651 atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release);
10653 static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (JSValue o, JSValue CustomMessageReader) {
10654 LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls");
10655 atomic_init(&calls->refcnt, 1);
10656 calls->instance_ptr = o;
10658 LDKCustomMessageHandler ret = {
10659 .this_arg = (void*) calls,
10660 .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall,
10661 .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall,
10662 .free = LDKCustomMessageHandler_JCalls_free,
10663 .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader),
10665 calls->CustomMessageReader = ret.CustomMessageReader.this_arg;
10668 long __attribute__((export_name("TS_LDKCustomMessageHandler_new"))) TS_LDKCustomMessageHandler_new(JSValue o, JSValue CustomMessageReader) {
10669 LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
10670 *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader);
10671 return (long)res_ptr;
10673 uint32_t __attribute__((export_name("TS_CustomMessageHandler_handle_custom_message"))) TS_CustomMessageHandler_handle_custom_message(uint32_t this_arg, uint32_t msg, int8_tArray sender_node_id) {
10674 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10675 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10676 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
10677 void* msg_ptr = (void*)(((uintptr_t)msg) & ~1);
10678 CHECK_ACCESS(msg_ptr);
10679 LDKType msg_conv = *(LDKType*)(msg_ptr);
10680 if (msg_conv.free == LDKType_JCalls_free) {
10681 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10682 LDKType_JCalls_cloned(&msg_conv);
10684 LDKPublicKey sender_node_id_ref;
10685 CHECK(sender_node_id->arr_len == 33);
10686 memcpy(sender_node_id_ref.compressed_form, sender_node_id->elems, 33); FREE(sender_node_id);
10687 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
10688 *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref);
10689 return (uint32_t)ret_conv;
10692 uint32_tArray __attribute__((export_name("TS_CustomMessageHandler_get_and_clear_pending_msg"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint32_t this_arg) {
10693 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10694 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10695 LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)this_arg_ptr;
10696 LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg);
10697 uint32_tArray ret_arr = NULL;
10698 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
10699 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
10700 for (size_t z = 0; z < ret_var.datalen; z++) {
10701 LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
10702 *ret_conv_25_conv = ret_var.data[z];
10703 ret_arr_ptr[z] = ((uint32_t)ret_conv_25_conv);
10706 FREE(ret_var.data);
10710 typedef struct LDKSocketDescriptor_JCalls {
10711 atomic_size_t refcnt;
10712 uint32_t instance_ptr;
10713 } LDKSocketDescriptor_JCalls;
10714 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
10715 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10716 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10720 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
10721 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10722 LDKu8slice data_var = data;
10723 int8_tArray data_arr = init_int8_tArray(data_var.datalen, __LINE__);
10724 memcpy(data_arr->elems, data_var.data, data_var.datalen);
10725 jboolean resume_read_conv = resume_read;
10726 return js_invoke_function_u_uu(j_calls->instance_ptr, 88, (uint32_t)data_arr, (uint32_t)resume_read_conv);
10728 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
10729 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10730 js_invoke_function_u_(j_calls->instance_ptr, 89);
10732 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
10733 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10734 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
10735 *other_arg_clone = SocketDescriptor_clone(other_arg);
10736 return js_invoke_function_u_u(j_calls->instance_ptr, 90, (uint32_t)(uint32_t)other_arg_clone);
10738 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
10739 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
10740 return js_invoke_function_b_(j_calls->instance_ptr, 91);
10742 static void LDKSocketDescriptor_JCalls_cloned(LDKSocketDescriptor* new_obj) {
10743 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) new_obj->this_arg;
10744 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10746 static inline LDKSocketDescriptor LDKSocketDescriptor_init (JSValue o) {
10747 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
10748 atomic_init(&calls->refcnt, 1);
10749 calls->instance_ptr = o;
10751 LDKSocketDescriptor ret = {
10752 .this_arg = (void*) calls,
10753 .send_data = send_data_LDKSocketDescriptor_jcall,
10754 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
10755 .eq = eq_LDKSocketDescriptor_jcall,
10756 .hash = hash_LDKSocketDescriptor_jcall,
10757 .cloned = LDKSocketDescriptor_JCalls_cloned,
10758 .free = LDKSocketDescriptor_JCalls_free,
10762 long __attribute__((export_name("TS_LDKSocketDescriptor_new"))) TS_LDKSocketDescriptor_new(JSValue o) {
10763 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
10764 *res_ptr = LDKSocketDescriptor_init(o);
10765 return (long)res_ptr;
10767 uint32_t __attribute__((export_name("TS_SocketDescriptor_send_data"))) TS_SocketDescriptor_send_data(uint32_t this_arg, int8_tArray data, jboolean resume_read) {
10768 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10769 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10770 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10771 LDKu8slice data_ref;
10772 data_ref.datalen = data->arr_len;
10773 data_ref.data = data->elems;
10774 uint32_t ret_conv = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
10779 void __attribute__((export_name("TS_SocketDescriptor_disconnect_socket"))) TS_SocketDescriptor_disconnect_socket(uint32_t this_arg) {
10780 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10781 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10782 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10783 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
10786 int64_t __attribute__((export_name("TS_SocketDescriptor_hash"))) TS_SocketDescriptor_hash(uint32_t this_arg) {
10787 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10788 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10789 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)this_arg_ptr;
10790 int64_t ret_conv = (this_arg_conv->hash)(this_arg_conv->this_arg);
10794 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_ty_from_ptr"))) TS_LDKEffectiveCapacity_ty_from_ptr(uint32_t ptr) {
10795 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)(ptr & ~1);
10797 case LDKEffectiveCapacity_ExactLiquidity: return 0;
10798 case LDKEffectiveCapacity_MaximumHTLC: return 1;
10799 case LDKEffectiveCapacity_Total: return 2;
10800 case LDKEffectiveCapacity_Infinite: return 3;
10801 case LDKEffectiveCapacity_Unknown: return 4;
10805 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat"))) TS_LDKEffectiveCapacity_ExactLiquidity_get_liquidity_msat(uint32_t ptr) {
10806 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)(ptr & ~1);
10807 assert(obj->tag == LDKEffectiveCapacity_ExactLiquidity);
10808 int64_t liquidity_msat_conv = obj->exact_liquidity.liquidity_msat;
10809 return liquidity_msat_conv;
10811 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat"))) TS_LDKEffectiveCapacity_MaximumHTLC_get_amount_msat(uint32_t ptr) {
10812 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)(ptr & ~1);
10813 assert(obj->tag == LDKEffectiveCapacity_MaximumHTLC);
10814 int64_t amount_msat_conv = obj->maximum_htlc.amount_msat;
10815 return amount_msat_conv;
10817 int64_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_capacity_msat"))) TS_LDKEffectiveCapacity_Total_get_capacity_msat(uint32_t ptr) {
10818 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)(ptr & ~1);
10819 assert(obj->tag == LDKEffectiveCapacity_Total);
10820 int64_t capacity_msat_conv = obj->total.capacity_msat;
10821 return capacity_msat_conv;
10823 uint32_t __attribute__((export_name("TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat"))) TS_LDKEffectiveCapacity_Total_get_htlc_maximum_msat(uint32_t ptr) {
10824 LDKEffectiveCapacity *obj = (LDKEffectiveCapacity*)(ptr & ~1);
10825 assert(obj->tag == LDKEffectiveCapacity_Total);
10826 uint32_t htlc_maximum_msat_ref = ((uintptr_t)&obj->total.htlc_maximum_msat) | 1;
10827 return htlc_maximum_msat_ref;
10829 typedef struct LDKLockableScore_JCalls {
10830 atomic_size_t refcnt;
10831 uint32_t instance_ptr;
10832 } LDKLockableScore_JCalls;
10833 static void LDKLockableScore_JCalls_free(void* this_arg) {
10834 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
10835 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10839 LDKScore lock_LDKLockableScore_jcall(const void* this_arg) {
10840 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) this_arg;
10841 uint32_t ret = js_invoke_function_u_(j_calls->instance_ptr, 92);
10842 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10843 CHECK_ACCESS(ret_ptr);
10844 LDKScore ret_conv = *(LDKScore*)(ret_ptr);
10845 if (ret_conv.free == LDKScore_JCalls_free) {
10846 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
10847 LDKScore_JCalls_cloned(&ret_conv);
10848 }// WARNING: we may need a move here but no clone is available for LDKScore
10852 static void LDKLockableScore_JCalls_cloned(LDKLockableScore* new_obj) {
10853 LDKLockableScore_JCalls *j_calls = (LDKLockableScore_JCalls*) new_obj->this_arg;
10854 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
10856 static inline LDKLockableScore LDKLockableScore_init (JSValue o) {
10857 LDKLockableScore_JCalls *calls = MALLOC(sizeof(LDKLockableScore_JCalls), "LDKLockableScore_JCalls");
10858 atomic_init(&calls->refcnt, 1);
10859 calls->instance_ptr = o;
10861 LDKLockableScore ret = {
10862 .this_arg = (void*) calls,
10863 .lock = lock_LDKLockableScore_jcall,
10864 .free = LDKLockableScore_JCalls_free,
10868 long __attribute__((export_name("TS_LDKLockableScore_new"))) TS_LDKLockableScore_new(JSValue o) {
10869 LDKLockableScore *res_ptr = MALLOC(sizeof(LDKLockableScore), "LDKLockableScore");
10870 *res_ptr = LDKLockableScore_init(o);
10871 return (long)res_ptr;
10873 uint32_t __attribute__((export_name("TS_LockableScore_lock"))) TS_LockableScore_lock(uint32_t this_arg) {
10874 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
10875 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
10876 LDKLockableScore* this_arg_conv = (LDKLockableScore*)this_arg_ptr;
10877 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
10878 *ret_ret = (this_arg_conv->lock)(this_arg_conv->this_arg);
10879 return (uint32_t)ret_ret;
10882 uint32_t __attribute__((export_name("TS_LDKFallback_ty_from_ptr"))) TS_LDKFallback_ty_from_ptr(uint32_t ptr) {
10883 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
10885 case LDKFallback_SegWitProgram: return 0;
10886 case LDKFallback_PubKeyHash: return 1;
10887 case LDKFallback_ScriptHash: return 2;
10891 int8_t __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_version"))) TS_LDKFallback_SegWitProgram_get_version(uint32_t ptr) {
10892 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
10893 assert(obj->tag == LDKFallback_SegWitProgram);
10894 uint8_t version_val = obj->seg_wit_program.version._0;
10895 return version_val;
10897 int8_tArray __attribute__((export_name("TS_LDKFallback_SegWitProgram_get_program"))) TS_LDKFallback_SegWitProgram_get_program(uint32_t ptr) {
10898 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
10899 assert(obj->tag == LDKFallback_SegWitProgram);
10900 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
10901 int8_tArray program_arr = init_int8_tArray(program_var.datalen, __LINE__);
10902 memcpy(program_arr->elems, program_var.data, program_var.datalen);
10903 return program_arr;
10905 int8_tArray __attribute__((export_name("TS_LDKFallback_PubKeyHash_get_pub_key_hash"))) TS_LDKFallback_PubKeyHash_get_pub_key_hash(uint32_t ptr) {
10906 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
10907 assert(obj->tag == LDKFallback_PubKeyHash);
10908 int8_tArray pub_key_hash_arr = init_int8_tArray(20, __LINE__);
10909 memcpy(pub_key_hash_arr->elems, obj->pub_key_hash.data, 20);
10910 return pub_key_hash_arr;
10912 int8_tArray __attribute__((export_name("TS_LDKFallback_ScriptHash_get_script_hash"))) TS_LDKFallback_ScriptHash_get_script_hash(uint32_t ptr) {
10913 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
10914 assert(obj->tag == LDKFallback_ScriptHash);
10915 int8_tArray script_hash_arr = init_int8_tArray(20, __LINE__);
10916 memcpy(script_hash_arr->elems, obj->script_hash.data, 20);
10917 return script_hash_arr;
10919 typedef struct LDKPayer_JCalls {
10920 atomic_size_t refcnt;
10921 uint32_t instance_ptr;
10923 static void LDKPayer_JCalls_free(void* this_arg) {
10924 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
10925 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
10929 LDKPublicKey node_id_LDKPayer_jcall(const void* this_arg) {
10930 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
10931 int8_tArray ret = (int8_tArray)js_invoke_function_u_(j_calls->instance_ptr, 93);
10932 LDKPublicKey ret_ref;
10933 CHECK(ret->arr_len == 33);
10934 memcpy(ret_ref.compressed_form, ret->elems, 33); FREE(ret);
10937 LDKCVec_ChannelDetailsZ first_hops_LDKPayer_jcall(const void* this_arg) {
10938 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
10939 uint32_tArray ret = (uint32_tArray)js_invoke_function_u_(j_calls->instance_ptr, 94);
10940 LDKCVec_ChannelDetailsZ ret_constr;
10941 ret_constr.datalen = ret->arr_len;
10942 if (ret_constr.datalen > 0)
10943 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
10945 ret_constr.data = NULL;
10946 uint32_t* ret_vals = ret->elems;
10947 for (size_t q = 0; q < ret_constr.datalen; q++) {
10948 uint32_t ret_conv_16 = ret_vals[q];
10949 LDKChannelDetails ret_conv_16_conv;
10950 ret_conv_16_conv.inner = (void*)(ret_conv_16 & (~1));
10951 ret_conv_16_conv.is_owned = (ret_conv_16 & 1) || (ret_conv_16 == 0);
10952 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_conv);
10953 ret_constr.data[q] = ret_conv_16_conv;
10958 LDKCResult_PaymentIdPaymentSendFailureZ send_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_hash, LDKThirtyTwoBytes payment_secret) {
10959 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
10960 LDKRoute route_var = *route;
10961 uint32_t route_ref = 0;
10962 route_var = Route_clone(&route_var);
10963 CHECK((((uintptr_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10964 CHECK((((uintptr_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10965 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
10966 route_ref = (uintptr_t)route_var.inner;
10967 if (route_var.is_owned) {
10970 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
10971 memcpy(payment_hash_arr->elems, payment_hash.data, 32);
10972 int8_tArray payment_secret_arr = init_int8_tArray(32, __LINE__);
10973 memcpy(payment_secret_arr->elems, payment_secret.data, 32);
10974 uint32_t ret = js_invoke_function_u_uuu(j_calls->instance_ptr, 95, (uint32_t)route_ref, (uint32_t)payment_hash_arr, (uint32_t)payment_secret_arr);
10975 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10976 CHECK_ACCESS(ret_ptr);
10977 LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
10981 LDKCResult_PaymentIdPaymentSendFailureZ send_spontaneous_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_preimage) {
10982 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
10983 LDKRoute route_var = *route;
10984 uint32_t route_ref = 0;
10985 route_var = Route_clone(&route_var);
10986 CHECK((((uintptr_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10987 CHECK((((uintptr_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10988 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
10989 route_ref = (uintptr_t)route_var.inner;
10990 if (route_var.is_owned) {
10993 int8_tArray payment_preimage_arr = init_int8_tArray(32, __LINE__);
10994 memcpy(payment_preimage_arr->elems, payment_preimage.data, 32);
10995 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 96, (uint32_t)route_ref, (uint32_t)payment_preimage_arr);
10996 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
10997 CHECK_ACCESS(ret_ptr);
10998 LDKCResult_PaymentIdPaymentSendFailureZ ret_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(ret_ptr);
11002 LDKCResult_NonePaymentSendFailureZ retry_payment_LDKPayer_jcall(const void* this_arg, const LDKRoute * route, LDKThirtyTwoBytes payment_id) {
11003 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11004 LDKRoute route_var = *route;
11005 uint32_t route_ref = 0;
11006 route_var = Route_clone(&route_var);
11007 CHECK((((uintptr_t)route_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11008 CHECK((((uintptr_t)&route_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11009 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_var);
11010 route_ref = (uintptr_t)route_var.inner;
11011 if (route_var.is_owned) {
11014 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11015 memcpy(payment_id_arr->elems, payment_id.data, 32);
11016 uint32_t ret = js_invoke_function_u_uu(j_calls->instance_ptr, 97, (uint32_t)route_ref, (uint32_t)payment_id_arr);
11017 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
11018 CHECK_ACCESS(ret_ptr);
11019 LDKCResult_NonePaymentSendFailureZ ret_conv = *(LDKCResult_NonePaymentSendFailureZ*)(ret_ptr);
11023 void abandon_payment_LDKPayer_jcall(const void* this_arg, LDKThirtyTwoBytes payment_id) {
11024 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) this_arg;
11025 int8_tArray payment_id_arr = init_int8_tArray(32, __LINE__);
11026 memcpy(payment_id_arr->elems, payment_id.data, 32);
11027 js_invoke_function_u_u(j_calls->instance_ptr, 98, (uint32_t)payment_id_arr);
11029 static void LDKPayer_JCalls_cloned(LDKPayer* new_obj) {
11030 LDKPayer_JCalls *j_calls = (LDKPayer_JCalls*) new_obj->this_arg;
11031 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11033 static inline LDKPayer LDKPayer_init (JSValue o) {
11034 LDKPayer_JCalls *calls = MALLOC(sizeof(LDKPayer_JCalls), "LDKPayer_JCalls");
11035 atomic_init(&calls->refcnt, 1);
11036 calls->instance_ptr = o;
11039 .this_arg = (void*) calls,
11040 .node_id = node_id_LDKPayer_jcall,
11041 .first_hops = first_hops_LDKPayer_jcall,
11042 .send_payment = send_payment_LDKPayer_jcall,
11043 .send_spontaneous_payment = send_spontaneous_payment_LDKPayer_jcall,
11044 .retry_payment = retry_payment_LDKPayer_jcall,
11045 .abandon_payment = abandon_payment_LDKPayer_jcall,
11046 .free = LDKPayer_JCalls_free,
11050 long __attribute__((export_name("TS_LDKPayer_new"))) TS_LDKPayer_new(JSValue o) {
11051 LDKPayer *res_ptr = MALLOC(sizeof(LDKPayer), "LDKPayer");
11052 *res_ptr = LDKPayer_init(o);
11053 return (long)res_ptr;
11055 int8_tArray __attribute__((export_name("TS_Payer_node_id"))) TS_Payer_node_id(uint32_t this_arg) {
11056 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11057 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11058 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11059 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
11060 memcpy(ret_arr->elems, (this_arg_conv->node_id)(this_arg_conv->this_arg).compressed_form, 33);
11064 uint32_tArray __attribute__((export_name("TS_Payer_first_hops"))) TS_Payer_first_hops(uint32_t this_arg) {
11065 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11066 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11067 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11068 LDKCVec_ChannelDetailsZ ret_var = (this_arg_conv->first_hops)(this_arg_conv->this_arg);
11069 uint32_tArray ret_arr = NULL;
11070 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
11071 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
11072 for (size_t q = 0; q < ret_var.datalen; q++) {
11073 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
11074 uint32_t ret_conv_16_ref = 0;
11075 CHECK((((uintptr_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11076 CHECK((((uintptr_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11077 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
11078 ret_conv_16_ref = (uintptr_t)ret_conv_16_var.inner;
11079 if (ret_conv_16_var.is_owned) {
11080 ret_conv_16_ref |= 1;
11082 ret_arr_ptr[q] = ret_conv_16_ref;
11085 FREE(ret_var.data);
11089 uint32_t __attribute__((export_name("TS_Payer_send_payment"))) TS_Payer_send_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_hash, int8_tArray payment_secret) {
11090 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11091 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11092 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11093 LDKRoute route_conv;
11094 route_conv.inner = (void*)(route & (~1));
11095 route_conv.is_owned = false;
11096 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11097 LDKThirtyTwoBytes payment_hash_ref;
11098 CHECK(payment_hash->arr_len == 32);
11099 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
11100 LDKThirtyTwoBytes payment_secret_ref;
11101 CHECK(payment_secret->arr_len == 32);
11102 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
11103 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
11104 *ret_conv = (this_arg_conv->send_payment)(this_arg_conv->this_arg, &route_conv, payment_hash_ref, payment_secret_ref);
11105 return (uint32_t)ret_conv;
11108 uint32_t __attribute__((export_name("TS_Payer_send_spontaneous_payment"))) TS_Payer_send_spontaneous_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_preimage) {
11109 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11110 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11111 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11112 LDKRoute route_conv;
11113 route_conv.inner = (void*)(route & (~1));
11114 route_conv.is_owned = false;
11115 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11116 LDKThirtyTwoBytes payment_preimage_ref;
11117 CHECK(payment_preimage->arr_len == 32);
11118 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
11119 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
11120 *ret_conv = (this_arg_conv->send_spontaneous_payment)(this_arg_conv->this_arg, &route_conv, payment_preimage_ref);
11121 return (uint32_t)ret_conv;
11124 uint32_t __attribute__((export_name("TS_Payer_retry_payment"))) TS_Payer_retry_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_id) {
11125 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11126 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11127 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11128 LDKRoute route_conv;
11129 route_conv.inner = (void*)(route & (~1));
11130 route_conv.is_owned = false;
11131 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
11132 LDKThirtyTwoBytes payment_id_ref;
11133 CHECK(payment_id->arr_len == 32);
11134 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11135 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
11136 *ret_conv = (this_arg_conv->retry_payment)(this_arg_conv->this_arg, &route_conv, payment_id_ref);
11137 return (uint32_t)ret_conv;
11140 void __attribute__((export_name("TS_Payer_abandon_payment"))) TS_Payer_abandon_payment(uint32_t this_arg, int8_tArray payment_id) {
11141 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11142 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11143 LDKPayer* this_arg_conv = (LDKPayer*)this_arg_ptr;
11144 LDKThirtyTwoBytes payment_id_ref;
11145 CHECK(payment_id->arr_len == 32);
11146 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
11147 (this_arg_conv->abandon_payment)(this_arg_conv->this_arg, payment_id_ref);
11150 typedef struct LDKRouter_JCalls {
11151 atomic_size_t refcnt;
11152 uint32_t instance_ptr;
11153 } LDKRouter_JCalls;
11154 static void LDKRouter_JCalls_free(void* this_arg) {
11155 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
11156 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
11160 LDKCResult_RouteLightningErrorZ find_route_LDKRouter_jcall(const void* this_arg, LDKPublicKey payer, const LDKRouteParameters * route_params, const uint8_t (* payment_hash)[32], LDKCVec_ChannelDetailsZ * first_hops, const LDKScore * scorer) {
11161 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) this_arg;
11162 int8_tArray payer_arr = init_int8_tArray(33, __LINE__);
11163 memcpy(payer_arr->elems, payer.compressed_form, 33);
11164 LDKRouteParameters route_params_var = *route_params;
11165 uint32_t route_params_ref = 0;
11166 route_params_var = RouteParameters_clone(&route_params_var);
11167 CHECK((((uintptr_t)route_params_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11168 CHECK((((uintptr_t)&route_params_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11169 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_var);
11170 route_params_ref = (uintptr_t)route_params_var.inner;
11171 if (route_params_var.is_owned) {
11172 route_params_ref |= 1;
11174 int8_tArray payment_hash_arr = init_int8_tArray(32, __LINE__);
11175 memcpy(payment_hash_arr->elems, *payment_hash, 32);
11176 LDKCVec_ChannelDetailsZ *first_hops_var_ptr = first_hops;
11177 uint32_tArray first_hops_arr = NULL;
11178 if (first_hops != NULL) {
11179 LDKCVec_ChannelDetailsZ first_hops_var = *first_hops_var_ptr;
11180 first_hops_arr = init_uint32_tArray(first_hops_var.datalen, __LINE__);
11181 uint32_t *first_hops_arr_ptr = (uint32_t*)(((uint8_t*)first_hops_arr) + 4);
11182 for (size_t q = 0; q < first_hops_var.datalen; q++) {
11183 LDKChannelDetails first_hops_conv_16_var = first_hops_var.data[q];
11184 uint32_t first_hops_conv_16_ref = 0;
11185 CHECK((((uintptr_t)first_hops_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11186 CHECK((((uintptr_t)&first_hops_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11187 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_var);
11188 first_hops_conv_16_ref = (uintptr_t)first_hops_conv_16_var.inner;
11189 if (first_hops_conv_16_var.is_owned) {
11190 first_hops_conv_16_ref |= 1;
11192 first_hops_arr_ptr[q] = first_hops_conv_16_ref;
11196 // WARNING: This object doesn't live past this scope, needs clone!
11197 uint32_t ret_scorer = ((uintptr_t)scorer) | 1;
11198 uint32_t ret = js_invoke_function_u_uuuuu(j_calls->instance_ptr, 99, (uint32_t)payer_arr, (uint32_t)route_params_ref, (uint32_t)payment_hash_arr, (uint32_t)first_hops_arr, (uint32_t)ret_scorer);
11199 void* ret_ptr = (void*)(((uintptr_t)ret) & ~1);
11200 CHECK_ACCESS(ret_ptr);
11201 LDKCResult_RouteLightningErrorZ ret_conv = *(LDKCResult_RouteLightningErrorZ*)(ret_ptr);
11205 static void LDKRouter_JCalls_cloned(LDKRouter* new_obj) {
11206 LDKRouter_JCalls *j_calls = (LDKRouter_JCalls*) new_obj->this_arg;
11207 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
11209 static inline LDKRouter LDKRouter_init (JSValue o) {
11210 LDKRouter_JCalls *calls = MALLOC(sizeof(LDKRouter_JCalls), "LDKRouter_JCalls");
11211 atomic_init(&calls->refcnt, 1);
11212 calls->instance_ptr = o;
11215 .this_arg = (void*) calls,
11216 .find_route = find_route_LDKRouter_jcall,
11217 .free = LDKRouter_JCalls_free,
11221 long __attribute__((export_name("TS_LDKRouter_new"))) TS_LDKRouter_new(JSValue o) {
11222 LDKRouter *res_ptr = MALLOC(sizeof(LDKRouter), "LDKRouter");
11223 *res_ptr = LDKRouter_init(o);
11224 return (long)res_ptr;
11226 uint32_t __attribute__((export_name("TS_Router_find_route"))) TS_Router_find_route(uint32_t this_arg, int8_tArray payer, uint32_t route_params, int8_tArray payment_hash, uint32_tArray first_hops, uint32_t scorer) {
11227 void* this_arg_ptr = (void*)(((uintptr_t)this_arg) & ~1);
11228 if (!(this_arg & 1)) { CHECK_ACCESS(this_arg_ptr); }
11229 LDKRouter* this_arg_conv = (LDKRouter*)this_arg_ptr;
11230 LDKPublicKey payer_ref;
11231 CHECK(payer->arr_len == 33);
11232 memcpy(payer_ref.compressed_form, payer->elems, 33); FREE(payer);
11233 LDKRouteParameters route_params_conv;
11234 route_params_conv.inner = (void*)(route_params & (~1));
11235 route_params_conv.is_owned = false;
11236 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
11237 unsigned char payment_hash_arr[32];
11238 CHECK(payment_hash->arr_len == 32);
11239 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
11240 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
11241 LDKCVec_ChannelDetailsZ first_hops_constr;
11242 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
11243 if (first_hops != 0) {
11244 first_hops_constr.datalen = first_hops->arr_len;
11245 if (first_hops_constr.datalen > 0)
11246 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
11248 first_hops_constr.data = NULL;
11249 uint32_t* first_hops_vals = first_hops->elems;
11250 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
11251 uint32_t first_hops_conv_16 = first_hops_vals[q];
11252 LDKChannelDetails first_hops_conv_16_conv;
11253 first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
11254 first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
11255 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
11256 first_hops_constr.data[q] = first_hops_conv_16_conv;
11259 first_hops_ptr = &first_hops_constr;
11261 void* scorer_ptr = (void*)(((uintptr_t)scorer) & ~1);
11262 if (!(scorer & 1)) { CHECK_ACCESS(scorer_ptr); }
11263 LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
11264 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
11265 *ret_conv = (this_arg_conv->find_route)(this_arg_conv->this_arg, payer_ref, &route_params_conv, payment_hash_ref, first_hops_ptr, scorer_conv);
11266 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
11267 return (uint32_t)ret_conv;
11270 uint32_t __attribute__((export_name("TS_LDKRetry_ty_from_ptr"))) TS_LDKRetry_ty_from_ptr(uint32_t ptr) {
11271 LDKRetry *obj = (LDKRetry*)(ptr & ~1);
11273 case LDKRetry_Attempts: return 0;
11277 uint32_t __attribute__((export_name("TS_LDKRetry_Attempts_get_attempts"))) TS_LDKRetry_Attempts_get_attempts(uint32_t ptr) {
11278 LDKRetry *obj = (LDKRetry*)(ptr & ~1);
11279 assert(obj->tag == LDKRetry_Attempts);
11280 uint32_t attempts_conv = obj->attempts;
11281 return attempts_conv;
11283 jstring __attribute__((export_name("TS__ldk_get_compiled_version"))) TS__ldk_get_compiled_version() {
11284 LDKStr ret_str = _ldk_get_compiled_version();
11285 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11290 jstring __attribute__((export_name("TS__ldk_c_bindings_get_compiled_version"))) TS__ldk_c_bindings_get_compiled_version() {
11291 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
11292 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
11297 static inline uintptr_t Bech32Error_clone_ptr(LDKBech32Error *NONNULL_PTR arg) {
11298 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11299 *ret_copy = Bech32Error_clone(arg);
11300 uint32_t ret_ref = (uintptr_t)ret_copy;
11303 uint32_t __attribute__((export_name("TS_Bech32Error_clone_ptr"))) TS_Bech32Error_clone_ptr(uint32_t arg) {
11304 LDKBech32Error* arg_conv = (LDKBech32Error*)arg;
11305 uint32_t ret_conv = Bech32Error_clone_ptr(arg_conv);
11309 uint32_t __attribute__((export_name("TS_Bech32Error_clone"))) TS_Bech32Error_clone(uint32_t orig) {
11310 LDKBech32Error* orig_conv = (LDKBech32Error*)orig;
11311 LDKBech32Error *ret_copy = MALLOC(sizeof(LDKBech32Error), "LDKBech32Error");
11312 *ret_copy = Bech32Error_clone(orig_conv);
11313 uint32_t ret_ref = (uintptr_t)ret_copy;
11317 void __attribute__((export_name("TS_Bech32Error_free"))) TS_Bech32Error_free(uint32_t o) {
11318 if ((o & 1) != 0) return;
11319 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
11320 CHECK_ACCESS(o_ptr);
11321 LDKBech32Error o_conv = *(LDKBech32Error*)(o_ptr);
11323 Bech32Error_free(o_conv);
11326 void __attribute__((export_name("TS_Transaction_free"))) TS_Transaction_free(int8_tArray _res) {
11327 LDKTransaction _res_ref;
11328 _res_ref.datalen = _res->arr_len;
11329 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
11330 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
11331 _res_ref.data_is_owned = true;
11332 Transaction_free(_res_ref);
11335 uint32_t __attribute__((export_name("TS_TxOut_new"))) TS_TxOut_new(int8_tArray script_pubkey, int64_t value) {
11336 LDKCVec_u8Z script_pubkey_ref;
11337 script_pubkey_ref.datalen = script_pubkey->arr_len;
11338 script_pubkey_ref.data = MALLOC(script_pubkey_ref.datalen, "LDKCVec_u8Z Bytes");
11339 memcpy(script_pubkey_ref.data, script_pubkey->elems, script_pubkey_ref.datalen); FREE(script_pubkey);
11340 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11341 *ret_ref = TxOut_new(script_pubkey_ref, value);
11342 return (uint32_t)ret_ref;
11345 void __attribute__((export_name("TS_TxOut_free"))) TS_TxOut_free(uint32_t _res) {
11346 if ((_res & 1) != 0) return;
11347 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11348 CHECK_ACCESS(_res_ptr);
11349 LDKTxOut _res_conv = *(LDKTxOut*)(_res_ptr);
11351 TxOut_free(_res_conv);
11354 static inline uintptr_t TxOut_clone_ptr(LDKTxOut *NONNULL_PTR arg) {
11355 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11356 *ret_ref = TxOut_clone(arg);
11357 return (uint32_t)ret_ref;
11359 uint32_t __attribute__((export_name("TS_TxOut_clone_ptr"))) TS_TxOut_clone_ptr(uint32_t arg) {
11360 LDKTxOut* arg_conv = (LDKTxOut*)(arg & ~1);
11361 uint32_t ret_conv = TxOut_clone_ptr(arg_conv);
11365 uint32_t __attribute__((export_name("TS_TxOut_clone"))) TS_TxOut_clone(uint32_t orig) {
11366 LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
11367 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
11368 *ret_ref = TxOut_clone(orig_conv);
11369 return (uint32_t)ret_ref;
11372 void __attribute__((export_name("TS_Str_free"))) TS_Str_free(jstring _res) {
11373 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
11377 uint32_t __attribute__((export_name("TS_CResult_NoneNoneZ_ok"))) TS_CResult_NoneNoneZ_ok() {
11378 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11379 *ret_conv = CResult_NoneNoneZ_ok();
11380 return (uint32_t)ret_conv;
11383 uint32_t __attribute__((export_name("TS_CResult_NoneNoneZ_err"))) TS_CResult_NoneNoneZ_err() {
11384 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11385 *ret_conv = CResult_NoneNoneZ_err();
11386 return (uint32_t)ret_conv;
11389 jboolean __attribute__((export_name("TS_CResult_NoneNoneZ_is_ok"))) TS_CResult_NoneNoneZ_is_ok(uint32_t o) {
11390 LDKCResult_NoneNoneZ* o_conv = (LDKCResult_NoneNoneZ*)(o & ~1);
11391 jboolean ret_conv = CResult_NoneNoneZ_is_ok(o_conv);
11395 void __attribute__((export_name("TS_CResult_NoneNoneZ_free"))) TS_CResult_NoneNoneZ_free(uint32_t _res) {
11396 if ((_res & 1) != 0) return;
11397 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11398 CHECK_ACCESS(_res_ptr);
11399 LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(_res_ptr);
11401 CResult_NoneNoneZ_free(_res_conv);
11404 static inline uintptr_t CResult_NoneNoneZ_clone_ptr(LDKCResult_NoneNoneZ *NONNULL_PTR arg) {
11405 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11406 *ret_conv = CResult_NoneNoneZ_clone(arg);
11407 return (uint32_t)ret_conv;
11409 uint32_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone_ptr"))) TS_CResult_NoneNoneZ_clone_ptr(uint32_t arg) {
11410 LDKCResult_NoneNoneZ* arg_conv = (LDKCResult_NoneNoneZ*)(arg & ~1);
11411 uint32_t ret_conv = CResult_NoneNoneZ_clone_ptr(arg_conv);
11415 uint32_t __attribute__((export_name("TS_CResult_NoneNoneZ_clone"))) TS_CResult_NoneNoneZ_clone(uint32_t orig) {
11416 LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1);
11417 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
11418 *ret_conv = CResult_NoneNoneZ_clone(orig_conv);
11419 return (uint32_t)ret_conv;
11422 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(uint32_t o) {
11423 LDKCounterpartyCommitmentSecrets o_conv;
11424 o_conv.inner = (void*)(o & (~1));
11425 o_conv.is_owned = (o & 1) || (o == 0);
11426 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11427 o_conv = CounterpartyCommitmentSecrets_clone(&o_conv);
11428 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11429 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_ok(o_conv);
11430 return (uint32_t)ret_conv;
11433 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(uint32_t e) {
11434 LDKDecodeError e_conv;
11435 e_conv.inner = (void*)(e & (~1));
11436 e_conv.is_owned = (e & 1) || (e == 0);
11437 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11438 e_conv = DecodeError_clone(&e_conv);
11439 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11440 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_err(e_conv);
11441 return (uint32_t)ret_conv;
11444 jboolean __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(uint32_t o) {
11445 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* o_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(o & ~1);
11446 jboolean ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_is_ok(o_conv);
11450 void __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(uint32_t _res) {
11451 if ((_res & 1) != 0) return;
11452 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11453 CHECK_ACCESS(_res_ptr);
11454 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(_res_ptr);
11456 CResult_CounterpartyCommitmentSecretsDecodeErrorZ_free(_res_conv);
11459 static inline uintptr_t CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ *NONNULL_PTR arg) {
11460 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11461 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(arg);
11462 return (uint32_t)ret_conv;
11464 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(uint32_t arg) {
11465 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(arg & ~1);
11466 uint32_t ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone_ptr(arg_conv);
11470 uint32_t __attribute__((export_name("TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone"))) TS_CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(uint32_t orig) {
11471 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ*)(orig & ~1);
11472 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
11473 *ret_conv = CResult_CounterpartyCommitmentSecretsDecodeErrorZ_clone(orig_conv);
11474 return (uint32_t)ret_conv;
11477 uint32_t __attribute__((export_name("TS_CResult_SecretKeyErrorZ_ok"))) TS_CResult_SecretKeyErrorZ_ok(int8_tArray o) {
11478 LDKSecretKey o_ref;
11479 CHECK(o->arr_len == 32);
11480 memcpy(o_ref.bytes, o->elems, 32); FREE(o);
11481 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
11482 *ret_conv = CResult_SecretKeyErrorZ_ok(o_ref);
11483 return (uint32_t)ret_conv;
11486 uint32_t __attribute__((export_name("TS_CResult_SecretKeyErrorZ_err"))) TS_CResult_SecretKeyErrorZ_err(uint32_t e) {
11487 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
11488 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
11489 *ret_conv = CResult_SecretKeyErrorZ_err(e_conv);
11490 return (uint32_t)ret_conv;
11493 jboolean __attribute__((export_name("TS_CResult_SecretKeyErrorZ_is_ok"))) TS_CResult_SecretKeyErrorZ_is_ok(uint32_t o) {
11494 LDKCResult_SecretKeyErrorZ* o_conv = (LDKCResult_SecretKeyErrorZ*)(o & ~1);
11495 jboolean ret_conv = CResult_SecretKeyErrorZ_is_ok(o_conv);
11499 void __attribute__((export_name("TS_CResult_SecretKeyErrorZ_free"))) TS_CResult_SecretKeyErrorZ_free(uint32_t _res) {
11500 if ((_res & 1) != 0) return;
11501 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11502 CHECK_ACCESS(_res_ptr);
11503 LDKCResult_SecretKeyErrorZ _res_conv = *(LDKCResult_SecretKeyErrorZ*)(_res_ptr);
11505 CResult_SecretKeyErrorZ_free(_res_conv);
11508 static inline uintptr_t CResult_SecretKeyErrorZ_clone_ptr(LDKCResult_SecretKeyErrorZ *NONNULL_PTR arg) {
11509 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
11510 *ret_conv = CResult_SecretKeyErrorZ_clone(arg);
11511 return (uint32_t)ret_conv;
11513 uint32_t __attribute__((export_name("TS_CResult_SecretKeyErrorZ_clone_ptr"))) TS_CResult_SecretKeyErrorZ_clone_ptr(uint32_t arg) {
11514 LDKCResult_SecretKeyErrorZ* arg_conv = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
11515 uint32_t ret_conv = CResult_SecretKeyErrorZ_clone_ptr(arg_conv);
11519 uint32_t __attribute__((export_name("TS_CResult_SecretKeyErrorZ_clone"))) TS_CResult_SecretKeyErrorZ_clone(uint32_t orig) {
11520 LDKCResult_SecretKeyErrorZ* orig_conv = (LDKCResult_SecretKeyErrorZ*)(orig & ~1);
11521 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
11522 *ret_conv = CResult_SecretKeyErrorZ_clone(orig_conv);
11523 return (uint32_t)ret_conv;
11526 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_ok"))) TS_CResult_PublicKeyErrorZ_ok(int8_tArray o) {
11527 LDKPublicKey o_ref;
11528 CHECK(o->arr_len == 33);
11529 memcpy(o_ref.compressed_form, o->elems, 33); FREE(o);
11530 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
11531 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
11532 return (uint32_t)ret_conv;
11535 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_err"))) TS_CResult_PublicKeyErrorZ_err(uint32_t e) {
11536 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
11537 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
11538 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
11539 return (uint32_t)ret_conv;
11542 jboolean __attribute__((export_name("TS_CResult_PublicKeyErrorZ_is_ok"))) TS_CResult_PublicKeyErrorZ_is_ok(uint32_t o) {
11543 LDKCResult_PublicKeyErrorZ* o_conv = (LDKCResult_PublicKeyErrorZ*)(o & ~1);
11544 jboolean ret_conv = CResult_PublicKeyErrorZ_is_ok(o_conv);
11548 void __attribute__((export_name("TS_CResult_PublicKeyErrorZ_free"))) TS_CResult_PublicKeyErrorZ_free(uint32_t _res) {
11549 if ((_res & 1) != 0) return;
11550 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11551 CHECK_ACCESS(_res_ptr);
11552 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(_res_ptr);
11554 CResult_PublicKeyErrorZ_free(_res_conv);
11557 static inline uintptr_t CResult_PublicKeyErrorZ_clone_ptr(LDKCResult_PublicKeyErrorZ *NONNULL_PTR arg) {
11558 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
11559 *ret_conv = CResult_PublicKeyErrorZ_clone(arg);
11560 return (uint32_t)ret_conv;
11562 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone_ptr"))) TS_CResult_PublicKeyErrorZ_clone_ptr(uint32_t arg) {
11563 LDKCResult_PublicKeyErrorZ* arg_conv = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
11564 uint32_t ret_conv = CResult_PublicKeyErrorZ_clone_ptr(arg_conv);
11568 uint32_t __attribute__((export_name("TS_CResult_PublicKeyErrorZ_clone"))) TS_CResult_PublicKeyErrorZ_clone(uint32_t orig) {
11569 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
11570 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
11571 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
11572 return (uint32_t)ret_conv;
11575 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint32_t o) {
11576 LDKTxCreationKeys o_conv;
11577 o_conv.inner = (void*)(o & (~1));
11578 o_conv.is_owned = (o & 1) || (o == 0);
11579 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11580 o_conv = TxCreationKeys_clone(&o_conv);
11581 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11582 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
11583 return (uint32_t)ret_conv;
11586 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_err"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint32_t e) {
11587 LDKDecodeError e_conv;
11588 e_conv.inner = (void*)(e & (~1));
11589 e_conv.is_owned = (e & 1) || (e == 0);
11590 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11591 e_conv = DecodeError_clone(&e_conv);
11592 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11593 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
11594 return (uint32_t)ret_conv;
11597 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_is_ok"))) TS_CResult_TxCreationKeysDecodeErrorZ_is_ok(uint32_t o) {
11598 LDKCResult_TxCreationKeysDecodeErrorZ* o_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(o & ~1);
11599 jboolean ret_conv = CResult_TxCreationKeysDecodeErrorZ_is_ok(o_conv);
11603 void __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_free"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint32_t _res) {
11604 if ((_res & 1) != 0) return;
11605 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11606 CHECK_ACCESS(_res_ptr);
11607 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(_res_ptr);
11609 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
11612 static inline uintptr_t CResult_TxCreationKeysDecodeErrorZ_clone_ptr(LDKCResult_TxCreationKeysDecodeErrorZ *NONNULL_PTR arg) {
11613 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11614 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(arg);
11615 return (uint32_t)ret_conv;
11617 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
11618 LDKCResult_TxCreationKeysDecodeErrorZ* arg_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
11619 uint32_t ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone_ptr(arg_conv);
11623 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysDecodeErrorZ_clone"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint32_t orig) {
11624 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
11625 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
11626 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
11627 return (uint32_t)ret_conv;
11630 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint32_t o) {
11631 LDKChannelPublicKeys o_conv;
11632 o_conv.inner = (void*)(o & (~1));
11633 o_conv.is_owned = (o & 1) || (o == 0);
11634 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11635 o_conv = ChannelPublicKeys_clone(&o_conv);
11636 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11637 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
11638 return (uint32_t)ret_conv;
11641 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_err"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint32_t e) {
11642 LDKDecodeError e_conv;
11643 e_conv.inner = (void*)(e & (~1));
11644 e_conv.is_owned = (e & 1) || (e == 0);
11645 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11646 e_conv = DecodeError_clone(&e_conv);
11647 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11648 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
11649 return (uint32_t)ret_conv;
11652 jboolean __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_is_ok(uint32_t o) {
11653 LDKCResult_ChannelPublicKeysDecodeErrorZ* o_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(o & ~1);
11654 jboolean ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_is_ok(o_conv);
11658 void __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_free"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint32_t _res) {
11659 if ((_res & 1) != 0) return;
11660 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11661 CHECK_ACCESS(_res_ptr);
11662 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(_res_ptr);
11664 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
11667 static inline uintptr_t CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(LDKCResult_ChannelPublicKeysDecodeErrorZ *NONNULL_PTR arg) {
11668 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11669 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(arg);
11670 return (uint32_t)ret_conv;
11672 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(uint32_t arg) {
11673 LDKCResult_ChannelPublicKeysDecodeErrorZ* arg_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
11674 uint32_t ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone_ptr(arg_conv);
11678 uint32_t __attribute__((export_name("TS_CResult_ChannelPublicKeysDecodeErrorZ_clone"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint32_t orig) {
11679 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
11680 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
11681 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
11682 return (uint32_t)ret_conv;
11685 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_ok"))) TS_CResult_TxCreationKeysErrorZ_ok(uint32_t o) {
11686 LDKTxCreationKeys o_conv;
11687 o_conv.inner = (void*)(o & (~1));
11688 o_conv.is_owned = (o & 1) || (o == 0);
11689 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11690 o_conv = TxCreationKeys_clone(&o_conv);
11691 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
11692 *ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
11693 return (uint32_t)ret_conv;
11696 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_err"))) TS_CResult_TxCreationKeysErrorZ_err(uint32_t e) {
11697 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
11698 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
11699 *ret_conv = CResult_TxCreationKeysErrorZ_err(e_conv);
11700 return (uint32_t)ret_conv;
11703 jboolean __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_is_ok"))) TS_CResult_TxCreationKeysErrorZ_is_ok(uint32_t o) {
11704 LDKCResult_TxCreationKeysErrorZ* o_conv = (LDKCResult_TxCreationKeysErrorZ*)(o & ~1);
11705 jboolean ret_conv = CResult_TxCreationKeysErrorZ_is_ok(o_conv);
11709 void __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_free"))) TS_CResult_TxCreationKeysErrorZ_free(uint32_t _res) {
11710 if ((_res & 1) != 0) return;
11711 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11712 CHECK_ACCESS(_res_ptr);
11713 LDKCResult_TxCreationKeysErrorZ _res_conv = *(LDKCResult_TxCreationKeysErrorZ*)(_res_ptr);
11715 CResult_TxCreationKeysErrorZ_free(_res_conv);
11718 static inline uintptr_t CResult_TxCreationKeysErrorZ_clone_ptr(LDKCResult_TxCreationKeysErrorZ *NONNULL_PTR arg) {
11719 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
11720 *ret_conv = CResult_TxCreationKeysErrorZ_clone(arg);
11721 return (uint32_t)ret_conv;
11723 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_clone_ptr"))) TS_CResult_TxCreationKeysErrorZ_clone_ptr(uint32_t arg) {
11724 LDKCResult_TxCreationKeysErrorZ* arg_conv = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
11725 uint32_t ret_conv = CResult_TxCreationKeysErrorZ_clone_ptr(arg_conv);
11729 uint32_t __attribute__((export_name("TS_CResult_TxCreationKeysErrorZ_clone"))) TS_CResult_TxCreationKeysErrorZ_clone(uint32_t orig) {
11730 LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
11731 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
11732 *ret_conv = CResult_TxCreationKeysErrorZ_clone(orig_conv);
11733 return (uint32_t)ret_conv;
11736 uint32_t __attribute__((export_name("TS_COption_u32Z_some"))) TS_COption_u32Z_some(int32_t o) {
11737 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11738 *ret_copy = COption_u32Z_some(o);
11739 uint32_t ret_ref = (uintptr_t)ret_copy;
11743 uint32_t __attribute__((export_name("TS_COption_u32Z_none"))) TS_COption_u32Z_none() {
11744 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11745 *ret_copy = COption_u32Z_none();
11746 uint32_t ret_ref = (uintptr_t)ret_copy;
11750 void __attribute__((export_name("TS_COption_u32Z_free"))) TS_COption_u32Z_free(uint32_t _res) {
11751 if ((_res & 1) != 0) return;
11752 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11753 CHECK_ACCESS(_res_ptr);
11754 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(_res_ptr);
11756 COption_u32Z_free(_res_conv);
11759 static inline uintptr_t COption_u32Z_clone_ptr(LDKCOption_u32Z *NONNULL_PTR arg) {
11760 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11761 *ret_copy = COption_u32Z_clone(arg);
11762 uint32_t ret_ref = (uintptr_t)ret_copy;
11765 uint32_t __attribute__((export_name("TS_COption_u32Z_clone_ptr"))) TS_COption_u32Z_clone_ptr(uint32_t arg) {
11766 LDKCOption_u32Z* arg_conv = (LDKCOption_u32Z*)arg;
11767 uint32_t ret_conv = COption_u32Z_clone_ptr(arg_conv);
11771 uint32_t __attribute__((export_name("TS_COption_u32Z_clone"))) TS_COption_u32Z_clone(uint32_t orig) {
11772 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
11773 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
11774 *ret_copy = COption_u32Z_clone(orig_conv);
11775 uint32_t ret_ref = (uintptr_t)ret_copy;
11779 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint32_t o) {
11780 LDKHTLCOutputInCommitment o_conv;
11781 o_conv.inner = (void*)(o & (~1));
11782 o_conv.is_owned = (o & 1) || (o == 0);
11783 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11784 o_conv = HTLCOutputInCommitment_clone(&o_conv);
11785 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11786 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
11787 return (uint32_t)ret_conv;
11790 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint32_t e) {
11791 LDKDecodeError e_conv;
11792 e_conv.inner = (void*)(e & (~1));
11793 e_conv.is_owned = (e & 1) || (e == 0);
11794 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11795 e_conv = DecodeError_clone(&e_conv);
11796 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11797 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
11798 return (uint32_t)ret_conv;
11801 jboolean __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(uint32_t o) {
11802 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* o_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(o & ~1);
11803 jboolean ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_is_ok(o_conv);
11807 void __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint32_t _res) {
11808 if ((_res & 1) != 0) return;
11809 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11810 CHECK_ACCESS(_res_ptr);
11811 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(_res_ptr);
11813 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
11816 static inline uintptr_t CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *NONNULL_PTR arg) {
11817 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11818 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(arg);
11819 return (uint32_t)ret_conv;
11821 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(uint32_t arg) {
11822 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* arg_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
11823 uint32_t ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone_ptr(arg_conv);
11827 uint32_t __attribute__((export_name("TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint32_t orig) {
11828 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
11829 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
11830 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
11831 return (uint32_t)ret_conv;
11834 uint32_t __attribute__((export_name("TS_COption_NoneZ_some"))) TS_COption_NoneZ_some() {
11835 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_some());
11839 uint32_t __attribute__((export_name("TS_COption_NoneZ_none"))) TS_COption_NoneZ_none() {
11840 uint32_t ret_conv = LDKCOption_NoneZ_to_js(COption_NoneZ_none());
11844 void __attribute__((export_name("TS_COption_NoneZ_free"))) TS_COption_NoneZ_free(uint32_t _res) {
11845 LDKCOption_NoneZ _res_conv = LDKCOption_NoneZ_from_js(_res);
11846 COption_NoneZ_free(_res_conv);
11849 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint32_t o) {
11850 LDKCounterpartyChannelTransactionParameters o_conv;
11851 o_conv.inner = (void*)(o & (~1));
11852 o_conv.is_owned = (o & 1) || (o == 0);
11853 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11854 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
11855 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
11856 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
11857 return (uint32_t)ret_conv;
11860 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint32_t e) {
11861 LDKDecodeError e_conv;
11862 e_conv.inner = (void*)(e & (~1));
11863 e_conv.is_owned = (e & 1) || (e == 0);
11864 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11865 e_conv = DecodeError_clone(&e_conv);
11866 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
11867 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
11868 return (uint32_t)ret_conv;
11871 jboolean __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
11872 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(o & ~1);
11873 jboolean ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
11877 void __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
11878 if ((_res & 1) != 0) return;
11879 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11880 CHECK_ACCESS(_res_ptr);
11881 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
11883 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
11886 static inline uintptr_t CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
11887 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
11888 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(arg);
11889 return (uint32_t)ret_conv;
11891 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
11892 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
11893 uint32_t ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
11897 uint32_t __attribute__((export_name("TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
11898 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
11899 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
11900 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
11901 return (uint32_t)ret_conv;
11904 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint32_t o) {
11905 LDKChannelTransactionParameters o_conv;
11906 o_conv.inner = (void*)(o & (~1));
11907 o_conv.is_owned = (o & 1) || (o == 0);
11908 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11909 o_conv = ChannelTransactionParameters_clone(&o_conv);
11910 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
11911 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
11912 return (uint32_t)ret_conv;
11915 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_err"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint32_t e) {
11916 LDKDecodeError e_conv;
11917 e_conv.inner = (void*)(e & (~1));
11918 e_conv.is_owned = (e & 1) || (e == 0);
11919 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11920 e_conv = DecodeError_clone(&e_conv);
11921 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
11922 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
11923 return (uint32_t)ret_conv;
11926 jboolean __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(uint32_t o) {
11927 LDKCResult_ChannelTransactionParametersDecodeErrorZ* o_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(o & ~1);
11928 jboolean ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_is_ok(o_conv);
11932 void __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_free"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
11933 if ((_res & 1) != 0) return;
11934 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
11935 CHECK_ACCESS(_res_ptr);
11936 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(_res_ptr);
11938 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
11941 static inline uintptr_t CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(LDKCResult_ChannelTransactionParametersDecodeErrorZ *NONNULL_PTR arg) {
11942 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
11943 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(arg);
11944 return (uint32_t)ret_conv;
11946 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
11947 LDKCResult_ChannelTransactionParametersDecodeErrorZ* arg_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
11948 uint32_t ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone_ptr(arg_conv);
11952 uint32_t __attribute__((export_name("TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
11953 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
11954 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
11955 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
11956 return (uint32_t)ret_conv;
11959 void __attribute__((export_name("TS_CVec_SignatureZ_free"))) TS_CVec_SignatureZ_free(ptrArray _res) {
11960 LDKCVec_SignatureZ _res_constr;
11961 _res_constr.datalen = _res->arr_len;
11962 if (_res_constr.datalen > 0)
11963 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
11965 _res_constr.data = NULL;
11966 int8_tArray* _res_vals = (void*) _res->elems;
11967 for (size_t m = 0; m < _res_constr.datalen; m++) {
11968 int8_tArray _res_conv_12 = _res_vals[m];
11969 LDKSignature _res_conv_12_ref;
11970 CHECK(_res_conv_12->arr_len == 64);
11971 memcpy(_res_conv_12_ref.compact_form, _res_conv_12->elems, 64); FREE(_res_conv_12);
11972 _res_constr.data[m] = _res_conv_12_ref;
11975 CVec_SignatureZ_free(_res_constr);
11978 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
11979 LDKHolderCommitmentTransaction o_conv;
11980 o_conv.inner = (void*)(o & (~1));
11981 o_conv.is_owned = (o & 1) || (o == 0);
11982 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
11983 o_conv = HolderCommitmentTransaction_clone(&o_conv);
11984 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
11985 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
11986 return (uint32_t)ret_conv;
11989 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint32_t e) {
11990 LDKDecodeError e_conv;
11991 e_conv.inner = (void*)(e & (~1));
11992 e_conv.is_owned = (e & 1) || (e == 0);
11993 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
11994 e_conv = DecodeError_clone(&e_conv);
11995 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
11996 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
11997 return (uint32_t)ret_conv;
12000 jboolean __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
12001 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(o & ~1);
12002 jboolean ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12006 void __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
12007 if ((_res & 1) != 0) return;
12008 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12009 CHECK_ACCESS(_res_ptr);
12010 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12012 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
12015 static inline uintptr_t CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_HolderCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12016 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12017 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(arg);
12018 return (uint32_t)ret_conv;
12020 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
12021 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
12022 uint32_t ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12026 uint32_t __attribute__((export_name("TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
12027 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
12028 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
12029 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12030 return (uint32_t)ret_conv;
12033 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
12034 LDKBuiltCommitmentTransaction o_conv;
12035 o_conv.inner = (void*)(o & (~1));
12036 o_conv.is_owned = (o & 1) || (o == 0);
12037 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12038 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
12039 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12040 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
12041 return (uint32_t)ret_conv;
12044 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint32_t e) {
12045 LDKDecodeError e_conv;
12046 e_conv.inner = (void*)(e & (~1));
12047 e_conv.is_owned = (e & 1) || (e == 0);
12048 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12049 e_conv = DecodeError_clone(&e_conv);
12050 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12051 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
12052 return (uint32_t)ret_conv;
12055 jboolean __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
12056 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(o & ~1);
12057 jboolean ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12061 void __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
12062 if ((_res & 1) != 0) return;
12063 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12064 CHECK_ACCESS(_res_ptr);
12065 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(_res_ptr);
12067 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
12070 static inline uintptr_t CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12071 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12072 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(arg);
12073 return (uint32_t)ret_conv;
12075 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
12076 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
12077 uint32_t ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12081 uint32_t __attribute__((export_name("TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
12082 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
12083 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
12084 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
12085 return (uint32_t)ret_conv;
12088 uint32_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint32_t o) {
12089 LDKTrustedClosingTransaction o_conv;
12090 o_conv.inner = (void*)(o & (~1));
12091 o_conv.is_owned = (o & 1) || (o == 0);
12092 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12093 // WARNING: we need a move here but no clone is available for LDKTrustedClosingTransaction
12094 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12095 *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv);
12096 return (uint32_t)ret_conv;
12099 uint32_t __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_err"))) TS_CResult_TrustedClosingTransactionNoneZ_err() {
12100 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
12101 *ret_conv = CResult_TrustedClosingTransactionNoneZ_err();
12102 return (uint32_t)ret_conv;
12105 jboolean __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_is_ok"))) TS_CResult_TrustedClosingTransactionNoneZ_is_ok(uint32_t o) {
12106 LDKCResult_TrustedClosingTransactionNoneZ* o_conv = (LDKCResult_TrustedClosingTransactionNoneZ*)(o & ~1);
12107 jboolean ret_conv = CResult_TrustedClosingTransactionNoneZ_is_ok(o_conv);
12111 void __attribute__((export_name("TS_CResult_TrustedClosingTransactionNoneZ_free"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint32_t _res) {
12112 if ((_res & 1) != 0) return;
12113 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12114 CHECK_ACCESS(_res_ptr);
12115 LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(_res_ptr);
12117 CResult_TrustedClosingTransactionNoneZ_free(_res_conv);
12120 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
12121 LDKCommitmentTransaction o_conv;
12122 o_conv.inner = (void*)(o & (~1));
12123 o_conv.is_owned = (o & 1) || (o == 0);
12124 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12125 o_conv = CommitmentTransaction_clone(&o_conv);
12126 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12127 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
12128 return (uint32_t)ret_conv;
12131 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_err"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint32_t e) {
12132 LDKDecodeError e_conv;
12133 e_conv.inner = (void*)(e & (~1));
12134 e_conv.is_owned = (e & 1) || (e == 0);
12135 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12136 e_conv = DecodeError_clone(&e_conv);
12137 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12138 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
12139 return (uint32_t)ret_conv;
12142 jboolean __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok"))) TS_CResult_CommitmentTransactionDecodeErrorZ_is_ok(uint32_t o) {
12143 LDKCResult_CommitmentTransactionDecodeErrorZ* o_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(o & ~1);
12144 jboolean ret_conv = CResult_CommitmentTransactionDecodeErrorZ_is_ok(o_conv);
12148 void __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_free"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
12149 if ((_res & 1) != 0) return;
12150 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12151 CHECK_ACCESS(_res_ptr);
12152 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(_res_ptr);
12154 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
12157 static inline uintptr_t CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(LDKCResult_CommitmentTransactionDecodeErrorZ *NONNULL_PTR arg) {
12158 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12159 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(arg);
12160 return (uint32_t)ret_conv;
12162 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(uint32_t arg) {
12163 LDKCResult_CommitmentTransactionDecodeErrorZ* arg_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
12164 uint32_t ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone_ptr(arg_conv);
12168 uint32_t __attribute__((export_name("TS_CResult_CommitmentTransactionDecodeErrorZ_clone"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
12169 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
12170 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
12171 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
12172 return (uint32_t)ret_conv;
12175 uint32_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint32_t o) {
12176 LDKTrustedCommitmentTransaction o_conv;
12177 o_conv.inner = (void*)(o & (~1));
12178 o_conv.is_owned = (o & 1) || (o == 0);
12179 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12180 // WARNING: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
12181 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12182 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
12183 return (uint32_t)ret_conv;
12186 uint32_t __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_err"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
12187 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
12188 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
12189 return (uint32_t)ret_conv;
12192 jboolean __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok"))) TS_CResult_TrustedCommitmentTransactionNoneZ_is_ok(uint32_t o) {
12193 LDKCResult_TrustedCommitmentTransactionNoneZ* o_conv = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(o & ~1);
12194 jboolean ret_conv = CResult_TrustedCommitmentTransactionNoneZ_is_ok(o_conv);
12198 void __attribute__((export_name("TS_CResult_TrustedCommitmentTransactionNoneZ_free"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
12199 if ((_res & 1) != 0) return;
12200 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12201 CHECK_ACCESS(_res_ptr);
12202 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(_res_ptr);
12204 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
12207 uint32_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_ok"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
12208 LDKCVec_SignatureZ o_constr;
12209 o_constr.datalen = o->arr_len;
12210 if (o_constr.datalen > 0)
12211 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
12213 o_constr.data = NULL;
12214 int8_tArray* o_vals = (void*) o->elems;
12215 for (size_t m = 0; m < o_constr.datalen; m++) {
12216 int8_tArray o_conv_12 = o_vals[m];
12217 LDKSignature o_conv_12_ref;
12218 CHECK(o_conv_12->arr_len == 64);
12219 memcpy(o_conv_12_ref.compact_form, o_conv_12->elems, 64); FREE(o_conv_12);
12220 o_constr.data[m] = o_conv_12_ref;
12223 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12224 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
12225 return (uint32_t)ret_conv;
12228 uint32_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_err"))) TS_CResult_CVec_SignatureZNoneZ_err() {
12229 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12230 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
12231 return (uint32_t)ret_conv;
12234 jboolean __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_is_ok"))) TS_CResult_CVec_SignatureZNoneZ_is_ok(uint32_t o) {
12235 LDKCResult_CVec_SignatureZNoneZ* o_conv = (LDKCResult_CVec_SignatureZNoneZ*)(o & ~1);
12236 jboolean ret_conv = CResult_CVec_SignatureZNoneZ_is_ok(o_conv);
12240 void __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_free"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
12241 if ((_res & 1) != 0) return;
12242 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12243 CHECK_ACCESS(_res_ptr);
12244 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(_res_ptr);
12246 CResult_CVec_SignatureZNoneZ_free(_res_conv);
12249 static inline uintptr_t CResult_CVec_SignatureZNoneZ_clone_ptr(LDKCResult_CVec_SignatureZNoneZ *NONNULL_PTR arg) {
12250 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12251 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(arg);
12252 return (uint32_t)ret_conv;
12254 uint32_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone_ptr"))) TS_CResult_CVec_SignatureZNoneZ_clone_ptr(uint32_t arg) {
12255 LDKCResult_CVec_SignatureZNoneZ* arg_conv = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
12256 uint32_t ret_conv = CResult_CVec_SignatureZNoneZ_clone_ptr(arg_conv);
12260 uint32_t __attribute__((export_name("TS_CResult_CVec_SignatureZNoneZ_clone"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
12261 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
12262 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
12263 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
12264 return (uint32_t)ret_conv;
12267 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_ok(uint32_t o) {
12268 LDKShutdownScript o_conv;
12269 o_conv.inner = (void*)(o & (~1));
12270 o_conv.is_owned = (o & 1) || (o == 0);
12271 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12272 o_conv = ShutdownScript_clone(&o_conv);
12273 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12274 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_ok(o_conv);
12275 return (uint32_t)ret_conv;
12278 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_err"))) TS_CResult_ShutdownScriptDecodeErrorZ_err(uint32_t e) {
12279 LDKDecodeError e_conv;
12280 e_conv.inner = (void*)(e & (~1));
12281 e_conv.is_owned = (e & 1) || (e == 0);
12282 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12283 e_conv = DecodeError_clone(&e_conv);
12284 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12285 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_err(e_conv);
12286 return (uint32_t)ret_conv;
12289 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_is_ok"))) TS_CResult_ShutdownScriptDecodeErrorZ_is_ok(uint32_t o) {
12290 LDKCResult_ShutdownScriptDecodeErrorZ* o_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(o & ~1);
12291 jboolean ret_conv = CResult_ShutdownScriptDecodeErrorZ_is_ok(o_conv);
12295 void __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_free"))) TS_CResult_ShutdownScriptDecodeErrorZ_free(uint32_t _res) {
12296 if ((_res & 1) != 0) return;
12297 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12298 CHECK_ACCESS(_res_ptr);
12299 LDKCResult_ShutdownScriptDecodeErrorZ _res_conv = *(LDKCResult_ShutdownScriptDecodeErrorZ*)(_res_ptr);
12301 CResult_ShutdownScriptDecodeErrorZ_free(_res_conv);
12304 static inline uintptr_t CResult_ShutdownScriptDecodeErrorZ_clone_ptr(LDKCResult_ShutdownScriptDecodeErrorZ *NONNULL_PTR arg) {
12305 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12306 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(arg);
12307 return (uint32_t)ret_conv;
12309 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone_ptr(uint32_t arg) {
12310 LDKCResult_ShutdownScriptDecodeErrorZ* arg_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(arg & ~1);
12311 uint32_t ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone_ptr(arg_conv);
12315 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptDecodeErrorZ_clone"))) TS_CResult_ShutdownScriptDecodeErrorZ_clone(uint32_t orig) {
12316 LDKCResult_ShutdownScriptDecodeErrorZ* orig_conv = (LDKCResult_ShutdownScriptDecodeErrorZ*)(orig & ~1);
12317 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
12318 *ret_conv = CResult_ShutdownScriptDecodeErrorZ_clone(orig_conv);
12319 return (uint32_t)ret_conv;
12322 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_ok(uint32_t o) {
12323 LDKShutdownScript o_conv;
12324 o_conv.inner = (void*)(o & (~1));
12325 o_conv.is_owned = (o & 1) || (o == 0);
12326 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12327 o_conv = ShutdownScript_clone(&o_conv);
12328 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12329 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_ok(o_conv);
12330 return (uint32_t)ret_conv;
12333 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_err(uint32_t e) {
12334 LDKInvalidShutdownScript e_conv;
12335 e_conv.inner = (void*)(e & (~1));
12336 e_conv.is_owned = (e & 1) || (e == 0);
12337 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12338 e_conv = InvalidShutdownScript_clone(&e_conv);
12339 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12340 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_err(e_conv);
12341 return (uint32_t)ret_conv;
12344 jboolean __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(uint32_t o) {
12345 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* o_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(o & ~1);
12346 jboolean ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_is_ok(o_conv);
12350 void __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_free(uint32_t _res) {
12351 if ((_res & 1) != 0) return;
12352 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12353 CHECK_ACCESS(_res_ptr);
12354 LDKCResult_ShutdownScriptInvalidShutdownScriptZ _res_conv = *(LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(_res_ptr);
12356 CResult_ShutdownScriptInvalidShutdownScriptZ_free(_res_conv);
12359 static inline uintptr_t CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(LDKCResult_ShutdownScriptInvalidShutdownScriptZ *NONNULL_PTR arg) {
12360 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12361 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(arg);
12362 return (uint32_t)ret_conv;
12364 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(uint32_t arg) {
12365 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* arg_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(arg & ~1);
12366 uint32_t ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone_ptr(arg_conv);
12370 uint32_t __attribute__((export_name("TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone"))) TS_CResult_ShutdownScriptInvalidShutdownScriptZ_clone(uint32_t orig) {
12371 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* orig_conv = (LDKCResult_ShutdownScriptInvalidShutdownScriptZ*)(orig & ~1);
12372 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
12373 *ret_conv = CResult_ShutdownScriptInvalidShutdownScriptZ_clone(orig_conv);
12374 return (uint32_t)ret_conv;
12377 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_ok"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint32_t o) {
12378 LDKRouteHop o_conv;
12379 o_conv.inner = (void*)(o & (~1));
12380 o_conv.is_owned = (o & 1) || (o == 0);
12381 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12382 o_conv = RouteHop_clone(&o_conv);
12383 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12384 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
12385 return (uint32_t)ret_conv;
12388 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_err"))) TS_CResult_RouteHopDecodeErrorZ_err(uint32_t e) {
12389 LDKDecodeError e_conv;
12390 e_conv.inner = (void*)(e & (~1));
12391 e_conv.is_owned = (e & 1) || (e == 0);
12392 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12393 e_conv = DecodeError_clone(&e_conv);
12394 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12395 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
12396 return (uint32_t)ret_conv;
12399 jboolean __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHopDecodeErrorZ_is_ok(uint32_t o) {
12400 LDKCResult_RouteHopDecodeErrorZ* o_conv = (LDKCResult_RouteHopDecodeErrorZ*)(o & ~1);
12401 jboolean ret_conv = CResult_RouteHopDecodeErrorZ_is_ok(o_conv);
12405 void __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_free"))) TS_CResult_RouteHopDecodeErrorZ_free(uint32_t _res) {
12406 if ((_res & 1) != 0) return;
12407 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12408 CHECK_ACCESS(_res_ptr);
12409 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(_res_ptr);
12411 CResult_RouteHopDecodeErrorZ_free(_res_conv);
12414 static inline uintptr_t CResult_RouteHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHopDecodeErrorZ *NONNULL_PTR arg) {
12415 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12416 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(arg);
12417 return (uint32_t)ret_conv;
12419 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHopDecodeErrorZ_clone_ptr(uint32_t arg) {
12420 LDKCResult_RouteHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
12421 uint32_t ret_conv = CResult_RouteHopDecodeErrorZ_clone_ptr(arg_conv);
12425 uint32_t __attribute__((export_name("TS_CResult_RouteHopDecodeErrorZ_clone"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint32_t orig) {
12426 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
12427 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
12428 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
12429 return (uint32_t)ret_conv;
12432 void __attribute__((export_name("TS_CVec_RouteHopZ_free"))) TS_CVec_RouteHopZ_free(uint32_tArray _res) {
12433 LDKCVec_RouteHopZ _res_constr;
12434 _res_constr.datalen = _res->arr_len;
12435 if (_res_constr.datalen > 0)
12436 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
12438 _res_constr.data = NULL;
12439 uint32_t* _res_vals = _res->elems;
12440 for (size_t k = 0; k < _res_constr.datalen; k++) {
12441 uint32_t _res_conv_10 = _res_vals[k];
12442 LDKRouteHop _res_conv_10_conv;
12443 _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
12444 _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
12445 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
12446 _res_constr.data[k] = _res_conv_10_conv;
12449 CVec_RouteHopZ_free(_res_constr);
12452 void __attribute__((export_name("TS_CVec_CVec_RouteHopZZ_free"))) TS_CVec_CVec_RouteHopZZ_free(ptrArray _res) {
12453 LDKCVec_CVec_RouteHopZZ _res_constr;
12454 _res_constr.datalen = _res->arr_len;
12455 if (_res_constr.datalen > 0)
12456 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
12458 _res_constr.data = NULL;
12459 uint32_tArray* _res_vals = (void*) _res->elems;
12460 for (size_t m = 0; m < _res_constr.datalen; m++) {
12461 uint32_tArray _res_conv_12 = _res_vals[m];
12462 LDKCVec_RouteHopZ _res_conv_12_constr;
12463 _res_conv_12_constr.datalen = _res_conv_12->arr_len;
12464 if (_res_conv_12_constr.datalen > 0)
12465 _res_conv_12_constr.data = MALLOC(_res_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
12467 _res_conv_12_constr.data = NULL;
12468 uint32_t* _res_conv_12_vals = _res_conv_12->elems;
12469 for (size_t k = 0; k < _res_conv_12_constr.datalen; k++) {
12470 uint32_t _res_conv_12_conv_10 = _res_conv_12_vals[k];
12471 LDKRouteHop _res_conv_12_conv_10_conv;
12472 _res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
12473 _res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
12474 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_12_conv_10_conv);
12475 _res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
12477 FREE(_res_conv_12);
12478 _res_constr.data[m] = _res_conv_12_constr;
12481 CVec_CVec_RouteHopZZ_free(_res_constr);
12484 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_ok"))) TS_CResult_RouteDecodeErrorZ_ok(uint32_t o) {
12486 o_conv.inner = (void*)(o & (~1));
12487 o_conv.is_owned = (o & 1) || (o == 0);
12488 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12489 o_conv = Route_clone(&o_conv);
12490 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
12491 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
12492 return (uint32_t)ret_conv;
12495 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_err"))) TS_CResult_RouteDecodeErrorZ_err(uint32_t e) {
12496 LDKDecodeError e_conv;
12497 e_conv.inner = (void*)(e & (~1));
12498 e_conv.is_owned = (e & 1) || (e == 0);
12499 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12500 e_conv = DecodeError_clone(&e_conv);
12501 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
12502 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
12503 return (uint32_t)ret_conv;
12506 jboolean __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_is_ok"))) TS_CResult_RouteDecodeErrorZ_is_ok(uint32_t o) {
12507 LDKCResult_RouteDecodeErrorZ* o_conv = (LDKCResult_RouteDecodeErrorZ*)(o & ~1);
12508 jboolean ret_conv = CResult_RouteDecodeErrorZ_is_ok(o_conv);
12512 void __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_free"))) TS_CResult_RouteDecodeErrorZ_free(uint32_t _res) {
12513 if ((_res & 1) != 0) return;
12514 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12515 CHECK_ACCESS(_res_ptr);
12516 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(_res_ptr);
12518 CResult_RouteDecodeErrorZ_free(_res_conv);
12521 static inline uintptr_t CResult_RouteDecodeErrorZ_clone_ptr(LDKCResult_RouteDecodeErrorZ *NONNULL_PTR arg) {
12522 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
12523 *ret_conv = CResult_RouteDecodeErrorZ_clone(arg);
12524 return (uint32_t)ret_conv;
12526 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone_ptr"))) TS_CResult_RouteDecodeErrorZ_clone_ptr(uint32_t arg) {
12527 LDKCResult_RouteDecodeErrorZ* arg_conv = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
12528 uint32_t ret_conv = CResult_RouteDecodeErrorZ_clone_ptr(arg_conv);
12532 uint32_t __attribute__((export_name("TS_CResult_RouteDecodeErrorZ_clone"))) TS_CResult_RouteDecodeErrorZ_clone(uint32_t orig) {
12533 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
12534 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
12535 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
12536 return (uint32_t)ret_conv;
12539 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_ok"))) TS_CResult_RouteParametersDecodeErrorZ_ok(uint32_t o) {
12540 LDKRouteParameters o_conv;
12541 o_conv.inner = (void*)(o & (~1));
12542 o_conv.is_owned = (o & 1) || (o == 0);
12543 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12544 o_conv = RouteParameters_clone(&o_conv);
12545 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
12546 *ret_conv = CResult_RouteParametersDecodeErrorZ_ok(o_conv);
12547 return (uint32_t)ret_conv;
12550 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_err"))) TS_CResult_RouteParametersDecodeErrorZ_err(uint32_t e) {
12551 LDKDecodeError e_conv;
12552 e_conv.inner = (void*)(e & (~1));
12553 e_conv.is_owned = (e & 1) || (e == 0);
12554 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12555 e_conv = DecodeError_clone(&e_conv);
12556 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
12557 *ret_conv = CResult_RouteParametersDecodeErrorZ_err(e_conv);
12558 return (uint32_t)ret_conv;
12561 jboolean __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_is_ok"))) TS_CResult_RouteParametersDecodeErrorZ_is_ok(uint32_t o) {
12562 LDKCResult_RouteParametersDecodeErrorZ* o_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(o & ~1);
12563 jboolean ret_conv = CResult_RouteParametersDecodeErrorZ_is_ok(o_conv);
12567 void __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_free"))) TS_CResult_RouteParametersDecodeErrorZ_free(uint32_t _res) {
12568 if ((_res & 1) != 0) return;
12569 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12570 CHECK_ACCESS(_res_ptr);
12571 LDKCResult_RouteParametersDecodeErrorZ _res_conv = *(LDKCResult_RouteParametersDecodeErrorZ*)(_res_ptr);
12573 CResult_RouteParametersDecodeErrorZ_free(_res_conv);
12576 static inline uintptr_t CResult_RouteParametersDecodeErrorZ_clone_ptr(LDKCResult_RouteParametersDecodeErrorZ *NONNULL_PTR arg) {
12577 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
12578 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(arg);
12579 return (uint32_t)ret_conv;
12581 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone_ptr"))) TS_CResult_RouteParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
12582 LDKCResult_RouteParametersDecodeErrorZ* arg_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(arg & ~1);
12583 uint32_t ret_conv = CResult_RouteParametersDecodeErrorZ_clone_ptr(arg_conv);
12587 uint32_t __attribute__((export_name("TS_CResult_RouteParametersDecodeErrorZ_clone"))) TS_CResult_RouteParametersDecodeErrorZ_clone(uint32_t orig) {
12588 LDKCResult_RouteParametersDecodeErrorZ* orig_conv = (LDKCResult_RouteParametersDecodeErrorZ*)(orig & ~1);
12589 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
12590 *ret_conv = CResult_RouteParametersDecodeErrorZ_clone(orig_conv);
12591 return (uint32_t)ret_conv;
12594 void __attribute__((export_name("TS_CVec_RouteHintZ_free"))) TS_CVec_RouteHintZ_free(uint32_tArray _res) {
12595 LDKCVec_RouteHintZ _res_constr;
12596 _res_constr.datalen = _res->arr_len;
12597 if (_res_constr.datalen > 0)
12598 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
12600 _res_constr.data = NULL;
12601 uint32_t* _res_vals = _res->elems;
12602 for (size_t l = 0; l < _res_constr.datalen; l++) {
12603 uint32_t _res_conv_11 = _res_vals[l];
12604 LDKRouteHint _res_conv_11_conv;
12605 _res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
12606 _res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
12607 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_11_conv);
12608 _res_constr.data[l] = _res_conv_11_conv;
12611 CVec_RouteHintZ_free(_res_constr);
12614 uint32_t __attribute__((export_name("TS_COption_u64Z_some"))) TS_COption_u64Z_some(int64_t o) {
12615 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12616 *ret_copy = COption_u64Z_some(o);
12617 uint32_t ret_ref = (uintptr_t)ret_copy;
12621 uint32_t __attribute__((export_name("TS_COption_u64Z_none"))) TS_COption_u64Z_none() {
12622 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12623 *ret_copy = COption_u64Z_none();
12624 uint32_t ret_ref = (uintptr_t)ret_copy;
12628 void __attribute__((export_name("TS_COption_u64Z_free"))) TS_COption_u64Z_free(uint32_t _res) {
12629 if ((_res & 1) != 0) return;
12630 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12631 CHECK_ACCESS(_res_ptr);
12632 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(_res_ptr);
12634 COption_u64Z_free(_res_conv);
12637 static inline uintptr_t COption_u64Z_clone_ptr(LDKCOption_u64Z *NONNULL_PTR arg) {
12638 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12639 *ret_copy = COption_u64Z_clone(arg);
12640 uint32_t ret_ref = (uintptr_t)ret_copy;
12643 uint32_t __attribute__((export_name("TS_COption_u64Z_clone_ptr"))) TS_COption_u64Z_clone_ptr(uint32_t arg) {
12644 LDKCOption_u64Z* arg_conv = (LDKCOption_u64Z*)arg;
12645 uint32_t ret_conv = COption_u64Z_clone_ptr(arg_conv);
12649 uint32_t __attribute__((export_name("TS_COption_u64Z_clone"))) TS_COption_u64Z_clone(uint32_t orig) {
12650 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
12651 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
12652 *ret_copy = COption_u64Z_clone(orig_conv);
12653 uint32_t ret_ref = (uintptr_t)ret_copy;
12657 void __attribute__((export_name("TS_CVec_u64Z_free"))) TS_CVec_u64Z_free(int64_tArray _res) {
12658 LDKCVec_u64Z _res_constr;
12659 _res_constr.datalen = _res->arr_len;
12660 if (_res_constr.datalen > 0)
12661 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
12663 _res_constr.data = NULL;
12664 int64_t* _res_vals = _res->elems;
12665 for (size_t i = 0; i < _res_constr.datalen; i++) {
12666 int64_t _res_conv_8 = _res_vals[i];
12667 _res_constr.data[i] = _res_conv_8;
12670 CVec_u64Z_free(_res_constr);
12673 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_ok(uint32_t o) {
12674 LDKPaymentParameters o_conv;
12675 o_conv.inner = (void*)(o & (~1));
12676 o_conv.is_owned = (o & 1) || (o == 0);
12677 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12678 o_conv = PaymentParameters_clone(&o_conv);
12679 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
12680 *ret_conv = CResult_PaymentParametersDecodeErrorZ_ok(o_conv);
12681 return (uint32_t)ret_conv;
12684 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_err"))) TS_CResult_PaymentParametersDecodeErrorZ_err(uint32_t e) {
12685 LDKDecodeError e_conv;
12686 e_conv.inner = (void*)(e & (~1));
12687 e_conv.is_owned = (e & 1) || (e == 0);
12688 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12689 e_conv = DecodeError_clone(&e_conv);
12690 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
12691 *ret_conv = CResult_PaymentParametersDecodeErrorZ_err(e_conv);
12692 return (uint32_t)ret_conv;
12695 jboolean __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_is_ok"))) TS_CResult_PaymentParametersDecodeErrorZ_is_ok(uint32_t o) {
12696 LDKCResult_PaymentParametersDecodeErrorZ* o_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)(o & ~1);
12697 jboolean ret_conv = CResult_PaymentParametersDecodeErrorZ_is_ok(o_conv);
12701 void __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_free"))) TS_CResult_PaymentParametersDecodeErrorZ_free(uint32_t _res) {
12702 if ((_res & 1) != 0) return;
12703 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12704 CHECK_ACCESS(_res_ptr);
12705 LDKCResult_PaymentParametersDecodeErrorZ _res_conv = *(LDKCResult_PaymentParametersDecodeErrorZ*)(_res_ptr);
12707 CResult_PaymentParametersDecodeErrorZ_free(_res_conv);
12710 static inline uintptr_t CResult_PaymentParametersDecodeErrorZ_clone_ptr(LDKCResult_PaymentParametersDecodeErrorZ *NONNULL_PTR arg) {
12711 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
12712 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(arg);
12713 return (uint32_t)ret_conv;
12715 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentParametersDecodeErrorZ_clone_ptr(uint32_t arg) {
12716 LDKCResult_PaymentParametersDecodeErrorZ* arg_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)(arg & ~1);
12717 uint32_t ret_conv = CResult_PaymentParametersDecodeErrorZ_clone_ptr(arg_conv);
12721 uint32_t __attribute__((export_name("TS_CResult_PaymentParametersDecodeErrorZ_clone"))) TS_CResult_PaymentParametersDecodeErrorZ_clone(uint32_t orig) {
12722 LDKCResult_PaymentParametersDecodeErrorZ* orig_conv = (LDKCResult_PaymentParametersDecodeErrorZ*)(orig & ~1);
12723 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
12724 *ret_conv = CResult_PaymentParametersDecodeErrorZ_clone(orig_conv);
12725 return (uint32_t)ret_conv;
12728 void __attribute__((export_name("TS_CVec_RouteHintHopZ_free"))) TS_CVec_RouteHintHopZ_free(uint32_tArray _res) {
12729 LDKCVec_RouteHintHopZ _res_constr;
12730 _res_constr.datalen = _res->arr_len;
12731 if (_res_constr.datalen > 0)
12732 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
12734 _res_constr.data = NULL;
12735 uint32_t* _res_vals = _res->elems;
12736 for (size_t o = 0; o < _res_constr.datalen; o++) {
12737 uint32_t _res_conv_14 = _res_vals[o];
12738 LDKRouteHintHop _res_conv_14_conv;
12739 _res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
12740 _res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
12741 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
12742 _res_constr.data[o] = _res_conv_14_conv;
12745 CVec_RouteHintHopZ_free(_res_constr);
12748 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_ok"))) TS_CResult_RouteHintDecodeErrorZ_ok(uint32_t o) {
12749 LDKRouteHint o_conv;
12750 o_conv.inner = (void*)(o & (~1));
12751 o_conv.is_owned = (o & 1) || (o == 0);
12752 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12753 o_conv = RouteHint_clone(&o_conv);
12754 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
12755 *ret_conv = CResult_RouteHintDecodeErrorZ_ok(o_conv);
12756 return (uint32_t)ret_conv;
12759 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_err"))) TS_CResult_RouteHintDecodeErrorZ_err(uint32_t e) {
12760 LDKDecodeError e_conv;
12761 e_conv.inner = (void*)(e & (~1));
12762 e_conv.is_owned = (e & 1) || (e == 0);
12763 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12764 e_conv = DecodeError_clone(&e_conv);
12765 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
12766 *ret_conv = CResult_RouteHintDecodeErrorZ_err(e_conv);
12767 return (uint32_t)ret_conv;
12770 jboolean __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_is_ok"))) TS_CResult_RouteHintDecodeErrorZ_is_ok(uint32_t o) {
12771 LDKCResult_RouteHintDecodeErrorZ* o_conv = (LDKCResult_RouteHintDecodeErrorZ*)(o & ~1);
12772 jboolean ret_conv = CResult_RouteHintDecodeErrorZ_is_ok(o_conv);
12776 void __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_free"))) TS_CResult_RouteHintDecodeErrorZ_free(uint32_t _res) {
12777 if ((_res & 1) != 0) return;
12778 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12779 CHECK_ACCESS(_res_ptr);
12780 LDKCResult_RouteHintDecodeErrorZ _res_conv = *(LDKCResult_RouteHintDecodeErrorZ*)(_res_ptr);
12782 CResult_RouteHintDecodeErrorZ_free(_res_conv);
12785 static inline uintptr_t CResult_RouteHintDecodeErrorZ_clone_ptr(LDKCResult_RouteHintDecodeErrorZ *NONNULL_PTR arg) {
12786 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
12787 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(arg);
12788 return (uint32_t)ret_conv;
12790 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintDecodeErrorZ_clone_ptr(uint32_t arg) {
12791 LDKCResult_RouteHintDecodeErrorZ* arg_conv = (LDKCResult_RouteHintDecodeErrorZ*)(arg & ~1);
12792 uint32_t ret_conv = CResult_RouteHintDecodeErrorZ_clone_ptr(arg_conv);
12796 uint32_t __attribute__((export_name("TS_CResult_RouteHintDecodeErrorZ_clone"))) TS_CResult_RouteHintDecodeErrorZ_clone(uint32_t orig) {
12797 LDKCResult_RouteHintDecodeErrorZ* orig_conv = (LDKCResult_RouteHintDecodeErrorZ*)(orig & ~1);
12798 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
12799 *ret_conv = CResult_RouteHintDecodeErrorZ_clone(orig_conv);
12800 return (uint32_t)ret_conv;
12803 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_ok(uint32_t o) {
12804 LDKRouteHintHop o_conv;
12805 o_conv.inner = (void*)(o & (~1));
12806 o_conv.is_owned = (o & 1) || (o == 0);
12807 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12808 o_conv = RouteHintHop_clone(&o_conv);
12809 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
12810 *ret_conv = CResult_RouteHintHopDecodeErrorZ_ok(o_conv);
12811 return (uint32_t)ret_conv;
12814 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_err"))) TS_CResult_RouteHintHopDecodeErrorZ_err(uint32_t e) {
12815 LDKDecodeError e_conv;
12816 e_conv.inner = (void*)(e & (~1));
12817 e_conv.is_owned = (e & 1) || (e == 0);
12818 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12819 e_conv = DecodeError_clone(&e_conv);
12820 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
12821 *ret_conv = CResult_RouteHintHopDecodeErrorZ_err(e_conv);
12822 return (uint32_t)ret_conv;
12825 jboolean __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_is_ok"))) TS_CResult_RouteHintHopDecodeErrorZ_is_ok(uint32_t o) {
12826 LDKCResult_RouteHintHopDecodeErrorZ* o_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(o & ~1);
12827 jboolean ret_conv = CResult_RouteHintHopDecodeErrorZ_is_ok(o_conv);
12831 void __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_free"))) TS_CResult_RouteHintHopDecodeErrorZ_free(uint32_t _res) {
12832 if ((_res & 1) != 0) return;
12833 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12834 CHECK_ACCESS(_res_ptr);
12835 LDKCResult_RouteHintHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHintHopDecodeErrorZ*)(_res_ptr);
12837 CResult_RouteHintHopDecodeErrorZ_free(_res_conv);
12840 static inline uintptr_t CResult_RouteHintHopDecodeErrorZ_clone_ptr(LDKCResult_RouteHintHopDecodeErrorZ *NONNULL_PTR arg) {
12841 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
12842 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(arg);
12843 return (uint32_t)ret_conv;
12845 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr"))) TS_CResult_RouteHintHopDecodeErrorZ_clone_ptr(uint32_t arg) {
12846 LDKCResult_RouteHintHopDecodeErrorZ* arg_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(arg & ~1);
12847 uint32_t ret_conv = CResult_RouteHintHopDecodeErrorZ_clone_ptr(arg_conv);
12851 uint32_t __attribute__((export_name("TS_CResult_RouteHintHopDecodeErrorZ_clone"))) TS_CResult_RouteHintHopDecodeErrorZ_clone(uint32_t orig) {
12852 LDKCResult_RouteHintHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHintHopDecodeErrorZ*)(orig & ~1);
12853 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
12854 *ret_conv = CResult_RouteHintHopDecodeErrorZ_clone(orig_conv);
12855 return (uint32_t)ret_conv;
12858 void __attribute__((export_name("TS_CVec_ChannelDetailsZ_free"))) TS_CVec_ChannelDetailsZ_free(uint32_tArray _res) {
12859 LDKCVec_ChannelDetailsZ _res_constr;
12860 _res_constr.datalen = _res->arr_len;
12861 if (_res_constr.datalen > 0)
12862 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
12864 _res_constr.data = NULL;
12865 uint32_t* _res_vals = _res->elems;
12866 for (size_t q = 0; q < _res_constr.datalen; q++) {
12867 uint32_t _res_conv_16 = _res_vals[q];
12868 LDKChannelDetails _res_conv_16_conv;
12869 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
12870 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
12871 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
12872 _res_constr.data[q] = _res_conv_16_conv;
12875 CVec_ChannelDetailsZ_free(_res_constr);
12878 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_ok"))) TS_CResult_RouteLightningErrorZ_ok(uint32_t o) {
12880 o_conv.inner = (void*)(o & (~1));
12881 o_conv.is_owned = (o & 1) || (o == 0);
12882 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
12883 o_conv = Route_clone(&o_conv);
12884 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12885 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
12886 return (uint32_t)ret_conv;
12889 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_err"))) TS_CResult_RouteLightningErrorZ_err(uint32_t e) {
12890 LDKLightningError e_conv;
12891 e_conv.inner = (void*)(e & (~1));
12892 e_conv.is_owned = (e & 1) || (e == 0);
12893 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12894 e_conv = LightningError_clone(&e_conv);
12895 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12896 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
12897 return (uint32_t)ret_conv;
12900 jboolean __attribute__((export_name("TS_CResult_RouteLightningErrorZ_is_ok"))) TS_CResult_RouteLightningErrorZ_is_ok(uint32_t o) {
12901 LDKCResult_RouteLightningErrorZ* o_conv = (LDKCResult_RouteLightningErrorZ*)(o & ~1);
12902 jboolean ret_conv = CResult_RouteLightningErrorZ_is_ok(o_conv);
12906 void __attribute__((export_name("TS_CResult_RouteLightningErrorZ_free"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
12907 if ((_res & 1) != 0) return;
12908 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12909 CHECK_ACCESS(_res_ptr);
12910 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(_res_ptr);
12912 CResult_RouteLightningErrorZ_free(_res_conv);
12915 static inline uintptr_t CResult_RouteLightningErrorZ_clone_ptr(LDKCResult_RouteLightningErrorZ *NONNULL_PTR arg) {
12916 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12917 *ret_conv = CResult_RouteLightningErrorZ_clone(arg);
12918 return (uint32_t)ret_conv;
12920 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone_ptr"))) TS_CResult_RouteLightningErrorZ_clone_ptr(uint32_t arg) {
12921 LDKCResult_RouteLightningErrorZ* arg_conv = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
12922 uint32_t ret_conv = CResult_RouteLightningErrorZ_clone_ptr(arg_conv);
12926 uint32_t __attribute__((export_name("TS_CResult_RouteLightningErrorZ_clone"))) TS_CResult_RouteLightningErrorZ_clone(uint32_t orig) {
12927 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
12928 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
12929 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
12930 return (uint32_t)ret_conv;
12933 void __attribute__((export_name("TS_CVec_PublicKeyZ_free"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
12934 LDKCVec_PublicKeyZ _res_constr;
12935 _res_constr.datalen = _res->arr_len;
12936 if (_res_constr.datalen > 0)
12937 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
12939 _res_constr.data = NULL;
12940 int8_tArray* _res_vals = (void*) _res->elems;
12941 for (size_t m = 0; m < _res_constr.datalen; m++) {
12942 int8_tArray _res_conv_12 = _res_vals[m];
12943 LDKPublicKey _res_conv_12_ref;
12944 CHECK(_res_conv_12->arr_len == 33);
12945 memcpy(_res_conv_12_ref.compressed_form, _res_conv_12->elems, 33); FREE(_res_conv_12);
12946 _res_constr.data[m] = _res_conv_12_ref;
12949 CVec_PublicKeyZ_free(_res_constr);
12952 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_ok(uint32_t o) {
12953 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
12954 CHECK_ACCESS(o_ptr);
12955 LDKPaymentPurpose o_conv = *(LDKPaymentPurpose*)(o_ptr);
12956 o_conv = PaymentPurpose_clone((LDKPaymentPurpose*)(((uintptr_t)o) & ~1));
12957 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
12958 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_ok(o_conv);
12959 return (uint32_t)ret_conv;
12962 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_err"))) TS_CResult_PaymentPurposeDecodeErrorZ_err(uint32_t e) {
12963 LDKDecodeError e_conv;
12964 e_conv.inner = (void*)(e & (~1));
12965 e_conv.is_owned = (e & 1) || (e == 0);
12966 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
12967 e_conv = DecodeError_clone(&e_conv);
12968 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
12969 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_err(e_conv);
12970 return (uint32_t)ret_conv;
12973 jboolean __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_is_ok"))) TS_CResult_PaymentPurposeDecodeErrorZ_is_ok(uint32_t o) {
12974 LDKCResult_PaymentPurposeDecodeErrorZ* o_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)(o & ~1);
12975 jboolean ret_conv = CResult_PaymentPurposeDecodeErrorZ_is_ok(o_conv);
12979 void __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_free"))) TS_CResult_PaymentPurposeDecodeErrorZ_free(uint32_t _res) {
12980 if ((_res & 1) != 0) return;
12981 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
12982 CHECK_ACCESS(_res_ptr);
12983 LDKCResult_PaymentPurposeDecodeErrorZ _res_conv = *(LDKCResult_PaymentPurposeDecodeErrorZ*)(_res_ptr);
12985 CResult_PaymentPurposeDecodeErrorZ_free(_res_conv);
12988 static inline uintptr_t CResult_PaymentPurposeDecodeErrorZ_clone_ptr(LDKCResult_PaymentPurposeDecodeErrorZ *NONNULL_PTR arg) {
12989 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
12990 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(arg);
12991 return (uint32_t)ret_conv;
12993 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone_ptr(uint32_t arg) {
12994 LDKCResult_PaymentPurposeDecodeErrorZ* arg_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)(arg & ~1);
12995 uint32_t ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone_ptr(arg_conv);
12999 uint32_t __attribute__((export_name("TS_CResult_PaymentPurposeDecodeErrorZ_clone"))) TS_CResult_PaymentPurposeDecodeErrorZ_clone(uint32_t orig) {
13000 LDKCResult_PaymentPurposeDecodeErrorZ* orig_conv = (LDKCResult_PaymentPurposeDecodeErrorZ*)(orig & ~1);
13001 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
13002 *ret_conv = CResult_PaymentPurposeDecodeErrorZ_clone(orig_conv);
13003 return (uint32_t)ret_conv;
13006 uint32_t __attribute__((export_name("TS_COption_ClosureReasonZ_some"))) TS_COption_ClosureReasonZ_some(uint32_t o) {
13007 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13008 CHECK_ACCESS(o_ptr);
13009 LDKClosureReason o_conv = *(LDKClosureReason*)(o_ptr);
13010 o_conv = ClosureReason_clone((LDKClosureReason*)(((uintptr_t)o) & ~1));
13011 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13012 *ret_copy = COption_ClosureReasonZ_some(o_conv);
13013 uint32_t ret_ref = (uintptr_t)ret_copy;
13017 uint32_t __attribute__((export_name("TS_COption_ClosureReasonZ_none"))) TS_COption_ClosureReasonZ_none() {
13018 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13019 *ret_copy = COption_ClosureReasonZ_none();
13020 uint32_t ret_ref = (uintptr_t)ret_copy;
13024 void __attribute__((export_name("TS_COption_ClosureReasonZ_free"))) TS_COption_ClosureReasonZ_free(uint32_t _res) {
13025 if ((_res & 1) != 0) return;
13026 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13027 CHECK_ACCESS(_res_ptr);
13028 LDKCOption_ClosureReasonZ _res_conv = *(LDKCOption_ClosureReasonZ*)(_res_ptr);
13030 COption_ClosureReasonZ_free(_res_conv);
13033 static inline uintptr_t COption_ClosureReasonZ_clone_ptr(LDKCOption_ClosureReasonZ *NONNULL_PTR arg) {
13034 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13035 *ret_copy = COption_ClosureReasonZ_clone(arg);
13036 uint32_t ret_ref = (uintptr_t)ret_copy;
13039 uint32_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone_ptr"))) TS_COption_ClosureReasonZ_clone_ptr(uint32_t arg) {
13040 LDKCOption_ClosureReasonZ* arg_conv = (LDKCOption_ClosureReasonZ*)arg;
13041 uint32_t ret_conv = COption_ClosureReasonZ_clone_ptr(arg_conv);
13045 uint32_t __attribute__((export_name("TS_COption_ClosureReasonZ_clone"))) TS_COption_ClosureReasonZ_clone(uint32_t orig) {
13046 LDKCOption_ClosureReasonZ* orig_conv = (LDKCOption_ClosureReasonZ*)orig;
13047 LDKCOption_ClosureReasonZ *ret_copy = MALLOC(sizeof(LDKCOption_ClosureReasonZ), "LDKCOption_ClosureReasonZ");
13048 *ret_copy = COption_ClosureReasonZ_clone(orig_conv);
13049 uint32_t ret_ref = (uintptr_t)ret_copy;
13053 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_ok(uint32_t o) {
13054 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13055 CHECK_ACCESS(o_ptr);
13056 LDKCOption_ClosureReasonZ o_conv = *(LDKCOption_ClosureReasonZ*)(o_ptr);
13057 o_conv = COption_ClosureReasonZ_clone((LDKCOption_ClosureReasonZ*)(((uintptr_t)o) & ~1));
13058 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13059 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_ok(o_conv);
13060 return (uint32_t)ret_conv;
13063 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_err"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_err(uint32_t e) {
13064 LDKDecodeError e_conv;
13065 e_conv.inner = (void*)(e & (~1));
13066 e_conv.is_owned = (e & 1) || (e == 0);
13067 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13068 e_conv = DecodeError_clone(&e_conv);
13069 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13070 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_err(e_conv);
13071 return (uint32_t)ret_conv;
13074 jboolean __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(uint32_t o) {
13075 LDKCResult_COption_ClosureReasonZDecodeErrorZ* o_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(o & ~1);
13076 jboolean ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_is_ok(o_conv);
13080 void __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_free"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_free(uint32_t _res) {
13081 if ((_res & 1) != 0) return;
13082 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13083 CHECK_ACCESS(_res_ptr);
13084 LDKCResult_COption_ClosureReasonZDecodeErrorZ _res_conv = *(LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(_res_ptr);
13086 CResult_COption_ClosureReasonZDecodeErrorZ_free(_res_conv);
13089 static inline uintptr_t CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(LDKCResult_COption_ClosureReasonZDecodeErrorZ *NONNULL_PTR arg) {
13090 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13091 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(arg);
13092 return (uint32_t)ret_conv;
13094 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(uint32_t arg) {
13095 LDKCResult_COption_ClosureReasonZDecodeErrorZ* arg_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(arg & ~1);
13096 uint32_t ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone_ptr(arg_conv);
13100 uint32_t __attribute__((export_name("TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone"))) TS_CResult_COption_ClosureReasonZDecodeErrorZ_clone(uint32_t orig) {
13101 LDKCResult_COption_ClosureReasonZDecodeErrorZ* orig_conv = (LDKCResult_COption_ClosureReasonZDecodeErrorZ*)(orig & ~1);
13102 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
13103 *ret_conv = CResult_COption_ClosureReasonZDecodeErrorZ_clone(orig_conv);
13104 return (uint32_t)ret_conv;
13107 uint32_t __attribute__((export_name("TS_COption_HTLCDestinationZ_some"))) TS_COption_HTLCDestinationZ_some(uint32_t o) {
13108 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13109 CHECK_ACCESS(o_ptr);
13110 LDKHTLCDestination o_conv = *(LDKHTLCDestination*)(o_ptr);
13111 o_conv = HTLCDestination_clone((LDKHTLCDestination*)(((uintptr_t)o) & ~1));
13112 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13113 *ret_copy = COption_HTLCDestinationZ_some(o_conv);
13114 uint32_t ret_ref = (uintptr_t)ret_copy;
13118 uint32_t __attribute__((export_name("TS_COption_HTLCDestinationZ_none"))) TS_COption_HTLCDestinationZ_none() {
13119 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13120 *ret_copy = COption_HTLCDestinationZ_none();
13121 uint32_t ret_ref = (uintptr_t)ret_copy;
13125 void __attribute__((export_name("TS_COption_HTLCDestinationZ_free"))) TS_COption_HTLCDestinationZ_free(uint32_t _res) {
13126 if ((_res & 1) != 0) return;
13127 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13128 CHECK_ACCESS(_res_ptr);
13129 LDKCOption_HTLCDestinationZ _res_conv = *(LDKCOption_HTLCDestinationZ*)(_res_ptr);
13131 COption_HTLCDestinationZ_free(_res_conv);
13134 static inline uintptr_t COption_HTLCDestinationZ_clone_ptr(LDKCOption_HTLCDestinationZ *NONNULL_PTR arg) {
13135 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13136 *ret_copy = COption_HTLCDestinationZ_clone(arg);
13137 uint32_t ret_ref = (uintptr_t)ret_copy;
13140 uint32_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone_ptr"))) TS_COption_HTLCDestinationZ_clone_ptr(uint32_t arg) {
13141 LDKCOption_HTLCDestinationZ* arg_conv = (LDKCOption_HTLCDestinationZ*)arg;
13142 uint32_t ret_conv = COption_HTLCDestinationZ_clone_ptr(arg_conv);
13146 uint32_t __attribute__((export_name("TS_COption_HTLCDestinationZ_clone"))) TS_COption_HTLCDestinationZ_clone(uint32_t orig) {
13147 LDKCOption_HTLCDestinationZ* orig_conv = (LDKCOption_HTLCDestinationZ*)orig;
13148 LDKCOption_HTLCDestinationZ *ret_copy = MALLOC(sizeof(LDKCOption_HTLCDestinationZ), "LDKCOption_HTLCDestinationZ");
13149 *ret_copy = COption_HTLCDestinationZ_clone(orig_conv);
13150 uint32_t ret_ref = (uintptr_t)ret_copy;
13154 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_ok(uint32_t o) {
13155 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13156 CHECK_ACCESS(o_ptr);
13157 LDKCOption_HTLCDestinationZ o_conv = *(LDKCOption_HTLCDestinationZ*)(o_ptr);
13158 o_conv = COption_HTLCDestinationZ_clone((LDKCOption_HTLCDestinationZ*)(((uintptr_t)o) & ~1));
13159 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13160 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_ok(o_conv);
13161 return (uint32_t)ret_conv;
13164 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_err(uint32_t e) {
13165 LDKDecodeError e_conv;
13166 e_conv.inner = (void*)(e & (~1));
13167 e_conv.is_owned = (e & 1) || (e == 0);
13168 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13169 e_conv = DecodeError_clone(&e_conv);
13170 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13171 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_err(e_conv);
13172 return (uint32_t)ret_conv;
13175 jboolean __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(uint32_t o) {
13176 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* o_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(o & ~1);
13177 jboolean ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_is_ok(o_conv);
13181 void __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_free(uint32_t _res) {
13182 if ((_res & 1) != 0) return;
13183 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13184 CHECK_ACCESS(_res_ptr);
13185 LDKCResult_COption_HTLCDestinationZDecodeErrorZ _res_conv = *(LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(_res_ptr);
13187 CResult_COption_HTLCDestinationZDecodeErrorZ_free(_res_conv);
13190 static inline uintptr_t CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(LDKCResult_COption_HTLCDestinationZDecodeErrorZ *NONNULL_PTR arg) {
13191 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13192 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(arg);
13193 return (uint32_t)ret_conv;
13195 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(uint32_t arg) {
13196 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* arg_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(arg & ~1);
13197 uint32_t ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone_ptr(arg_conv);
13201 uint32_t __attribute__((export_name("TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone"))) TS_CResult_COption_HTLCDestinationZDecodeErrorZ_clone(uint32_t orig) {
13202 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* orig_conv = (LDKCResult_COption_HTLCDestinationZDecodeErrorZ*)(orig & ~1);
13203 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
13204 *ret_conv = CResult_COption_HTLCDestinationZDecodeErrorZ_clone(orig_conv);
13205 return (uint32_t)ret_conv;
13208 uint32_t __attribute__((export_name("TS_COption_NetworkUpdateZ_some"))) TS_COption_NetworkUpdateZ_some(uint32_t o) {
13209 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13210 CHECK_ACCESS(o_ptr);
13211 LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(o_ptr);
13212 o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)(((uintptr_t)o) & ~1));
13213 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13214 *ret_copy = COption_NetworkUpdateZ_some(o_conv);
13215 uint32_t ret_ref = (uintptr_t)ret_copy;
13219 uint32_t __attribute__((export_name("TS_COption_NetworkUpdateZ_none"))) TS_COption_NetworkUpdateZ_none() {
13220 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13221 *ret_copy = COption_NetworkUpdateZ_none();
13222 uint32_t ret_ref = (uintptr_t)ret_copy;
13226 void __attribute__((export_name("TS_COption_NetworkUpdateZ_free"))) TS_COption_NetworkUpdateZ_free(uint32_t _res) {
13227 if ((_res & 1) != 0) return;
13228 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13229 CHECK_ACCESS(_res_ptr);
13230 LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(_res_ptr);
13232 COption_NetworkUpdateZ_free(_res_conv);
13235 static inline uintptr_t COption_NetworkUpdateZ_clone_ptr(LDKCOption_NetworkUpdateZ *NONNULL_PTR arg) {
13236 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13237 *ret_copy = COption_NetworkUpdateZ_clone(arg);
13238 uint32_t ret_ref = (uintptr_t)ret_copy;
13241 uint32_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone_ptr"))) TS_COption_NetworkUpdateZ_clone_ptr(uint32_t arg) {
13242 LDKCOption_NetworkUpdateZ* arg_conv = (LDKCOption_NetworkUpdateZ*)arg;
13243 uint32_t ret_conv = COption_NetworkUpdateZ_clone_ptr(arg_conv);
13247 uint32_t __attribute__((export_name("TS_COption_NetworkUpdateZ_clone"))) TS_COption_NetworkUpdateZ_clone(uint32_t orig) {
13248 LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig;
13249 LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ");
13250 *ret_copy = COption_NetworkUpdateZ_clone(orig_conv);
13251 uint32_t ret_ref = (uintptr_t)ret_copy;
13255 void __attribute__((export_name("TS_CVec_SpendableOutputDescriptorZ_free"))) TS_CVec_SpendableOutputDescriptorZ_free(uint32_tArray _res) {
13256 LDKCVec_SpendableOutputDescriptorZ _res_constr;
13257 _res_constr.datalen = _res->arr_len;
13258 if (_res_constr.datalen > 0)
13259 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
13261 _res_constr.data = NULL;
13262 uint32_t* _res_vals = _res->elems;
13263 for (size_t b = 0; b < _res_constr.datalen; b++) {
13264 uint32_t _res_conv_27 = _res_vals[b];
13265 void* _res_conv_27_ptr = (void*)(((uintptr_t)_res_conv_27) & ~1);
13266 CHECK_ACCESS(_res_conv_27_ptr);
13267 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(_res_conv_27_ptr);
13268 FREE((void*)_res_conv_27);
13269 _res_constr.data[b] = _res_conv_27_conv;
13272 CVec_SpendableOutputDescriptorZ_free(_res_constr);
13275 uint32_t __attribute__((export_name("TS_COption_EventZ_some"))) TS_COption_EventZ_some(uint32_t o) {
13276 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13277 CHECK_ACCESS(o_ptr);
13278 LDKEvent o_conv = *(LDKEvent*)(o_ptr);
13279 o_conv = Event_clone((LDKEvent*)(((uintptr_t)o) & ~1));
13280 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13281 *ret_copy = COption_EventZ_some(o_conv);
13282 uint32_t ret_ref = (uintptr_t)ret_copy;
13286 uint32_t __attribute__((export_name("TS_COption_EventZ_none"))) TS_COption_EventZ_none() {
13287 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13288 *ret_copy = COption_EventZ_none();
13289 uint32_t ret_ref = (uintptr_t)ret_copy;
13293 void __attribute__((export_name("TS_COption_EventZ_free"))) TS_COption_EventZ_free(uint32_t _res) {
13294 if ((_res & 1) != 0) return;
13295 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13296 CHECK_ACCESS(_res_ptr);
13297 LDKCOption_EventZ _res_conv = *(LDKCOption_EventZ*)(_res_ptr);
13299 COption_EventZ_free(_res_conv);
13302 static inline uintptr_t COption_EventZ_clone_ptr(LDKCOption_EventZ *NONNULL_PTR arg) {
13303 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13304 *ret_copy = COption_EventZ_clone(arg);
13305 uint32_t ret_ref = (uintptr_t)ret_copy;
13308 uint32_t __attribute__((export_name("TS_COption_EventZ_clone_ptr"))) TS_COption_EventZ_clone_ptr(uint32_t arg) {
13309 LDKCOption_EventZ* arg_conv = (LDKCOption_EventZ*)arg;
13310 uint32_t ret_conv = COption_EventZ_clone_ptr(arg_conv);
13314 uint32_t __attribute__((export_name("TS_COption_EventZ_clone"))) TS_COption_EventZ_clone(uint32_t orig) {
13315 LDKCOption_EventZ* orig_conv = (LDKCOption_EventZ*)orig;
13316 LDKCOption_EventZ *ret_copy = MALLOC(sizeof(LDKCOption_EventZ), "LDKCOption_EventZ");
13317 *ret_copy = COption_EventZ_clone(orig_conv);
13318 uint32_t ret_ref = (uintptr_t)ret_copy;
13322 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_ok"))) TS_CResult_COption_EventZDecodeErrorZ_ok(uint32_t o) {
13323 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13324 CHECK_ACCESS(o_ptr);
13325 LDKCOption_EventZ o_conv = *(LDKCOption_EventZ*)(o_ptr);
13326 o_conv = COption_EventZ_clone((LDKCOption_EventZ*)(((uintptr_t)o) & ~1));
13327 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13328 *ret_conv = CResult_COption_EventZDecodeErrorZ_ok(o_conv);
13329 return (uint32_t)ret_conv;
13332 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_err"))) TS_CResult_COption_EventZDecodeErrorZ_err(uint32_t e) {
13333 LDKDecodeError e_conv;
13334 e_conv.inner = (void*)(e & (~1));
13335 e_conv.is_owned = (e & 1) || (e == 0);
13336 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13337 e_conv = DecodeError_clone(&e_conv);
13338 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13339 *ret_conv = CResult_COption_EventZDecodeErrorZ_err(e_conv);
13340 return (uint32_t)ret_conv;
13343 jboolean __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_is_ok"))) TS_CResult_COption_EventZDecodeErrorZ_is_ok(uint32_t o) {
13344 LDKCResult_COption_EventZDecodeErrorZ* o_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(o & ~1);
13345 jboolean ret_conv = CResult_COption_EventZDecodeErrorZ_is_ok(o_conv);
13349 void __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_free"))) TS_CResult_COption_EventZDecodeErrorZ_free(uint32_t _res) {
13350 if ((_res & 1) != 0) return;
13351 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13352 CHECK_ACCESS(_res_ptr);
13353 LDKCResult_COption_EventZDecodeErrorZ _res_conv = *(LDKCResult_COption_EventZDecodeErrorZ*)(_res_ptr);
13355 CResult_COption_EventZDecodeErrorZ_free(_res_conv);
13358 static inline uintptr_t CResult_COption_EventZDecodeErrorZ_clone_ptr(LDKCResult_COption_EventZDecodeErrorZ *NONNULL_PTR arg) {
13359 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13360 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(arg);
13361 return (uint32_t)ret_conv;
13363 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_EventZDecodeErrorZ_clone_ptr(uint32_t arg) {
13364 LDKCResult_COption_EventZDecodeErrorZ* arg_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(arg & ~1);
13365 uint32_t ret_conv = CResult_COption_EventZDecodeErrorZ_clone_ptr(arg_conv);
13369 uint32_t __attribute__((export_name("TS_CResult_COption_EventZDecodeErrorZ_clone"))) TS_CResult_COption_EventZDecodeErrorZ_clone(uint32_t orig) {
13370 LDKCResult_COption_EventZDecodeErrorZ* orig_conv = (LDKCResult_COption_EventZDecodeErrorZ*)(orig & ~1);
13371 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
13372 *ret_conv = CResult_COption_EventZDecodeErrorZ_clone(orig_conv);
13373 return (uint32_t)ret_conv;
13376 void __attribute__((export_name("TS_CVec_MessageSendEventZ_free"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
13377 LDKCVec_MessageSendEventZ _res_constr;
13378 _res_constr.datalen = _res->arr_len;
13379 if (_res_constr.datalen > 0)
13380 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
13382 _res_constr.data = NULL;
13383 uint32_t* _res_vals = _res->elems;
13384 for (size_t s = 0; s < _res_constr.datalen; s++) {
13385 uint32_t _res_conv_18 = _res_vals[s];
13386 void* _res_conv_18_ptr = (void*)(((uintptr_t)_res_conv_18) & ~1);
13387 CHECK_ACCESS(_res_conv_18_ptr);
13388 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(_res_conv_18_ptr);
13389 FREE((void*)_res_conv_18);
13390 _res_constr.data[s] = _res_conv_18_conv;
13393 CVec_MessageSendEventZ_free(_res_constr);
13396 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_ok"))) TS_CResult_TxOutAccessErrorZ_ok(uint32_t o) {
13397 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13398 CHECK_ACCESS(o_ptr);
13399 LDKTxOut o_conv = *(LDKTxOut*)(o_ptr);
13400 o_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)o) & ~1));
13401 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13402 *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv);
13403 return (uint32_t)ret_conv;
13406 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_err"))) TS_CResult_TxOutAccessErrorZ_err(uint32_t e) {
13407 LDKAccessError e_conv = LDKAccessError_from_js(e);
13408 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13409 *ret_conv = CResult_TxOutAccessErrorZ_err(e_conv);
13410 return (uint32_t)ret_conv;
13413 jboolean __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_is_ok"))) TS_CResult_TxOutAccessErrorZ_is_ok(uint32_t o) {
13414 LDKCResult_TxOutAccessErrorZ* o_conv = (LDKCResult_TxOutAccessErrorZ*)(o & ~1);
13415 jboolean ret_conv = CResult_TxOutAccessErrorZ_is_ok(o_conv);
13419 void __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_free"))) TS_CResult_TxOutAccessErrorZ_free(uint32_t _res) {
13420 if ((_res & 1) != 0) return;
13421 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13422 CHECK_ACCESS(_res_ptr);
13423 LDKCResult_TxOutAccessErrorZ _res_conv = *(LDKCResult_TxOutAccessErrorZ*)(_res_ptr);
13425 CResult_TxOutAccessErrorZ_free(_res_conv);
13428 static inline uintptr_t CResult_TxOutAccessErrorZ_clone_ptr(LDKCResult_TxOutAccessErrorZ *NONNULL_PTR arg) {
13429 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13430 *ret_conv = CResult_TxOutAccessErrorZ_clone(arg);
13431 return (uint32_t)ret_conv;
13433 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_clone_ptr"))) TS_CResult_TxOutAccessErrorZ_clone_ptr(uint32_t arg) {
13434 LDKCResult_TxOutAccessErrorZ* arg_conv = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
13435 uint32_t ret_conv = CResult_TxOutAccessErrorZ_clone_ptr(arg_conv);
13439 uint32_t __attribute__((export_name("TS_CResult_TxOutAccessErrorZ_clone"))) TS_CResult_TxOutAccessErrorZ_clone(uint32_t orig) {
13440 LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
13441 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
13442 *ret_conv = CResult_TxOutAccessErrorZ_clone(orig_conv);
13443 return (uint32_t)ret_conv;
13446 static inline uintptr_t C2Tuple_usizeTransactionZ_clone_ptr(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR arg) {
13447 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13448 *ret_conv = C2Tuple_usizeTransactionZ_clone(arg);
13449 return ((uint32_t)ret_conv);
13451 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone_ptr"))) TS_C2Tuple_usizeTransactionZ_clone_ptr(uint32_t arg) {
13452 LDKC2Tuple_usizeTransactionZ* arg_conv = (LDKC2Tuple_usizeTransactionZ*)(arg & ~1);
13453 uint32_t ret_conv = C2Tuple_usizeTransactionZ_clone_ptr(arg_conv);
13457 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_clone"))) TS_C2Tuple_usizeTransactionZ_clone(uint32_t orig) {
13458 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
13459 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13460 *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv);
13461 return ((uint32_t)ret_conv);
13464 uint32_t __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_new"))) TS_C2Tuple_usizeTransactionZ_new(uint32_t a, int8_tArray b) {
13465 LDKTransaction b_ref;
13466 b_ref.datalen = b->arr_len;
13467 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
13468 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
13469 b_ref.data_is_owned = true;
13470 LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
13471 *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref);
13472 return ((uint32_t)ret_conv);
13475 void __attribute__((export_name("TS_C2Tuple_usizeTransactionZ_free"))) TS_C2Tuple_usizeTransactionZ_free(uint32_t _res) {
13476 if ((_res & 1) != 0) return;
13477 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13478 CHECK_ACCESS(_res_ptr);
13479 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_ptr);
13481 C2Tuple_usizeTransactionZ_free(_res_conv);
13484 void __attribute__((export_name("TS_CVec_C2Tuple_usizeTransactionZZ_free"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint32_tArray _res) {
13485 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
13486 _res_constr.datalen = _res->arr_len;
13487 if (_res_constr.datalen > 0)
13488 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
13490 _res_constr.data = NULL;
13491 uint32_t* _res_vals = _res->elems;
13492 for (size_t c = 0; c < _res_constr.datalen; c++) {
13493 uint32_t _res_conv_28 = _res_vals[c];
13494 void* _res_conv_28_ptr = (void*)(((uintptr_t)_res_conv_28) & ~1);
13495 CHECK_ACCESS(_res_conv_28_ptr);
13496 LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(_res_conv_28_ptr);
13497 FREE((void*)_res_conv_28);
13498 _res_constr.data[c] = _res_conv_28_conv;
13501 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
13504 void __attribute__((export_name("TS_CVec_TxidZ_free"))) TS_CVec_TxidZ_free(ptrArray _res) {
13505 LDKCVec_TxidZ _res_constr;
13506 _res_constr.datalen = _res->arr_len;
13507 if (_res_constr.datalen > 0)
13508 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
13510 _res_constr.data = NULL;
13511 int8_tArray* _res_vals = (void*) _res->elems;
13512 for (size_t m = 0; m < _res_constr.datalen; m++) {
13513 int8_tArray _res_conv_12 = _res_vals[m];
13514 LDKThirtyTwoBytes _res_conv_12_ref;
13515 CHECK(_res_conv_12->arr_len == 32);
13516 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
13517 _res_constr.data[m] = _res_conv_12_ref;
13520 CVec_TxidZ_free(_res_constr);
13523 uint32_t __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_ok"))) TS_CResult_NoneChannelMonitorUpdateErrZ_ok() {
13524 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
13525 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_ok();
13526 return (uint32_t)ret_conv;
13529 uint32_t __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_err"))) TS_CResult_NoneChannelMonitorUpdateErrZ_err(uint32_t e) {
13530 LDKChannelMonitorUpdateErr e_conv = LDKChannelMonitorUpdateErr_from_js(e);
13531 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
13532 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_err(e_conv);
13533 return (uint32_t)ret_conv;
13536 jboolean __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok"))) TS_CResult_NoneChannelMonitorUpdateErrZ_is_ok(uint32_t o) {
13537 LDKCResult_NoneChannelMonitorUpdateErrZ* o_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(o & ~1);
13538 jboolean ret_conv = CResult_NoneChannelMonitorUpdateErrZ_is_ok(o_conv);
13542 void __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_free"))) TS_CResult_NoneChannelMonitorUpdateErrZ_free(uint32_t _res) {
13543 if ((_res & 1) != 0) return;
13544 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13545 CHECK_ACCESS(_res_ptr);
13546 LDKCResult_NoneChannelMonitorUpdateErrZ _res_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(_res_ptr);
13548 CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
13551 static inline uintptr_t CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(LDKCResult_NoneChannelMonitorUpdateErrZ *NONNULL_PTR arg) {
13552 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
13553 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(arg);
13554 return (uint32_t)ret_conv;
13556 uint32_t __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(uint32_t arg) {
13557 LDKCResult_NoneChannelMonitorUpdateErrZ* arg_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
13558 uint32_t ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone_ptr(arg_conv);
13562 uint32_t __attribute__((export_name("TS_CResult_NoneChannelMonitorUpdateErrZ_clone"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone(uint32_t orig) {
13563 LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
13564 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
13565 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(orig_conv);
13566 return (uint32_t)ret_conv;
13569 void __attribute__((export_name("TS_CVec_MonitorEventZ_free"))) TS_CVec_MonitorEventZ_free(uint32_tArray _res) {
13570 LDKCVec_MonitorEventZ _res_constr;
13571 _res_constr.datalen = _res->arr_len;
13572 if (_res_constr.datalen > 0)
13573 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
13575 _res_constr.data = NULL;
13576 uint32_t* _res_vals = _res->elems;
13577 for (size_t o = 0; o < _res_constr.datalen; o++) {
13578 uint32_t _res_conv_14 = _res_vals[o];
13579 void* _res_conv_14_ptr = (void*)(((uintptr_t)_res_conv_14) & ~1);
13580 CHECK_ACCESS(_res_conv_14_ptr);
13581 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(_res_conv_14_ptr);
13582 FREE((void*)_res_conv_14);
13583 _res_constr.data[o] = _res_conv_14_conv;
13586 CVec_MonitorEventZ_free(_res_constr);
13589 static inline uintptr_t C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ *NONNULL_PTR arg) {
13590 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13591 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(arg);
13592 return ((uint32_t)ret_conv);
13594 uint32_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(uint32_t arg) {
13595 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* arg_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(arg & ~1);
13596 uint32_t ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone_ptr(arg_conv);
13600 uint32_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(uint32_t orig) {
13601 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* orig_conv = (LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(orig & ~1);
13602 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13603 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_clone(orig_conv);
13604 return ((uint32_t)ret_conv);
13607 uint32_t __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(uint32_t a, uint32_tArray b, int8_tArray c) {
13608 LDKOutPoint a_conv;
13609 a_conv.inner = (void*)(a & (~1));
13610 a_conv.is_owned = (a & 1) || (a == 0);
13611 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
13612 a_conv = OutPoint_clone(&a_conv);
13613 LDKCVec_MonitorEventZ b_constr;
13614 b_constr.datalen = b->arr_len;
13615 if (b_constr.datalen > 0)
13616 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
13618 b_constr.data = NULL;
13619 uint32_t* b_vals = b->elems;
13620 for (size_t o = 0; o < b_constr.datalen; o++) {
13621 uint32_t b_conv_14 = b_vals[o];
13622 void* b_conv_14_ptr = (void*)(((uintptr_t)b_conv_14) & ~1);
13623 CHECK_ACCESS(b_conv_14_ptr);
13624 LDKMonitorEvent b_conv_14_conv = *(LDKMonitorEvent*)(b_conv_14_ptr);
13625 b_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uintptr_t)b_conv_14) & ~1));
13626 b_constr.data[o] = b_conv_14_conv;
13629 LDKPublicKey c_ref;
13630 CHECK(c->arr_len == 33);
13631 memcpy(c_ref.compressed_form, c->elems, 33); FREE(c);
13632 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ");
13633 *ret_conv = C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_new(a_conv, b_constr, c_ref);
13634 return ((uint32_t)ret_conv);
13637 void __attribute__((export_name("TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free"))) TS_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(uint32_t _res) {
13638 if ((_res & 1) != 0) return;
13639 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13640 CHECK_ACCESS(_res_ptr);
13641 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_ptr);
13643 C3Tuple_OutPointCVec_MonitorEventZPublicKeyZ_free(_res_conv);
13646 void __attribute__((export_name("TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free"))) TS_CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(uint32_tArray _res) {
13647 LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ _res_constr;
13648 _res_constr.datalen = _res->arr_len;
13649 if (_res_constr.datalen > 0)
13650 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ), "LDKCVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ Elements");
13652 _res_constr.data = NULL;
13653 uint32_t* _res_vals = _res->elems;
13654 for (size_t x = 0; x < _res_constr.datalen; x++) {
13655 uint32_t _res_conv_49 = _res_vals[x];
13656 void* _res_conv_49_ptr = (void*)(((uintptr_t)_res_conv_49) & ~1);
13657 CHECK_ACCESS(_res_conv_49_ptr);
13658 LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ _res_conv_49_conv = *(LDKC3Tuple_OutPointCVec_MonitorEventZPublicKeyZ*)(_res_conv_49_ptr);
13659 FREE((void*)_res_conv_49);
13660 _res_constr.data[x] = _res_conv_49_conv;
13663 CVec_C3Tuple_OutPointCVec_MonitorEventZPublicKeyZZ_free(_res_constr);
13666 uint32_t __attribute__((export_name("TS_COption_C2Tuple_usizeTransactionZZ_some"))) TS_COption_C2Tuple_usizeTransactionZZ_some(uint32_t o) {
13667 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13668 CHECK_ACCESS(o_ptr);
13669 LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(o_ptr);
13670 o_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uintptr_t)o) & ~1));
13671 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
13672 *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv);
13673 uint32_t ret_ref = (uintptr_t)ret_copy;
13677 uint32_t __attribute__((export_name("TS_COption_C2Tuple_usizeTransactionZZ_none"))) TS_COption_C2Tuple_usizeTransactionZZ_none() {
13678 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
13679 *ret_copy = COption_C2Tuple_usizeTransactionZZ_none();
13680 uint32_t ret_ref = (uintptr_t)ret_copy;
13684 void __attribute__((export_name("TS_COption_C2Tuple_usizeTransactionZZ_free"))) TS_COption_C2Tuple_usizeTransactionZZ_free(uint32_t _res) {
13685 if ((_res & 1) != 0) return;
13686 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13687 CHECK_ACCESS(_res_ptr);
13688 LDKCOption_C2Tuple_usizeTransactionZZ _res_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(_res_ptr);
13690 COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
13693 static inline uintptr_t COption_C2Tuple_usizeTransactionZZ_clone_ptr(LDKCOption_C2Tuple_usizeTransactionZZ *NONNULL_PTR arg) {
13694 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
13695 *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(arg);
13696 uint32_t ret_ref = (uintptr_t)ret_copy;
13699 uint32_t __attribute__((export_name("TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr"))) TS_COption_C2Tuple_usizeTransactionZZ_clone_ptr(uint32_t arg) {
13700 LDKCOption_C2Tuple_usizeTransactionZZ* arg_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)arg;
13701 uint32_t ret_conv = COption_C2Tuple_usizeTransactionZZ_clone_ptr(arg_conv);
13705 uint32_t __attribute__((export_name("TS_COption_C2Tuple_usizeTransactionZZ_clone"))) TS_COption_C2Tuple_usizeTransactionZZ_clone(uint32_t orig) {
13706 LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
13707 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
13708 *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(orig_conv);
13709 uint32_t ret_ref = (uintptr_t)ret_copy;
13713 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_ok(uint32_t o) {
13714 LDKFixedPenaltyScorer o_conv;
13715 o_conv.inner = (void*)(o & (~1));
13716 o_conv.is_owned = (o & 1) || (o == 0);
13717 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13718 o_conv = FixedPenaltyScorer_clone(&o_conv);
13719 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
13720 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_ok(o_conv);
13721 return (uint32_t)ret_conv;
13724 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_err"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_err(uint32_t e) {
13725 LDKDecodeError e_conv;
13726 e_conv.inner = (void*)(e & (~1));
13727 e_conv.is_owned = (e & 1) || (e == 0);
13728 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13729 e_conv = DecodeError_clone(&e_conv);
13730 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
13731 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_err(e_conv);
13732 return (uint32_t)ret_conv;
13735 jboolean __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(uint32_t o) {
13736 LDKCResult_FixedPenaltyScorerDecodeErrorZ* o_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(o & ~1);
13737 jboolean ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_is_ok(o_conv);
13741 void __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_free"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_free(uint32_t _res) {
13742 if ((_res & 1) != 0) return;
13743 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13744 CHECK_ACCESS(_res_ptr);
13745 LDKCResult_FixedPenaltyScorerDecodeErrorZ _res_conv = *(LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(_res_ptr);
13747 CResult_FixedPenaltyScorerDecodeErrorZ_free(_res_conv);
13750 static inline uintptr_t CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(LDKCResult_FixedPenaltyScorerDecodeErrorZ *NONNULL_PTR arg) {
13751 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
13752 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(arg);
13753 return (uint32_t)ret_conv;
13755 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(uint32_t arg) {
13756 LDKCResult_FixedPenaltyScorerDecodeErrorZ* arg_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(arg & ~1);
13757 uint32_t ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone_ptr(arg_conv);
13761 uint32_t __attribute__((export_name("TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone"))) TS_CResult_FixedPenaltyScorerDecodeErrorZ_clone(uint32_t orig) {
13762 LDKCResult_FixedPenaltyScorerDecodeErrorZ* orig_conv = (LDKCResult_FixedPenaltyScorerDecodeErrorZ*)(orig & ~1);
13763 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
13764 *ret_conv = CResult_FixedPenaltyScorerDecodeErrorZ_clone(orig_conv);
13765 return (uint32_t)ret_conv;
13768 static inline uintptr_t C2Tuple_u64u64Z_clone_ptr(LDKC2Tuple_u64u64Z *NONNULL_PTR arg) {
13769 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
13770 *ret_conv = C2Tuple_u64u64Z_clone(arg);
13771 return ((uint32_t)ret_conv);
13773 uint32_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone_ptr"))) TS_C2Tuple_u64u64Z_clone_ptr(uint32_t arg) {
13774 LDKC2Tuple_u64u64Z* arg_conv = (LDKC2Tuple_u64u64Z*)(arg & ~1);
13775 uint32_t ret_conv = C2Tuple_u64u64Z_clone_ptr(arg_conv);
13779 uint32_t __attribute__((export_name("TS_C2Tuple_u64u64Z_clone"))) TS_C2Tuple_u64u64Z_clone(uint32_t orig) {
13780 LDKC2Tuple_u64u64Z* orig_conv = (LDKC2Tuple_u64u64Z*)(orig & ~1);
13781 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
13782 *ret_conv = C2Tuple_u64u64Z_clone(orig_conv);
13783 return ((uint32_t)ret_conv);
13786 uint32_t __attribute__((export_name("TS_C2Tuple_u64u64Z_new"))) TS_C2Tuple_u64u64Z_new(int64_t a, int64_t b) {
13787 LDKC2Tuple_u64u64Z* ret_conv = MALLOC(sizeof(LDKC2Tuple_u64u64Z), "LDKC2Tuple_u64u64Z");
13788 *ret_conv = C2Tuple_u64u64Z_new(a, b);
13789 return ((uint32_t)ret_conv);
13792 void __attribute__((export_name("TS_C2Tuple_u64u64Z_free"))) TS_C2Tuple_u64u64Z_free(uint32_t _res) {
13793 if ((_res & 1) != 0) return;
13794 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13795 CHECK_ACCESS(_res_ptr);
13796 LDKC2Tuple_u64u64Z _res_conv = *(LDKC2Tuple_u64u64Z*)(_res_ptr);
13798 C2Tuple_u64u64Z_free(_res_conv);
13801 uint32_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_some"))) TS_COption_C2Tuple_u64u64ZZ_some(uint32_t o) {
13802 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
13803 CHECK_ACCESS(o_ptr);
13804 LDKC2Tuple_u64u64Z o_conv = *(LDKC2Tuple_u64u64Z*)(o_ptr);
13805 o_conv = C2Tuple_u64u64Z_clone((LDKC2Tuple_u64u64Z*)(((uintptr_t)o) & ~1));
13806 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
13807 *ret_copy = COption_C2Tuple_u64u64ZZ_some(o_conv);
13808 uint32_t ret_ref = (uintptr_t)ret_copy;
13812 uint32_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_none"))) TS_COption_C2Tuple_u64u64ZZ_none() {
13813 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
13814 *ret_copy = COption_C2Tuple_u64u64ZZ_none();
13815 uint32_t ret_ref = (uintptr_t)ret_copy;
13819 void __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_free"))) TS_COption_C2Tuple_u64u64ZZ_free(uint32_t _res) {
13820 if ((_res & 1) != 0) return;
13821 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13822 CHECK_ACCESS(_res_ptr);
13823 LDKCOption_C2Tuple_u64u64ZZ _res_conv = *(LDKCOption_C2Tuple_u64u64ZZ*)(_res_ptr);
13825 COption_C2Tuple_u64u64ZZ_free(_res_conv);
13828 static inline uintptr_t COption_C2Tuple_u64u64ZZ_clone_ptr(LDKCOption_C2Tuple_u64u64ZZ *NONNULL_PTR arg) {
13829 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
13830 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(arg);
13831 uint32_t ret_ref = (uintptr_t)ret_copy;
13834 uint32_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone_ptr"))) TS_COption_C2Tuple_u64u64ZZ_clone_ptr(uint32_t arg) {
13835 LDKCOption_C2Tuple_u64u64ZZ* arg_conv = (LDKCOption_C2Tuple_u64u64ZZ*)arg;
13836 uint32_t ret_conv = COption_C2Tuple_u64u64ZZ_clone_ptr(arg_conv);
13840 uint32_t __attribute__((export_name("TS_COption_C2Tuple_u64u64ZZ_clone"))) TS_COption_C2Tuple_u64u64ZZ_clone(uint32_t orig) {
13841 LDKCOption_C2Tuple_u64u64ZZ* orig_conv = (LDKCOption_C2Tuple_u64u64ZZ*)orig;
13842 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
13843 *ret_copy = COption_C2Tuple_u64u64ZZ_clone(orig_conv);
13844 uint32_t ret_ref = (uintptr_t)ret_copy;
13848 void __attribute__((export_name("TS_CVec_NodeIdZ_free"))) TS_CVec_NodeIdZ_free(uint32_tArray _res) {
13849 LDKCVec_NodeIdZ _res_constr;
13850 _res_constr.datalen = _res->arr_len;
13851 if (_res_constr.datalen > 0)
13852 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
13854 _res_constr.data = NULL;
13855 uint32_t* _res_vals = _res->elems;
13856 for (size_t i = 0; i < _res_constr.datalen; i++) {
13857 uint32_t _res_conv_8 = _res_vals[i];
13858 LDKNodeId _res_conv_8_conv;
13859 _res_conv_8_conv.inner = (void*)(_res_conv_8 & (~1));
13860 _res_conv_8_conv.is_owned = (_res_conv_8 & 1) || (_res_conv_8 == 0);
13861 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_8_conv);
13862 _res_constr.data[i] = _res_conv_8_conv;
13865 CVec_NodeIdZ_free(_res_constr);
13868 uint32_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_ok(uint32_t o) {
13869 LDKProbabilisticScorer o_conv;
13870 o_conv.inner = (void*)(o & (~1));
13871 o_conv.is_owned = (o & 1) || (o == 0);
13872 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13873 // WARNING: we need a move here but no clone is available for LDKProbabilisticScorer
13874 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
13875 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_ok(o_conv);
13876 return (uint32_t)ret_conv;
13879 uint32_t __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_err"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_err(uint32_t e) {
13880 LDKDecodeError e_conv;
13881 e_conv.inner = (void*)(e & (~1));
13882 e_conv.is_owned = (e & 1) || (e == 0);
13883 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13884 e_conv = DecodeError_clone(&e_conv);
13885 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
13886 *ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_err(e_conv);
13887 return (uint32_t)ret_conv;
13890 jboolean __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_is_ok(uint32_t o) {
13891 LDKCResult_ProbabilisticScorerDecodeErrorZ* o_conv = (LDKCResult_ProbabilisticScorerDecodeErrorZ*)(o & ~1);
13892 jboolean ret_conv = CResult_ProbabilisticScorerDecodeErrorZ_is_ok(o_conv);
13896 void __attribute__((export_name("TS_CResult_ProbabilisticScorerDecodeErrorZ_free"))) TS_CResult_ProbabilisticScorerDecodeErrorZ_free(uint32_t _res) {
13897 if ((_res & 1) != 0) return;
13898 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13899 CHECK_ACCESS(_res_ptr);
13900 LDKCResult_ProbabilisticScorerDecodeErrorZ _res_conv = *(LDKCResult_ProbabilisticScorerDecodeErrorZ*)(_res_ptr);
13902 CResult_ProbabilisticScorerDecodeErrorZ_free(_res_conv);
13905 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint32_t o) {
13906 LDKInitFeatures o_conv;
13907 o_conv.inner = (void*)(o & (~1));
13908 o_conv.is_owned = (o & 1) || (o == 0);
13909 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13910 o_conv = InitFeatures_clone(&o_conv);
13911 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
13912 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
13913 return (uint32_t)ret_conv;
13916 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_err"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint32_t e) {
13917 LDKDecodeError e_conv;
13918 e_conv.inner = (void*)(e & (~1));
13919 e_conv.is_owned = (e & 1) || (e == 0);
13920 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13921 e_conv = DecodeError_clone(&e_conv);
13922 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
13923 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
13924 return (uint32_t)ret_conv;
13927 jboolean __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InitFeaturesDecodeErrorZ_is_ok(uint32_t o) {
13928 LDKCResult_InitFeaturesDecodeErrorZ* o_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(o & ~1);
13929 jboolean ret_conv = CResult_InitFeaturesDecodeErrorZ_is_ok(o_conv);
13933 void __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_free"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
13934 if ((_res & 1) != 0) return;
13935 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13936 CHECK_ACCESS(_res_ptr);
13937 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(_res_ptr);
13939 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
13942 static inline uintptr_t CResult_InitFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InitFeaturesDecodeErrorZ *NONNULL_PTR arg) {
13943 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
13944 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(arg);
13945 return (uint32_t)ret_conv;
13947 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InitFeaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
13948 LDKCResult_InitFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
13949 uint32_t ret_conv = CResult_InitFeaturesDecodeErrorZ_clone_ptr(arg_conv);
13953 uint32_t __attribute__((export_name("TS_CResult_InitFeaturesDecodeErrorZ_clone"))) TS_CResult_InitFeaturesDecodeErrorZ_clone(uint32_t orig) {
13954 LDKCResult_InitFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InitFeaturesDecodeErrorZ*)(orig & ~1);
13955 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
13956 *ret_conv = CResult_InitFeaturesDecodeErrorZ_clone(orig_conv);
13957 return (uint32_t)ret_conv;
13960 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint32_t o) {
13961 LDKChannelFeatures o_conv;
13962 o_conv.inner = (void*)(o & (~1));
13963 o_conv.is_owned = (o & 1) || (o == 0);
13964 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
13965 o_conv = ChannelFeatures_clone(&o_conv);
13966 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
13967 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
13968 return (uint32_t)ret_conv;
13971 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint32_t e) {
13972 LDKDecodeError e_conv;
13973 e_conv.inner = (void*)(e & (~1));
13974 e_conv.is_owned = (e & 1) || (e == 0);
13975 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
13976 e_conv = DecodeError_clone(&e_conv);
13977 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
13978 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
13979 return (uint32_t)ret_conv;
13982 jboolean __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelFeaturesDecodeErrorZ_is_ok(uint32_t o) {
13983 LDKCResult_ChannelFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(o & ~1);
13984 jboolean ret_conv = CResult_ChannelFeaturesDecodeErrorZ_is_ok(o_conv);
13988 void __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
13989 if ((_res & 1) != 0) return;
13990 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
13991 CHECK_ACCESS(_res_ptr);
13992 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(_res_ptr);
13994 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
13997 static inline uintptr_t CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelFeaturesDecodeErrorZ *NONNULL_PTR arg) {
13998 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
13999 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(arg);
14000 return (uint32_t)ret_conv;
14002 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
14003 LDKCResult_ChannelFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
14004 uint32_t ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14008 uint32_t __attribute__((export_name("TS_CResult_ChannelFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelFeaturesDecodeErrorZ_clone(uint32_t orig) {
14009 LDKCResult_ChannelFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(orig & ~1);
14010 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
14011 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_clone(orig_conv);
14012 return (uint32_t)ret_conv;
14015 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint32_t o) {
14016 LDKNodeFeatures o_conv;
14017 o_conv.inner = (void*)(o & (~1));
14018 o_conv.is_owned = (o & 1) || (o == 0);
14019 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14020 o_conv = NodeFeatures_clone(&o_conv);
14021 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14022 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
14023 return (uint32_t)ret_conv;
14026 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_err"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint32_t e) {
14027 LDKDecodeError e_conv;
14028 e_conv.inner = (void*)(e & (~1));
14029 e_conv.is_owned = (e & 1) || (e == 0);
14030 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14031 e_conv = DecodeError_clone(&e_conv);
14032 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14033 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
14034 return (uint32_t)ret_conv;
14037 jboolean __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_NodeFeaturesDecodeErrorZ_is_ok(uint32_t o) {
14038 LDKCResult_NodeFeaturesDecodeErrorZ* o_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(o & ~1);
14039 jboolean ret_conv = CResult_NodeFeaturesDecodeErrorZ_is_ok(o_conv);
14043 void __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_free"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
14044 if ((_res & 1) != 0) return;
14045 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14046 CHECK_ACCESS(_res_ptr);
14047 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(_res_ptr);
14049 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
14052 static inline uintptr_t CResult_NodeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_NodeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14053 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14054 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(arg);
14055 return (uint32_t)ret_conv;
14057 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
14058 LDKCResult_NodeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
14059 uint32_t ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14063 uint32_t __attribute__((export_name("TS_CResult_NodeFeaturesDecodeErrorZ_clone"))) TS_CResult_NodeFeaturesDecodeErrorZ_clone(uint32_t orig) {
14064 LDKCResult_NodeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_NodeFeaturesDecodeErrorZ*)(orig & ~1);
14065 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
14066 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_clone(orig_conv);
14067 return (uint32_t)ret_conv;
14070 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint32_t o) {
14071 LDKInvoiceFeatures o_conv;
14072 o_conv.inner = (void*)(o & (~1));
14073 o_conv.is_owned = (o & 1) || (o == 0);
14074 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14075 o_conv = InvoiceFeatures_clone(&o_conv);
14076 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14077 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
14078 return (uint32_t)ret_conv;
14081 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_err"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint32_t e) {
14082 LDKDecodeError e_conv;
14083 e_conv.inner = (void*)(e & (~1));
14084 e_conv.is_owned = (e & 1) || (e == 0);
14085 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14086 e_conv = DecodeError_clone(&e_conv);
14087 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14088 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
14089 return (uint32_t)ret_conv;
14092 jboolean __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_is_ok(uint32_t o) {
14093 LDKCResult_InvoiceFeaturesDecodeErrorZ* o_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(o & ~1);
14094 jboolean ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_is_ok(o_conv);
14098 void __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_free"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint32_t _res) {
14099 if ((_res & 1) != 0) return;
14100 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14101 CHECK_ACCESS(_res_ptr);
14102 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(_res_ptr);
14104 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
14107 static inline uintptr_t CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(LDKCResult_InvoiceFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14108 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14109 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(arg);
14110 return (uint32_t)ret_conv;
14112 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
14113 LDKCResult_InvoiceFeaturesDecodeErrorZ* arg_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
14114 uint32_t ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14118 uint32_t __attribute__((export_name("TS_CResult_InvoiceFeaturesDecodeErrorZ_clone"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_clone(uint32_t orig) {
14119 LDKCResult_InvoiceFeaturesDecodeErrorZ* orig_conv = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(orig & ~1);
14120 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
14121 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_clone(orig_conv);
14122 return (uint32_t)ret_conv;
14125 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_ok(uint32_t o) {
14126 LDKChannelTypeFeatures o_conv;
14127 o_conv.inner = (void*)(o & (~1));
14128 o_conv.is_owned = (o & 1) || (o == 0);
14129 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14130 o_conv = ChannelTypeFeatures_clone(&o_conv);
14131 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14132 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_ok(o_conv);
14133 return (uint32_t)ret_conv;
14136 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_err(uint32_t e) {
14137 LDKDecodeError e_conv;
14138 e_conv.inner = (void*)(e & (~1));
14139 e_conv.is_owned = (e & 1) || (e == 0);
14140 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14141 e_conv = DecodeError_clone(&e_conv);
14142 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14143 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_err(e_conv);
14144 return (uint32_t)ret_conv;
14147 jboolean __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(uint32_t o) {
14148 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* o_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(o & ~1);
14149 jboolean ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_is_ok(o_conv);
14153 void __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_free(uint32_t _res) {
14154 if ((_res & 1) != 0) return;
14155 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14156 CHECK_ACCESS(_res_ptr);
14157 LDKCResult_ChannelTypeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(_res_ptr);
14159 CResult_ChannelTypeFeaturesDecodeErrorZ_free(_res_conv);
14162 static inline uintptr_t CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(LDKCResult_ChannelTypeFeaturesDecodeErrorZ *NONNULL_PTR arg) {
14163 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14164 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(arg);
14165 return (uint32_t)ret_conv;
14167 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
14168 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* arg_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(arg & ~1);
14169 uint32_t ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone_ptr(arg_conv);
14173 uint32_t __attribute__((export_name("TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone"))) TS_CResult_ChannelTypeFeaturesDecodeErrorZ_clone(uint32_t orig) {
14174 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* orig_conv = (LDKCResult_ChannelTypeFeaturesDecodeErrorZ*)(orig & ~1);
14175 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
14176 *ret_conv = CResult_ChannelTypeFeaturesDecodeErrorZ_clone(orig_conv);
14177 return (uint32_t)ret_conv;
14180 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_ok"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint32_t o) {
14182 o_conv.inner = (void*)(o & (~1));
14183 o_conv.is_owned = (o & 1) || (o == 0);
14184 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14185 o_conv = NodeId_clone(&o_conv);
14186 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14187 *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv);
14188 return (uint32_t)ret_conv;
14191 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_err"))) TS_CResult_NodeIdDecodeErrorZ_err(uint32_t e) {
14192 LDKDecodeError e_conv;
14193 e_conv.inner = (void*)(e & (~1));
14194 e_conv.is_owned = (e & 1) || (e == 0);
14195 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14196 e_conv = DecodeError_clone(&e_conv);
14197 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14198 *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv);
14199 return (uint32_t)ret_conv;
14202 jboolean __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_is_ok"))) TS_CResult_NodeIdDecodeErrorZ_is_ok(uint32_t o) {
14203 LDKCResult_NodeIdDecodeErrorZ* o_conv = (LDKCResult_NodeIdDecodeErrorZ*)(o & ~1);
14204 jboolean ret_conv = CResult_NodeIdDecodeErrorZ_is_ok(o_conv);
14208 void __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_free"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) {
14209 if ((_res & 1) != 0) return;
14210 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14211 CHECK_ACCESS(_res_ptr);
14212 LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(_res_ptr);
14214 CResult_NodeIdDecodeErrorZ_free(_res_conv);
14217 static inline uintptr_t CResult_NodeIdDecodeErrorZ_clone_ptr(LDKCResult_NodeIdDecodeErrorZ *NONNULL_PTR arg) {
14218 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14219 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(arg);
14220 return (uint32_t)ret_conv;
14222 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone_ptr"))) TS_CResult_NodeIdDecodeErrorZ_clone_ptr(uint32_t arg) {
14223 LDKCResult_NodeIdDecodeErrorZ* arg_conv = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1);
14224 uint32_t ret_conv = CResult_NodeIdDecodeErrorZ_clone_ptr(arg_conv);
14228 uint32_t __attribute__((export_name("TS_CResult_NodeIdDecodeErrorZ_clone"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) {
14229 LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1);
14230 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
14231 *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv);
14232 return (uint32_t)ret_conv;
14235 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_ok(uint32_t o) {
14236 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
14237 CHECK_ACCESS(o_ptr);
14238 LDKCOption_NetworkUpdateZ o_conv = *(LDKCOption_NetworkUpdateZ*)(o_ptr);
14239 o_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uintptr_t)o) & ~1));
14240 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14241 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_ok(o_conv);
14242 return (uint32_t)ret_conv;
14245 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_err(uint32_t e) {
14246 LDKDecodeError e_conv;
14247 e_conv.inner = (void*)(e & (~1));
14248 e_conv.is_owned = (e & 1) || (e == 0);
14249 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14250 e_conv = DecodeError_clone(&e_conv);
14251 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14252 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_err(e_conv);
14253 return (uint32_t)ret_conv;
14256 jboolean __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(uint32_t o) {
14257 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* o_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(o & ~1);
14258 jboolean ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_is_ok(o_conv);
14262 void __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_free(uint32_t _res) {
14263 if ((_res & 1) != 0) return;
14264 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14265 CHECK_ACCESS(_res_ptr);
14266 LDKCResult_COption_NetworkUpdateZDecodeErrorZ _res_conv = *(LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(_res_ptr);
14268 CResult_COption_NetworkUpdateZDecodeErrorZ_free(_res_conv);
14271 static inline uintptr_t CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(LDKCResult_COption_NetworkUpdateZDecodeErrorZ *NONNULL_PTR arg) {
14272 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14273 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(arg);
14274 return (uint32_t)ret_conv;
14276 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(uint32_t arg) {
14277 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* arg_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(arg & ~1);
14278 uint32_t ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone_ptr(arg_conv);
14282 uint32_t __attribute__((export_name("TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone"))) TS_CResult_COption_NetworkUpdateZDecodeErrorZ_clone(uint32_t orig) {
14283 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* orig_conv = (LDKCResult_COption_NetworkUpdateZDecodeErrorZ*)(orig & ~1);
14284 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
14285 *ret_conv = CResult_COption_NetworkUpdateZDecodeErrorZ_clone(orig_conv);
14286 return (uint32_t)ret_conv;
14289 uint32_t __attribute__((export_name("TS_COption_AccessZ_some"))) TS_COption_AccessZ_some(uint32_t o) {
14290 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
14291 CHECK_ACCESS(o_ptr);
14292 LDKAccess o_conv = *(LDKAccess*)(o_ptr);
14293 if (o_conv.free == LDKAccess_JCalls_free) {
14294 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
14295 LDKAccess_JCalls_cloned(&o_conv);
14297 LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
14298 *ret_copy = COption_AccessZ_some(o_conv);
14299 uint32_t ret_ref = (uintptr_t)ret_copy;
14303 uint32_t __attribute__((export_name("TS_COption_AccessZ_none"))) TS_COption_AccessZ_none() {
14304 LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ");
14305 *ret_copy = COption_AccessZ_none();
14306 uint32_t ret_ref = (uintptr_t)ret_copy;
14310 void __attribute__((export_name("TS_COption_AccessZ_free"))) TS_COption_AccessZ_free(uint32_t _res) {
14311 if ((_res & 1) != 0) return;
14312 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14313 CHECK_ACCESS(_res_ptr);
14314 LDKCOption_AccessZ _res_conv = *(LDKCOption_AccessZ*)(_res_ptr);
14316 COption_AccessZ_free(_res_conv);
14319 uint32_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_ok"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
14320 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14321 *ret_conv = CResult_boolLightningErrorZ_ok(o);
14322 return (uint32_t)ret_conv;
14325 uint32_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_err"))) TS_CResult_boolLightningErrorZ_err(uint32_t e) {
14326 LDKLightningError e_conv;
14327 e_conv.inner = (void*)(e & (~1));
14328 e_conv.is_owned = (e & 1) || (e == 0);
14329 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14330 e_conv = LightningError_clone(&e_conv);
14331 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14332 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
14333 return (uint32_t)ret_conv;
14336 jboolean __attribute__((export_name("TS_CResult_boolLightningErrorZ_is_ok"))) TS_CResult_boolLightningErrorZ_is_ok(uint32_t o) {
14337 LDKCResult_boolLightningErrorZ* o_conv = (LDKCResult_boolLightningErrorZ*)(o & ~1);
14338 jboolean ret_conv = CResult_boolLightningErrorZ_is_ok(o_conv);
14342 void __attribute__((export_name("TS_CResult_boolLightningErrorZ_free"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
14343 if ((_res & 1) != 0) return;
14344 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14345 CHECK_ACCESS(_res_ptr);
14346 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(_res_ptr);
14348 CResult_boolLightningErrorZ_free(_res_conv);
14351 static inline uintptr_t CResult_boolLightningErrorZ_clone_ptr(LDKCResult_boolLightningErrorZ *NONNULL_PTR arg) {
14352 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14353 *ret_conv = CResult_boolLightningErrorZ_clone(arg);
14354 return (uint32_t)ret_conv;
14356 uint32_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone_ptr"))) TS_CResult_boolLightningErrorZ_clone_ptr(uint32_t arg) {
14357 LDKCResult_boolLightningErrorZ* arg_conv = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
14358 uint32_t ret_conv = CResult_boolLightningErrorZ_clone_ptr(arg_conv);
14362 uint32_t __attribute__((export_name("TS_CResult_boolLightningErrorZ_clone"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
14363 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
14364 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
14365 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
14366 return (uint32_t)ret_conv;
14369 static inline uintptr_t C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR arg) {
14370 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14371 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(arg);
14372 return ((uint32_t)ret_conv);
14374 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(uint32_t arg) {
14375 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* arg_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(arg & ~1);
14376 uint32_t ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone_ptr(arg_conv);
14380 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
14381 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
14382 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14383 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
14384 return ((uint32_t)ret_conv);
14387 uint32_t __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
14388 LDKChannelAnnouncement a_conv;
14389 a_conv.inner = (void*)(a & (~1));
14390 a_conv.is_owned = (a & 1) || (a == 0);
14391 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
14392 a_conv = ChannelAnnouncement_clone(&a_conv);
14393 LDKChannelUpdate b_conv;
14394 b_conv.inner = (void*)(b & (~1));
14395 b_conv.is_owned = (b & 1) || (b == 0);
14396 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
14397 b_conv = ChannelUpdate_clone(&b_conv);
14398 LDKChannelUpdate c_conv;
14399 c_conv.inner = (void*)(c & (~1));
14400 c_conv.is_owned = (c & 1) || (c == 0);
14401 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
14402 c_conv = ChannelUpdate_clone(&c_conv);
14403 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
14404 *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
14405 return ((uint32_t)ret_conv);
14408 void __attribute__((export_name("TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) {
14409 if ((_res & 1) != 0) return;
14410 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14411 CHECK_ACCESS(_res_ptr);
14412 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_ptr);
14414 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
14417 void __attribute__((export_name("TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free"))) TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint32_tArray _res) {
14418 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
14419 _res_constr.datalen = _res->arr_len;
14420 if (_res_constr.datalen > 0)
14421 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
14423 _res_constr.data = NULL;
14424 uint32_t* _res_vals = _res->elems;
14425 for (size_t h = 0; h < _res_constr.datalen; h++) {
14426 uint32_t _res_conv_59 = _res_vals[h];
14427 void* _res_conv_59_ptr = (void*)(((uintptr_t)_res_conv_59) & ~1);
14428 CHECK_ACCESS(_res_conv_59_ptr);
14429 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(_res_conv_59_ptr);
14430 FREE((void*)_res_conv_59);
14431 _res_constr.data[h] = _res_conv_59_conv;
14434 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
14437 void __attribute__((export_name("TS_CVec_NodeAnnouncementZ_free"))) TS_CVec_NodeAnnouncementZ_free(uint32_tArray _res) {
14438 LDKCVec_NodeAnnouncementZ _res_constr;
14439 _res_constr.datalen = _res->arr_len;
14440 if (_res_constr.datalen > 0)
14441 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
14443 _res_constr.data = NULL;
14444 uint32_t* _res_vals = _res->elems;
14445 for (size_t s = 0; s < _res_constr.datalen; s++) {
14446 uint32_t _res_conv_18 = _res_vals[s];
14447 LDKNodeAnnouncement _res_conv_18_conv;
14448 _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
14449 _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
14450 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_18_conv);
14451 _res_constr.data[s] = _res_conv_18_conv;
14454 CVec_NodeAnnouncementZ_free(_res_constr);
14457 uint32_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_ok"))) TS_CResult_NoneLightningErrorZ_ok() {
14458 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14459 *ret_conv = CResult_NoneLightningErrorZ_ok();
14460 return (uint32_t)ret_conv;
14463 uint32_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_err"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) {
14464 LDKLightningError e_conv;
14465 e_conv.inner = (void*)(e & (~1));
14466 e_conv.is_owned = (e & 1) || (e == 0);
14467 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14468 e_conv = LightningError_clone(&e_conv);
14469 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14470 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
14471 return (uint32_t)ret_conv;
14474 jboolean __attribute__((export_name("TS_CResult_NoneLightningErrorZ_is_ok"))) TS_CResult_NoneLightningErrorZ_is_ok(uint32_t o) {
14475 LDKCResult_NoneLightningErrorZ* o_conv = (LDKCResult_NoneLightningErrorZ*)(o & ~1);
14476 jboolean ret_conv = CResult_NoneLightningErrorZ_is_ok(o_conv);
14480 void __attribute__((export_name("TS_CResult_NoneLightningErrorZ_free"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
14481 if ((_res & 1) != 0) return;
14482 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14483 CHECK_ACCESS(_res_ptr);
14484 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(_res_ptr);
14486 CResult_NoneLightningErrorZ_free(_res_conv);
14489 static inline uintptr_t CResult_NoneLightningErrorZ_clone_ptr(LDKCResult_NoneLightningErrorZ *NONNULL_PTR arg) {
14490 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14491 *ret_conv = CResult_NoneLightningErrorZ_clone(arg);
14492 return (uint32_t)ret_conv;
14494 uint32_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone_ptr"))) TS_CResult_NoneLightningErrorZ_clone_ptr(uint32_t arg) {
14495 LDKCResult_NoneLightningErrorZ* arg_conv = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
14496 uint32_t ret_conv = CResult_NoneLightningErrorZ_clone_ptr(arg_conv);
14500 uint32_t __attribute__((export_name("TS_CResult_NoneLightningErrorZ_clone"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
14501 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
14502 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
14503 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
14504 return (uint32_t)ret_conv;
14507 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_ok(uint32_t o) {
14508 LDKChannelUpdateInfo o_conv;
14509 o_conv.inner = (void*)(o & (~1));
14510 o_conv.is_owned = (o & 1) || (o == 0);
14511 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14512 o_conv = ChannelUpdateInfo_clone(&o_conv);
14513 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
14514 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_ok(o_conv);
14515 return (uint32_t)ret_conv;
14518 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_err"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_err(uint32_t e) {
14519 LDKDecodeError e_conv;
14520 e_conv.inner = (void*)(e & (~1));
14521 e_conv.is_owned = (e & 1) || (e == 0);
14522 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14523 e_conv = DecodeError_clone(&e_conv);
14524 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
14525 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_err(e_conv);
14526 return (uint32_t)ret_conv;
14529 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(uint32_t o) {
14530 LDKCResult_ChannelUpdateInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(o & ~1);
14531 jboolean ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_is_ok(o_conv);
14535 void __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_free"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_free(uint32_t _res) {
14536 if ((_res & 1) != 0) return;
14537 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14538 CHECK_ACCESS(_res_ptr);
14539 LDKCResult_ChannelUpdateInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(_res_ptr);
14541 CResult_ChannelUpdateInfoDecodeErrorZ_free(_res_conv);
14544 static inline uintptr_t CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateInfoDecodeErrorZ *NONNULL_PTR arg) {
14545 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
14546 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(arg);
14547 return (uint32_t)ret_conv;
14549 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
14550 LDKCResult_ChannelUpdateInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(arg & ~1);
14551 uint32_t ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone_ptr(arg_conv);
14555 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateInfoDecodeErrorZ_clone(uint32_t orig) {
14556 LDKCResult_ChannelUpdateInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateInfoDecodeErrorZ*)(orig & ~1);
14557 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
14558 *ret_conv = CResult_ChannelUpdateInfoDecodeErrorZ_clone(orig_conv);
14559 return (uint32_t)ret_conv;
14562 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint32_t o) {
14563 LDKChannelInfo o_conv;
14564 o_conv.inner = (void*)(o & (~1));
14565 o_conv.is_owned = (o & 1) || (o == 0);
14566 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14567 o_conv = ChannelInfo_clone(&o_conv);
14568 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
14569 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
14570 return (uint32_t)ret_conv;
14573 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_err"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint32_t e) {
14574 LDKDecodeError e_conv;
14575 e_conv.inner = (void*)(e & (~1));
14576 e_conv.is_owned = (e & 1) || (e == 0);
14577 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14578 e_conv = DecodeError_clone(&e_conv);
14579 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
14580 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
14581 return (uint32_t)ret_conv;
14584 jboolean __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_is_ok"))) TS_CResult_ChannelInfoDecodeErrorZ_is_ok(uint32_t o) {
14585 LDKCResult_ChannelInfoDecodeErrorZ* o_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(o & ~1);
14586 jboolean ret_conv = CResult_ChannelInfoDecodeErrorZ_is_ok(o_conv);
14590 void __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_free"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint32_t _res) {
14591 if ((_res & 1) != 0) return;
14592 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14593 CHECK_ACCESS(_res_ptr);
14594 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(_res_ptr);
14596 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
14599 static inline uintptr_t CResult_ChannelInfoDecodeErrorZ_clone_ptr(LDKCResult_ChannelInfoDecodeErrorZ *NONNULL_PTR arg) {
14600 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
14601 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(arg);
14602 return (uint32_t)ret_conv;
14604 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
14605 LDKCResult_ChannelInfoDecodeErrorZ* arg_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
14606 uint32_t ret_conv = CResult_ChannelInfoDecodeErrorZ_clone_ptr(arg_conv);
14610 uint32_t __attribute__((export_name("TS_CResult_ChannelInfoDecodeErrorZ_clone"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint32_t orig) {
14611 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
14612 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
14613 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
14614 return (uint32_t)ret_conv;
14617 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint32_t o) {
14618 LDKRoutingFees o_conv;
14619 o_conv.inner = (void*)(o & (~1));
14620 o_conv.is_owned = (o & 1) || (o == 0);
14621 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14622 o_conv = RoutingFees_clone(&o_conv);
14623 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
14624 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
14625 return (uint32_t)ret_conv;
14628 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_err"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint32_t e) {
14629 LDKDecodeError e_conv;
14630 e_conv.inner = (void*)(e & (~1));
14631 e_conv.is_owned = (e & 1) || (e == 0);
14632 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14633 e_conv = DecodeError_clone(&e_conv);
14634 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
14635 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
14636 return (uint32_t)ret_conv;
14639 jboolean __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_is_ok"))) TS_CResult_RoutingFeesDecodeErrorZ_is_ok(uint32_t o) {
14640 LDKCResult_RoutingFeesDecodeErrorZ* o_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(o & ~1);
14641 jboolean ret_conv = CResult_RoutingFeesDecodeErrorZ_is_ok(o_conv);
14645 void __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_free"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint32_t _res) {
14646 if ((_res & 1) != 0) return;
14647 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14648 CHECK_ACCESS(_res_ptr);
14649 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(_res_ptr);
14651 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
14654 static inline uintptr_t CResult_RoutingFeesDecodeErrorZ_clone_ptr(LDKCResult_RoutingFeesDecodeErrorZ *NONNULL_PTR arg) {
14655 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
14656 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(arg);
14657 return (uint32_t)ret_conv;
14659 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr"))) TS_CResult_RoutingFeesDecodeErrorZ_clone_ptr(uint32_t arg) {
14660 LDKCResult_RoutingFeesDecodeErrorZ* arg_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
14661 uint32_t ret_conv = CResult_RoutingFeesDecodeErrorZ_clone_ptr(arg_conv);
14665 uint32_t __attribute__((export_name("TS_CResult_RoutingFeesDecodeErrorZ_clone"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint32_t orig) {
14666 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
14667 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
14668 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
14669 return (uint32_t)ret_conv;
14672 void __attribute__((export_name("TS_CVec_NetAddressZ_free"))) TS_CVec_NetAddressZ_free(uint32_tArray _res) {
14673 LDKCVec_NetAddressZ _res_constr;
14674 _res_constr.datalen = _res->arr_len;
14675 if (_res_constr.datalen > 0)
14676 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
14678 _res_constr.data = NULL;
14679 uint32_t* _res_vals = _res->elems;
14680 for (size_t m = 0; m < _res_constr.datalen; m++) {
14681 uint32_t _res_conv_12 = _res_vals[m];
14682 void* _res_conv_12_ptr = (void*)(((uintptr_t)_res_conv_12) & ~1);
14683 CHECK_ACCESS(_res_conv_12_ptr);
14684 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(_res_conv_12_ptr);
14685 FREE((void*)_res_conv_12);
14686 _res_constr.data[m] = _res_conv_12_conv;
14689 CVec_NetAddressZ_free(_res_constr);
14692 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint32_t o) {
14693 LDKNodeAnnouncementInfo o_conv;
14694 o_conv.inner = (void*)(o & (~1));
14695 o_conv.is_owned = (o & 1) || (o == 0);
14696 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14697 o_conv = NodeAnnouncementInfo_clone(&o_conv);
14698 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
14699 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
14700 return (uint32_t)ret_conv;
14703 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint32_t e) {
14704 LDKDecodeError e_conv;
14705 e_conv.inner = (void*)(e & (~1));
14706 e_conv.is_owned = (e & 1) || (e == 0);
14707 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14708 e_conv = DecodeError_clone(&e_conv);
14709 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
14710 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
14711 return (uint32_t)ret_conv;
14714 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(uint32_t o) {
14715 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(o & ~1);
14716 jboolean ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_is_ok(o_conv);
14720 void __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint32_t _res) {
14721 if ((_res & 1) != 0) return;
14722 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14723 CHECK_ACCESS(_res_ptr);
14724 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(_res_ptr);
14726 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
14729 static inline uintptr_t CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementInfoDecodeErrorZ *NONNULL_PTR arg) {
14730 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
14731 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(arg);
14732 return (uint32_t)ret_conv;
14734 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
14735 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
14736 uint32_t ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone_ptr(arg_conv);
14740 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint32_t orig) {
14741 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
14742 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
14743 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
14744 return (uint32_t)ret_conv;
14747 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_ok"))) TS_CResult_NodeAliasDecodeErrorZ_ok(uint32_t o) {
14748 LDKNodeAlias o_conv;
14749 o_conv.inner = (void*)(o & (~1));
14750 o_conv.is_owned = (o & 1) || (o == 0);
14751 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14752 o_conv = NodeAlias_clone(&o_conv);
14753 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
14754 *ret_conv = CResult_NodeAliasDecodeErrorZ_ok(o_conv);
14755 return (uint32_t)ret_conv;
14758 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_err"))) TS_CResult_NodeAliasDecodeErrorZ_err(uint32_t e) {
14759 LDKDecodeError e_conv;
14760 e_conv.inner = (void*)(e & (~1));
14761 e_conv.is_owned = (e & 1) || (e == 0);
14762 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14763 e_conv = DecodeError_clone(&e_conv);
14764 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
14765 *ret_conv = CResult_NodeAliasDecodeErrorZ_err(e_conv);
14766 return (uint32_t)ret_conv;
14769 jboolean __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_is_ok"))) TS_CResult_NodeAliasDecodeErrorZ_is_ok(uint32_t o) {
14770 LDKCResult_NodeAliasDecodeErrorZ* o_conv = (LDKCResult_NodeAliasDecodeErrorZ*)(o & ~1);
14771 jboolean ret_conv = CResult_NodeAliasDecodeErrorZ_is_ok(o_conv);
14775 void __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_free"))) TS_CResult_NodeAliasDecodeErrorZ_free(uint32_t _res) {
14776 if ((_res & 1) != 0) return;
14777 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14778 CHECK_ACCESS(_res_ptr);
14779 LDKCResult_NodeAliasDecodeErrorZ _res_conv = *(LDKCResult_NodeAliasDecodeErrorZ*)(_res_ptr);
14781 CResult_NodeAliasDecodeErrorZ_free(_res_conv);
14784 static inline uintptr_t CResult_NodeAliasDecodeErrorZ_clone_ptr(LDKCResult_NodeAliasDecodeErrorZ *NONNULL_PTR arg) {
14785 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
14786 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(arg);
14787 return (uint32_t)ret_conv;
14789 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAliasDecodeErrorZ_clone_ptr(uint32_t arg) {
14790 LDKCResult_NodeAliasDecodeErrorZ* arg_conv = (LDKCResult_NodeAliasDecodeErrorZ*)(arg & ~1);
14791 uint32_t ret_conv = CResult_NodeAliasDecodeErrorZ_clone_ptr(arg_conv);
14795 uint32_t __attribute__((export_name("TS_CResult_NodeAliasDecodeErrorZ_clone"))) TS_CResult_NodeAliasDecodeErrorZ_clone(uint32_t orig) {
14796 LDKCResult_NodeAliasDecodeErrorZ* orig_conv = (LDKCResult_NodeAliasDecodeErrorZ*)(orig & ~1);
14797 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
14798 *ret_conv = CResult_NodeAliasDecodeErrorZ_clone(orig_conv);
14799 return (uint32_t)ret_conv;
14802 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_ok"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint32_t o) {
14803 LDKNodeInfo o_conv;
14804 o_conv.inner = (void*)(o & (~1));
14805 o_conv.is_owned = (o & 1) || (o == 0);
14806 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14807 o_conv = NodeInfo_clone(&o_conv);
14808 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
14809 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
14810 return (uint32_t)ret_conv;
14813 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_err"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint32_t e) {
14814 LDKDecodeError e_conv;
14815 e_conv.inner = (void*)(e & (~1));
14816 e_conv.is_owned = (e & 1) || (e == 0);
14817 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14818 e_conv = DecodeError_clone(&e_conv);
14819 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
14820 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
14821 return (uint32_t)ret_conv;
14824 jboolean __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_is_ok"))) TS_CResult_NodeInfoDecodeErrorZ_is_ok(uint32_t o) {
14825 LDKCResult_NodeInfoDecodeErrorZ* o_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(o & ~1);
14826 jboolean ret_conv = CResult_NodeInfoDecodeErrorZ_is_ok(o_conv);
14830 void __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_free"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint32_t _res) {
14831 if ((_res & 1) != 0) return;
14832 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14833 CHECK_ACCESS(_res_ptr);
14834 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(_res_ptr);
14836 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
14839 static inline uintptr_t CResult_NodeInfoDecodeErrorZ_clone_ptr(LDKCResult_NodeInfoDecodeErrorZ *NONNULL_PTR arg) {
14840 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
14841 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(arg);
14842 return (uint32_t)ret_conv;
14844 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone_ptr"))) TS_CResult_NodeInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
14845 LDKCResult_NodeInfoDecodeErrorZ* arg_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
14846 uint32_t ret_conv = CResult_NodeInfoDecodeErrorZ_clone_ptr(arg_conv);
14850 uint32_t __attribute__((export_name("TS_CResult_NodeInfoDecodeErrorZ_clone"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint32_t orig) {
14851 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
14852 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
14853 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
14854 return (uint32_t)ret_conv;
14857 uint32_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint32_t o) {
14858 LDKNetworkGraph o_conv;
14859 o_conv.inner = (void*)(o & (~1));
14860 o_conv.is_owned = (o & 1) || (o == 0);
14861 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14862 // WARNING: we need a move here but no clone is available for LDKNetworkGraph
14863 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
14864 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
14865 return (uint32_t)ret_conv;
14868 uint32_t __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_err"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint32_t e) {
14869 LDKDecodeError e_conv;
14870 e_conv.inner = (void*)(e & (~1));
14871 e_conv.is_owned = (e & 1) || (e == 0);
14872 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14873 e_conv = DecodeError_clone(&e_conv);
14874 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
14875 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
14876 return (uint32_t)ret_conv;
14879 jboolean __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_is_ok"))) TS_CResult_NetworkGraphDecodeErrorZ_is_ok(uint32_t o) {
14880 LDKCResult_NetworkGraphDecodeErrorZ* o_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(o & ~1);
14881 jboolean ret_conv = CResult_NetworkGraphDecodeErrorZ_is_ok(o_conv);
14885 void __attribute__((export_name("TS_CResult_NetworkGraphDecodeErrorZ_free"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint32_t _res) {
14886 if ((_res & 1) != 0) return;
14887 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14888 CHECK_ACCESS(_res_ptr);
14889 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(_res_ptr);
14891 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
14894 uint32_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_some"))) TS_COption_CVec_NetAddressZZ_some(uint32_tArray o) {
14895 LDKCVec_NetAddressZ o_constr;
14896 o_constr.datalen = o->arr_len;
14897 if (o_constr.datalen > 0)
14898 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
14900 o_constr.data = NULL;
14901 uint32_t* o_vals = o->elems;
14902 for (size_t m = 0; m < o_constr.datalen; m++) {
14903 uint32_t o_conv_12 = o_vals[m];
14904 void* o_conv_12_ptr = (void*)(((uintptr_t)o_conv_12) & ~1);
14905 CHECK_ACCESS(o_conv_12_ptr);
14906 LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(o_conv_12_ptr);
14907 o_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uintptr_t)o_conv_12) & ~1));
14908 o_constr.data[m] = o_conv_12_conv;
14911 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
14912 *ret_copy = COption_CVec_NetAddressZZ_some(o_constr);
14913 uint32_t ret_ref = (uintptr_t)ret_copy;
14917 uint32_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_none"))) TS_COption_CVec_NetAddressZZ_none() {
14918 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
14919 *ret_copy = COption_CVec_NetAddressZZ_none();
14920 uint32_t ret_ref = (uintptr_t)ret_copy;
14924 void __attribute__((export_name("TS_COption_CVec_NetAddressZZ_free"))) TS_COption_CVec_NetAddressZZ_free(uint32_t _res) {
14925 if ((_res & 1) != 0) return;
14926 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14927 CHECK_ACCESS(_res_ptr);
14928 LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(_res_ptr);
14930 COption_CVec_NetAddressZZ_free(_res_conv);
14933 static inline uintptr_t COption_CVec_NetAddressZZ_clone_ptr(LDKCOption_CVec_NetAddressZZ *NONNULL_PTR arg) {
14934 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
14935 *ret_copy = COption_CVec_NetAddressZZ_clone(arg);
14936 uint32_t ret_ref = (uintptr_t)ret_copy;
14939 uint32_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone_ptr"))) TS_COption_CVec_NetAddressZZ_clone_ptr(uint32_t arg) {
14940 LDKCOption_CVec_NetAddressZZ* arg_conv = (LDKCOption_CVec_NetAddressZZ*)arg;
14941 uint32_t ret_conv = COption_CVec_NetAddressZZ_clone_ptr(arg_conv);
14945 uint32_t __attribute__((export_name("TS_COption_CVec_NetAddressZZ_clone"))) TS_COption_CVec_NetAddressZZ_clone(uint32_t orig) {
14946 LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig;
14947 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
14948 *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv);
14949 uint32_t ret_ref = (uintptr_t)ret_copy;
14953 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
14954 LDKDelayedPaymentOutputDescriptor o_conv;
14955 o_conv.inner = (void*)(o & (~1));
14956 o_conv.is_owned = (o & 1) || (o == 0);
14957 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
14958 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
14959 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
14960 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
14961 return (uint32_t)ret_conv;
14964 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
14965 LDKDecodeError e_conv;
14966 e_conv.inner = (void*)(e & (~1));
14967 e_conv.is_owned = (e & 1) || (e == 0);
14968 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
14969 e_conv = DecodeError_clone(&e_conv);
14970 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
14971 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
14972 return (uint32_t)ret_conv;
14975 jboolean __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
14976 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
14977 jboolean ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
14981 void __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
14982 if ((_res & 1) != 0) return;
14983 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
14984 CHECK_ACCESS(_res_ptr);
14985 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
14987 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
14990 static inline uintptr_t CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
14991 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
14992 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(arg);
14993 return (uint32_t)ret_conv;
14995 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
14996 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
14997 uint32_t ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15001 uint32_t __attribute__((export_name("TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
15002 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
15003 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
15004 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15005 return (uint32_t)ret_conv;
15008 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
15009 LDKStaticPaymentOutputDescriptor o_conv;
15010 o_conv.inner = (void*)(o & (~1));
15011 o_conv.is_owned = (o & 1) || (o == 0);
15012 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15013 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
15014 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15015 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
15016 return (uint32_t)ret_conv;
15019 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
15020 LDKDecodeError e_conv;
15021 e_conv.inner = (void*)(e & (~1));
15022 e_conv.is_owned = (e & 1) || (e == 0);
15023 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15024 e_conv = DecodeError_clone(&e_conv);
15025 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15026 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
15027 return (uint32_t)ret_conv;
15030 jboolean __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
15031 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(o & ~1);
15032 jboolean ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15036 void __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
15037 if ((_res & 1) != 0) return;
15038 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15039 CHECK_ACCESS(_res_ptr);
15040 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(_res_ptr);
15042 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
15045 static inline uintptr_t CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15046 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15047 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(arg);
15048 return (uint32_t)ret_conv;
15050 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
15051 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
15052 uint32_t ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15056 uint32_t __attribute__((export_name("TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
15057 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
15058 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
15059 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
15060 return (uint32_t)ret_conv;
15063 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
15064 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
15065 CHECK_ACCESS(o_ptr);
15066 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(o_ptr);
15067 o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uintptr_t)o) & ~1));
15068 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15069 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
15070 return (uint32_t)ret_conv;
15073 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint32_t e) {
15074 LDKDecodeError e_conv;
15075 e_conv.inner = (void*)(e & (~1));
15076 e_conv.is_owned = (e & 1) || (e == 0);
15077 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15078 e_conv = DecodeError_clone(&e_conv);
15079 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15080 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
15081 return (uint32_t)ret_conv;
15084 jboolean __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(uint32_t o) {
15085 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* o_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(o & ~1);
15086 jboolean ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_is_ok(o_conv);
15090 void __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
15091 if ((_res & 1) != 0) return;
15092 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15093 CHECK_ACCESS(_res_ptr);
15094 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(_res_ptr);
15096 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
15099 static inline uintptr_t CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(LDKCResult_SpendableOutputDescriptorDecodeErrorZ *NONNULL_PTR arg) {
15100 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15101 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(arg);
15102 return (uint32_t)ret_conv;
15104 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(uint32_t arg) {
15105 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* arg_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
15106 uint32_t ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone_ptr(arg_conv);
15110 uint32_t __attribute__((export_name("TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
15111 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
15112 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
15113 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
15114 return (uint32_t)ret_conv;
15117 void __attribute__((export_name("TS_CVec_PaymentPreimageZ_free"))) TS_CVec_PaymentPreimageZ_free(ptrArray _res) {
15118 LDKCVec_PaymentPreimageZ _res_constr;
15119 _res_constr.datalen = _res->arr_len;
15120 if (_res_constr.datalen > 0)
15121 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_PaymentPreimageZ Elements");
15123 _res_constr.data = NULL;
15124 int8_tArray* _res_vals = (void*) _res->elems;
15125 for (size_t m = 0; m < _res_constr.datalen; m++) {
15126 int8_tArray _res_conv_12 = _res_vals[m];
15127 LDKThirtyTwoBytes _res_conv_12_ref;
15128 CHECK(_res_conv_12->arr_len == 32);
15129 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
15130 _res_constr.data[m] = _res_conv_12_ref;
15133 CVec_PaymentPreimageZ_free(_res_constr);
15136 static inline uintptr_t C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR arg) {
15137 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15138 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(arg);
15139 return ((uint32_t)ret_conv);
15141 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(uint32_t arg) {
15142 LDKC2Tuple_SignatureCVec_SignatureZZ* arg_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(arg & ~1);
15143 uint32_t ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone_ptr(arg_conv);
15147 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_clone"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) {
15148 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
15149 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15150 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
15151 return ((uint32_t)ret_conv);
15154 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_new"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
15155 LDKSignature a_ref;
15156 CHECK(a->arr_len == 64);
15157 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
15158 LDKCVec_SignatureZ b_constr;
15159 b_constr.datalen = b->arr_len;
15160 if (b_constr.datalen > 0)
15161 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
15163 b_constr.data = NULL;
15164 int8_tArray* b_vals = (void*) b->elems;
15165 for (size_t m = 0; m < b_constr.datalen; m++) {
15166 int8_tArray b_conv_12 = b_vals[m];
15167 LDKSignature b_conv_12_ref;
15168 CHECK(b_conv_12->arr_len == 64);
15169 memcpy(b_conv_12_ref.compact_form, b_conv_12->elems, 64); FREE(b_conv_12);
15170 b_constr.data[m] = b_conv_12_ref;
15173 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
15174 *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
15175 return ((uint32_t)ret_conv);
15178 void __attribute__((export_name("TS_C2Tuple_SignatureCVec_SignatureZZ_free"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint32_t _res) {
15179 if ((_res & 1) != 0) return;
15180 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15181 CHECK_ACCESS(_res_ptr);
15182 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(_res_ptr);
15184 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
15187 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint32_t o) {
15188 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
15189 CHECK_ACCESS(o_ptr);
15190 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(o_ptr);
15191 o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uintptr_t)o) & ~1));
15192 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15193 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
15194 return (uint32_t)ret_conv;
15197 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
15198 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15199 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
15200 return (uint32_t)ret_conv;
15203 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(uint32_t o) {
15204 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(o & ~1);
15205 jboolean ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_is_ok(o_conv);
15209 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint32_t _res) {
15210 if ((_res & 1) != 0) return;
15211 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15212 CHECK_ACCESS(_res_ptr);
15213 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(_res_ptr);
15215 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
15218 static inline uintptr_t CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *NONNULL_PTR arg) {
15219 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15220 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(arg);
15221 return (uint32_t)ret_conv;
15223 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(uint32_t arg) {
15224 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
15225 uint32_t ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone_ptr(arg_conv);
15229 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint32_t orig) {
15230 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
15231 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
15232 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
15233 return (uint32_t)ret_conv;
15236 uint32_t __attribute__((export_name("TS_CResult_SignatureNoneZ_ok"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
15237 LDKSignature o_ref;
15238 CHECK(o->arr_len == 64);
15239 memcpy(o_ref.compact_form, o->elems, 64); FREE(o);
15240 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15241 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
15242 return (uint32_t)ret_conv;
15245 uint32_t __attribute__((export_name("TS_CResult_SignatureNoneZ_err"))) TS_CResult_SignatureNoneZ_err() {
15246 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15247 *ret_conv = CResult_SignatureNoneZ_err();
15248 return (uint32_t)ret_conv;
15251 jboolean __attribute__((export_name("TS_CResult_SignatureNoneZ_is_ok"))) TS_CResult_SignatureNoneZ_is_ok(uint32_t o) {
15252 LDKCResult_SignatureNoneZ* o_conv = (LDKCResult_SignatureNoneZ*)(o & ~1);
15253 jboolean ret_conv = CResult_SignatureNoneZ_is_ok(o_conv);
15257 void __attribute__((export_name("TS_CResult_SignatureNoneZ_free"))) TS_CResult_SignatureNoneZ_free(uint32_t _res) {
15258 if ((_res & 1) != 0) return;
15259 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15260 CHECK_ACCESS(_res_ptr);
15261 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(_res_ptr);
15263 CResult_SignatureNoneZ_free(_res_conv);
15266 static inline uintptr_t CResult_SignatureNoneZ_clone_ptr(LDKCResult_SignatureNoneZ *NONNULL_PTR arg) {
15267 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15268 *ret_conv = CResult_SignatureNoneZ_clone(arg);
15269 return (uint32_t)ret_conv;
15271 uint32_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone_ptr"))) TS_CResult_SignatureNoneZ_clone_ptr(uint32_t arg) {
15272 LDKCResult_SignatureNoneZ* arg_conv = (LDKCResult_SignatureNoneZ*)(arg & ~1);
15273 uint32_t ret_conv = CResult_SignatureNoneZ_clone_ptr(arg_conv);
15277 uint32_t __attribute__((export_name("TS_CResult_SignatureNoneZ_clone"))) TS_CResult_SignatureNoneZ_clone(uint32_t orig) {
15278 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
15279 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
15280 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
15281 return (uint32_t)ret_conv;
15284 static inline uintptr_t C2Tuple_SignatureSignatureZ_clone_ptr(LDKC2Tuple_SignatureSignatureZ *NONNULL_PTR arg) {
15285 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15286 *ret_conv = C2Tuple_SignatureSignatureZ_clone(arg);
15287 return ((uint32_t)ret_conv);
15289 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_clone_ptr"))) TS_C2Tuple_SignatureSignatureZ_clone_ptr(uint32_t arg) {
15290 LDKC2Tuple_SignatureSignatureZ* arg_conv = (LDKC2Tuple_SignatureSignatureZ*)(arg & ~1);
15291 uint32_t ret_conv = C2Tuple_SignatureSignatureZ_clone_ptr(arg_conv);
15295 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_clone"))) TS_C2Tuple_SignatureSignatureZ_clone(uint32_t orig) {
15296 LDKC2Tuple_SignatureSignatureZ* orig_conv = (LDKC2Tuple_SignatureSignatureZ*)(orig & ~1);
15297 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15298 *ret_conv = C2Tuple_SignatureSignatureZ_clone(orig_conv);
15299 return ((uint32_t)ret_conv);
15302 uint32_t __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_new"))) TS_C2Tuple_SignatureSignatureZ_new(int8_tArray a, int8_tArray b) {
15303 LDKSignature a_ref;
15304 CHECK(a->arr_len == 64);
15305 memcpy(a_ref.compact_form, a->elems, 64); FREE(a);
15306 LDKSignature b_ref;
15307 CHECK(b->arr_len == 64);
15308 memcpy(b_ref.compact_form, b->elems, 64); FREE(b);
15309 LDKC2Tuple_SignatureSignatureZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureSignatureZ), "LDKC2Tuple_SignatureSignatureZ");
15310 *ret_conv = C2Tuple_SignatureSignatureZ_new(a_ref, b_ref);
15311 return ((uint32_t)ret_conv);
15314 void __attribute__((export_name("TS_C2Tuple_SignatureSignatureZ_free"))) TS_C2Tuple_SignatureSignatureZ_free(uint32_t _res) {
15315 if ((_res & 1) != 0) return;
15316 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15317 CHECK_ACCESS(_res_ptr);
15318 LDKC2Tuple_SignatureSignatureZ _res_conv = *(LDKC2Tuple_SignatureSignatureZ*)(_res_ptr);
15320 C2Tuple_SignatureSignatureZ_free(_res_conv);
15323 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_ok(uint32_t o) {
15324 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
15325 CHECK_ACCESS(o_ptr);
15326 LDKC2Tuple_SignatureSignatureZ o_conv = *(LDKC2Tuple_SignatureSignatureZ*)(o_ptr);
15327 o_conv = C2Tuple_SignatureSignatureZ_clone((LDKC2Tuple_SignatureSignatureZ*)(((uintptr_t)o) & ~1));
15328 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15329 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_ok(o_conv);
15330 return (uint32_t)ret_conv;
15333 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_err() {
15334 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15335 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_err();
15336 return (uint32_t)ret_conv;
15339 jboolean __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(uint32_t o) {
15340 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* o_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(o & ~1);
15341 jboolean ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_is_ok(o_conv);
15345 void __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_free(uint32_t _res) {
15346 if ((_res & 1) != 0) return;
15347 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15348 CHECK_ACCESS(_res_ptr);
15349 LDKCResult_C2Tuple_SignatureSignatureZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(_res_ptr);
15351 CResult_C2Tuple_SignatureSignatureZNoneZ_free(_res_conv);
15354 static inline uintptr_t CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(LDKCResult_C2Tuple_SignatureSignatureZNoneZ *NONNULL_PTR arg) {
15355 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15356 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone(arg);
15357 return (uint32_t)ret_conv;
15359 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(uint32_t arg) {
15360 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* arg_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(arg & ~1);
15361 uint32_t ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone_ptr(arg_conv);
15365 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone"))) TS_CResult_C2Tuple_SignatureSignatureZNoneZ_clone(uint32_t orig) {
15366 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureSignatureZNoneZ*)(orig & ~1);
15367 LDKCResult_C2Tuple_SignatureSignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureSignatureZNoneZ), "LDKCResult_C2Tuple_SignatureSignatureZNoneZ");
15368 *ret_conv = CResult_C2Tuple_SignatureSignatureZNoneZ_clone(orig_conv);
15369 return (uint32_t)ret_conv;
15372 uint32_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_ok"))) TS_CResult_SecretKeyNoneZ_ok(int8_tArray o) {
15373 LDKSecretKey o_ref;
15374 CHECK(o->arr_len == 32);
15375 memcpy(o_ref.bytes, o->elems, 32); FREE(o);
15376 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15377 *ret_conv = CResult_SecretKeyNoneZ_ok(o_ref);
15378 return (uint32_t)ret_conv;
15381 uint32_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_err"))) TS_CResult_SecretKeyNoneZ_err() {
15382 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15383 *ret_conv = CResult_SecretKeyNoneZ_err();
15384 return (uint32_t)ret_conv;
15387 jboolean __attribute__((export_name("TS_CResult_SecretKeyNoneZ_is_ok"))) TS_CResult_SecretKeyNoneZ_is_ok(uint32_t o) {
15388 LDKCResult_SecretKeyNoneZ* o_conv = (LDKCResult_SecretKeyNoneZ*)(o & ~1);
15389 jboolean ret_conv = CResult_SecretKeyNoneZ_is_ok(o_conv);
15393 void __attribute__((export_name("TS_CResult_SecretKeyNoneZ_free"))) TS_CResult_SecretKeyNoneZ_free(uint32_t _res) {
15394 if ((_res & 1) != 0) return;
15395 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15396 CHECK_ACCESS(_res_ptr);
15397 LDKCResult_SecretKeyNoneZ _res_conv = *(LDKCResult_SecretKeyNoneZ*)(_res_ptr);
15399 CResult_SecretKeyNoneZ_free(_res_conv);
15402 static inline uintptr_t CResult_SecretKeyNoneZ_clone_ptr(LDKCResult_SecretKeyNoneZ *NONNULL_PTR arg) {
15403 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15404 *ret_conv = CResult_SecretKeyNoneZ_clone(arg);
15405 return (uint32_t)ret_conv;
15407 uint32_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_clone_ptr"))) TS_CResult_SecretKeyNoneZ_clone_ptr(uint32_t arg) {
15408 LDKCResult_SecretKeyNoneZ* arg_conv = (LDKCResult_SecretKeyNoneZ*)(arg & ~1);
15409 uint32_t ret_conv = CResult_SecretKeyNoneZ_clone_ptr(arg_conv);
15413 uint32_t __attribute__((export_name("TS_CResult_SecretKeyNoneZ_clone"))) TS_CResult_SecretKeyNoneZ_clone(uint32_t orig) {
15414 LDKCResult_SecretKeyNoneZ* orig_conv = (LDKCResult_SecretKeyNoneZ*)(orig & ~1);
15415 LDKCResult_SecretKeyNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyNoneZ), "LDKCResult_SecretKeyNoneZ");
15416 *ret_conv = CResult_SecretKeyNoneZ_clone(orig_conv);
15417 return (uint32_t)ret_conv;
15420 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_ok"))) TS_CResult_SignDecodeErrorZ_ok(uint32_t o) {
15421 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
15422 CHECK_ACCESS(o_ptr);
15423 LDKSign o_conv = *(LDKSign*)(o_ptr);
15424 if (o_conv.free == LDKSign_JCalls_free) {
15425 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
15426 LDKSign_JCalls_cloned(&o_conv);
15428 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
15429 *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
15430 return (uint32_t)ret_conv;
15433 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_err"))) TS_CResult_SignDecodeErrorZ_err(uint32_t e) {
15434 LDKDecodeError e_conv;
15435 e_conv.inner = (void*)(e & (~1));
15436 e_conv.is_owned = (e & 1) || (e == 0);
15437 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15438 e_conv = DecodeError_clone(&e_conv);
15439 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
15440 *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
15441 return (uint32_t)ret_conv;
15444 jboolean __attribute__((export_name("TS_CResult_SignDecodeErrorZ_is_ok"))) TS_CResult_SignDecodeErrorZ_is_ok(uint32_t o) {
15445 LDKCResult_SignDecodeErrorZ* o_conv = (LDKCResult_SignDecodeErrorZ*)(o & ~1);
15446 jboolean ret_conv = CResult_SignDecodeErrorZ_is_ok(o_conv);
15450 void __attribute__((export_name("TS_CResult_SignDecodeErrorZ_free"))) TS_CResult_SignDecodeErrorZ_free(uint32_t _res) {
15451 if ((_res & 1) != 0) return;
15452 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15453 CHECK_ACCESS(_res_ptr);
15454 LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(_res_ptr);
15456 CResult_SignDecodeErrorZ_free(_res_conv);
15459 static inline uintptr_t CResult_SignDecodeErrorZ_clone_ptr(LDKCResult_SignDecodeErrorZ *NONNULL_PTR arg) {
15460 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
15461 *ret_conv = CResult_SignDecodeErrorZ_clone(arg);
15462 return (uint32_t)ret_conv;
15464 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_clone_ptr"))) TS_CResult_SignDecodeErrorZ_clone_ptr(uint32_t arg) {
15465 LDKCResult_SignDecodeErrorZ* arg_conv = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
15466 uint32_t ret_conv = CResult_SignDecodeErrorZ_clone_ptr(arg_conv);
15470 uint32_t __attribute__((export_name("TS_CResult_SignDecodeErrorZ_clone"))) TS_CResult_SignDecodeErrorZ_clone(uint32_t orig) {
15471 LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
15472 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
15473 *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
15474 return (uint32_t)ret_conv;
15477 void __attribute__((export_name("TS_CVec_u5Z_free"))) TS_CVec_u5Z_free(ptrArray _res) {
15478 LDKCVec_u5Z _res_constr;
15479 _res_constr.datalen = _res->arr_len;
15480 if (_res_constr.datalen > 0)
15481 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKu5), "LDKCVec_u5Z Elements");
15483 _res_constr.data = NULL;
15484 int8_t* _res_vals = (void*) _res->elems;
15485 for (size_t h = 0; h < _res_constr.datalen; h++) {
15486 int8_t _res_conv_7 = _res_vals[h];
15488 _res_constr.data[h] = (LDKu5){ ._0 = _res_conv_7 };
15491 CVec_u5Z_free(_res_constr);
15494 uint32_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_ok"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray o) {
15495 LDKRecoverableSignature o_ref;
15496 CHECK(o->arr_len == 68);
15497 memcpy(o_ref.serialized_form, o->elems, 68); FREE(o);
15498 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
15499 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(o_ref);
15500 return (uint32_t)ret_conv;
15503 uint32_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_err"))) TS_CResult_RecoverableSignatureNoneZ_err() {
15504 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
15505 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
15506 return (uint32_t)ret_conv;
15509 jboolean __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_is_ok"))) TS_CResult_RecoverableSignatureNoneZ_is_ok(uint32_t o) {
15510 LDKCResult_RecoverableSignatureNoneZ* o_conv = (LDKCResult_RecoverableSignatureNoneZ*)(o & ~1);
15511 jboolean ret_conv = CResult_RecoverableSignatureNoneZ_is_ok(o_conv);
15515 void __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_free"))) TS_CResult_RecoverableSignatureNoneZ_free(uint32_t _res) {
15516 if ((_res & 1) != 0) return;
15517 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15518 CHECK_ACCESS(_res_ptr);
15519 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(_res_ptr);
15521 CResult_RecoverableSignatureNoneZ_free(_res_conv);
15524 static inline uintptr_t CResult_RecoverableSignatureNoneZ_clone_ptr(LDKCResult_RecoverableSignatureNoneZ *NONNULL_PTR arg) {
15525 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
15526 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(arg);
15527 return (uint32_t)ret_conv;
15529 uint32_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone_ptr"))) TS_CResult_RecoverableSignatureNoneZ_clone_ptr(uint32_t arg) {
15530 LDKCResult_RecoverableSignatureNoneZ* arg_conv = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
15531 uint32_t ret_conv = CResult_RecoverableSignatureNoneZ_clone_ptr(arg_conv);
15535 uint32_t __attribute__((export_name("TS_CResult_RecoverableSignatureNoneZ_clone"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint32_t orig) {
15536 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
15537 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
15538 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
15539 return (uint32_t)ret_conv;
15542 void __attribute__((export_name("TS_CVec_u8Z_free"))) TS_CVec_u8Z_free(int8_tArray _res) {
15543 LDKCVec_u8Z _res_ref;
15544 _res_ref.datalen = _res->arr_len;
15545 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
15546 memcpy(_res_ref.data, _res->elems, _res_ref.datalen); FREE(_res);
15547 CVec_u8Z_free(_res_ref);
15550 void __attribute__((export_name("TS_CVec_CVec_u8ZZ_free"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
15551 LDKCVec_CVec_u8ZZ _res_constr;
15552 _res_constr.datalen = _res->arr_len;
15553 if (_res_constr.datalen > 0)
15554 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
15556 _res_constr.data = NULL;
15557 int8_tArray* _res_vals = (void*) _res->elems;
15558 for (size_t m = 0; m < _res_constr.datalen; m++) {
15559 int8_tArray _res_conv_12 = _res_vals[m];
15560 LDKCVec_u8Z _res_conv_12_ref;
15561 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
15562 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
15563 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
15564 _res_constr.data[m] = _res_conv_12_ref;
15567 CVec_CVec_u8ZZ_free(_res_constr);
15570 uint32_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
15571 LDKCVec_CVec_u8ZZ o_constr;
15572 o_constr.datalen = o->arr_len;
15573 if (o_constr.datalen > 0)
15574 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
15576 o_constr.data = NULL;
15577 int8_tArray* o_vals = (void*) o->elems;
15578 for (size_t m = 0; m < o_constr.datalen; m++) {
15579 int8_tArray o_conv_12 = o_vals[m];
15580 LDKCVec_u8Z o_conv_12_ref;
15581 o_conv_12_ref.datalen = o_conv_12->arr_len;
15582 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
15583 memcpy(o_conv_12_ref.data, o_conv_12->elems, o_conv_12_ref.datalen); FREE(o_conv_12);
15584 o_constr.data[m] = o_conv_12_ref;
15587 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15588 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
15589 return (uint32_t)ret_conv;
15592 uint32_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_err"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
15593 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15594 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
15595 return (uint32_t)ret_conv;
15598 jboolean __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok"))) TS_CResult_CVec_CVec_u8ZZNoneZ_is_ok(uint32_t o) {
15599 LDKCResult_CVec_CVec_u8ZZNoneZ* o_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(o & ~1);
15600 jboolean ret_conv = CResult_CVec_CVec_u8ZZNoneZ_is_ok(o_conv);
15604 void __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_free"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint32_t _res) {
15605 if ((_res & 1) != 0) return;
15606 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15607 CHECK_ACCESS(_res_ptr);
15608 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(_res_ptr);
15610 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
15613 static inline uintptr_t CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(LDKCResult_CVec_CVec_u8ZZNoneZ *NONNULL_PTR arg) {
15614 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15615 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(arg);
15616 return (uint32_t)ret_conv;
15618 uint32_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(uint32_t arg) {
15619 LDKCResult_CVec_CVec_u8ZZNoneZ* arg_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
15620 uint32_t ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone_ptr(arg_conv);
15624 uint32_t __attribute__((export_name("TS_CResult_CVec_CVec_u8ZZNoneZ_clone"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint32_t orig) {
15625 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
15626 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
15627 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
15628 return (uint32_t)ret_conv;
15631 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint32_t o) {
15632 LDKInMemorySigner o_conv;
15633 o_conv.inner = (void*)(o & (~1));
15634 o_conv.is_owned = (o & 1) || (o == 0);
15635 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
15636 o_conv = InMemorySigner_clone(&o_conv);
15637 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
15638 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
15639 return (uint32_t)ret_conv;
15642 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_err"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint32_t e) {
15643 LDKDecodeError e_conv;
15644 e_conv.inner = (void*)(e & (~1));
15645 e_conv.is_owned = (e & 1) || (e == 0);
15646 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
15647 e_conv = DecodeError_clone(&e_conv);
15648 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
15649 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
15650 return (uint32_t)ret_conv;
15653 jboolean __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_is_ok"))) TS_CResult_InMemorySignerDecodeErrorZ_is_ok(uint32_t o) {
15654 LDKCResult_InMemorySignerDecodeErrorZ* o_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(o & ~1);
15655 jboolean ret_conv = CResult_InMemorySignerDecodeErrorZ_is_ok(o_conv);
15659 void __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_free"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint32_t _res) {
15660 if ((_res & 1) != 0) return;
15661 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15662 CHECK_ACCESS(_res_ptr);
15663 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(_res_ptr);
15665 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
15668 static inline uintptr_t CResult_InMemorySignerDecodeErrorZ_clone_ptr(LDKCResult_InMemorySignerDecodeErrorZ *NONNULL_PTR arg) {
15669 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
15670 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(arg);
15671 return (uint32_t)ret_conv;
15673 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr"))) TS_CResult_InMemorySignerDecodeErrorZ_clone_ptr(uint32_t arg) {
15674 LDKCResult_InMemorySignerDecodeErrorZ* arg_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
15675 uint32_t ret_conv = CResult_InMemorySignerDecodeErrorZ_clone_ptr(arg_conv);
15679 uint32_t __attribute__((export_name("TS_CResult_InMemorySignerDecodeErrorZ_clone"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint32_t orig) {
15680 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
15681 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
15682 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
15683 return (uint32_t)ret_conv;
15686 void __attribute__((export_name("TS_CVec_TxOutZ_free"))) TS_CVec_TxOutZ_free(uint32_tArray _res) {
15687 LDKCVec_TxOutZ _res_constr;
15688 _res_constr.datalen = _res->arr_len;
15689 if (_res_constr.datalen > 0)
15690 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
15692 _res_constr.data = NULL;
15693 uint32_t* _res_vals = _res->elems;
15694 for (size_t h = 0; h < _res_constr.datalen; h++) {
15695 uint32_t _res_conv_7 = _res_vals[h];
15696 void* _res_conv_7_ptr = (void*)(((uintptr_t)_res_conv_7) & ~1);
15697 CHECK_ACCESS(_res_conv_7_ptr);
15698 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(_res_conv_7_ptr);
15699 FREE((void*)_res_conv_7);
15700 _res_constr.data[h] = _res_conv_7_conv;
15703 CVec_TxOutZ_free(_res_constr);
15706 uint32_t __attribute__((export_name("TS_CResult_TransactionNoneZ_ok"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
15707 LDKTransaction o_ref;
15708 o_ref.datalen = o->arr_len;
15709 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
15710 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
15711 o_ref.data_is_owned = true;
15712 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
15713 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
15714 return (uint32_t)ret_conv;
15717 uint32_t __attribute__((export_name("TS_CResult_TransactionNoneZ_err"))) TS_CResult_TransactionNoneZ_err() {
15718 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
15719 *ret_conv = CResult_TransactionNoneZ_err();
15720 return (uint32_t)ret_conv;
15723 jboolean __attribute__((export_name("TS_CResult_TransactionNoneZ_is_ok"))) TS_CResult_TransactionNoneZ_is_ok(uint32_t o) {
15724 LDKCResult_TransactionNoneZ* o_conv = (LDKCResult_TransactionNoneZ*)(o & ~1);
15725 jboolean ret_conv = CResult_TransactionNoneZ_is_ok(o_conv);
15729 void __attribute__((export_name("TS_CResult_TransactionNoneZ_free"))) TS_CResult_TransactionNoneZ_free(uint32_t _res) {
15730 if ((_res & 1) != 0) return;
15731 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15732 CHECK_ACCESS(_res_ptr);
15733 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(_res_ptr);
15735 CResult_TransactionNoneZ_free(_res_conv);
15738 static inline uintptr_t CResult_TransactionNoneZ_clone_ptr(LDKCResult_TransactionNoneZ *NONNULL_PTR arg) {
15739 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
15740 *ret_conv = CResult_TransactionNoneZ_clone(arg);
15741 return (uint32_t)ret_conv;
15743 uint32_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone_ptr"))) TS_CResult_TransactionNoneZ_clone_ptr(uint32_t arg) {
15744 LDKCResult_TransactionNoneZ* arg_conv = (LDKCResult_TransactionNoneZ*)(arg & ~1);
15745 uint32_t ret_conv = CResult_TransactionNoneZ_clone_ptr(arg_conv);
15749 uint32_t __attribute__((export_name("TS_CResult_TransactionNoneZ_clone"))) TS_CResult_TransactionNoneZ_clone(uint32_t orig) {
15750 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
15751 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
15752 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
15753 return (uint32_t)ret_conv;
15756 uint32_t __attribute__((export_name("TS_COption_u16Z_some"))) TS_COption_u16Z_some(int16_t o) {
15757 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
15758 *ret_copy = COption_u16Z_some(o);
15759 uint32_t ret_ref = (uintptr_t)ret_copy;
15763 uint32_t __attribute__((export_name("TS_COption_u16Z_none"))) TS_COption_u16Z_none() {
15764 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
15765 *ret_copy = COption_u16Z_none();
15766 uint32_t ret_ref = (uintptr_t)ret_copy;
15770 void __attribute__((export_name("TS_COption_u16Z_free"))) TS_COption_u16Z_free(uint32_t _res) {
15771 if ((_res & 1) != 0) return;
15772 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15773 CHECK_ACCESS(_res_ptr);
15774 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(_res_ptr);
15776 COption_u16Z_free(_res_conv);
15779 static inline uintptr_t COption_u16Z_clone_ptr(LDKCOption_u16Z *NONNULL_PTR arg) {
15780 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
15781 *ret_copy = COption_u16Z_clone(arg);
15782 uint32_t ret_ref = (uintptr_t)ret_copy;
15785 uint32_t __attribute__((export_name("TS_COption_u16Z_clone_ptr"))) TS_COption_u16Z_clone_ptr(uint32_t arg) {
15786 LDKCOption_u16Z* arg_conv = (LDKCOption_u16Z*)arg;
15787 uint32_t ret_conv = COption_u16Z_clone_ptr(arg_conv);
15791 uint32_t __attribute__((export_name("TS_COption_u16Z_clone"))) TS_COption_u16Z_clone(uint32_t orig) {
15792 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
15793 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
15794 *ret_copy = COption_u16Z_clone(orig_conv);
15795 uint32_t ret_ref = (uintptr_t)ret_copy;
15799 uint32_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_ok"))) TS_CResult_NoneAPIErrorZ_ok() {
15800 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15801 *ret_conv = CResult_NoneAPIErrorZ_ok();
15802 return (uint32_t)ret_conv;
15805 uint32_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_err"))) TS_CResult_NoneAPIErrorZ_err(uint32_t e) {
15806 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
15807 CHECK_ACCESS(e_ptr);
15808 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
15809 e_conv = APIError_clone((LDKAPIError*)(((uintptr_t)e) & ~1));
15810 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15811 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
15812 return (uint32_t)ret_conv;
15815 jboolean __attribute__((export_name("TS_CResult_NoneAPIErrorZ_is_ok"))) TS_CResult_NoneAPIErrorZ_is_ok(uint32_t o) {
15816 LDKCResult_NoneAPIErrorZ* o_conv = (LDKCResult_NoneAPIErrorZ*)(o & ~1);
15817 jboolean ret_conv = CResult_NoneAPIErrorZ_is_ok(o_conv);
15821 void __attribute__((export_name("TS_CResult_NoneAPIErrorZ_free"))) TS_CResult_NoneAPIErrorZ_free(uint32_t _res) {
15822 if ((_res & 1) != 0) return;
15823 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15824 CHECK_ACCESS(_res_ptr);
15825 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_ptr);
15827 CResult_NoneAPIErrorZ_free(_res_conv);
15830 static inline uintptr_t CResult_NoneAPIErrorZ_clone_ptr(LDKCResult_NoneAPIErrorZ *NONNULL_PTR arg) {
15831 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15832 *ret_conv = CResult_NoneAPIErrorZ_clone(arg);
15833 return (uint32_t)ret_conv;
15835 uint32_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone_ptr"))) TS_CResult_NoneAPIErrorZ_clone_ptr(uint32_t arg) {
15836 LDKCResult_NoneAPIErrorZ* arg_conv = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
15837 uint32_t ret_conv = CResult_NoneAPIErrorZ_clone_ptr(arg_conv);
15841 uint32_t __attribute__((export_name("TS_CResult_NoneAPIErrorZ_clone"))) TS_CResult_NoneAPIErrorZ_clone(uint32_t orig) {
15842 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
15843 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
15844 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
15845 return (uint32_t)ret_conv;
15848 void __attribute__((export_name("TS_CVec_CResult_NoneAPIErrorZZ_free"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint32_tArray _res) {
15849 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
15850 _res_constr.datalen = _res->arr_len;
15851 if (_res_constr.datalen > 0)
15852 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
15854 _res_constr.data = NULL;
15855 uint32_t* _res_vals = _res->elems;
15856 for (size_t w = 0; w < _res_constr.datalen; w++) {
15857 uint32_t _res_conv_22 = _res_vals[w];
15858 void* _res_conv_22_ptr = (void*)(((uintptr_t)_res_conv_22) & ~1);
15859 CHECK_ACCESS(_res_conv_22_ptr);
15860 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(_res_conv_22_ptr);
15861 FREE((void*)_res_conv_22);
15862 _res_constr.data[w] = _res_conv_22_conv;
15865 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
15868 void __attribute__((export_name("TS_CVec_APIErrorZ_free"))) TS_CVec_APIErrorZ_free(uint32_tArray _res) {
15869 LDKCVec_APIErrorZ _res_constr;
15870 _res_constr.datalen = _res->arr_len;
15871 if (_res_constr.datalen > 0)
15872 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
15874 _res_constr.data = NULL;
15875 uint32_t* _res_vals = _res->elems;
15876 for (size_t k = 0; k < _res_constr.datalen; k++) {
15877 uint32_t _res_conv_10 = _res_vals[k];
15878 void* _res_conv_10_ptr = (void*)(((uintptr_t)_res_conv_10) & ~1);
15879 CHECK_ACCESS(_res_conv_10_ptr);
15880 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(_res_conv_10_ptr);
15881 FREE((void*)_res_conv_10);
15882 _res_constr.data[k] = _res_conv_10_conv;
15885 CVec_APIErrorZ_free(_res_constr);
15888 uint32_t __attribute__((export_name("TS_CResult__u832APIErrorZ_ok"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) {
15889 LDKThirtyTwoBytes o_ref;
15890 CHECK(o->arr_len == 32);
15891 memcpy(o_ref.data, o->elems, 32); FREE(o);
15892 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
15893 *ret_conv = CResult__u832APIErrorZ_ok(o_ref);
15894 return (uint32_t)ret_conv;
15897 uint32_t __attribute__((export_name("TS_CResult__u832APIErrorZ_err"))) TS_CResult__u832APIErrorZ_err(uint32_t e) {
15898 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
15899 CHECK_ACCESS(e_ptr);
15900 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
15901 e_conv = APIError_clone((LDKAPIError*)(((uintptr_t)e) & ~1));
15902 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
15903 *ret_conv = CResult__u832APIErrorZ_err(e_conv);
15904 return (uint32_t)ret_conv;
15907 jboolean __attribute__((export_name("TS_CResult__u832APIErrorZ_is_ok"))) TS_CResult__u832APIErrorZ_is_ok(uint32_t o) {
15908 LDKCResult__u832APIErrorZ* o_conv = (LDKCResult__u832APIErrorZ*)(o & ~1);
15909 jboolean ret_conv = CResult__u832APIErrorZ_is_ok(o_conv);
15913 void __attribute__((export_name("TS_CResult__u832APIErrorZ_free"))) TS_CResult__u832APIErrorZ_free(uint32_t _res) {
15914 if ((_res & 1) != 0) return;
15915 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15916 CHECK_ACCESS(_res_ptr);
15917 LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(_res_ptr);
15919 CResult__u832APIErrorZ_free(_res_conv);
15922 static inline uintptr_t CResult__u832APIErrorZ_clone_ptr(LDKCResult__u832APIErrorZ *NONNULL_PTR arg) {
15923 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
15924 *ret_conv = CResult__u832APIErrorZ_clone(arg);
15925 return (uint32_t)ret_conv;
15927 uint32_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone_ptr"))) TS_CResult__u832APIErrorZ_clone_ptr(uint32_t arg) {
15928 LDKCResult__u832APIErrorZ* arg_conv = (LDKCResult__u832APIErrorZ*)(arg & ~1);
15929 uint32_t ret_conv = CResult__u832APIErrorZ_clone_ptr(arg_conv);
15933 uint32_t __attribute__((export_name("TS_CResult__u832APIErrorZ_clone"))) TS_CResult__u832APIErrorZ_clone(uint32_t orig) {
15934 LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1);
15935 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
15936 *ret_conv = CResult__u832APIErrorZ_clone(orig_conv);
15937 return (uint32_t)ret_conv;
15940 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_ok"))) TS_CResult_PaymentIdPaymentSendFailureZ_ok(int8_tArray o) {
15941 LDKThirtyTwoBytes o_ref;
15942 CHECK(o->arr_len == 32);
15943 memcpy(o_ref.data, o->elems, 32); FREE(o);
15944 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
15945 *ret_conv = CResult_PaymentIdPaymentSendFailureZ_ok(o_ref);
15946 return (uint32_t)ret_conv;
15949 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_err"))) TS_CResult_PaymentIdPaymentSendFailureZ_err(uint32_t e) {
15950 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
15951 CHECK_ACCESS(e_ptr);
15952 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
15953 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uintptr_t)e) & ~1));
15954 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
15955 *ret_conv = CResult_PaymentIdPaymentSendFailureZ_err(e_conv);
15956 return (uint32_t)ret_conv;
15959 jboolean __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_is_ok"))) TS_CResult_PaymentIdPaymentSendFailureZ_is_ok(uint32_t o) {
15960 LDKCResult_PaymentIdPaymentSendFailureZ* o_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(o & ~1);
15961 jboolean ret_conv = CResult_PaymentIdPaymentSendFailureZ_is_ok(o_conv);
15965 void __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_free"))) TS_CResult_PaymentIdPaymentSendFailureZ_free(uint32_t _res) {
15966 if ((_res & 1) != 0) return;
15967 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
15968 CHECK_ACCESS(_res_ptr);
15969 LDKCResult_PaymentIdPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(_res_ptr);
15971 CResult_PaymentIdPaymentSendFailureZ_free(_res_conv);
15974 static inline uintptr_t CResult_PaymentIdPaymentSendFailureZ_clone_ptr(LDKCResult_PaymentIdPaymentSendFailureZ *NONNULL_PTR arg) {
15975 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
15976 *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(arg);
15977 return (uint32_t)ret_conv;
15979 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone_ptr(uint32_t arg) {
15980 LDKCResult_PaymentIdPaymentSendFailureZ* arg_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1);
15981 uint32_t ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone_ptr(arg_conv);
15985 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentSendFailureZ_clone"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone(uint32_t orig) {
15986 LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1);
15987 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
15988 *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(orig_conv);
15989 return (uint32_t)ret_conv;
15992 uint32_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_ok"))) TS_CResult_NonePaymentSendFailureZ_ok() {
15993 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
15994 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
15995 return (uint32_t)ret_conv;
15998 uint32_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_err"))) TS_CResult_NonePaymentSendFailureZ_err(uint32_t e) {
15999 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16000 CHECK_ACCESS(e_ptr);
16001 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
16002 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uintptr_t)e) & ~1));
16003 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16004 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
16005 return (uint32_t)ret_conv;
16008 jboolean __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_is_ok"))) TS_CResult_NonePaymentSendFailureZ_is_ok(uint32_t o) {
16009 LDKCResult_NonePaymentSendFailureZ* o_conv = (LDKCResult_NonePaymentSendFailureZ*)(o & ~1);
16010 jboolean ret_conv = CResult_NonePaymentSendFailureZ_is_ok(o_conv);
16014 void __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_free"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) {
16015 if ((_res & 1) != 0) return;
16016 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16017 CHECK_ACCESS(_res_ptr);
16018 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(_res_ptr);
16020 CResult_NonePaymentSendFailureZ_free(_res_conv);
16023 static inline uintptr_t CResult_NonePaymentSendFailureZ_clone_ptr(LDKCResult_NonePaymentSendFailureZ *NONNULL_PTR arg) {
16024 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16025 *ret_conv = CResult_NonePaymentSendFailureZ_clone(arg);
16026 return (uint32_t)ret_conv;
16028 uint32_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone_ptr"))) TS_CResult_NonePaymentSendFailureZ_clone_ptr(uint32_t arg) {
16029 LDKCResult_NonePaymentSendFailureZ* arg_conv = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
16030 uint32_t ret_conv = CResult_NonePaymentSendFailureZ_clone_ptr(arg_conv);
16034 uint32_t __attribute__((export_name("TS_CResult_NonePaymentSendFailureZ_clone"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) {
16035 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
16036 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
16037 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
16038 return (uint32_t)ret_conv;
16041 static inline uintptr_t C2Tuple_PaymentHashPaymentIdZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR arg) {
16042 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16043 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(arg);
16044 return ((uint32_t)ret_conv);
16046 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone_ptr(uint32_t arg) {
16047 LDKC2Tuple_PaymentHashPaymentIdZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(arg & ~1);
16048 uint32_t ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone_ptr(arg_conv);
16052 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_clone"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint32_t orig) {
16053 LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1);
16054 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16055 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv);
16056 return ((uint32_t)ret_conv);
16059 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_new"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, int8_tArray b) {
16060 LDKThirtyTwoBytes a_ref;
16061 CHECK(a->arr_len == 32);
16062 memcpy(a_ref.data, a->elems, 32); FREE(a);
16063 LDKThirtyTwoBytes b_ref;
16064 CHECK(b->arr_len == 32);
16065 memcpy(b_ref.data, b->elems, 32); FREE(b);
16066 LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ");
16067 *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_ref);
16068 return ((uint32_t)ret_conv);
16071 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentIdZ_free"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint32_t _res) {
16072 if ((_res & 1) != 0) return;
16073 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16074 CHECK_ACCESS(_res_ptr);
16075 LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(_res_ptr);
16077 C2Tuple_PaymentHashPaymentIdZ_free(_res_conv);
16080 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint32_t o) {
16081 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16082 CHECK_ACCESS(o_ptr);
16083 LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(o_ptr);
16084 o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)(((uintptr_t)o) & ~1));
16085 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16086 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv);
16087 return (uint32_t)ret_conv;
16090 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint32_t e) {
16091 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16092 CHECK_ACCESS(e_ptr);
16093 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(e_ptr);
16094 e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uintptr_t)e) & ~1));
16095 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16096 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv);
16097 return (uint32_t)ret_conv;
16100 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(uint32_t o) {
16101 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(o & ~1);
16102 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_is_ok(o_conv);
16106 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint32_t _res) {
16107 if ((_res & 1) != 0) return;
16108 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16109 CHECK_ACCESS(_res_ptr);
16110 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(_res_ptr);
16112 CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv);
16115 static inline uintptr_t CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *NONNULL_PTR arg) {
16116 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16117 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(arg);
16118 return (uint32_t)ret_conv;
16120 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(uint32_t arg) {
16121 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1);
16122 uint32_t ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone_ptr(arg_conv);
16126 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint32_t orig) {
16127 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1);
16128 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
16129 *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv);
16130 return (uint32_t)ret_conv;
16133 void __attribute__((export_name("TS_CVec_ThirtyTwoBytesZ_free"))) TS_CVec_ThirtyTwoBytesZ_free(ptrArray _res) {
16134 LDKCVec_ThirtyTwoBytesZ _res_constr;
16135 _res_constr.datalen = _res->arr_len;
16136 if (_res_constr.datalen > 0)
16137 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
16139 _res_constr.data = NULL;
16140 int8_tArray* _res_vals = (void*) _res->elems;
16141 for (size_t m = 0; m < _res_constr.datalen; m++) {
16142 int8_tArray _res_conv_12 = _res_vals[m];
16143 LDKThirtyTwoBytes _res_conv_12_ref;
16144 CHECK(_res_conv_12->arr_len == 32);
16145 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, 32); FREE(_res_conv_12);
16146 _res_constr.data[m] = _res_conv_12_ref;
16149 CVec_ThirtyTwoBytesZ_free(_res_constr);
16152 static inline uintptr_t C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR arg) {
16153 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16154 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(arg);
16155 return ((uint32_t)ret_conv);
16157 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(uint32_t arg) {
16158 LDKC2Tuple_PaymentHashPaymentSecretZ* arg_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(arg & ~1);
16159 uint32_t ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone_ptr(arg_conv);
16163 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_clone"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) {
16164 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
16165 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16166 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
16167 return ((uint32_t)ret_conv);
16170 uint32_t __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_new"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
16171 LDKThirtyTwoBytes a_ref;
16172 CHECK(a->arr_len == 32);
16173 memcpy(a_ref.data, a->elems, 32); FREE(a);
16174 LDKThirtyTwoBytes b_ref;
16175 CHECK(b->arr_len == 32);
16176 memcpy(b_ref.data, b->elems, 32); FREE(b);
16177 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
16178 *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
16179 return ((uint32_t)ret_conv);
16182 void __attribute__((export_name("TS_C2Tuple_PaymentHashPaymentSecretZ_free"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint32_t _res) {
16183 if ((_res & 1) != 0) return;
16184 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16185 CHECK_ACCESS(_res_ptr);
16186 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(_res_ptr);
16188 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
16191 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(uint32_t o) {
16192 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16193 CHECK_ACCESS(o_ptr);
16194 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
16195 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)(((uintptr_t)o) & ~1));
16196 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16197 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_ok(o_conv);
16198 return (uint32_t)ret_conv;
16201 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err() {
16202 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16203 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_err();
16204 return (uint32_t)ret_conv;
16207 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(uint32_t o) {
16208 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(o & ~1);
16209 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_is_ok(o_conv);
16213 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(uint32_t _res) {
16214 if ((_res & 1) != 0) return;
16215 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16216 CHECK_ACCESS(_res_ptr);
16217 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(_res_ptr);
16219 CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_free(_res_conv);
16222 static inline uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ *NONNULL_PTR arg) {
16223 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16224 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(arg);
16225 return (uint32_t)ret_conv;
16227 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(uint32_t arg) {
16228 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(arg & ~1);
16229 uint32_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone_ptr(arg_conv);
16233 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(uint32_t orig) {
16234 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ*)(orig & ~1);
16235 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
16236 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZNoneZ_clone(orig_conv);
16237 return (uint32_t)ret_conv;
16240 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(uint32_t o) {
16241 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16242 CHECK_ACCESS(o_ptr);
16243 LDKC2Tuple_PaymentHashPaymentSecretZ o_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(o_ptr);
16244 o_conv = C2Tuple_PaymentHashPaymentSecretZ_clone((LDKC2Tuple_PaymentHashPaymentSecretZ*)(((uintptr_t)o) & ~1));
16245 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16246 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_ok(o_conv);
16247 return (uint32_t)ret_conv;
16250 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(uint32_t e) {
16251 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16252 CHECK_ACCESS(e_ptr);
16253 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16254 e_conv = APIError_clone((LDKAPIError*)(((uintptr_t)e) & ~1));
16255 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16256 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_err(e_conv);
16257 return (uint32_t)ret_conv;
16260 jboolean __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(uint32_t o) {
16261 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* o_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(o & ~1);
16262 jboolean ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_is_ok(o_conv);
16266 void __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(uint32_t _res) {
16267 if ((_res & 1) != 0) return;
16268 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16269 CHECK_ACCESS(_res_ptr);
16270 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(_res_ptr);
16272 CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_free(_res_conv);
16275 static inline uintptr_t CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ *NONNULL_PTR arg) {
16276 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16277 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(arg);
16278 return (uint32_t)ret_conv;
16280 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(uint32_t arg) {
16281 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* arg_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(arg & ~1);
16282 uint32_t ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone_ptr(arg_conv);
16286 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone"))) TS_CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(uint32_t orig) {
16287 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ*)(orig & ~1);
16288 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
16289 *ret_conv = CResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ_clone(orig_conv);
16290 return (uint32_t)ret_conv;
16293 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_ok"))) TS_CResult_PaymentSecretNoneZ_ok(int8_tArray o) {
16294 LDKThirtyTwoBytes o_ref;
16295 CHECK(o->arr_len == 32);
16296 memcpy(o_ref.data, o->elems, 32); FREE(o);
16297 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16298 *ret_conv = CResult_PaymentSecretNoneZ_ok(o_ref);
16299 return (uint32_t)ret_conv;
16302 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_err"))) TS_CResult_PaymentSecretNoneZ_err() {
16303 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16304 *ret_conv = CResult_PaymentSecretNoneZ_err();
16305 return (uint32_t)ret_conv;
16308 jboolean __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_is_ok"))) TS_CResult_PaymentSecretNoneZ_is_ok(uint32_t o) {
16309 LDKCResult_PaymentSecretNoneZ* o_conv = (LDKCResult_PaymentSecretNoneZ*)(o & ~1);
16310 jboolean ret_conv = CResult_PaymentSecretNoneZ_is_ok(o_conv);
16314 void __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_free"))) TS_CResult_PaymentSecretNoneZ_free(uint32_t _res) {
16315 if ((_res & 1) != 0) return;
16316 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16317 CHECK_ACCESS(_res_ptr);
16318 LDKCResult_PaymentSecretNoneZ _res_conv = *(LDKCResult_PaymentSecretNoneZ*)(_res_ptr);
16320 CResult_PaymentSecretNoneZ_free(_res_conv);
16323 static inline uintptr_t CResult_PaymentSecretNoneZ_clone_ptr(LDKCResult_PaymentSecretNoneZ *NONNULL_PTR arg) {
16324 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16325 *ret_conv = CResult_PaymentSecretNoneZ_clone(arg);
16326 return (uint32_t)ret_conv;
16328 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone_ptr"))) TS_CResult_PaymentSecretNoneZ_clone_ptr(uint32_t arg) {
16329 LDKCResult_PaymentSecretNoneZ* arg_conv = (LDKCResult_PaymentSecretNoneZ*)(arg & ~1);
16330 uint32_t ret_conv = CResult_PaymentSecretNoneZ_clone_ptr(arg_conv);
16334 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretNoneZ_clone"))) TS_CResult_PaymentSecretNoneZ_clone(uint32_t orig) {
16335 LDKCResult_PaymentSecretNoneZ* orig_conv = (LDKCResult_PaymentSecretNoneZ*)(orig & ~1);
16336 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
16337 *ret_conv = CResult_PaymentSecretNoneZ_clone(orig_conv);
16338 return (uint32_t)ret_conv;
16341 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_ok"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
16342 LDKThirtyTwoBytes o_ref;
16343 CHECK(o->arr_len == 32);
16344 memcpy(o_ref.data, o->elems, 32); FREE(o);
16345 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16346 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
16347 return (uint32_t)ret_conv;
16350 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_err"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint32_t e) {
16351 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16352 CHECK_ACCESS(e_ptr);
16353 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16354 e_conv = APIError_clone((LDKAPIError*)(((uintptr_t)e) & ~1));
16355 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16356 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
16357 return (uint32_t)ret_conv;
16360 jboolean __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_is_ok"))) TS_CResult_PaymentSecretAPIErrorZ_is_ok(uint32_t o) {
16361 LDKCResult_PaymentSecretAPIErrorZ* o_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(o & ~1);
16362 jboolean ret_conv = CResult_PaymentSecretAPIErrorZ_is_ok(o_conv);
16366 void __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_free"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint32_t _res) {
16367 if ((_res & 1) != 0) return;
16368 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16369 CHECK_ACCESS(_res_ptr);
16370 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(_res_ptr);
16372 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
16375 static inline uintptr_t CResult_PaymentSecretAPIErrorZ_clone_ptr(LDKCResult_PaymentSecretAPIErrorZ *NONNULL_PTR arg) {
16376 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16377 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(arg);
16378 return (uint32_t)ret_conv;
16380 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone_ptr"))) TS_CResult_PaymentSecretAPIErrorZ_clone_ptr(uint32_t arg) {
16381 LDKCResult_PaymentSecretAPIErrorZ* arg_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
16382 uint32_t ret_conv = CResult_PaymentSecretAPIErrorZ_clone_ptr(arg_conv);
16386 uint32_t __attribute__((export_name("TS_CResult_PaymentSecretAPIErrorZ_clone"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint32_t orig) {
16387 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
16388 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
16389 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
16390 return (uint32_t)ret_conv;
16393 uint32_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_ok(int8_tArray o) {
16394 LDKThirtyTwoBytes o_ref;
16395 CHECK(o->arr_len == 32);
16396 memcpy(o_ref.data, o->elems, 32); FREE(o);
16397 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
16398 *ret_conv = CResult_PaymentPreimageAPIErrorZ_ok(o_ref);
16399 return (uint32_t)ret_conv;
16402 uint32_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_err"))) TS_CResult_PaymentPreimageAPIErrorZ_err(uint32_t e) {
16403 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16404 CHECK_ACCESS(e_ptr);
16405 LDKAPIError e_conv = *(LDKAPIError*)(e_ptr);
16406 e_conv = APIError_clone((LDKAPIError*)(((uintptr_t)e) & ~1));
16407 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
16408 *ret_conv = CResult_PaymentPreimageAPIErrorZ_err(e_conv);
16409 return (uint32_t)ret_conv;
16412 jboolean __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_is_ok"))) TS_CResult_PaymentPreimageAPIErrorZ_is_ok(uint32_t o) {
16413 LDKCResult_PaymentPreimageAPIErrorZ* o_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)(o & ~1);
16414 jboolean ret_conv = CResult_PaymentPreimageAPIErrorZ_is_ok(o_conv);
16418 void __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_free"))) TS_CResult_PaymentPreimageAPIErrorZ_free(uint32_t _res) {
16419 if ((_res & 1) != 0) return;
16420 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16421 CHECK_ACCESS(_res_ptr);
16422 LDKCResult_PaymentPreimageAPIErrorZ _res_conv = *(LDKCResult_PaymentPreimageAPIErrorZ*)(_res_ptr);
16424 CResult_PaymentPreimageAPIErrorZ_free(_res_conv);
16427 static inline uintptr_t CResult_PaymentPreimageAPIErrorZ_clone_ptr(LDKCResult_PaymentPreimageAPIErrorZ *NONNULL_PTR arg) {
16428 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
16429 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(arg);
16430 return (uint32_t)ret_conv;
16432 uint32_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr"))) TS_CResult_PaymentPreimageAPIErrorZ_clone_ptr(uint32_t arg) {
16433 LDKCResult_PaymentPreimageAPIErrorZ* arg_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)(arg & ~1);
16434 uint32_t ret_conv = CResult_PaymentPreimageAPIErrorZ_clone_ptr(arg_conv);
16438 uint32_t __attribute__((export_name("TS_CResult_PaymentPreimageAPIErrorZ_clone"))) TS_CResult_PaymentPreimageAPIErrorZ_clone(uint32_t orig) {
16439 LDKCResult_PaymentPreimageAPIErrorZ* orig_conv = (LDKCResult_PaymentPreimageAPIErrorZ*)(orig & ~1);
16440 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
16441 *ret_conv = CResult_PaymentPreimageAPIErrorZ_clone(orig_conv);
16442 return (uint32_t)ret_conv;
16445 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(uint32_t o) {
16446 LDKCounterpartyForwardingInfo o_conv;
16447 o_conv.inner = (void*)(o & (~1));
16448 o_conv.is_owned = (o & 1) || (o == 0);
16449 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16450 o_conv = CounterpartyForwardingInfo_clone(&o_conv);
16451 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
16452 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_ok(o_conv);
16453 return (uint32_t)ret_conv;
16456 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_err(uint32_t e) {
16457 LDKDecodeError e_conv;
16458 e_conv.inner = (void*)(e & (~1));
16459 e_conv.is_owned = (e & 1) || (e == 0);
16460 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16461 e_conv = DecodeError_clone(&e_conv);
16462 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
16463 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_err(e_conv);
16464 return (uint32_t)ret_conv;
16467 jboolean __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(uint32_t o) {
16468 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* o_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(o & ~1);
16469 jboolean ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_is_ok(o_conv);
16473 void __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_free(uint32_t _res) {
16474 if ((_res & 1) != 0) return;
16475 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16476 CHECK_ACCESS(_res_ptr);
16477 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(_res_ptr);
16479 CResult_CounterpartyForwardingInfoDecodeErrorZ_free(_res_conv);
16482 static inline uintptr_t CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ *NONNULL_PTR arg) {
16483 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
16484 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(arg);
16485 return (uint32_t)ret_conv;
16487 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(uint32_t arg) {
16488 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* arg_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(arg & ~1);
16489 uint32_t ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone_ptr(arg_conv);
16493 uint32_t __attribute__((export_name("TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone"))) TS_CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(uint32_t orig) {
16494 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyForwardingInfoDecodeErrorZ*)(orig & ~1);
16495 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
16496 *ret_conv = CResult_CounterpartyForwardingInfoDecodeErrorZ_clone(orig_conv);
16497 return (uint32_t)ret_conv;
16500 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_ok(uint32_t o) {
16501 LDKChannelCounterparty o_conv;
16502 o_conv.inner = (void*)(o & (~1));
16503 o_conv.is_owned = (o & 1) || (o == 0);
16504 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16505 o_conv = ChannelCounterparty_clone(&o_conv);
16506 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
16507 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_ok(o_conv);
16508 return (uint32_t)ret_conv;
16511 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_err"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_err(uint32_t e) {
16512 LDKDecodeError e_conv;
16513 e_conv.inner = (void*)(e & (~1));
16514 e_conv.is_owned = (e & 1) || (e == 0);
16515 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16516 e_conv = DecodeError_clone(&e_conv);
16517 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
16518 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_err(e_conv);
16519 return (uint32_t)ret_conv;
16522 jboolean __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_is_ok(uint32_t o) {
16523 LDKCResult_ChannelCounterpartyDecodeErrorZ* o_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)(o & ~1);
16524 jboolean ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_is_ok(o_conv);
16528 void __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_free"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_free(uint32_t _res) {
16529 if ((_res & 1) != 0) return;
16530 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16531 CHECK_ACCESS(_res_ptr);
16532 LDKCResult_ChannelCounterpartyDecodeErrorZ _res_conv = *(LDKCResult_ChannelCounterpartyDecodeErrorZ*)(_res_ptr);
16534 CResult_ChannelCounterpartyDecodeErrorZ_free(_res_conv);
16537 static inline uintptr_t CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(LDKCResult_ChannelCounterpartyDecodeErrorZ *NONNULL_PTR arg) {
16538 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
16539 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(arg);
16540 return (uint32_t)ret_conv;
16542 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(uint32_t arg) {
16543 LDKCResult_ChannelCounterpartyDecodeErrorZ* arg_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)(arg & ~1);
16544 uint32_t ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone_ptr(arg_conv);
16548 uint32_t __attribute__((export_name("TS_CResult_ChannelCounterpartyDecodeErrorZ_clone"))) TS_CResult_ChannelCounterpartyDecodeErrorZ_clone(uint32_t orig) {
16549 LDKCResult_ChannelCounterpartyDecodeErrorZ* orig_conv = (LDKCResult_ChannelCounterpartyDecodeErrorZ*)(orig & ~1);
16550 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
16551 *ret_conv = CResult_ChannelCounterpartyDecodeErrorZ_clone(orig_conv);
16552 return (uint32_t)ret_conv;
16555 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_ok(uint32_t o) {
16556 LDKChannelDetails o_conv;
16557 o_conv.inner = (void*)(o & (~1));
16558 o_conv.is_owned = (o & 1) || (o == 0);
16559 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16560 o_conv = ChannelDetails_clone(&o_conv);
16561 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
16562 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_ok(o_conv);
16563 return (uint32_t)ret_conv;
16566 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_err"))) TS_CResult_ChannelDetailsDecodeErrorZ_err(uint32_t e) {
16567 LDKDecodeError e_conv;
16568 e_conv.inner = (void*)(e & (~1));
16569 e_conv.is_owned = (e & 1) || (e == 0);
16570 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16571 e_conv = DecodeError_clone(&e_conv);
16572 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
16573 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_err(e_conv);
16574 return (uint32_t)ret_conv;
16577 jboolean __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_is_ok"))) TS_CResult_ChannelDetailsDecodeErrorZ_is_ok(uint32_t o) {
16578 LDKCResult_ChannelDetailsDecodeErrorZ* o_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)(o & ~1);
16579 jboolean ret_conv = CResult_ChannelDetailsDecodeErrorZ_is_ok(o_conv);
16583 void __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_free"))) TS_CResult_ChannelDetailsDecodeErrorZ_free(uint32_t _res) {
16584 if ((_res & 1) != 0) return;
16585 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16586 CHECK_ACCESS(_res_ptr);
16587 LDKCResult_ChannelDetailsDecodeErrorZ _res_conv = *(LDKCResult_ChannelDetailsDecodeErrorZ*)(_res_ptr);
16589 CResult_ChannelDetailsDecodeErrorZ_free(_res_conv);
16592 static inline uintptr_t CResult_ChannelDetailsDecodeErrorZ_clone_ptr(LDKCResult_ChannelDetailsDecodeErrorZ *NONNULL_PTR arg) {
16593 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
16594 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(arg);
16595 return (uint32_t)ret_conv;
16597 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone_ptr(uint32_t arg) {
16598 LDKCResult_ChannelDetailsDecodeErrorZ* arg_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)(arg & ~1);
16599 uint32_t ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone_ptr(arg_conv);
16603 uint32_t __attribute__((export_name("TS_CResult_ChannelDetailsDecodeErrorZ_clone"))) TS_CResult_ChannelDetailsDecodeErrorZ_clone(uint32_t orig) {
16604 LDKCResult_ChannelDetailsDecodeErrorZ* orig_conv = (LDKCResult_ChannelDetailsDecodeErrorZ*)(orig & ~1);
16605 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
16606 *ret_conv = CResult_ChannelDetailsDecodeErrorZ_clone(orig_conv);
16607 return (uint32_t)ret_conv;
16610 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_ok(uint32_t o) {
16611 LDKPhantomRouteHints o_conv;
16612 o_conv.inner = (void*)(o & (~1));
16613 o_conv.is_owned = (o & 1) || (o == 0);
16614 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16615 o_conv = PhantomRouteHints_clone(&o_conv);
16616 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
16617 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_ok(o_conv);
16618 return (uint32_t)ret_conv;
16621 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_err"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_err(uint32_t e) {
16622 LDKDecodeError e_conv;
16623 e_conv.inner = (void*)(e & (~1));
16624 e_conv.is_owned = (e & 1) || (e == 0);
16625 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16626 e_conv = DecodeError_clone(&e_conv);
16627 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
16628 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_err(e_conv);
16629 return (uint32_t)ret_conv;
16632 jboolean __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_is_ok(uint32_t o) {
16633 LDKCResult_PhantomRouteHintsDecodeErrorZ* o_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)(o & ~1);
16634 jboolean ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_is_ok(o_conv);
16638 void __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_free"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_free(uint32_t _res) {
16639 if ((_res & 1) != 0) return;
16640 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16641 CHECK_ACCESS(_res_ptr);
16642 LDKCResult_PhantomRouteHintsDecodeErrorZ _res_conv = *(LDKCResult_PhantomRouteHintsDecodeErrorZ*)(_res_ptr);
16644 CResult_PhantomRouteHintsDecodeErrorZ_free(_res_conv);
16647 static inline uintptr_t CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(LDKCResult_PhantomRouteHintsDecodeErrorZ *NONNULL_PTR arg) {
16648 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
16649 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(arg);
16650 return (uint32_t)ret_conv;
16652 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(uint32_t arg) {
16653 LDKCResult_PhantomRouteHintsDecodeErrorZ* arg_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)(arg & ~1);
16654 uint32_t ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone_ptr(arg_conv);
16658 uint32_t __attribute__((export_name("TS_CResult_PhantomRouteHintsDecodeErrorZ_clone"))) TS_CResult_PhantomRouteHintsDecodeErrorZ_clone(uint32_t orig) {
16659 LDKCResult_PhantomRouteHintsDecodeErrorZ* orig_conv = (LDKCResult_PhantomRouteHintsDecodeErrorZ*)(orig & ~1);
16660 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
16661 *ret_conv = CResult_PhantomRouteHintsDecodeErrorZ_clone(orig_conv);
16662 return (uint32_t)ret_conv;
16665 void __attribute__((export_name("TS_CVec_ChannelMonitorZ_free"))) TS_CVec_ChannelMonitorZ_free(uint32_tArray _res) {
16666 LDKCVec_ChannelMonitorZ _res_constr;
16667 _res_constr.datalen = _res->arr_len;
16668 if (_res_constr.datalen > 0)
16669 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
16671 _res_constr.data = NULL;
16672 uint32_t* _res_vals = _res->elems;
16673 for (size_t q = 0; q < _res_constr.datalen; q++) {
16674 uint32_t _res_conv_16 = _res_vals[q];
16675 LDKChannelMonitor _res_conv_16_conv;
16676 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
16677 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
16678 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
16679 _res_constr.data[q] = _res_conv_16_conv;
16682 CVec_ChannelMonitorZ_free(_res_constr);
16685 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_new"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint32_t b) {
16686 LDKThirtyTwoBytes a_ref;
16687 CHECK(a->arr_len == 32);
16688 memcpy(a_ref.data, a->elems, 32); FREE(a);
16689 LDKChannelManager b_conv;
16690 b_conv.inner = (void*)(b & (~1));
16691 b_conv.is_owned = (b & 1) || (b == 0);
16692 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
16693 // WARNING: we need a move here but no clone is available for LDKChannelManager
16694 LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
16695 *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
16696 return ((uint32_t)ret_conv);
16699 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_free"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint32_t _res) {
16700 if ((_res & 1) != 0) return;
16701 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16702 CHECK_ACCESS(_res_ptr);
16703 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(_res_ptr);
16705 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
16708 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint32_t o) {
16709 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16710 CHECK_ACCESS(o_ptr);
16711 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(o_ptr);
16712 // WARNING: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ
16713 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
16714 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
16715 return (uint32_t)ret_conv;
16718 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint32_t e) {
16719 LDKDecodeError e_conv;
16720 e_conv.inner = (void*)(e & (~1));
16721 e_conv.is_owned = (e & 1) || (e == 0);
16722 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16723 e_conv = DecodeError_clone(&e_conv);
16724 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
16725 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
16726 return (uint32_t)ret_conv;
16729 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(uint32_t o) {
16730 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(o & ~1);
16731 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_is_ok(o_conv);
16735 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint32_t _res) {
16736 if ((_res & 1) != 0) return;
16737 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16738 CHECK_ACCESS(_res_ptr);
16739 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(_res_ptr);
16741 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
16744 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint32_t o) {
16745 LDKChannelConfig o_conv;
16746 o_conv.inner = (void*)(o & (~1));
16747 o_conv.is_owned = (o & 1) || (o == 0);
16748 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16749 o_conv = ChannelConfig_clone(&o_conv);
16750 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
16751 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
16752 return (uint32_t)ret_conv;
16755 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_err"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint32_t e) {
16756 LDKDecodeError e_conv;
16757 e_conv.inner = (void*)(e & (~1));
16758 e_conv.is_owned = (e & 1) || (e == 0);
16759 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16760 e_conv = DecodeError_clone(&e_conv);
16761 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
16762 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
16763 return (uint32_t)ret_conv;
16766 jboolean __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_is_ok"))) TS_CResult_ChannelConfigDecodeErrorZ_is_ok(uint32_t o) {
16767 LDKCResult_ChannelConfigDecodeErrorZ* o_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(o & ~1);
16768 jboolean ret_conv = CResult_ChannelConfigDecodeErrorZ_is_ok(o_conv);
16772 void __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_free"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
16773 if ((_res & 1) != 0) return;
16774 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16775 CHECK_ACCESS(_res_ptr);
16776 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(_res_ptr);
16778 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
16781 static inline uintptr_t CResult_ChannelConfigDecodeErrorZ_clone_ptr(LDKCResult_ChannelConfigDecodeErrorZ *NONNULL_PTR arg) {
16782 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
16783 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(arg);
16784 return (uint32_t)ret_conv;
16786 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelConfigDecodeErrorZ_clone_ptr(uint32_t arg) {
16787 LDKCResult_ChannelConfigDecodeErrorZ* arg_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
16788 uint32_t ret_conv = CResult_ChannelConfigDecodeErrorZ_clone_ptr(arg_conv);
16792 uint32_t __attribute__((export_name("TS_CResult_ChannelConfigDecodeErrorZ_clone"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
16793 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
16794 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
16795 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
16796 return (uint32_t)ret_conv;
16799 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_ok"))) TS_CResult_OutPointDecodeErrorZ_ok(uint32_t o) {
16800 LDKOutPoint o_conv;
16801 o_conv.inner = (void*)(o & (~1));
16802 o_conv.is_owned = (o & 1) || (o == 0);
16803 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
16804 o_conv = OutPoint_clone(&o_conv);
16805 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
16806 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
16807 return (uint32_t)ret_conv;
16810 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_err"))) TS_CResult_OutPointDecodeErrorZ_err(uint32_t e) {
16811 LDKDecodeError e_conv;
16812 e_conv.inner = (void*)(e & (~1));
16813 e_conv.is_owned = (e & 1) || (e == 0);
16814 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16815 e_conv = DecodeError_clone(&e_conv);
16816 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
16817 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
16818 return (uint32_t)ret_conv;
16821 jboolean __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_is_ok"))) TS_CResult_OutPointDecodeErrorZ_is_ok(uint32_t o) {
16822 LDKCResult_OutPointDecodeErrorZ* o_conv = (LDKCResult_OutPointDecodeErrorZ*)(o & ~1);
16823 jboolean ret_conv = CResult_OutPointDecodeErrorZ_is_ok(o_conv);
16827 void __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_free"))) TS_CResult_OutPointDecodeErrorZ_free(uint32_t _res) {
16828 if ((_res & 1) != 0) return;
16829 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16830 CHECK_ACCESS(_res_ptr);
16831 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(_res_ptr);
16833 CResult_OutPointDecodeErrorZ_free(_res_conv);
16836 static inline uintptr_t CResult_OutPointDecodeErrorZ_clone_ptr(LDKCResult_OutPointDecodeErrorZ *NONNULL_PTR arg) {
16837 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
16838 *ret_conv = CResult_OutPointDecodeErrorZ_clone(arg);
16839 return (uint32_t)ret_conv;
16841 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone_ptr"))) TS_CResult_OutPointDecodeErrorZ_clone_ptr(uint32_t arg) {
16842 LDKCResult_OutPointDecodeErrorZ* arg_conv = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
16843 uint32_t ret_conv = CResult_OutPointDecodeErrorZ_clone_ptr(arg_conv);
16847 uint32_t __attribute__((export_name("TS_CResult_OutPointDecodeErrorZ_clone"))) TS_CResult_OutPointDecodeErrorZ_clone(uint32_t orig) {
16848 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
16849 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
16850 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
16851 return (uint32_t)ret_conv;
16854 uint32_t __attribute__((export_name("TS_COption_TypeZ_some"))) TS_COption_TypeZ_some(uint32_t o) {
16855 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16856 CHECK_ACCESS(o_ptr);
16857 LDKType o_conv = *(LDKType*)(o_ptr);
16858 if (o_conv.free == LDKType_JCalls_free) {
16859 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
16860 LDKType_JCalls_cloned(&o_conv);
16862 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
16863 *ret_copy = COption_TypeZ_some(o_conv);
16864 uint32_t ret_ref = (uintptr_t)ret_copy;
16868 uint32_t __attribute__((export_name("TS_COption_TypeZ_none"))) TS_COption_TypeZ_none() {
16869 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
16870 *ret_copy = COption_TypeZ_none();
16871 uint32_t ret_ref = (uintptr_t)ret_copy;
16875 void __attribute__((export_name("TS_COption_TypeZ_free"))) TS_COption_TypeZ_free(uint32_t _res) {
16876 if ((_res & 1) != 0) return;
16877 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16878 CHECK_ACCESS(_res_ptr);
16879 LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(_res_ptr);
16881 COption_TypeZ_free(_res_conv);
16884 static inline uintptr_t COption_TypeZ_clone_ptr(LDKCOption_TypeZ *NONNULL_PTR arg) {
16885 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
16886 *ret_copy = COption_TypeZ_clone(arg);
16887 uint32_t ret_ref = (uintptr_t)ret_copy;
16890 uint32_t __attribute__((export_name("TS_COption_TypeZ_clone_ptr"))) TS_COption_TypeZ_clone_ptr(uint32_t arg) {
16891 LDKCOption_TypeZ* arg_conv = (LDKCOption_TypeZ*)arg;
16892 uint32_t ret_conv = COption_TypeZ_clone_ptr(arg_conv);
16896 uint32_t __attribute__((export_name("TS_COption_TypeZ_clone"))) TS_COption_TypeZ_clone(uint32_t orig) {
16897 LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig;
16898 LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ");
16899 *ret_copy = COption_TypeZ_clone(orig_conv);
16900 uint32_t ret_ref = (uintptr_t)ret_copy;
16904 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint32_t o) {
16905 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
16906 CHECK_ACCESS(o_ptr);
16907 LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(o_ptr);
16908 o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)(((uintptr_t)o) & ~1));
16909 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
16910 *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv);
16911 return (uint32_t)ret_conv;
16914 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_err"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint32_t e) {
16915 LDKDecodeError e_conv;
16916 e_conv.inner = (void*)(e & (~1));
16917 e_conv.is_owned = (e & 1) || (e == 0);
16918 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
16919 e_conv = DecodeError_clone(&e_conv);
16920 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
16921 *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv);
16922 return (uint32_t)ret_conv;
16925 jboolean __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_is_ok"))) TS_CResult_COption_TypeZDecodeErrorZ_is_ok(uint32_t o) {
16926 LDKCResult_COption_TypeZDecodeErrorZ* o_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(o & ~1);
16927 jboolean ret_conv = CResult_COption_TypeZDecodeErrorZ_is_ok(o_conv);
16931 void __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_free"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint32_t _res) {
16932 if ((_res & 1) != 0) return;
16933 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16934 CHECK_ACCESS(_res_ptr);
16935 LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(_res_ptr);
16937 CResult_COption_TypeZDecodeErrorZ_free(_res_conv);
16940 static inline uintptr_t CResult_COption_TypeZDecodeErrorZ_clone_ptr(LDKCResult_COption_TypeZDecodeErrorZ *NONNULL_PTR arg) {
16941 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
16942 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(arg);
16943 return (uint32_t)ret_conv;
16945 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_TypeZDecodeErrorZ_clone_ptr(uint32_t arg) {
16946 LDKCResult_COption_TypeZDecodeErrorZ* arg_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1);
16947 uint32_t ret_conv = CResult_COption_TypeZDecodeErrorZ_clone_ptr(arg_conv);
16951 uint32_t __attribute__((export_name("TS_CResult_COption_TypeZDecodeErrorZ_clone"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint32_t orig) {
16952 LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1);
16953 LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ");
16954 *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv);
16955 return (uint32_t)ret_conv;
16958 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_ok"))) TS_CResult_PaymentIdPaymentErrorZ_ok(int8_tArray o) {
16959 LDKThirtyTwoBytes o_ref;
16960 CHECK(o->arr_len == 32);
16961 memcpy(o_ref.data, o->elems, 32); FREE(o);
16962 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
16963 *ret_conv = CResult_PaymentIdPaymentErrorZ_ok(o_ref);
16964 return (uint32_t)ret_conv;
16967 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_err"))) TS_CResult_PaymentIdPaymentErrorZ_err(uint32_t e) {
16968 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
16969 CHECK_ACCESS(e_ptr);
16970 LDKPaymentError e_conv = *(LDKPaymentError*)(e_ptr);
16971 e_conv = PaymentError_clone((LDKPaymentError*)(((uintptr_t)e) & ~1));
16972 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
16973 *ret_conv = CResult_PaymentIdPaymentErrorZ_err(e_conv);
16974 return (uint32_t)ret_conv;
16977 jboolean __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_is_ok"))) TS_CResult_PaymentIdPaymentErrorZ_is_ok(uint32_t o) {
16978 LDKCResult_PaymentIdPaymentErrorZ* o_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(o & ~1);
16979 jboolean ret_conv = CResult_PaymentIdPaymentErrorZ_is_ok(o_conv);
16983 void __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_free"))) TS_CResult_PaymentIdPaymentErrorZ_free(uint32_t _res) {
16984 if ((_res & 1) != 0) return;
16985 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
16986 CHECK_ACCESS(_res_ptr);
16987 LDKCResult_PaymentIdPaymentErrorZ _res_conv = *(LDKCResult_PaymentIdPaymentErrorZ*)(_res_ptr);
16989 CResult_PaymentIdPaymentErrorZ_free(_res_conv);
16992 static inline uintptr_t CResult_PaymentIdPaymentErrorZ_clone_ptr(LDKCResult_PaymentIdPaymentErrorZ *NONNULL_PTR arg) {
16993 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
16994 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(arg);
16995 return (uint32_t)ret_conv;
16997 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone_ptr"))) TS_CResult_PaymentIdPaymentErrorZ_clone_ptr(uint32_t arg) {
16998 LDKCResult_PaymentIdPaymentErrorZ* arg_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(arg & ~1);
16999 uint32_t ret_conv = CResult_PaymentIdPaymentErrorZ_clone_ptr(arg_conv);
17003 uint32_t __attribute__((export_name("TS_CResult_PaymentIdPaymentErrorZ_clone"))) TS_CResult_PaymentIdPaymentErrorZ_clone(uint32_t orig) {
17004 LDKCResult_PaymentIdPaymentErrorZ* orig_conv = (LDKCResult_PaymentIdPaymentErrorZ*)(orig & ~1);
17005 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
17006 *ret_conv = CResult_PaymentIdPaymentErrorZ_clone(orig_conv);
17007 return (uint32_t)ret_conv;
17010 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_ok"))) TS_CResult_SiPrefixParseErrorZ_ok(uint32_t o) {
17011 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
17012 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
17013 *ret_conv = CResult_SiPrefixParseErrorZ_ok(o_conv);
17014 return (uint32_t)ret_conv;
17017 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_err"))) TS_CResult_SiPrefixParseErrorZ_err(uint32_t e) {
17018 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
17019 CHECK_ACCESS(e_ptr);
17020 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
17021 e_conv = ParseError_clone((LDKParseError*)(((uintptr_t)e) & ~1));
17022 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
17023 *ret_conv = CResult_SiPrefixParseErrorZ_err(e_conv);
17024 return (uint32_t)ret_conv;
17027 jboolean __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_is_ok"))) TS_CResult_SiPrefixParseErrorZ_is_ok(uint32_t o) {
17028 LDKCResult_SiPrefixParseErrorZ* o_conv = (LDKCResult_SiPrefixParseErrorZ*)(o & ~1);
17029 jboolean ret_conv = CResult_SiPrefixParseErrorZ_is_ok(o_conv);
17033 void __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_free"))) TS_CResult_SiPrefixParseErrorZ_free(uint32_t _res) {
17034 if ((_res & 1) != 0) return;
17035 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17036 CHECK_ACCESS(_res_ptr);
17037 LDKCResult_SiPrefixParseErrorZ _res_conv = *(LDKCResult_SiPrefixParseErrorZ*)(_res_ptr);
17039 CResult_SiPrefixParseErrorZ_free(_res_conv);
17042 static inline uintptr_t CResult_SiPrefixParseErrorZ_clone_ptr(LDKCResult_SiPrefixParseErrorZ *NONNULL_PTR arg) {
17043 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
17044 *ret_conv = CResult_SiPrefixParseErrorZ_clone(arg);
17045 return (uint32_t)ret_conv;
17047 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone_ptr"))) TS_CResult_SiPrefixParseErrorZ_clone_ptr(uint32_t arg) {
17048 LDKCResult_SiPrefixParseErrorZ* arg_conv = (LDKCResult_SiPrefixParseErrorZ*)(arg & ~1);
17049 uint32_t ret_conv = CResult_SiPrefixParseErrorZ_clone_ptr(arg_conv);
17053 uint32_t __attribute__((export_name("TS_CResult_SiPrefixParseErrorZ_clone"))) TS_CResult_SiPrefixParseErrorZ_clone(uint32_t orig) {
17054 LDKCResult_SiPrefixParseErrorZ* orig_conv = (LDKCResult_SiPrefixParseErrorZ*)(orig & ~1);
17055 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
17056 *ret_conv = CResult_SiPrefixParseErrorZ_clone(orig_conv);
17057 return (uint32_t)ret_conv;
17060 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_ok(uint32_t o) {
17062 o_conv.inner = (void*)(o & (~1));
17063 o_conv.is_owned = (o & 1) || (o == 0);
17064 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17065 o_conv = Invoice_clone(&o_conv);
17066 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
17067 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_ok(o_conv);
17068 return (uint32_t)ret_conv;
17071 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_err"))) TS_CResult_InvoiceParseOrSemanticErrorZ_err(uint32_t e) {
17072 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
17073 CHECK_ACCESS(e_ptr);
17074 LDKParseOrSemanticError e_conv = *(LDKParseOrSemanticError*)(e_ptr);
17075 e_conv = ParseOrSemanticError_clone((LDKParseOrSemanticError*)(((uintptr_t)e) & ~1));
17076 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
17077 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_err(e_conv);
17078 return (uint32_t)ret_conv;
17081 jboolean __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok"))) TS_CResult_InvoiceParseOrSemanticErrorZ_is_ok(uint32_t o) {
17082 LDKCResult_InvoiceParseOrSemanticErrorZ* o_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)(o & ~1);
17083 jboolean ret_conv = CResult_InvoiceParseOrSemanticErrorZ_is_ok(o_conv);
17087 void __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_free"))) TS_CResult_InvoiceParseOrSemanticErrorZ_free(uint32_t _res) {
17088 if ((_res & 1) != 0) return;
17089 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17090 CHECK_ACCESS(_res_ptr);
17091 LDKCResult_InvoiceParseOrSemanticErrorZ _res_conv = *(LDKCResult_InvoiceParseOrSemanticErrorZ*)(_res_ptr);
17093 CResult_InvoiceParseOrSemanticErrorZ_free(_res_conv);
17096 static inline uintptr_t CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(LDKCResult_InvoiceParseOrSemanticErrorZ *NONNULL_PTR arg) {
17097 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
17098 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(arg);
17099 return (uint32_t)ret_conv;
17101 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(uint32_t arg) {
17102 LDKCResult_InvoiceParseOrSemanticErrorZ* arg_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)(arg & ~1);
17103 uint32_t ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone_ptr(arg_conv);
17107 uint32_t __attribute__((export_name("TS_CResult_InvoiceParseOrSemanticErrorZ_clone"))) TS_CResult_InvoiceParseOrSemanticErrorZ_clone(uint32_t orig) {
17108 LDKCResult_InvoiceParseOrSemanticErrorZ* orig_conv = (LDKCResult_InvoiceParseOrSemanticErrorZ*)(orig & ~1);
17109 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
17110 *ret_conv = CResult_InvoiceParseOrSemanticErrorZ_clone(orig_conv);
17111 return (uint32_t)ret_conv;
17114 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_ok(uint32_t o) {
17115 LDKSignedRawInvoice o_conv;
17116 o_conv.inner = (void*)(o & (~1));
17117 o_conv.is_owned = (o & 1) || (o == 0);
17118 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17119 o_conv = SignedRawInvoice_clone(&o_conv);
17120 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
17121 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_ok(o_conv);
17122 return (uint32_t)ret_conv;
17125 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_err"))) TS_CResult_SignedRawInvoiceParseErrorZ_err(uint32_t e) {
17126 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
17127 CHECK_ACCESS(e_ptr);
17128 LDKParseError e_conv = *(LDKParseError*)(e_ptr);
17129 e_conv = ParseError_clone((LDKParseError*)(((uintptr_t)e) & ~1));
17130 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
17131 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_err(e_conv);
17132 return (uint32_t)ret_conv;
17135 jboolean __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_is_ok"))) TS_CResult_SignedRawInvoiceParseErrorZ_is_ok(uint32_t o) {
17136 LDKCResult_SignedRawInvoiceParseErrorZ* o_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)(o & ~1);
17137 jboolean ret_conv = CResult_SignedRawInvoiceParseErrorZ_is_ok(o_conv);
17141 void __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_free"))) TS_CResult_SignedRawInvoiceParseErrorZ_free(uint32_t _res) {
17142 if ((_res & 1) != 0) return;
17143 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17144 CHECK_ACCESS(_res_ptr);
17145 LDKCResult_SignedRawInvoiceParseErrorZ _res_conv = *(LDKCResult_SignedRawInvoiceParseErrorZ*)(_res_ptr);
17147 CResult_SignedRawInvoiceParseErrorZ_free(_res_conv);
17150 static inline uintptr_t CResult_SignedRawInvoiceParseErrorZ_clone_ptr(LDKCResult_SignedRawInvoiceParseErrorZ *NONNULL_PTR arg) {
17151 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
17152 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(arg);
17153 return (uint32_t)ret_conv;
17155 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone_ptr(uint32_t arg) {
17156 LDKCResult_SignedRawInvoiceParseErrorZ* arg_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)(arg & ~1);
17157 uint32_t ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone_ptr(arg_conv);
17161 uint32_t __attribute__((export_name("TS_CResult_SignedRawInvoiceParseErrorZ_clone"))) TS_CResult_SignedRawInvoiceParseErrorZ_clone(uint32_t orig) {
17162 LDKCResult_SignedRawInvoiceParseErrorZ* orig_conv = (LDKCResult_SignedRawInvoiceParseErrorZ*)(orig & ~1);
17163 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
17164 *ret_conv = CResult_SignedRawInvoiceParseErrorZ_clone(orig_conv);
17165 return (uint32_t)ret_conv;
17168 static inline uintptr_t C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR arg) {
17169 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
17170 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(arg);
17171 return ((uint32_t)ret_conv);
17173 uint32_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(uint32_t arg) {
17174 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* arg_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(arg & ~1);
17175 uint32_t ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone_ptr(arg_conv);
17179 uint32_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) {
17180 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
17181 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
17182 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
17183 return ((uint32_t)ret_conv);
17186 uint32_t __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint32_t a, int8_tArray b, uint32_t c) {
17187 LDKRawInvoice a_conv;
17188 a_conv.inner = (void*)(a & (~1));
17189 a_conv.is_owned = (a & 1) || (a == 0);
17190 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
17191 a_conv = RawInvoice_clone(&a_conv);
17192 LDKThirtyTwoBytes b_ref;
17193 CHECK(b->arr_len == 32);
17194 memcpy(b_ref.data, b->elems, 32); FREE(b);
17195 LDKInvoiceSignature c_conv;
17196 c_conv.inner = (void*)(c & (~1));
17197 c_conv.is_owned = (c & 1) || (c == 0);
17198 CHECK_INNER_FIELD_ACCESS_OR_NULL(c_conv);
17199 c_conv = InvoiceSignature_clone(&c_conv);
17200 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
17201 *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
17202 return ((uint32_t)ret_conv);
17205 void __attribute__((export_name("TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint32_t _res) {
17206 if ((_res & 1) != 0) return;
17207 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17208 CHECK_ACCESS(_res_ptr);
17209 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(_res_ptr);
17211 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
17214 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_ok"))) TS_CResult_PayeePubKeyErrorZ_ok(uint32_t o) {
17215 LDKPayeePubKey o_conv;
17216 o_conv.inner = (void*)(o & (~1));
17217 o_conv.is_owned = (o & 1) || (o == 0);
17218 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17219 o_conv = PayeePubKey_clone(&o_conv);
17220 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
17221 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
17222 return (uint32_t)ret_conv;
17225 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_err"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
17226 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
17227 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
17228 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
17229 return (uint32_t)ret_conv;
17232 jboolean __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_is_ok"))) TS_CResult_PayeePubKeyErrorZ_is_ok(uint32_t o) {
17233 LDKCResult_PayeePubKeyErrorZ* o_conv = (LDKCResult_PayeePubKeyErrorZ*)(o & ~1);
17234 jboolean ret_conv = CResult_PayeePubKeyErrorZ_is_ok(o_conv);
17238 void __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_free"))) TS_CResult_PayeePubKeyErrorZ_free(uint32_t _res) {
17239 if ((_res & 1) != 0) return;
17240 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17241 CHECK_ACCESS(_res_ptr);
17242 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(_res_ptr);
17244 CResult_PayeePubKeyErrorZ_free(_res_conv);
17247 static inline uintptr_t CResult_PayeePubKeyErrorZ_clone_ptr(LDKCResult_PayeePubKeyErrorZ *NONNULL_PTR arg) {
17248 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
17249 *ret_conv = CResult_PayeePubKeyErrorZ_clone(arg);
17250 return (uint32_t)ret_conv;
17252 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone_ptr"))) TS_CResult_PayeePubKeyErrorZ_clone_ptr(uint32_t arg) {
17253 LDKCResult_PayeePubKeyErrorZ* arg_conv = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
17254 uint32_t ret_conv = CResult_PayeePubKeyErrorZ_clone_ptr(arg_conv);
17258 uint32_t __attribute__((export_name("TS_CResult_PayeePubKeyErrorZ_clone"))) TS_CResult_PayeePubKeyErrorZ_clone(uint32_t orig) {
17259 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
17260 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
17261 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
17262 return (uint32_t)ret_conv;
17265 void __attribute__((export_name("TS_CVec_PrivateRouteZ_free"))) TS_CVec_PrivateRouteZ_free(uint32_tArray _res) {
17266 LDKCVec_PrivateRouteZ _res_constr;
17267 _res_constr.datalen = _res->arr_len;
17268 if (_res_constr.datalen > 0)
17269 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
17271 _res_constr.data = NULL;
17272 uint32_t* _res_vals = _res->elems;
17273 for (size_t o = 0; o < _res_constr.datalen; o++) {
17274 uint32_t _res_conv_14 = _res_vals[o];
17275 LDKPrivateRoute _res_conv_14_conv;
17276 _res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
17277 _res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
17278 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_14_conv);
17279 _res_constr.data[o] = _res_conv_14_conv;
17282 CVec_PrivateRouteZ_free(_res_constr);
17285 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint32_t o) {
17286 LDKPositiveTimestamp o_conv;
17287 o_conv.inner = (void*)(o & (~1));
17288 o_conv.is_owned = (o & 1) || (o == 0);
17289 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17290 o_conv = PositiveTimestamp_clone(&o_conv);
17291 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
17292 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
17293 return (uint32_t)ret_conv;
17296 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_err"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
17297 LDKCreationError e_conv = LDKCreationError_from_js(e);
17298 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
17299 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
17300 return (uint32_t)ret_conv;
17303 jboolean __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_is_ok"))) TS_CResult_PositiveTimestampCreationErrorZ_is_ok(uint32_t o) {
17304 LDKCResult_PositiveTimestampCreationErrorZ* o_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(o & ~1);
17305 jboolean ret_conv = CResult_PositiveTimestampCreationErrorZ_is_ok(o_conv);
17309 void __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_free"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint32_t _res) {
17310 if ((_res & 1) != 0) return;
17311 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17312 CHECK_ACCESS(_res_ptr);
17313 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(_res_ptr);
17315 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
17318 static inline uintptr_t CResult_PositiveTimestampCreationErrorZ_clone_ptr(LDKCResult_PositiveTimestampCreationErrorZ *NONNULL_PTR arg) {
17319 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
17320 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(arg);
17321 return (uint32_t)ret_conv;
17323 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr"))) TS_CResult_PositiveTimestampCreationErrorZ_clone_ptr(uint32_t arg) {
17324 LDKCResult_PositiveTimestampCreationErrorZ* arg_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
17325 uint32_t ret_conv = CResult_PositiveTimestampCreationErrorZ_clone_ptr(arg_conv);
17329 uint32_t __attribute__((export_name("TS_CResult_PositiveTimestampCreationErrorZ_clone"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint32_t orig) {
17330 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
17331 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
17332 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
17333 return (uint32_t)ret_conv;
17336 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_ok"))) TS_CResult_NoneSemanticErrorZ_ok() {
17337 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
17338 *ret_conv = CResult_NoneSemanticErrorZ_ok();
17339 return (uint32_t)ret_conv;
17342 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_err"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
17343 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
17344 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
17345 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
17346 return (uint32_t)ret_conv;
17349 jboolean __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_is_ok"))) TS_CResult_NoneSemanticErrorZ_is_ok(uint32_t o) {
17350 LDKCResult_NoneSemanticErrorZ* o_conv = (LDKCResult_NoneSemanticErrorZ*)(o & ~1);
17351 jboolean ret_conv = CResult_NoneSemanticErrorZ_is_ok(o_conv);
17355 void __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_free"))) TS_CResult_NoneSemanticErrorZ_free(uint32_t _res) {
17356 if ((_res & 1) != 0) return;
17357 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17358 CHECK_ACCESS(_res_ptr);
17359 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(_res_ptr);
17361 CResult_NoneSemanticErrorZ_free(_res_conv);
17364 static inline uintptr_t CResult_NoneSemanticErrorZ_clone_ptr(LDKCResult_NoneSemanticErrorZ *NONNULL_PTR arg) {
17365 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
17366 *ret_conv = CResult_NoneSemanticErrorZ_clone(arg);
17367 return (uint32_t)ret_conv;
17369 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone_ptr"))) TS_CResult_NoneSemanticErrorZ_clone_ptr(uint32_t arg) {
17370 LDKCResult_NoneSemanticErrorZ* arg_conv = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
17371 uint32_t ret_conv = CResult_NoneSemanticErrorZ_clone_ptr(arg_conv);
17375 uint32_t __attribute__((export_name("TS_CResult_NoneSemanticErrorZ_clone"))) TS_CResult_NoneSemanticErrorZ_clone(uint32_t orig) {
17376 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
17377 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
17378 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
17379 return (uint32_t)ret_conv;
17382 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_ok"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint32_t o) {
17384 o_conv.inner = (void*)(o & (~1));
17385 o_conv.is_owned = (o & 1) || (o == 0);
17386 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17387 o_conv = Invoice_clone(&o_conv);
17388 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
17389 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
17390 return (uint32_t)ret_conv;
17393 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_err"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
17394 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
17395 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
17396 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
17397 return (uint32_t)ret_conv;
17400 jboolean __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_is_ok"))) TS_CResult_InvoiceSemanticErrorZ_is_ok(uint32_t o) {
17401 LDKCResult_InvoiceSemanticErrorZ* o_conv = (LDKCResult_InvoiceSemanticErrorZ*)(o & ~1);
17402 jboolean ret_conv = CResult_InvoiceSemanticErrorZ_is_ok(o_conv);
17406 void __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_free"))) TS_CResult_InvoiceSemanticErrorZ_free(uint32_t _res) {
17407 if ((_res & 1) != 0) return;
17408 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17409 CHECK_ACCESS(_res_ptr);
17410 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(_res_ptr);
17412 CResult_InvoiceSemanticErrorZ_free(_res_conv);
17415 static inline uintptr_t CResult_InvoiceSemanticErrorZ_clone_ptr(LDKCResult_InvoiceSemanticErrorZ *NONNULL_PTR arg) {
17416 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
17417 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(arg);
17418 return (uint32_t)ret_conv;
17420 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone_ptr"))) TS_CResult_InvoiceSemanticErrorZ_clone_ptr(uint32_t arg) {
17421 LDKCResult_InvoiceSemanticErrorZ* arg_conv = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
17422 uint32_t ret_conv = CResult_InvoiceSemanticErrorZ_clone_ptr(arg_conv);
17426 uint32_t __attribute__((export_name("TS_CResult_InvoiceSemanticErrorZ_clone"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint32_t orig) {
17427 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
17428 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
17429 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
17430 return (uint32_t)ret_conv;
17433 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_ok"))) TS_CResult_DescriptionCreationErrorZ_ok(uint32_t o) {
17434 LDKDescription o_conv;
17435 o_conv.inner = (void*)(o & (~1));
17436 o_conv.is_owned = (o & 1) || (o == 0);
17437 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17438 o_conv = Description_clone(&o_conv);
17439 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
17440 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
17441 return (uint32_t)ret_conv;
17444 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_err"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
17445 LDKCreationError e_conv = LDKCreationError_from_js(e);
17446 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
17447 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
17448 return (uint32_t)ret_conv;
17451 jboolean __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_is_ok"))) TS_CResult_DescriptionCreationErrorZ_is_ok(uint32_t o) {
17452 LDKCResult_DescriptionCreationErrorZ* o_conv = (LDKCResult_DescriptionCreationErrorZ*)(o & ~1);
17453 jboolean ret_conv = CResult_DescriptionCreationErrorZ_is_ok(o_conv);
17457 void __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_free"))) TS_CResult_DescriptionCreationErrorZ_free(uint32_t _res) {
17458 if ((_res & 1) != 0) return;
17459 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17460 CHECK_ACCESS(_res_ptr);
17461 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(_res_ptr);
17463 CResult_DescriptionCreationErrorZ_free(_res_conv);
17466 static inline uintptr_t CResult_DescriptionCreationErrorZ_clone_ptr(LDKCResult_DescriptionCreationErrorZ *NONNULL_PTR arg) {
17467 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
17468 *ret_conv = CResult_DescriptionCreationErrorZ_clone(arg);
17469 return (uint32_t)ret_conv;
17471 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone_ptr"))) TS_CResult_DescriptionCreationErrorZ_clone_ptr(uint32_t arg) {
17472 LDKCResult_DescriptionCreationErrorZ* arg_conv = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
17473 uint32_t ret_conv = CResult_DescriptionCreationErrorZ_clone_ptr(arg_conv);
17477 uint32_t __attribute__((export_name("TS_CResult_DescriptionCreationErrorZ_clone"))) TS_CResult_DescriptionCreationErrorZ_clone(uint32_t orig) {
17478 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
17479 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
17480 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
17481 return (uint32_t)ret_conv;
17484 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_ok"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint32_t o) {
17485 LDKPrivateRoute o_conv;
17486 o_conv.inner = (void*)(o & (~1));
17487 o_conv.is_owned = (o & 1) || (o == 0);
17488 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17489 o_conv = PrivateRoute_clone(&o_conv);
17490 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
17491 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
17492 return (uint32_t)ret_conv;
17495 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_err"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
17496 LDKCreationError e_conv = LDKCreationError_from_js(e);
17497 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
17498 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
17499 return (uint32_t)ret_conv;
17502 jboolean __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_is_ok"))) TS_CResult_PrivateRouteCreationErrorZ_is_ok(uint32_t o) {
17503 LDKCResult_PrivateRouteCreationErrorZ* o_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(o & ~1);
17504 jboolean ret_conv = CResult_PrivateRouteCreationErrorZ_is_ok(o_conv);
17508 void __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_free"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint32_t _res) {
17509 if ((_res & 1) != 0) return;
17510 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17511 CHECK_ACCESS(_res_ptr);
17512 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(_res_ptr);
17514 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
17517 static inline uintptr_t CResult_PrivateRouteCreationErrorZ_clone_ptr(LDKCResult_PrivateRouteCreationErrorZ *NONNULL_PTR arg) {
17518 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
17519 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(arg);
17520 return (uint32_t)ret_conv;
17522 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone_ptr"))) TS_CResult_PrivateRouteCreationErrorZ_clone_ptr(uint32_t arg) {
17523 LDKCResult_PrivateRouteCreationErrorZ* arg_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
17524 uint32_t ret_conv = CResult_PrivateRouteCreationErrorZ_clone_ptr(arg_conv);
17528 uint32_t __attribute__((export_name("TS_CResult_PrivateRouteCreationErrorZ_clone"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint32_t orig) {
17529 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
17530 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
17531 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
17532 return (uint32_t)ret_conv;
17535 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_ok"))) TS_CResult_StringErrorZ_ok(jstring o) {
17536 LDKStr o_conv = str_ref_to_owned_c(o);
17537 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17538 *ret_conv = CResult_StringErrorZ_ok(o_conv);
17539 return (uint32_t)ret_conv;
17542 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_err"))) TS_CResult_StringErrorZ_err(uint32_t e) {
17543 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
17544 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17545 *ret_conv = CResult_StringErrorZ_err(e_conv);
17546 return (uint32_t)ret_conv;
17549 jboolean __attribute__((export_name("TS_CResult_StringErrorZ_is_ok"))) TS_CResult_StringErrorZ_is_ok(uint32_t o) {
17550 LDKCResult_StringErrorZ* o_conv = (LDKCResult_StringErrorZ*)(o & ~1);
17551 jboolean ret_conv = CResult_StringErrorZ_is_ok(o_conv);
17555 void __attribute__((export_name("TS_CResult_StringErrorZ_free"))) TS_CResult_StringErrorZ_free(uint32_t _res) {
17556 if ((_res & 1) != 0) return;
17557 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17558 CHECK_ACCESS(_res_ptr);
17559 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(_res_ptr);
17561 CResult_StringErrorZ_free(_res_conv);
17564 static inline uintptr_t CResult_StringErrorZ_clone_ptr(LDKCResult_StringErrorZ *NONNULL_PTR arg) {
17565 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17566 *ret_conv = CResult_StringErrorZ_clone(arg);
17567 return (uint32_t)ret_conv;
17569 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_clone_ptr"))) TS_CResult_StringErrorZ_clone_ptr(uint32_t arg) {
17570 LDKCResult_StringErrorZ* arg_conv = (LDKCResult_StringErrorZ*)(arg & ~1);
17571 uint32_t ret_conv = CResult_StringErrorZ_clone_ptr(arg_conv);
17575 uint32_t __attribute__((export_name("TS_CResult_StringErrorZ_clone"))) TS_CResult_StringErrorZ_clone(uint32_t orig) {
17576 LDKCResult_StringErrorZ* orig_conv = (LDKCResult_StringErrorZ*)(orig & ~1);
17577 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
17578 *ret_conv = CResult_StringErrorZ_clone(orig_conv);
17579 return (uint32_t)ret_conv;
17582 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint32_t o) {
17583 LDKChannelMonitorUpdate o_conv;
17584 o_conv.inner = (void*)(o & (~1));
17585 o_conv.is_owned = (o & 1) || (o == 0);
17586 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17587 o_conv = ChannelMonitorUpdate_clone(&o_conv);
17588 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17589 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
17590 return (uint32_t)ret_conv;
17593 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint32_t e) {
17594 LDKDecodeError e_conv;
17595 e_conv.inner = (void*)(e & (~1));
17596 e_conv.is_owned = (e & 1) || (e == 0);
17597 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
17598 e_conv = DecodeError_clone(&e_conv);
17599 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17600 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
17601 return (uint32_t)ret_conv;
17604 jboolean __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(uint32_t o) {
17605 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(o & ~1);
17606 jboolean ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_is_ok(o_conv);
17610 void __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint32_t _res) {
17611 if ((_res & 1) != 0) return;
17612 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17613 CHECK_ACCESS(_res_ptr);
17614 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(_res_ptr);
17616 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
17619 static inline uintptr_t CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelMonitorUpdateDecodeErrorZ *NONNULL_PTR arg) {
17620 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17621 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(arg);
17622 return (uint32_t)ret_conv;
17624 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
17625 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
17626 uint32_t ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone_ptr(arg_conv);
17630 uint32_t __attribute__((export_name("TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint32_t orig) {
17631 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
17632 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
17633 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
17634 return (uint32_t)ret_conv;
17637 uint32_t __attribute__((export_name("TS_COption_MonitorEventZ_some"))) TS_COption_MonitorEventZ_some(uint32_t o) {
17638 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
17639 CHECK_ACCESS(o_ptr);
17640 LDKMonitorEvent o_conv = *(LDKMonitorEvent*)(o_ptr);
17641 o_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uintptr_t)o) & ~1));
17642 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17643 *ret_copy = COption_MonitorEventZ_some(o_conv);
17644 uint32_t ret_ref = (uintptr_t)ret_copy;
17648 uint32_t __attribute__((export_name("TS_COption_MonitorEventZ_none"))) TS_COption_MonitorEventZ_none() {
17649 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17650 *ret_copy = COption_MonitorEventZ_none();
17651 uint32_t ret_ref = (uintptr_t)ret_copy;
17655 void __attribute__((export_name("TS_COption_MonitorEventZ_free"))) TS_COption_MonitorEventZ_free(uint32_t _res) {
17656 if ((_res & 1) != 0) return;
17657 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17658 CHECK_ACCESS(_res_ptr);
17659 LDKCOption_MonitorEventZ _res_conv = *(LDKCOption_MonitorEventZ*)(_res_ptr);
17661 COption_MonitorEventZ_free(_res_conv);
17664 static inline uintptr_t COption_MonitorEventZ_clone_ptr(LDKCOption_MonitorEventZ *NONNULL_PTR arg) {
17665 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17666 *ret_copy = COption_MonitorEventZ_clone(arg);
17667 uint32_t ret_ref = (uintptr_t)ret_copy;
17670 uint32_t __attribute__((export_name("TS_COption_MonitorEventZ_clone_ptr"))) TS_COption_MonitorEventZ_clone_ptr(uint32_t arg) {
17671 LDKCOption_MonitorEventZ* arg_conv = (LDKCOption_MonitorEventZ*)arg;
17672 uint32_t ret_conv = COption_MonitorEventZ_clone_ptr(arg_conv);
17676 uint32_t __attribute__((export_name("TS_COption_MonitorEventZ_clone"))) TS_COption_MonitorEventZ_clone(uint32_t orig) {
17677 LDKCOption_MonitorEventZ* orig_conv = (LDKCOption_MonitorEventZ*)orig;
17678 LDKCOption_MonitorEventZ *ret_copy = MALLOC(sizeof(LDKCOption_MonitorEventZ), "LDKCOption_MonitorEventZ");
17679 *ret_copy = COption_MonitorEventZ_clone(orig_conv);
17680 uint32_t ret_ref = (uintptr_t)ret_copy;
17684 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_ok(uint32_t o) {
17685 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
17686 CHECK_ACCESS(o_ptr);
17687 LDKCOption_MonitorEventZ o_conv = *(LDKCOption_MonitorEventZ*)(o_ptr);
17688 o_conv = COption_MonitorEventZ_clone((LDKCOption_MonitorEventZ*)(((uintptr_t)o) & ~1));
17689 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17690 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_ok(o_conv);
17691 return (uint32_t)ret_conv;
17694 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_err"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_err(uint32_t e) {
17695 LDKDecodeError e_conv;
17696 e_conv.inner = (void*)(e & (~1));
17697 e_conv.is_owned = (e & 1) || (e == 0);
17698 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
17699 e_conv = DecodeError_clone(&e_conv);
17700 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17701 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_err(e_conv);
17702 return (uint32_t)ret_conv;
17705 jboolean __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_is_ok(uint32_t o) {
17706 LDKCResult_COption_MonitorEventZDecodeErrorZ* o_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(o & ~1);
17707 jboolean ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_is_ok(o_conv);
17711 void __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_free"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_free(uint32_t _res) {
17712 if ((_res & 1) != 0) return;
17713 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17714 CHECK_ACCESS(_res_ptr);
17715 LDKCResult_COption_MonitorEventZDecodeErrorZ _res_conv = *(LDKCResult_COption_MonitorEventZDecodeErrorZ*)(_res_ptr);
17717 CResult_COption_MonitorEventZDecodeErrorZ_free(_res_conv);
17720 static inline uintptr_t CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(LDKCResult_COption_MonitorEventZDecodeErrorZ *NONNULL_PTR arg) {
17721 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17722 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(arg);
17723 return (uint32_t)ret_conv;
17725 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(uint32_t arg) {
17726 LDKCResult_COption_MonitorEventZDecodeErrorZ* arg_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(arg & ~1);
17727 uint32_t ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone_ptr(arg_conv);
17731 uint32_t __attribute__((export_name("TS_CResult_COption_MonitorEventZDecodeErrorZ_clone"))) TS_CResult_COption_MonitorEventZDecodeErrorZ_clone(uint32_t orig) {
17732 LDKCResult_COption_MonitorEventZDecodeErrorZ* orig_conv = (LDKCResult_COption_MonitorEventZDecodeErrorZ*)(orig & ~1);
17733 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
17734 *ret_conv = CResult_COption_MonitorEventZDecodeErrorZ_clone(orig_conv);
17735 return (uint32_t)ret_conv;
17738 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint32_t o) {
17739 LDKHTLCUpdate o_conv;
17740 o_conv.inner = (void*)(o & (~1));
17741 o_conv.is_owned = (o & 1) || (o == 0);
17742 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
17743 o_conv = HTLCUpdate_clone(&o_conv);
17744 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17745 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
17746 return (uint32_t)ret_conv;
17749 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_err"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint32_t e) {
17750 LDKDecodeError e_conv;
17751 e_conv.inner = (void*)(e & (~1));
17752 e_conv.is_owned = (e & 1) || (e == 0);
17753 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
17754 e_conv = DecodeError_clone(&e_conv);
17755 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17756 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
17757 return (uint32_t)ret_conv;
17760 jboolean __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_is_ok"))) TS_CResult_HTLCUpdateDecodeErrorZ_is_ok(uint32_t o) {
17761 LDKCResult_HTLCUpdateDecodeErrorZ* o_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(o & ~1);
17762 jboolean ret_conv = CResult_HTLCUpdateDecodeErrorZ_is_ok(o_conv);
17766 void __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_free"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint32_t _res) {
17767 if ((_res & 1) != 0) return;
17768 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17769 CHECK_ACCESS(_res_ptr);
17770 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(_res_ptr);
17772 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
17775 static inline uintptr_t CResult_HTLCUpdateDecodeErrorZ_clone_ptr(LDKCResult_HTLCUpdateDecodeErrorZ *NONNULL_PTR arg) {
17776 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17777 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(arg);
17778 return (uint32_t)ret_conv;
17780 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
17781 LDKCResult_HTLCUpdateDecodeErrorZ* arg_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
17782 uint32_t ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone_ptr(arg_conv);
17786 uint32_t __attribute__((export_name("TS_CResult_HTLCUpdateDecodeErrorZ_clone"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint32_t orig) {
17787 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
17788 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
17789 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
17790 return (uint32_t)ret_conv;
17793 static inline uintptr_t C2Tuple_OutPointScriptZ_clone_ptr(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR arg) {
17794 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17795 *ret_conv = C2Tuple_OutPointScriptZ_clone(arg);
17796 return ((uint32_t)ret_conv);
17798 uint32_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone_ptr"))) TS_C2Tuple_OutPointScriptZ_clone_ptr(uint32_t arg) {
17799 LDKC2Tuple_OutPointScriptZ* arg_conv = (LDKC2Tuple_OutPointScriptZ*)(arg & ~1);
17800 uint32_t ret_conv = C2Tuple_OutPointScriptZ_clone_ptr(arg_conv);
17804 uint32_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_clone"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) {
17805 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
17806 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17807 *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv);
17808 return ((uint32_t)ret_conv);
17811 uint32_t __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_new"))) TS_C2Tuple_OutPointScriptZ_new(uint32_t a, int8_tArray b) {
17812 LDKOutPoint a_conv;
17813 a_conv.inner = (void*)(a & (~1));
17814 a_conv.is_owned = (a & 1) || (a == 0);
17815 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
17816 a_conv = OutPoint_clone(&a_conv);
17818 b_ref.datalen = b->arr_len;
17819 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
17820 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
17821 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
17822 *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
17823 return ((uint32_t)ret_conv);
17826 void __attribute__((export_name("TS_C2Tuple_OutPointScriptZ_free"))) TS_C2Tuple_OutPointScriptZ_free(uint32_t _res) {
17827 if ((_res & 1) != 0) return;
17828 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17829 CHECK_ACCESS(_res_ptr);
17830 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(_res_ptr);
17832 C2Tuple_OutPointScriptZ_free(_res_conv);
17835 static inline uintptr_t C2Tuple_u32ScriptZ_clone_ptr(LDKC2Tuple_u32ScriptZ *NONNULL_PTR arg) {
17836 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
17837 *ret_conv = C2Tuple_u32ScriptZ_clone(arg);
17838 return ((uint32_t)ret_conv);
17840 uint32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone_ptr"))) TS_C2Tuple_u32ScriptZ_clone_ptr(uint32_t arg) {
17841 LDKC2Tuple_u32ScriptZ* arg_conv = (LDKC2Tuple_u32ScriptZ*)(arg & ~1);
17842 uint32_t ret_conv = C2Tuple_u32ScriptZ_clone_ptr(arg_conv);
17846 uint32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_clone"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) {
17847 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
17848 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
17849 *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv);
17850 return ((uint32_t)ret_conv);
17853 uint32_t __attribute__((export_name("TS_C2Tuple_u32ScriptZ_new"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
17855 b_ref.datalen = b->arr_len;
17856 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
17857 memcpy(b_ref.data, b->elems, b_ref.datalen); FREE(b);
17858 LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
17859 *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref);
17860 return ((uint32_t)ret_conv);
17863 void __attribute__((export_name("TS_C2Tuple_u32ScriptZ_free"))) TS_C2Tuple_u32ScriptZ_free(uint32_t _res) {
17864 if ((_res & 1) != 0) return;
17865 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17866 CHECK_ACCESS(_res_ptr);
17867 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_ptr);
17869 C2Tuple_u32ScriptZ_free(_res_conv);
17872 void __attribute__((export_name("TS_CVec_C2Tuple_u32ScriptZZ_free"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint32_tArray _res) {
17873 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
17874 _res_constr.datalen = _res->arr_len;
17875 if (_res_constr.datalen > 0)
17876 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
17878 _res_constr.data = NULL;
17879 uint32_t* _res_vals = _res->elems;
17880 for (size_t v = 0; v < _res_constr.datalen; v++) {
17881 uint32_t _res_conv_21 = _res_vals[v];
17882 void* _res_conv_21_ptr = (void*)(((uintptr_t)_res_conv_21) & ~1);
17883 CHECK_ACCESS(_res_conv_21_ptr);
17884 LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(_res_conv_21_ptr);
17885 FREE((void*)_res_conv_21);
17886 _res_constr.data[v] = _res_conv_21_conv;
17889 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
17892 static inline uintptr_t C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR arg) {
17893 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
17894 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(arg);
17895 return ((uint32_t)ret_conv);
17897 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(uint32_t arg) {
17898 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(arg & ~1);
17899 uint32_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone_ptr(arg_conv);
17903 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) {
17904 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
17905 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
17906 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
17907 return ((uint32_t)ret_conv);
17910 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint32_tArray b) {
17911 LDKThirtyTwoBytes a_ref;
17912 CHECK(a->arr_len == 32);
17913 memcpy(a_ref.data, a->elems, 32); FREE(a);
17914 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
17915 b_constr.datalen = b->arr_len;
17916 if (b_constr.datalen > 0)
17917 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
17919 b_constr.data = NULL;
17920 uint32_t* b_vals = b->elems;
17921 for (size_t v = 0; v < b_constr.datalen; v++) {
17922 uint32_t b_conv_21 = b_vals[v];
17923 void* b_conv_21_ptr = (void*)(((uintptr_t)b_conv_21) & ~1);
17924 CHECK_ACCESS(b_conv_21_ptr);
17925 LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(b_conv_21_ptr);
17926 b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uintptr_t)b_conv_21) & ~1));
17927 b_constr.data[v] = b_conv_21_conv;
17930 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
17931 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
17932 return ((uint32_t)ret_conv);
17935 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint32_t _res) {
17936 if ((_res & 1) != 0) return;
17937 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
17938 CHECK_ACCESS(_res_ptr);
17939 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_ptr);
17941 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
17944 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint32_tArray _res) {
17945 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
17946 _res_constr.datalen = _res->arr_len;
17947 if (_res_constr.datalen > 0)
17948 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
17950 _res_constr.data = NULL;
17951 uint32_t* _res_vals = _res->elems;
17952 for (size_t o = 0; o < _res_constr.datalen; o++) {
17953 uint32_t _res_conv_40 = _res_vals[o];
17954 void* _res_conv_40_ptr = (void*)(((uintptr_t)_res_conv_40) & ~1);
17955 CHECK_ACCESS(_res_conv_40_ptr);
17956 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(_res_conv_40_ptr);
17957 FREE((void*)_res_conv_40);
17958 _res_constr.data[o] = _res_conv_40_conv;
17961 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
17964 void __attribute__((export_name("TS_CVec_EventZ_free"))) TS_CVec_EventZ_free(uint32_tArray _res) {
17965 LDKCVec_EventZ _res_constr;
17966 _res_constr.datalen = _res->arr_len;
17967 if (_res_constr.datalen > 0)
17968 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
17970 _res_constr.data = NULL;
17971 uint32_t* _res_vals = _res->elems;
17972 for (size_t h = 0; h < _res_constr.datalen; h++) {
17973 uint32_t _res_conv_7 = _res_vals[h];
17974 void* _res_conv_7_ptr = (void*)(((uintptr_t)_res_conv_7) & ~1);
17975 CHECK_ACCESS(_res_conv_7_ptr);
17976 LDKEvent _res_conv_7_conv = *(LDKEvent*)(_res_conv_7_ptr);
17977 FREE((void*)_res_conv_7);
17978 _res_constr.data[h] = _res_conv_7_conv;
17981 CVec_EventZ_free(_res_constr);
17984 void __attribute__((export_name("TS_CVec_TransactionZ_free"))) TS_CVec_TransactionZ_free(ptrArray _res) {
17985 LDKCVec_TransactionZ _res_constr;
17986 _res_constr.datalen = _res->arr_len;
17987 if (_res_constr.datalen > 0)
17988 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
17990 _res_constr.data = NULL;
17991 int8_tArray* _res_vals = (void*) _res->elems;
17992 for (size_t m = 0; m < _res_constr.datalen; m++) {
17993 int8_tArray _res_conv_12 = _res_vals[m];
17994 LDKTransaction _res_conv_12_ref;
17995 _res_conv_12_ref.datalen = _res_conv_12->arr_len;
17996 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
17997 memcpy(_res_conv_12_ref.data, _res_conv_12->elems, _res_conv_12_ref.datalen); FREE(_res_conv_12);
17998 _res_conv_12_ref.data_is_owned = true;
17999 _res_constr.data[m] = _res_conv_12_ref;
18002 CVec_TransactionZ_free(_res_constr);
18005 static inline uintptr_t C2Tuple_u32TxOutZ_clone_ptr(LDKC2Tuple_u32TxOutZ *NONNULL_PTR arg) {
18006 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18007 *ret_conv = C2Tuple_u32TxOutZ_clone(arg);
18008 return ((uint32_t)ret_conv);
18010 uint32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone_ptr"))) TS_C2Tuple_u32TxOutZ_clone_ptr(uint32_t arg) {
18011 LDKC2Tuple_u32TxOutZ* arg_conv = (LDKC2Tuple_u32TxOutZ*)(arg & ~1);
18012 uint32_t ret_conv = C2Tuple_u32TxOutZ_clone_ptr(arg_conv);
18016 uint32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_clone"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) {
18017 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
18018 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18019 *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv);
18020 return ((uint32_t)ret_conv);
18023 uint32_t __attribute__((export_name("TS_C2Tuple_u32TxOutZ_new"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint32_t b) {
18024 void* b_ptr = (void*)(((uintptr_t)b) & ~1);
18025 CHECK_ACCESS(b_ptr);
18026 LDKTxOut b_conv = *(LDKTxOut*)(b_ptr);
18027 b_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)b) & ~1));
18028 LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
18029 *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv);
18030 return ((uint32_t)ret_conv);
18033 void __attribute__((export_name("TS_C2Tuple_u32TxOutZ_free"))) TS_C2Tuple_u32TxOutZ_free(uint32_t _res) {
18034 if ((_res & 1) != 0) return;
18035 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18036 CHECK_ACCESS(_res_ptr);
18037 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_ptr);
18039 C2Tuple_u32TxOutZ_free(_res_conv);
18042 void __attribute__((export_name("TS_CVec_C2Tuple_u32TxOutZZ_free"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint32_tArray _res) {
18043 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
18044 _res_constr.datalen = _res->arr_len;
18045 if (_res_constr.datalen > 0)
18046 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
18048 _res_constr.data = NULL;
18049 uint32_t* _res_vals = _res->elems;
18050 for (size_t u = 0; u < _res_constr.datalen; u++) {
18051 uint32_t _res_conv_20 = _res_vals[u];
18052 void* _res_conv_20_ptr = (void*)(((uintptr_t)_res_conv_20) & ~1);
18053 CHECK_ACCESS(_res_conv_20_ptr);
18054 LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(_res_conv_20_ptr);
18055 FREE((void*)_res_conv_20);
18056 _res_constr.data[u] = _res_conv_20_conv;
18059 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
18062 static inline uintptr_t C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR arg) {
18063 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18064 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(arg);
18065 return ((uint32_t)ret_conv);
18067 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(uint32_t arg) {
18068 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* arg_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(arg & ~1);
18069 uint32_t ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone_ptr(arg_conv);
18073 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) {
18074 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
18075 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18076 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
18077 return ((uint32_t)ret_conv);
18080 uint32_t __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint32_tArray b) {
18081 LDKThirtyTwoBytes a_ref;
18082 CHECK(a->arr_len == 32);
18083 memcpy(a_ref.data, a->elems, 32); FREE(a);
18084 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
18085 b_constr.datalen = b->arr_len;
18086 if (b_constr.datalen > 0)
18087 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
18089 b_constr.data = NULL;
18090 uint32_t* b_vals = b->elems;
18091 for (size_t u = 0; u < b_constr.datalen; u++) {
18092 uint32_t b_conv_20 = b_vals[u];
18093 void* b_conv_20_ptr = (void*)(((uintptr_t)b_conv_20) & ~1);
18094 CHECK_ACCESS(b_conv_20_ptr);
18095 LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(b_conv_20_ptr);
18096 b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uintptr_t)b_conv_20) & ~1));
18097 b_constr.data[u] = b_conv_20_conv;
18100 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
18101 *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
18102 return ((uint32_t)ret_conv);
18105 void __attribute__((export_name("TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint32_t _res) {
18106 if ((_res & 1) != 0) return;
18107 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18108 CHECK_ACCESS(_res_ptr);
18109 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_ptr);
18111 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
18114 void __attribute__((export_name("TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint32_tArray _res) {
18115 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
18116 _res_constr.datalen = _res->arr_len;
18117 if (_res_constr.datalen > 0)
18118 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
18120 _res_constr.data = NULL;
18121 uint32_t* _res_vals = _res->elems;
18122 for (size_t n = 0; n < _res_constr.datalen; n++) {
18123 uint32_t _res_conv_39 = _res_vals[n];
18124 void* _res_conv_39_ptr = (void*)(((uintptr_t)_res_conv_39) & ~1);
18125 CHECK_ACCESS(_res_conv_39_ptr);
18126 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(_res_conv_39_ptr);
18127 FREE((void*)_res_conv_39);
18128 _res_constr.data[n] = _res_conv_39_conv;
18131 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
18134 void __attribute__((export_name("TS_CVec_BalanceZ_free"))) TS_CVec_BalanceZ_free(uint32_tArray _res) {
18135 LDKCVec_BalanceZ _res_constr;
18136 _res_constr.datalen = _res->arr_len;
18137 if (_res_constr.datalen > 0)
18138 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements");
18140 _res_constr.data = NULL;
18141 uint32_t* _res_vals = _res->elems;
18142 for (size_t j = 0; j < _res_constr.datalen; j++) {
18143 uint32_t _res_conv_9 = _res_vals[j];
18144 void* _res_conv_9_ptr = (void*)(((uintptr_t)_res_conv_9) & ~1);
18145 CHECK_ACCESS(_res_conv_9_ptr);
18146 LDKBalance _res_conv_9_conv = *(LDKBalance*)(_res_conv_9_ptr);
18147 FREE((void*)_res_conv_9);
18148 _res_constr.data[j] = _res_conv_9_conv;
18151 CVec_BalanceZ_free(_res_constr);
18154 static inline uintptr_t C2Tuple_BlockHashChannelMonitorZ_clone_ptr(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR arg) {
18155 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18156 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(arg);
18157 return ((uint32_t)ret_conv);
18159 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone_ptr(uint32_t arg) {
18160 LDKC2Tuple_BlockHashChannelMonitorZ* arg_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(arg & ~1);
18161 uint32_t ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone_ptr(arg_conv);
18165 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_clone"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint32_t orig) {
18166 LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1);
18167 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18168 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv);
18169 return ((uint32_t)ret_conv);
18172 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_new"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint32_t b) {
18173 LDKThirtyTwoBytes a_ref;
18174 CHECK(a->arr_len == 32);
18175 memcpy(a_ref.data, a->elems, 32); FREE(a);
18176 LDKChannelMonitor b_conv;
18177 b_conv.inner = (void*)(b & (~1));
18178 b_conv.is_owned = (b & 1) || (b == 0);
18179 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
18180 b_conv = ChannelMonitor_clone(&b_conv);
18181 LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
18182 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
18183 return ((uint32_t)ret_conv);
18186 void __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_free"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint32_t _res) {
18187 if ((_res & 1) != 0) return;
18188 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18189 CHECK_ACCESS(_res_ptr);
18190 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(_res_ptr);
18192 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
18195 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint32_t o) {
18196 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
18197 CHECK_ACCESS(o_ptr);
18198 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(o_ptr);
18199 o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uintptr_t)o) & ~1));
18200 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18201 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
18202 return (uint32_t)ret_conv;
18205 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint32_t e) {
18206 LDKDecodeError e_conv;
18207 e_conv.inner = (void*)(e & (~1));
18208 e_conv.is_owned = (e & 1) || (e == 0);
18209 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18210 e_conv = DecodeError_clone(&e_conv);
18211 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18212 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
18213 return (uint32_t)ret_conv;
18216 jboolean __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(uint32_t o) {
18217 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* o_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(o & ~1);
18218 jboolean ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_is_ok(o_conv);
18222 void __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint32_t _res) {
18223 if ((_res & 1) != 0) return;
18224 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18225 CHECK_ACCESS(_res_ptr);
18226 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(_res_ptr);
18228 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
18231 static inline uintptr_t CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *NONNULL_PTR arg) {
18232 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18233 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(arg);
18234 return (uint32_t)ret_conv;
18236 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(uint32_t arg) {
18237 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* arg_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
18238 uint32_t ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone_ptr(arg_conv);
18242 uint32_t __attribute__((export_name("TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint32_t orig) {
18243 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1);
18244 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
18245 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv);
18246 return (uint32_t)ret_conv;
18249 static inline uintptr_t C2Tuple_PublicKeyTypeZ_clone_ptr(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR arg) {
18250 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18251 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(arg);
18252 return ((uint32_t)ret_conv);
18254 uint32_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone_ptr"))) TS_C2Tuple_PublicKeyTypeZ_clone_ptr(uint32_t arg) {
18255 LDKC2Tuple_PublicKeyTypeZ* arg_conv = (LDKC2Tuple_PublicKeyTypeZ*)(arg & ~1);
18256 uint32_t ret_conv = C2Tuple_PublicKeyTypeZ_clone_ptr(arg_conv);
18260 uint32_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_clone"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) {
18261 LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1);
18262 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18263 *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv);
18264 return ((uint32_t)ret_conv);
18267 uint32_t __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_new"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint32_t b) {
18268 LDKPublicKey a_ref;
18269 CHECK(a->arr_len == 33);
18270 memcpy(a_ref.compressed_form, a->elems, 33); FREE(a);
18271 void* b_ptr = (void*)(((uintptr_t)b) & ~1);
18272 CHECK_ACCESS(b_ptr);
18273 LDKType b_conv = *(LDKType*)(b_ptr);
18274 if (b_conv.free == LDKType_JCalls_free) {
18275 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
18276 LDKType_JCalls_cloned(&b_conv);
18278 LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ");
18279 *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv);
18280 return ((uint32_t)ret_conv);
18283 void __attribute__((export_name("TS_C2Tuple_PublicKeyTypeZ_free"))) TS_C2Tuple_PublicKeyTypeZ_free(uint32_t _res) {
18284 if ((_res & 1) != 0) return;
18285 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18286 CHECK_ACCESS(_res_ptr);
18287 LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_ptr);
18289 C2Tuple_PublicKeyTypeZ_free(_res_conv);
18292 void __attribute__((export_name("TS_CVec_C2Tuple_PublicKeyTypeZZ_free"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint32_tArray _res) {
18293 LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr;
18294 _res_constr.datalen = _res->arr_len;
18295 if (_res_constr.datalen > 0)
18296 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements");
18298 _res_constr.data = NULL;
18299 uint32_t* _res_vals = _res->elems;
18300 for (size_t z = 0; z < _res_constr.datalen; z++) {
18301 uint32_t _res_conv_25 = _res_vals[z];
18302 void* _res_conv_25_ptr = (void*)(((uintptr_t)_res_conv_25) & ~1);
18303 CHECK_ACCESS(_res_conv_25_ptr);
18304 LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(_res_conv_25_ptr);
18305 FREE((void*)_res_conv_25);
18306 _res_constr.data[z] = _res_conv_25_conv;
18309 CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr);
18312 uint32_t __attribute__((export_name("TS_COption_NetAddressZ_some"))) TS_COption_NetAddressZ_some(uint32_t o) {
18313 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
18314 CHECK_ACCESS(o_ptr);
18315 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
18316 o_conv = NetAddress_clone((LDKNetAddress*)(((uintptr_t)o) & ~1));
18317 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18318 *ret_copy = COption_NetAddressZ_some(o_conv);
18319 uint32_t ret_ref = (uintptr_t)ret_copy;
18323 uint32_t __attribute__((export_name("TS_COption_NetAddressZ_none"))) TS_COption_NetAddressZ_none() {
18324 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18325 *ret_copy = COption_NetAddressZ_none();
18326 uint32_t ret_ref = (uintptr_t)ret_copy;
18330 void __attribute__((export_name("TS_COption_NetAddressZ_free"))) TS_COption_NetAddressZ_free(uint32_t _res) {
18331 if ((_res & 1) != 0) return;
18332 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18333 CHECK_ACCESS(_res_ptr);
18334 LDKCOption_NetAddressZ _res_conv = *(LDKCOption_NetAddressZ*)(_res_ptr);
18336 COption_NetAddressZ_free(_res_conv);
18339 static inline uintptr_t COption_NetAddressZ_clone_ptr(LDKCOption_NetAddressZ *NONNULL_PTR arg) {
18340 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18341 *ret_copy = COption_NetAddressZ_clone(arg);
18342 uint32_t ret_ref = (uintptr_t)ret_copy;
18345 uint32_t __attribute__((export_name("TS_COption_NetAddressZ_clone_ptr"))) TS_COption_NetAddressZ_clone_ptr(uint32_t arg) {
18346 LDKCOption_NetAddressZ* arg_conv = (LDKCOption_NetAddressZ*)arg;
18347 uint32_t ret_conv = COption_NetAddressZ_clone_ptr(arg_conv);
18351 uint32_t __attribute__((export_name("TS_COption_NetAddressZ_clone"))) TS_COption_NetAddressZ_clone(uint32_t orig) {
18352 LDKCOption_NetAddressZ* orig_conv = (LDKCOption_NetAddressZ*)orig;
18353 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
18354 *ret_copy = COption_NetAddressZ_clone(orig_conv);
18355 uint32_t ret_ref = (uintptr_t)ret_copy;
18359 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
18361 o_ref.datalen = o->arr_len;
18362 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
18363 memcpy(o_ref.data, o->elems, o_ref.datalen); FREE(o);
18364 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18365 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
18366 return (uint32_t)ret_conv;
18369 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_err"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint32_t e) {
18370 LDKPeerHandleError e_conv;
18371 e_conv.inner = (void*)(e & (~1));
18372 e_conv.is_owned = (e & 1) || (e == 0);
18373 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18374 e_conv = PeerHandleError_clone(&e_conv);
18375 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18376 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
18377 return (uint32_t)ret_conv;
18380 jboolean __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_is_ok(uint32_t o) {
18381 LDKCResult_CVec_u8ZPeerHandleErrorZ* o_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(o & ~1);
18382 jboolean ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_is_ok(o_conv);
18386 void __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_free"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint32_t _res) {
18387 if ((_res & 1) != 0) return;
18388 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18389 CHECK_ACCESS(_res_ptr);
18390 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(_res_ptr);
18392 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
18395 static inline uintptr_t CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(LDKCResult_CVec_u8ZPeerHandleErrorZ *NONNULL_PTR arg) {
18396 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18397 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(arg);
18398 return (uint32_t)ret_conv;
18400 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(uint32_t arg) {
18401 LDKCResult_CVec_u8ZPeerHandleErrorZ* arg_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
18402 uint32_t ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone_ptr(arg_conv);
18406 uint32_t __attribute__((export_name("TS_CResult_CVec_u8ZPeerHandleErrorZ_clone"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint32_t orig) {
18407 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
18408 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18409 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
18410 return (uint32_t)ret_conv;
18413 uint32_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_ok"))) TS_CResult_NonePeerHandleErrorZ_ok() {
18414 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18415 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
18416 return (uint32_t)ret_conv;
18419 uint32_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_err"))) TS_CResult_NonePeerHandleErrorZ_err(uint32_t e) {
18420 LDKPeerHandleError e_conv;
18421 e_conv.inner = (void*)(e & (~1));
18422 e_conv.is_owned = (e & 1) || (e == 0);
18423 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18424 e_conv = PeerHandleError_clone(&e_conv);
18425 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18426 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
18427 return (uint32_t)ret_conv;
18430 jboolean __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_is_ok"))) TS_CResult_NonePeerHandleErrorZ_is_ok(uint32_t o) {
18431 LDKCResult_NonePeerHandleErrorZ* o_conv = (LDKCResult_NonePeerHandleErrorZ*)(o & ~1);
18432 jboolean ret_conv = CResult_NonePeerHandleErrorZ_is_ok(o_conv);
18436 void __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_free"))) TS_CResult_NonePeerHandleErrorZ_free(uint32_t _res) {
18437 if ((_res & 1) != 0) return;
18438 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18439 CHECK_ACCESS(_res_ptr);
18440 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(_res_ptr);
18442 CResult_NonePeerHandleErrorZ_free(_res_conv);
18445 static inline uintptr_t CResult_NonePeerHandleErrorZ_clone_ptr(LDKCResult_NonePeerHandleErrorZ *NONNULL_PTR arg) {
18446 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18447 *ret_conv = CResult_NonePeerHandleErrorZ_clone(arg);
18448 return (uint32_t)ret_conv;
18450 uint32_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone_ptr"))) TS_CResult_NonePeerHandleErrorZ_clone_ptr(uint32_t arg) {
18451 LDKCResult_NonePeerHandleErrorZ* arg_conv = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
18452 uint32_t ret_conv = CResult_NonePeerHandleErrorZ_clone_ptr(arg_conv);
18456 uint32_t __attribute__((export_name("TS_CResult_NonePeerHandleErrorZ_clone"))) TS_CResult_NonePeerHandleErrorZ_clone(uint32_t orig) {
18457 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
18458 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18459 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
18460 return (uint32_t)ret_conv;
18463 uint32_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_ok"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
18464 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18465 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
18466 return (uint32_t)ret_conv;
18469 uint32_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_err"))) TS_CResult_boolPeerHandleErrorZ_err(uint32_t e) {
18470 LDKPeerHandleError e_conv;
18471 e_conv.inner = (void*)(e & (~1));
18472 e_conv.is_owned = (e & 1) || (e == 0);
18473 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18474 e_conv = PeerHandleError_clone(&e_conv);
18475 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18476 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
18477 return (uint32_t)ret_conv;
18480 jboolean __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_is_ok"))) TS_CResult_boolPeerHandleErrorZ_is_ok(uint32_t o) {
18481 LDKCResult_boolPeerHandleErrorZ* o_conv = (LDKCResult_boolPeerHandleErrorZ*)(o & ~1);
18482 jboolean ret_conv = CResult_boolPeerHandleErrorZ_is_ok(o_conv);
18486 void __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_free"))) TS_CResult_boolPeerHandleErrorZ_free(uint32_t _res) {
18487 if ((_res & 1) != 0) return;
18488 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18489 CHECK_ACCESS(_res_ptr);
18490 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(_res_ptr);
18492 CResult_boolPeerHandleErrorZ_free(_res_conv);
18495 static inline uintptr_t CResult_boolPeerHandleErrorZ_clone_ptr(LDKCResult_boolPeerHandleErrorZ *NONNULL_PTR arg) {
18496 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18497 *ret_conv = CResult_boolPeerHandleErrorZ_clone(arg);
18498 return (uint32_t)ret_conv;
18500 uint32_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone_ptr"))) TS_CResult_boolPeerHandleErrorZ_clone_ptr(uint32_t arg) {
18501 LDKCResult_boolPeerHandleErrorZ* arg_conv = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
18502 uint32_t ret_conv = CResult_boolPeerHandleErrorZ_clone_ptr(arg_conv);
18506 uint32_t __attribute__((export_name("TS_CResult_boolPeerHandleErrorZ_clone"))) TS_CResult_boolPeerHandleErrorZ_clone(uint32_t orig) {
18507 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
18508 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18509 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
18510 return (uint32_t)ret_conv;
18513 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_ok"))) TS_CResult_NoneErrorZ_ok() {
18514 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
18515 *ret_conv = CResult_NoneErrorZ_ok();
18516 return (uint32_t)ret_conv;
18519 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_err"))) TS_CResult_NoneErrorZ_err(uint32_t e) {
18520 LDKIOError e_conv = LDKIOError_from_js(e);
18521 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
18522 *ret_conv = CResult_NoneErrorZ_err(e_conv);
18523 return (uint32_t)ret_conv;
18526 jboolean __attribute__((export_name("TS_CResult_NoneErrorZ_is_ok"))) TS_CResult_NoneErrorZ_is_ok(uint32_t o) {
18527 LDKCResult_NoneErrorZ* o_conv = (LDKCResult_NoneErrorZ*)(o & ~1);
18528 jboolean ret_conv = CResult_NoneErrorZ_is_ok(o_conv);
18532 void __attribute__((export_name("TS_CResult_NoneErrorZ_free"))) TS_CResult_NoneErrorZ_free(uint32_t _res) {
18533 if ((_res & 1) != 0) return;
18534 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18535 CHECK_ACCESS(_res_ptr);
18536 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(_res_ptr);
18538 CResult_NoneErrorZ_free(_res_conv);
18541 static inline uintptr_t CResult_NoneErrorZ_clone_ptr(LDKCResult_NoneErrorZ *NONNULL_PTR arg) {
18542 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
18543 *ret_conv = CResult_NoneErrorZ_clone(arg);
18544 return (uint32_t)ret_conv;
18546 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone_ptr"))) TS_CResult_NoneErrorZ_clone_ptr(uint32_t arg) {
18547 LDKCResult_NoneErrorZ* arg_conv = (LDKCResult_NoneErrorZ*)(arg & ~1);
18548 uint32_t ret_conv = CResult_NoneErrorZ_clone_ptr(arg_conv);
18552 uint32_t __attribute__((export_name("TS_CResult_NoneErrorZ_clone"))) TS_CResult_NoneErrorZ_clone(uint32_t orig) {
18553 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
18554 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
18555 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
18556 return (uint32_t)ret_conv;
18559 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_ok"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint32_t o) {
18560 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
18561 CHECK_ACCESS(o_ptr);
18562 LDKNetAddress o_conv = *(LDKNetAddress*)(o_ptr);
18563 o_conv = NetAddress_clone((LDKNetAddress*)(((uintptr_t)o) & ~1));
18564 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
18565 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
18566 return (uint32_t)ret_conv;
18569 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_err"))) TS_CResult_NetAddressDecodeErrorZ_err(uint32_t e) {
18570 LDKDecodeError e_conv;
18571 e_conv.inner = (void*)(e & (~1));
18572 e_conv.is_owned = (e & 1) || (e == 0);
18573 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18574 e_conv = DecodeError_clone(&e_conv);
18575 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
18576 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
18577 return (uint32_t)ret_conv;
18580 jboolean __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_is_ok"))) TS_CResult_NetAddressDecodeErrorZ_is_ok(uint32_t o) {
18581 LDKCResult_NetAddressDecodeErrorZ* o_conv = (LDKCResult_NetAddressDecodeErrorZ*)(o & ~1);
18582 jboolean ret_conv = CResult_NetAddressDecodeErrorZ_is_ok(o_conv);
18586 void __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_free"))) TS_CResult_NetAddressDecodeErrorZ_free(uint32_t _res) {
18587 if ((_res & 1) != 0) return;
18588 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18589 CHECK_ACCESS(_res_ptr);
18590 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(_res_ptr);
18592 CResult_NetAddressDecodeErrorZ_free(_res_conv);
18595 static inline uintptr_t CResult_NetAddressDecodeErrorZ_clone_ptr(LDKCResult_NetAddressDecodeErrorZ *NONNULL_PTR arg) {
18596 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
18597 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(arg);
18598 return (uint32_t)ret_conv;
18600 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone_ptr"))) TS_CResult_NetAddressDecodeErrorZ_clone_ptr(uint32_t arg) {
18601 LDKCResult_NetAddressDecodeErrorZ* arg_conv = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
18602 uint32_t ret_conv = CResult_NetAddressDecodeErrorZ_clone_ptr(arg_conv);
18606 uint32_t __attribute__((export_name("TS_CResult_NetAddressDecodeErrorZ_clone"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint32_t orig) {
18607 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
18608 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
18609 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
18610 return (uint32_t)ret_conv;
18613 void __attribute__((export_name("TS_CVec_UpdateAddHTLCZ_free"))) TS_CVec_UpdateAddHTLCZ_free(uint32_tArray _res) {
18614 LDKCVec_UpdateAddHTLCZ _res_constr;
18615 _res_constr.datalen = _res->arr_len;
18616 if (_res_constr.datalen > 0)
18617 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
18619 _res_constr.data = NULL;
18620 uint32_t* _res_vals = _res->elems;
18621 for (size_t p = 0; p < _res_constr.datalen; p++) {
18622 uint32_t _res_conv_15 = _res_vals[p];
18623 LDKUpdateAddHTLC _res_conv_15_conv;
18624 _res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
18625 _res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
18626 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_15_conv);
18627 _res_constr.data[p] = _res_conv_15_conv;
18630 CVec_UpdateAddHTLCZ_free(_res_constr);
18633 void __attribute__((export_name("TS_CVec_UpdateFulfillHTLCZ_free"))) TS_CVec_UpdateFulfillHTLCZ_free(uint32_tArray _res) {
18634 LDKCVec_UpdateFulfillHTLCZ _res_constr;
18635 _res_constr.datalen = _res->arr_len;
18636 if (_res_constr.datalen > 0)
18637 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
18639 _res_constr.data = NULL;
18640 uint32_t* _res_vals = _res->elems;
18641 for (size_t t = 0; t < _res_constr.datalen; t++) {
18642 uint32_t _res_conv_19 = _res_vals[t];
18643 LDKUpdateFulfillHTLC _res_conv_19_conv;
18644 _res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
18645 _res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
18646 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_19_conv);
18647 _res_constr.data[t] = _res_conv_19_conv;
18650 CVec_UpdateFulfillHTLCZ_free(_res_constr);
18653 void __attribute__((export_name("TS_CVec_UpdateFailHTLCZ_free"))) TS_CVec_UpdateFailHTLCZ_free(uint32_tArray _res) {
18654 LDKCVec_UpdateFailHTLCZ _res_constr;
18655 _res_constr.datalen = _res->arr_len;
18656 if (_res_constr.datalen > 0)
18657 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
18659 _res_constr.data = NULL;
18660 uint32_t* _res_vals = _res->elems;
18661 for (size_t q = 0; q < _res_constr.datalen; q++) {
18662 uint32_t _res_conv_16 = _res_vals[q];
18663 LDKUpdateFailHTLC _res_conv_16_conv;
18664 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
18665 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
18666 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_16_conv);
18667 _res_constr.data[q] = _res_conv_16_conv;
18670 CVec_UpdateFailHTLCZ_free(_res_constr);
18673 void __attribute__((export_name("TS_CVec_UpdateFailMalformedHTLCZ_free"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint32_tArray _res) {
18674 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
18675 _res_constr.datalen = _res->arr_len;
18676 if (_res_constr.datalen > 0)
18677 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
18679 _res_constr.data = NULL;
18680 uint32_t* _res_vals = _res->elems;
18681 for (size_t z = 0; z < _res_constr.datalen; z++) {
18682 uint32_t _res_conv_25 = _res_vals[z];
18683 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
18684 _res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
18685 _res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
18686 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_25_conv);
18687 _res_constr.data[z] = _res_conv_25_conv;
18690 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
18693 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint32_t o) {
18694 LDKAcceptChannel o_conv;
18695 o_conv.inner = (void*)(o & (~1));
18696 o_conv.is_owned = (o & 1) || (o == 0);
18697 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18698 o_conv = AcceptChannel_clone(&o_conv);
18699 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
18700 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
18701 return (uint32_t)ret_conv;
18704 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_err"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint32_t e) {
18705 LDKDecodeError e_conv;
18706 e_conv.inner = (void*)(e & (~1));
18707 e_conv.is_owned = (e & 1) || (e == 0);
18708 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18709 e_conv = DecodeError_clone(&e_conv);
18710 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
18711 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
18712 return (uint32_t)ret_conv;
18715 jboolean __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_is_ok"))) TS_CResult_AcceptChannelDecodeErrorZ_is_ok(uint32_t o) {
18716 LDKCResult_AcceptChannelDecodeErrorZ* o_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(o & ~1);
18717 jboolean ret_conv = CResult_AcceptChannelDecodeErrorZ_is_ok(o_conv);
18721 void __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_free"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint32_t _res) {
18722 if ((_res & 1) != 0) return;
18723 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18724 CHECK_ACCESS(_res_ptr);
18725 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(_res_ptr);
18727 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
18730 static inline uintptr_t CResult_AcceptChannelDecodeErrorZ_clone_ptr(LDKCResult_AcceptChannelDecodeErrorZ *NONNULL_PTR arg) {
18731 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
18732 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(arg);
18733 return (uint32_t)ret_conv;
18735 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr"))) TS_CResult_AcceptChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
18736 LDKCResult_AcceptChannelDecodeErrorZ* arg_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
18737 uint32_t ret_conv = CResult_AcceptChannelDecodeErrorZ_clone_ptr(arg_conv);
18741 uint32_t __attribute__((export_name("TS_CResult_AcceptChannelDecodeErrorZ_clone"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint32_t orig) {
18742 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
18743 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
18744 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
18745 return (uint32_t)ret_conv;
18748 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint32_t o) {
18749 LDKAnnouncementSignatures o_conv;
18750 o_conv.inner = (void*)(o & (~1));
18751 o_conv.is_owned = (o & 1) || (o == 0);
18752 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18753 o_conv = AnnouncementSignatures_clone(&o_conv);
18754 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
18755 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
18756 return (uint32_t)ret_conv;
18759 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_err"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint32_t e) {
18760 LDKDecodeError e_conv;
18761 e_conv.inner = (void*)(e & (~1));
18762 e_conv.is_owned = (e & 1) || (e == 0);
18763 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18764 e_conv = DecodeError_clone(&e_conv);
18765 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
18766 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
18767 return (uint32_t)ret_conv;
18770 jboolean __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(uint32_t o) {
18771 LDKCResult_AnnouncementSignaturesDecodeErrorZ* o_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(o & ~1);
18772 jboolean ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_is_ok(o_conv);
18776 void __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_free"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint32_t _res) {
18777 if ((_res & 1) != 0) return;
18778 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18779 CHECK_ACCESS(_res_ptr);
18780 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(_res_ptr);
18782 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
18785 static inline uintptr_t CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(LDKCResult_AnnouncementSignaturesDecodeErrorZ *NONNULL_PTR arg) {
18786 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
18787 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(arg);
18788 return (uint32_t)ret_conv;
18790 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(uint32_t arg) {
18791 LDKCResult_AnnouncementSignaturesDecodeErrorZ* arg_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
18792 uint32_t ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone_ptr(arg_conv);
18796 uint32_t __attribute__((export_name("TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint32_t orig) {
18797 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
18798 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
18799 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
18800 return (uint32_t)ret_conv;
18803 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint32_t o) {
18804 LDKChannelReestablish o_conv;
18805 o_conv.inner = (void*)(o & (~1));
18806 o_conv.is_owned = (o & 1) || (o == 0);
18807 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18808 o_conv = ChannelReestablish_clone(&o_conv);
18809 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
18810 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
18811 return (uint32_t)ret_conv;
18814 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_err"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint32_t e) {
18815 LDKDecodeError e_conv;
18816 e_conv.inner = (void*)(e & (~1));
18817 e_conv.is_owned = (e & 1) || (e == 0);
18818 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18819 e_conv = DecodeError_clone(&e_conv);
18820 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
18821 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
18822 return (uint32_t)ret_conv;
18825 jboolean __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_is_ok"))) TS_CResult_ChannelReestablishDecodeErrorZ_is_ok(uint32_t o) {
18826 LDKCResult_ChannelReestablishDecodeErrorZ* o_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(o & ~1);
18827 jboolean ret_conv = CResult_ChannelReestablishDecodeErrorZ_is_ok(o_conv);
18831 void __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_free"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint32_t _res) {
18832 if ((_res & 1) != 0) return;
18833 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18834 CHECK_ACCESS(_res_ptr);
18835 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(_res_ptr);
18837 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
18840 static inline uintptr_t CResult_ChannelReestablishDecodeErrorZ_clone_ptr(LDKCResult_ChannelReestablishDecodeErrorZ *NONNULL_PTR arg) {
18841 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
18842 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(arg);
18843 return (uint32_t)ret_conv;
18845 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone_ptr(uint32_t arg) {
18846 LDKCResult_ChannelReestablishDecodeErrorZ* arg_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
18847 uint32_t ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone_ptr(arg_conv);
18851 uint32_t __attribute__((export_name("TS_CResult_ChannelReestablishDecodeErrorZ_clone"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint32_t orig) {
18852 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
18853 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
18854 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
18855 return (uint32_t)ret_conv;
18858 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint32_t o) {
18859 LDKClosingSigned o_conv;
18860 o_conv.inner = (void*)(o & (~1));
18861 o_conv.is_owned = (o & 1) || (o == 0);
18862 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18863 o_conv = ClosingSigned_clone(&o_conv);
18864 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
18865 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
18866 return (uint32_t)ret_conv;
18869 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_err"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint32_t e) {
18870 LDKDecodeError e_conv;
18871 e_conv.inner = (void*)(e & (~1));
18872 e_conv.is_owned = (e & 1) || (e == 0);
18873 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18874 e_conv = DecodeError_clone(&e_conv);
18875 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
18876 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
18877 return (uint32_t)ret_conv;
18880 jboolean __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedDecodeErrorZ_is_ok(uint32_t o) {
18881 LDKCResult_ClosingSignedDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(o & ~1);
18882 jboolean ret_conv = CResult_ClosingSignedDecodeErrorZ_is_ok(o_conv);
18886 void __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_free"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint32_t _res) {
18887 if ((_res & 1) != 0) return;
18888 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18889 CHECK_ACCESS(_res_ptr);
18890 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(_res_ptr);
18892 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
18895 static inline uintptr_t CResult_ClosingSignedDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedDecodeErrorZ *NONNULL_PTR arg) {
18896 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
18897 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(arg);
18898 return (uint32_t)ret_conv;
18900 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
18901 LDKCResult_ClosingSignedDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
18902 uint32_t ret_conv = CResult_ClosingSignedDecodeErrorZ_clone_ptr(arg_conv);
18906 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedDecodeErrorZ_clone"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint32_t orig) {
18907 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
18908 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
18909 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
18910 return (uint32_t)ret_conv;
18913 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(uint32_t o) {
18914 LDKClosingSignedFeeRange o_conv;
18915 o_conv.inner = (void*)(o & (~1));
18916 o_conv.is_owned = (o & 1) || (o == 0);
18917 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18918 o_conv = ClosingSignedFeeRange_clone(&o_conv);
18919 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
18920 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_ok(o_conv);
18921 return (uint32_t)ret_conv;
18924 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_err(uint32_t e) {
18925 LDKDecodeError e_conv;
18926 e_conv.inner = (void*)(e & (~1));
18927 e_conv.is_owned = (e & 1) || (e == 0);
18928 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18929 e_conv = DecodeError_clone(&e_conv);
18930 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
18931 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_err(e_conv);
18932 return (uint32_t)ret_conv;
18935 jboolean __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(uint32_t o) {
18936 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* o_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(o & ~1);
18937 jboolean ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_is_ok(o_conv);
18941 void __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_free(uint32_t _res) {
18942 if ((_res & 1) != 0) return;
18943 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18944 CHECK_ACCESS(_res_ptr);
18945 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(_res_ptr);
18947 CResult_ClosingSignedFeeRangeDecodeErrorZ_free(_res_conv);
18950 static inline uintptr_t CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ *NONNULL_PTR arg) {
18951 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
18952 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(arg);
18953 return (uint32_t)ret_conv;
18955 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
18956 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* arg_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(arg & ~1);
18957 uint32_t ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone_ptr(arg_conv);
18961 uint32_t __attribute__((export_name("TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone"))) TS_CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(uint32_t orig) {
18962 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedFeeRangeDecodeErrorZ*)(orig & ~1);
18963 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
18964 *ret_conv = CResult_ClosingSignedFeeRangeDecodeErrorZ_clone(orig_conv);
18965 return (uint32_t)ret_conv;
18968 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint32_t o) {
18969 LDKCommitmentSigned o_conv;
18970 o_conv.inner = (void*)(o & (~1));
18971 o_conv.is_owned = (o & 1) || (o == 0);
18972 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
18973 o_conv = CommitmentSigned_clone(&o_conv);
18974 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
18975 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
18976 return (uint32_t)ret_conv;
18979 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_err"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint32_t e) {
18980 LDKDecodeError e_conv;
18981 e_conv.inner = (void*)(e & (~1));
18982 e_conv.is_owned = (e & 1) || (e == 0);
18983 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
18984 e_conv = DecodeError_clone(&e_conv);
18985 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
18986 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
18987 return (uint32_t)ret_conv;
18990 jboolean __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_is_ok"))) TS_CResult_CommitmentSignedDecodeErrorZ_is_ok(uint32_t o) {
18991 LDKCResult_CommitmentSignedDecodeErrorZ* o_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(o & ~1);
18992 jboolean ret_conv = CResult_CommitmentSignedDecodeErrorZ_is_ok(o_conv);
18996 void __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_free"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint32_t _res) {
18997 if ((_res & 1) != 0) return;
18998 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
18999 CHECK_ACCESS(_res_ptr);
19000 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(_res_ptr);
19002 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
19005 static inline uintptr_t CResult_CommitmentSignedDecodeErrorZ_clone_ptr(LDKCResult_CommitmentSignedDecodeErrorZ *NONNULL_PTR arg) {
19006 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19007 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(arg);
19008 return (uint32_t)ret_conv;
19010 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
19011 LDKCResult_CommitmentSignedDecodeErrorZ* arg_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
19012 uint32_t ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone_ptr(arg_conv);
19016 uint32_t __attribute__((export_name("TS_CResult_CommitmentSignedDecodeErrorZ_clone"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint32_t orig) {
19017 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
19018 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
19019 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
19020 return (uint32_t)ret_conv;
19023 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint32_t o) {
19024 LDKFundingCreated o_conv;
19025 o_conv.inner = (void*)(o & (~1));
19026 o_conv.is_owned = (o & 1) || (o == 0);
19027 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19028 o_conv = FundingCreated_clone(&o_conv);
19029 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19030 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
19031 return (uint32_t)ret_conv;
19034 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_err"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint32_t e) {
19035 LDKDecodeError e_conv;
19036 e_conv.inner = (void*)(e & (~1));
19037 e_conv.is_owned = (e & 1) || (e == 0);
19038 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19039 e_conv = DecodeError_clone(&e_conv);
19040 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19041 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
19042 return (uint32_t)ret_conv;
19045 jboolean __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_is_ok"))) TS_CResult_FundingCreatedDecodeErrorZ_is_ok(uint32_t o) {
19046 LDKCResult_FundingCreatedDecodeErrorZ* o_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(o & ~1);
19047 jboolean ret_conv = CResult_FundingCreatedDecodeErrorZ_is_ok(o_conv);
19051 void __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_free"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint32_t _res) {
19052 if ((_res & 1) != 0) return;
19053 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19054 CHECK_ACCESS(_res_ptr);
19055 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(_res_ptr);
19057 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
19060 static inline uintptr_t CResult_FundingCreatedDecodeErrorZ_clone_ptr(LDKCResult_FundingCreatedDecodeErrorZ *NONNULL_PTR arg) {
19061 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19062 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(arg);
19063 return (uint32_t)ret_conv;
19065 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingCreatedDecodeErrorZ_clone_ptr(uint32_t arg) {
19066 LDKCResult_FundingCreatedDecodeErrorZ* arg_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
19067 uint32_t ret_conv = CResult_FundingCreatedDecodeErrorZ_clone_ptr(arg_conv);
19071 uint32_t __attribute__((export_name("TS_CResult_FundingCreatedDecodeErrorZ_clone"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint32_t orig) {
19072 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
19073 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
19074 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
19075 return (uint32_t)ret_conv;
19078 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_ok"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint32_t o) {
19079 LDKFundingSigned o_conv;
19080 o_conv.inner = (void*)(o & (~1));
19081 o_conv.is_owned = (o & 1) || (o == 0);
19082 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19083 o_conv = FundingSigned_clone(&o_conv);
19084 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19085 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
19086 return (uint32_t)ret_conv;
19089 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_err"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint32_t e) {
19090 LDKDecodeError e_conv;
19091 e_conv.inner = (void*)(e & (~1));
19092 e_conv.is_owned = (e & 1) || (e == 0);
19093 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19094 e_conv = DecodeError_clone(&e_conv);
19095 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19096 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
19097 return (uint32_t)ret_conv;
19100 jboolean __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_is_ok"))) TS_CResult_FundingSignedDecodeErrorZ_is_ok(uint32_t o) {
19101 LDKCResult_FundingSignedDecodeErrorZ* o_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(o & ~1);
19102 jboolean ret_conv = CResult_FundingSignedDecodeErrorZ_is_ok(o_conv);
19106 void __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_free"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint32_t _res) {
19107 if ((_res & 1) != 0) return;
19108 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19109 CHECK_ACCESS(_res_ptr);
19110 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(_res_ptr);
19112 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
19115 static inline uintptr_t CResult_FundingSignedDecodeErrorZ_clone_ptr(LDKCResult_FundingSignedDecodeErrorZ *NONNULL_PTR arg) {
19116 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19117 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(arg);
19118 return (uint32_t)ret_conv;
19120 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone_ptr"))) TS_CResult_FundingSignedDecodeErrorZ_clone_ptr(uint32_t arg) {
19121 LDKCResult_FundingSignedDecodeErrorZ* arg_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
19122 uint32_t ret_conv = CResult_FundingSignedDecodeErrorZ_clone_ptr(arg_conv);
19126 uint32_t __attribute__((export_name("TS_CResult_FundingSignedDecodeErrorZ_clone"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint32_t orig) {
19127 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
19128 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
19129 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
19130 return (uint32_t)ret_conv;
19133 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_ok(uint32_t o) {
19134 LDKChannelReady o_conv;
19135 o_conv.inner = (void*)(o & (~1));
19136 o_conv.is_owned = (o & 1) || (o == 0);
19137 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19138 o_conv = ChannelReady_clone(&o_conv);
19139 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19140 *ret_conv = CResult_ChannelReadyDecodeErrorZ_ok(o_conv);
19141 return (uint32_t)ret_conv;
19144 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_err"))) TS_CResult_ChannelReadyDecodeErrorZ_err(uint32_t e) {
19145 LDKDecodeError e_conv;
19146 e_conv.inner = (void*)(e & (~1));
19147 e_conv.is_owned = (e & 1) || (e == 0);
19148 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19149 e_conv = DecodeError_clone(&e_conv);
19150 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19151 *ret_conv = CResult_ChannelReadyDecodeErrorZ_err(e_conv);
19152 return (uint32_t)ret_conv;
19155 jboolean __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_is_ok"))) TS_CResult_ChannelReadyDecodeErrorZ_is_ok(uint32_t o) {
19156 LDKCResult_ChannelReadyDecodeErrorZ* o_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)(o & ~1);
19157 jboolean ret_conv = CResult_ChannelReadyDecodeErrorZ_is_ok(o_conv);
19161 void __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_free"))) TS_CResult_ChannelReadyDecodeErrorZ_free(uint32_t _res) {
19162 if ((_res & 1) != 0) return;
19163 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19164 CHECK_ACCESS(_res_ptr);
19165 LDKCResult_ChannelReadyDecodeErrorZ _res_conv = *(LDKCResult_ChannelReadyDecodeErrorZ*)(_res_ptr);
19167 CResult_ChannelReadyDecodeErrorZ_free(_res_conv);
19170 static inline uintptr_t CResult_ChannelReadyDecodeErrorZ_clone_ptr(LDKCResult_ChannelReadyDecodeErrorZ *NONNULL_PTR arg) {
19171 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19172 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(arg);
19173 return (uint32_t)ret_conv;
19175 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelReadyDecodeErrorZ_clone_ptr(uint32_t arg) {
19176 LDKCResult_ChannelReadyDecodeErrorZ* arg_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)(arg & ~1);
19177 uint32_t ret_conv = CResult_ChannelReadyDecodeErrorZ_clone_ptr(arg_conv);
19181 uint32_t __attribute__((export_name("TS_CResult_ChannelReadyDecodeErrorZ_clone"))) TS_CResult_ChannelReadyDecodeErrorZ_clone(uint32_t orig) {
19182 LDKCResult_ChannelReadyDecodeErrorZ* orig_conv = (LDKCResult_ChannelReadyDecodeErrorZ*)(orig & ~1);
19183 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
19184 *ret_conv = CResult_ChannelReadyDecodeErrorZ_clone(orig_conv);
19185 return (uint32_t)ret_conv;
19188 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_ok"))) TS_CResult_InitDecodeErrorZ_ok(uint32_t o) {
19190 o_conv.inner = (void*)(o & (~1));
19191 o_conv.is_owned = (o & 1) || (o == 0);
19192 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19193 o_conv = Init_clone(&o_conv);
19194 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
19195 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
19196 return (uint32_t)ret_conv;
19199 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_err"))) TS_CResult_InitDecodeErrorZ_err(uint32_t e) {
19200 LDKDecodeError e_conv;
19201 e_conv.inner = (void*)(e & (~1));
19202 e_conv.is_owned = (e & 1) || (e == 0);
19203 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19204 e_conv = DecodeError_clone(&e_conv);
19205 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
19206 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
19207 return (uint32_t)ret_conv;
19210 jboolean __attribute__((export_name("TS_CResult_InitDecodeErrorZ_is_ok"))) TS_CResult_InitDecodeErrorZ_is_ok(uint32_t o) {
19211 LDKCResult_InitDecodeErrorZ* o_conv = (LDKCResult_InitDecodeErrorZ*)(o & ~1);
19212 jboolean ret_conv = CResult_InitDecodeErrorZ_is_ok(o_conv);
19216 void __attribute__((export_name("TS_CResult_InitDecodeErrorZ_free"))) TS_CResult_InitDecodeErrorZ_free(uint32_t _res) {
19217 if ((_res & 1) != 0) return;
19218 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19219 CHECK_ACCESS(_res_ptr);
19220 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(_res_ptr);
19222 CResult_InitDecodeErrorZ_free(_res_conv);
19225 static inline uintptr_t CResult_InitDecodeErrorZ_clone_ptr(LDKCResult_InitDecodeErrorZ *NONNULL_PTR arg) {
19226 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
19227 *ret_conv = CResult_InitDecodeErrorZ_clone(arg);
19228 return (uint32_t)ret_conv;
19230 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone_ptr"))) TS_CResult_InitDecodeErrorZ_clone_ptr(uint32_t arg) {
19231 LDKCResult_InitDecodeErrorZ* arg_conv = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
19232 uint32_t ret_conv = CResult_InitDecodeErrorZ_clone_ptr(arg_conv);
19236 uint32_t __attribute__((export_name("TS_CResult_InitDecodeErrorZ_clone"))) TS_CResult_InitDecodeErrorZ_clone(uint32_t orig) {
19237 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
19238 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
19239 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
19240 return (uint32_t)ret_conv;
19243 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_ok"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint32_t o) {
19244 LDKOpenChannel o_conv;
19245 o_conv.inner = (void*)(o & (~1));
19246 o_conv.is_owned = (o & 1) || (o == 0);
19247 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19248 o_conv = OpenChannel_clone(&o_conv);
19249 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
19250 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
19251 return (uint32_t)ret_conv;
19254 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_err"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint32_t e) {
19255 LDKDecodeError e_conv;
19256 e_conv.inner = (void*)(e & (~1));
19257 e_conv.is_owned = (e & 1) || (e == 0);
19258 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19259 e_conv = DecodeError_clone(&e_conv);
19260 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
19261 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
19262 return (uint32_t)ret_conv;
19265 jboolean __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_is_ok"))) TS_CResult_OpenChannelDecodeErrorZ_is_ok(uint32_t o) {
19266 LDKCResult_OpenChannelDecodeErrorZ* o_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(o & ~1);
19267 jboolean ret_conv = CResult_OpenChannelDecodeErrorZ_is_ok(o_conv);
19271 void __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_free"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint32_t _res) {
19272 if ((_res & 1) != 0) return;
19273 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19274 CHECK_ACCESS(_res_ptr);
19275 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(_res_ptr);
19277 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
19280 static inline uintptr_t CResult_OpenChannelDecodeErrorZ_clone_ptr(LDKCResult_OpenChannelDecodeErrorZ *NONNULL_PTR arg) {
19281 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
19282 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(arg);
19283 return (uint32_t)ret_conv;
19285 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone_ptr"))) TS_CResult_OpenChannelDecodeErrorZ_clone_ptr(uint32_t arg) {
19286 LDKCResult_OpenChannelDecodeErrorZ* arg_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
19287 uint32_t ret_conv = CResult_OpenChannelDecodeErrorZ_clone_ptr(arg_conv);
19291 uint32_t __attribute__((export_name("TS_CResult_OpenChannelDecodeErrorZ_clone"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint32_t orig) {
19292 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
19293 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
19294 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
19295 return (uint32_t)ret_conv;
19298 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint32_t o) {
19299 LDKRevokeAndACK o_conv;
19300 o_conv.inner = (void*)(o & (~1));
19301 o_conv.is_owned = (o & 1) || (o == 0);
19302 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19303 o_conv = RevokeAndACK_clone(&o_conv);
19304 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
19305 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
19306 return (uint32_t)ret_conv;
19309 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_err"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint32_t e) {
19310 LDKDecodeError e_conv;
19311 e_conv.inner = (void*)(e & (~1));
19312 e_conv.is_owned = (e & 1) || (e == 0);
19313 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19314 e_conv = DecodeError_clone(&e_conv);
19315 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
19316 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
19317 return (uint32_t)ret_conv;
19320 jboolean __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_is_ok"))) TS_CResult_RevokeAndACKDecodeErrorZ_is_ok(uint32_t o) {
19321 LDKCResult_RevokeAndACKDecodeErrorZ* o_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(o & ~1);
19322 jboolean ret_conv = CResult_RevokeAndACKDecodeErrorZ_is_ok(o_conv);
19326 void __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_free"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint32_t _res) {
19327 if ((_res & 1) != 0) return;
19328 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19329 CHECK_ACCESS(_res_ptr);
19330 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(_res_ptr);
19332 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
19335 static inline uintptr_t CResult_RevokeAndACKDecodeErrorZ_clone_ptr(LDKCResult_RevokeAndACKDecodeErrorZ *NONNULL_PTR arg) {
19336 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
19337 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(arg);
19338 return (uint32_t)ret_conv;
19340 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone_ptr(uint32_t arg) {
19341 LDKCResult_RevokeAndACKDecodeErrorZ* arg_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
19342 uint32_t ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone_ptr(arg_conv);
19346 uint32_t __attribute__((export_name("TS_CResult_RevokeAndACKDecodeErrorZ_clone"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint32_t orig) {
19347 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
19348 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
19349 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
19350 return (uint32_t)ret_conv;
19353 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_ok"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint32_t o) {
19354 LDKShutdown o_conv;
19355 o_conv.inner = (void*)(o & (~1));
19356 o_conv.is_owned = (o & 1) || (o == 0);
19357 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19358 o_conv = Shutdown_clone(&o_conv);
19359 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
19360 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
19361 return (uint32_t)ret_conv;
19364 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_err"))) TS_CResult_ShutdownDecodeErrorZ_err(uint32_t e) {
19365 LDKDecodeError e_conv;
19366 e_conv.inner = (void*)(e & (~1));
19367 e_conv.is_owned = (e & 1) || (e == 0);
19368 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19369 e_conv = DecodeError_clone(&e_conv);
19370 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
19371 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
19372 return (uint32_t)ret_conv;
19375 jboolean __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_is_ok"))) TS_CResult_ShutdownDecodeErrorZ_is_ok(uint32_t o) {
19376 LDKCResult_ShutdownDecodeErrorZ* o_conv = (LDKCResult_ShutdownDecodeErrorZ*)(o & ~1);
19377 jboolean ret_conv = CResult_ShutdownDecodeErrorZ_is_ok(o_conv);
19381 void __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_free"))) TS_CResult_ShutdownDecodeErrorZ_free(uint32_t _res) {
19382 if ((_res & 1) != 0) return;
19383 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19384 CHECK_ACCESS(_res_ptr);
19385 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(_res_ptr);
19387 CResult_ShutdownDecodeErrorZ_free(_res_conv);
19390 static inline uintptr_t CResult_ShutdownDecodeErrorZ_clone_ptr(LDKCResult_ShutdownDecodeErrorZ *NONNULL_PTR arg) {
19391 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
19392 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(arg);
19393 return (uint32_t)ret_conv;
19395 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone_ptr"))) TS_CResult_ShutdownDecodeErrorZ_clone_ptr(uint32_t arg) {
19396 LDKCResult_ShutdownDecodeErrorZ* arg_conv = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
19397 uint32_t ret_conv = CResult_ShutdownDecodeErrorZ_clone_ptr(arg_conv);
19401 uint32_t __attribute__((export_name("TS_CResult_ShutdownDecodeErrorZ_clone"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint32_t orig) {
19402 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
19403 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
19404 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
19405 return (uint32_t)ret_conv;
19408 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint32_t o) {
19409 LDKUpdateFailHTLC o_conv;
19410 o_conv.inner = (void*)(o & (~1));
19411 o_conv.is_owned = (o & 1) || (o == 0);
19412 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19413 o_conv = UpdateFailHTLC_clone(&o_conv);
19414 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
19415 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
19416 return (uint32_t)ret_conv;
19419 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint32_t e) {
19420 LDKDecodeError e_conv;
19421 e_conv.inner = (void*)(e & (~1));
19422 e_conv.is_owned = (e & 1) || (e == 0);
19423 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19424 e_conv = DecodeError_clone(&e_conv);
19425 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
19426 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
19427 return (uint32_t)ret_conv;
19430 jboolean __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_is_ok(uint32_t o) {
19431 LDKCResult_UpdateFailHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(o & ~1);
19432 jboolean ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_is_ok(o_conv);
19436 void __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint32_t _res) {
19437 if ((_res & 1) != 0) return;
19438 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19439 CHECK_ACCESS(_res_ptr);
19440 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(_res_ptr);
19442 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
19445 static inline uintptr_t CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailHTLCDecodeErrorZ *NONNULL_PTR arg) {
19446 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
19447 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(arg);
19448 return (uint32_t)ret_conv;
19450 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
19451 LDKCResult_UpdateFailHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
19452 uint32_t ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone_ptr(arg_conv);
19456 uint32_t __attribute__((export_name("TS_CResult_UpdateFailHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint32_t orig) {
19457 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
19458 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
19459 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
19460 return (uint32_t)ret_conv;
19463 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint32_t o) {
19464 LDKUpdateFailMalformedHTLC o_conv;
19465 o_conv.inner = (void*)(o & (~1));
19466 o_conv.is_owned = (o & 1) || (o == 0);
19467 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19468 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
19469 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
19470 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
19471 return (uint32_t)ret_conv;
19474 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint32_t e) {
19475 LDKDecodeError e_conv;
19476 e_conv.inner = (void*)(e & (~1));
19477 e_conv.is_owned = (e & 1) || (e == 0);
19478 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19479 e_conv = DecodeError_clone(&e_conv);
19480 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
19481 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
19482 return (uint32_t)ret_conv;
19485 jboolean __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(uint32_t o) {
19486 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(o & ~1);
19487 jboolean ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_is_ok(o_conv);
19491 void __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint32_t _res) {
19492 if ((_res & 1) != 0) return;
19493 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19494 CHECK_ACCESS(_res_ptr);
19495 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(_res_ptr);
19497 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
19500 static inline uintptr_t CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *NONNULL_PTR arg) {
19501 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
19502 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(arg);
19503 return (uint32_t)ret_conv;
19505 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
19506 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
19507 uint32_t ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone_ptr(arg_conv);
19511 uint32_t __attribute__((export_name("TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint32_t orig) {
19512 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
19513 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
19514 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
19515 return (uint32_t)ret_conv;
19518 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint32_t o) {
19519 LDKUpdateFee o_conv;
19520 o_conv.inner = (void*)(o & (~1));
19521 o_conv.is_owned = (o & 1) || (o == 0);
19522 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19523 o_conv = UpdateFee_clone(&o_conv);
19524 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
19525 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
19526 return (uint32_t)ret_conv;
19529 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_err"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint32_t e) {
19530 LDKDecodeError e_conv;
19531 e_conv.inner = (void*)(e & (~1));
19532 e_conv.is_owned = (e & 1) || (e == 0);
19533 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19534 e_conv = DecodeError_clone(&e_conv);
19535 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
19536 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
19537 return (uint32_t)ret_conv;
19540 jboolean __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_is_ok"))) TS_CResult_UpdateFeeDecodeErrorZ_is_ok(uint32_t o) {
19541 LDKCResult_UpdateFeeDecodeErrorZ* o_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(o & ~1);
19542 jboolean ret_conv = CResult_UpdateFeeDecodeErrorZ_is_ok(o_conv);
19546 void __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_free"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint32_t _res) {
19547 if ((_res & 1) != 0) return;
19548 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19549 CHECK_ACCESS(_res_ptr);
19550 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(_res_ptr);
19552 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
19555 static inline uintptr_t CResult_UpdateFeeDecodeErrorZ_clone_ptr(LDKCResult_UpdateFeeDecodeErrorZ *NONNULL_PTR arg) {
19556 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
19557 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(arg);
19558 return (uint32_t)ret_conv;
19560 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFeeDecodeErrorZ_clone_ptr(uint32_t arg) {
19561 LDKCResult_UpdateFeeDecodeErrorZ* arg_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
19562 uint32_t ret_conv = CResult_UpdateFeeDecodeErrorZ_clone_ptr(arg_conv);
19566 uint32_t __attribute__((export_name("TS_CResult_UpdateFeeDecodeErrorZ_clone"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint32_t orig) {
19567 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
19568 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
19569 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
19570 return (uint32_t)ret_conv;
19573 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint32_t o) {
19574 LDKUpdateFulfillHTLC o_conv;
19575 o_conv.inner = (void*)(o & (~1));
19576 o_conv.is_owned = (o & 1) || (o == 0);
19577 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19578 o_conv = UpdateFulfillHTLC_clone(&o_conv);
19579 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
19580 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
19581 return (uint32_t)ret_conv;
19584 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint32_t e) {
19585 LDKDecodeError e_conv;
19586 e_conv.inner = (void*)(e & (~1));
19587 e_conv.is_owned = (e & 1) || (e == 0);
19588 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19589 e_conv = DecodeError_clone(&e_conv);
19590 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
19591 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
19592 return (uint32_t)ret_conv;
19595 jboolean __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(uint32_t o) {
19596 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(o & ~1);
19597 jboolean ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_is_ok(o_conv);
19601 void __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint32_t _res) {
19602 if ((_res & 1) != 0) return;
19603 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19604 CHECK_ACCESS(_res_ptr);
19605 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(_res_ptr);
19607 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
19610 static inline uintptr_t CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateFulfillHTLCDecodeErrorZ *NONNULL_PTR arg) {
19611 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
19612 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(arg);
19613 return (uint32_t)ret_conv;
19615 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
19616 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
19617 uint32_t ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone_ptr(arg_conv);
19621 uint32_t __attribute__((export_name("TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint32_t orig) {
19622 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
19623 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
19624 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
19625 return (uint32_t)ret_conv;
19628 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint32_t o) {
19629 LDKUpdateAddHTLC o_conv;
19630 o_conv.inner = (void*)(o & (~1));
19631 o_conv.is_owned = (o & 1) || (o == 0);
19632 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19633 o_conv = UpdateAddHTLC_clone(&o_conv);
19634 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
19635 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
19636 return (uint32_t)ret_conv;
19639 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_err"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint32_t e) {
19640 LDKDecodeError e_conv;
19641 e_conv.inner = (void*)(e & (~1));
19642 e_conv.is_owned = (e & 1) || (e == 0);
19643 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19644 e_conv = DecodeError_clone(&e_conv);
19645 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
19646 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
19647 return (uint32_t)ret_conv;
19650 jboolean __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_is_ok(uint32_t o) {
19651 LDKCResult_UpdateAddHTLCDecodeErrorZ* o_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(o & ~1);
19652 jboolean ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_is_ok(o_conv);
19656 void __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_free"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint32_t _res) {
19657 if ((_res & 1) != 0) return;
19658 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19659 CHECK_ACCESS(_res_ptr);
19660 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(_res_ptr);
19662 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
19665 static inline uintptr_t CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(LDKCResult_UpdateAddHTLCDecodeErrorZ *NONNULL_PTR arg) {
19666 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
19667 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(arg);
19668 return (uint32_t)ret_conv;
19670 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(uint32_t arg) {
19671 LDKCResult_UpdateAddHTLCDecodeErrorZ* arg_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
19672 uint32_t ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone_ptr(arg_conv);
19676 uint32_t __attribute__((export_name("TS_CResult_UpdateAddHTLCDecodeErrorZ_clone"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint32_t orig) {
19677 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
19678 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
19679 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
19680 return (uint32_t)ret_conv;
19683 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_ok"))) TS_CResult_PingDecodeErrorZ_ok(uint32_t o) {
19685 o_conv.inner = (void*)(o & (~1));
19686 o_conv.is_owned = (o & 1) || (o == 0);
19687 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19688 o_conv = Ping_clone(&o_conv);
19689 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
19690 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
19691 return (uint32_t)ret_conv;
19694 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_err"))) TS_CResult_PingDecodeErrorZ_err(uint32_t e) {
19695 LDKDecodeError e_conv;
19696 e_conv.inner = (void*)(e & (~1));
19697 e_conv.is_owned = (e & 1) || (e == 0);
19698 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19699 e_conv = DecodeError_clone(&e_conv);
19700 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
19701 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
19702 return (uint32_t)ret_conv;
19705 jboolean __attribute__((export_name("TS_CResult_PingDecodeErrorZ_is_ok"))) TS_CResult_PingDecodeErrorZ_is_ok(uint32_t o) {
19706 LDKCResult_PingDecodeErrorZ* o_conv = (LDKCResult_PingDecodeErrorZ*)(o & ~1);
19707 jboolean ret_conv = CResult_PingDecodeErrorZ_is_ok(o_conv);
19711 void __attribute__((export_name("TS_CResult_PingDecodeErrorZ_free"))) TS_CResult_PingDecodeErrorZ_free(uint32_t _res) {
19712 if ((_res & 1) != 0) return;
19713 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19714 CHECK_ACCESS(_res_ptr);
19715 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(_res_ptr);
19717 CResult_PingDecodeErrorZ_free(_res_conv);
19720 static inline uintptr_t CResult_PingDecodeErrorZ_clone_ptr(LDKCResult_PingDecodeErrorZ *NONNULL_PTR arg) {
19721 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
19722 *ret_conv = CResult_PingDecodeErrorZ_clone(arg);
19723 return (uint32_t)ret_conv;
19725 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone_ptr"))) TS_CResult_PingDecodeErrorZ_clone_ptr(uint32_t arg) {
19726 LDKCResult_PingDecodeErrorZ* arg_conv = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
19727 uint32_t ret_conv = CResult_PingDecodeErrorZ_clone_ptr(arg_conv);
19731 uint32_t __attribute__((export_name("TS_CResult_PingDecodeErrorZ_clone"))) TS_CResult_PingDecodeErrorZ_clone(uint32_t orig) {
19732 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
19733 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
19734 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
19735 return (uint32_t)ret_conv;
19738 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_ok"))) TS_CResult_PongDecodeErrorZ_ok(uint32_t o) {
19740 o_conv.inner = (void*)(o & (~1));
19741 o_conv.is_owned = (o & 1) || (o == 0);
19742 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19743 o_conv = Pong_clone(&o_conv);
19744 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
19745 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
19746 return (uint32_t)ret_conv;
19749 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_err"))) TS_CResult_PongDecodeErrorZ_err(uint32_t e) {
19750 LDKDecodeError e_conv;
19751 e_conv.inner = (void*)(e & (~1));
19752 e_conv.is_owned = (e & 1) || (e == 0);
19753 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19754 e_conv = DecodeError_clone(&e_conv);
19755 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
19756 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
19757 return (uint32_t)ret_conv;
19760 jboolean __attribute__((export_name("TS_CResult_PongDecodeErrorZ_is_ok"))) TS_CResult_PongDecodeErrorZ_is_ok(uint32_t o) {
19761 LDKCResult_PongDecodeErrorZ* o_conv = (LDKCResult_PongDecodeErrorZ*)(o & ~1);
19762 jboolean ret_conv = CResult_PongDecodeErrorZ_is_ok(o_conv);
19766 void __attribute__((export_name("TS_CResult_PongDecodeErrorZ_free"))) TS_CResult_PongDecodeErrorZ_free(uint32_t _res) {
19767 if ((_res & 1) != 0) return;
19768 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19769 CHECK_ACCESS(_res_ptr);
19770 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(_res_ptr);
19772 CResult_PongDecodeErrorZ_free(_res_conv);
19775 static inline uintptr_t CResult_PongDecodeErrorZ_clone_ptr(LDKCResult_PongDecodeErrorZ *NONNULL_PTR arg) {
19776 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
19777 *ret_conv = CResult_PongDecodeErrorZ_clone(arg);
19778 return (uint32_t)ret_conv;
19780 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone_ptr"))) TS_CResult_PongDecodeErrorZ_clone_ptr(uint32_t arg) {
19781 LDKCResult_PongDecodeErrorZ* arg_conv = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
19782 uint32_t ret_conv = CResult_PongDecodeErrorZ_clone_ptr(arg_conv);
19786 uint32_t __attribute__((export_name("TS_CResult_PongDecodeErrorZ_clone"))) TS_CResult_PongDecodeErrorZ_clone(uint32_t orig) {
19787 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
19788 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
19789 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
19790 return (uint32_t)ret_conv;
19793 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
19794 LDKUnsignedChannelAnnouncement o_conv;
19795 o_conv.inner = (void*)(o & (~1));
19796 o_conv.is_owned = (o & 1) || (o == 0);
19797 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19798 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
19799 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
19800 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
19801 return (uint32_t)ret_conv;
19804 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
19805 LDKDecodeError e_conv;
19806 e_conv.inner = (void*)(e & (~1));
19807 e_conv.is_owned = (e & 1) || (e == 0);
19808 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19809 e_conv = DecodeError_clone(&e_conv);
19810 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
19811 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
19812 return (uint32_t)ret_conv;
19815 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
19816 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(o & ~1);
19817 jboolean ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
19821 void __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
19822 if ((_res & 1) != 0) return;
19823 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19824 CHECK_ACCESS(_res_ptr);
19825 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(_res_ptr);
19827 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
19830 static inline uintptr_t CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
19831 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
19832 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(arg);
19833 return (uint32_t)ret_conv;
19835 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
19836 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
19837 uint32_t ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
19841 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
19842 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
19843 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
19844 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
19845 return (uint32_t)ret_conv;
19848 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
19849 LDKChannelAnnouncement o_conv;
19850 o_conv.inner = (void*)(o & (~1));
19851 o_conv.is_owned = (o & 1) || (o == 0);
19852 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19853 o_conv = ChannelAnnouncement_clone(&o_conv);
19854 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
19855 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
19856 return (uint32_t)ret_conv;
19859 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_err"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
19860 LDKDecodeError e_conv;
19861 e_conv.inner = (void*)(e & (~1));
19862 e_conv.is_owned = (e & 1) || (e == 0);
19863 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19864 e_conv = DecodeError_clone(&e_conv);
19865 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
19866 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
19867 return (uint32_t)ret_conv;
19870 jboolean __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
19871 LDKCResult_ChannelAnnouncementDecodeErrorZ* o_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(o & ~1);
19872 jboolean ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_is_ok(o_conv);
19876 void __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_free"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
19877 if ((_res & 1) != 0) return;
19878 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19879 CHECK_ACCESS(_res_ptr);
19880 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(_res_ptr);
19882 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
19885 static inline uintptr_t CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_ChannelAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
19886 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
19887 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(arg);
19888 return (uint32_t)ret_conv;
19890 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
19891 LDKCResult_ChannelAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
19892 uint32_t ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
19896 uint32_t __attribute__((export_name("TS_CResult_ChannelAnnouncementDecodeErrorZ_clone"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
19897 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
19898 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
19899 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
19900 return (uint32_t)ret_conv;
19903 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint32_t o) {
19904 LDKUnsignedChannelUpdate o_conv;
19905 o_conv.inner = (void*)(o & (~1));
19906 o_conv.is_owned = (o & 1) || (o == 0);
19907 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19908 o_conv = UnsignedChannelUpdate_clone(&o_conv);
19909 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
19910 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
19911 return (uint32_t)ret_conv;
19914 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint32_t e) {
19915 LDKDecodeError e_conv;
19916 e_conv.inner = (void*)(e & (~1));
19917 e_conv.is_owned = (e & 1) || (e == 0);
19918 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19919 e_conv = DecodeError_clone(&e_conv);
19920 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
19921 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
19922 return (uint32_t)ret_conv;
19925 jboolean __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
19926 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(o & ~1);
19927 jboolean ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_is_ok(o_conv);
19931 void __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint32_t _res) {
19932 if ((_res & 1) != 0) return;
19933 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19934 CHECK_ACCESS(_res_ptr);
19935 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(_res_ptr);
19937 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
19940 static inline uintptr_t CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_UnsignedChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
19941 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
19942 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(arg);
19943 return (uint32_t)ret_conv;
19945 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
19946 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
19947 uint32_t ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
19951 uint32_t __attribute__((export_name("TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
19952 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
19953 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
19954 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
19955 return (uint32_t)ret_conv;
19958 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint32_t o) {
19959 LDKChannelUpdate o_conv;
19960 o_conv.inner = (void*)(o & (~1));
19961 o_conv.is_owned = (o & 1) || (o == 0);
19962 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
19963 o_conv = ChannelUpdate_clone(&o_conv);
19964 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
19965 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
19966 return (uint32_t)ret_conv;
19969 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_err"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint32_t e) {
19970 LDKDecodeError e_conv;
19971 e_conv.inner = (void*)(e & (~1));
19972 e_conv.is_owned = (e & 1) || (e == 0);
19973 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
19974 e_conv = DecodeError_clone(&e_conv);
19975 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
19976 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
19977 return (uint32_t)ret_conv;
19980 jboolean __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_is_ok"))) TS_CResult_ChannelUpdateDecodeErrorZ_is_ok(uint32_t o) {
19981 LDKCResult_ChannelUpdateDecodeErrorZ* o_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(o & ~1);
19982 jboolean ret_conv = CResult_ChannelUpdateDecodeErrorZ_is_ok(o_conv);
19986 void __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_free"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint32_t _res) {
19987 if ((_res & 1) != 0) return;
19988 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
19989 CHECK_ACCESS(_res_ptr);
19990 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(_res_ptr);
19992 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
19995 static inline uintptr_t CResult_ChannelUpdateDecodeErrorZ_clone_ptr(LDKCResult_ChannelUpdateDecodeErrorZ *NONNULL_PTR arg) {
19996 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
19997 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(arg);
19998 return (uint32_t)ret_conv;
20000 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone_ptr(uint32_t arg) {
20001 LDKCResult_ChannelUpdateDecodeErrorZ* arg_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
20002 uint32_t ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone_ptr(arg_conv);
20006 uint32_t __attribute__((export_name("TS_CResult_ChannelUpdateDecodeErrorZ_clone"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
20007 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
20008 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
20009 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
20010 return (uint32_t)ret_conv;
20013 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint32_t o) {
20014 LDKErrorMessage o_conv;
20015 o_conv.inner = (void*)(o & (~1));
20016 o_conv.is_owned = (o & 1) || (o == 0);
20017 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20018 o_conv = ErrorMessage_clone(&o_conv);
20019 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20020 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
20021 return (uint32_t)ret_conv;
20024 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_err"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint32_t e) {
20025 LDKDecodeError e_conv;
20026 e_conv.inner = (void*)(e & (~1));
20027 e_conv.is_owned = (e & 1) || (e == 0);
20028 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20029 e_conv = DecodeError_clone(&e_conv);
20030 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20031 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
20032 return (uint32_t)ret_conv;
20035 jboolean __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_is_ok"))) TS_CResult_ErrorMessageDecodeErrorZ_is_ok(uint32_t o) {
20036 LDKCResult_ErrorMessageDecodeErrorZ* o_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(o & ~1);
20037 jboolean ret_conv = CResult_ErrorMessageDecodeErrorZ_is_ok(o_conv);
20041 void __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_free"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint32_t _res) {
20042 if ((_res & 1) != 0) return;
20043 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20044 CHECK_ACCESS(_res_ptr);
20045 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(_res_ptr);
20047 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
20050 static inline uintptr_t CResult_ErrorMessageDecodeErrorZ_clone_ptr(LDKCResult_ErrorMessageDecodeErrorZ *NONNULL_PTR arg) {
20051 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20052 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(arg);
20053 return (uint32_t)ret_conv;
20055 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr"))) TS_CResult_ErrorMessageDecodeErrorZ_clone_ptr(uint32_t arg) {
20056 LDKCResult_ErrorMessageDecodeErrorZ* arg_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
20057 uint32_t ret_conv = CResult_ErrorMessageDecodeErrorZ_clone_ptr(arg_conv);
20061 uint32_t __attribute__((export_name("TS_CResult_ErrorMessageDecodeErrorZ_clone"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint32_t orig) {
20062 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
20063 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
20064 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
20065 return (uint32_t)ret_conv;
20068 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_ok"))) TS_CResult_WarningMessageDecodeErrorZ_ok(uint32_t o) {
20069 LDKWarningMessage o_conv;
20070 o_conv.inner = (void*)(o & (~1));
20071 o_conv.is_owned = (o & 1) || (o == 0);
20072 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20073 o_conv = WarningMessage_clone(&o_conv);
20074 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20075 *ret_conv = CResult_WarningMessageDecodeErrorZ_ok(o_conv);
20076 return (uint32_t)ret_conv;
20079 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_err"))) TS_CResult_WarningMessageDecodeErrorZ_err(uint32_t e) {
20080 LDKDecodeError e_conv;
20081 e_conv.inner = (void*)(e & (~1));
20082 e_conv.is_owned = (e & 1) || (e == 0);
20083 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20084 e_conv = DecodeError_clone(&e_conv);
20085 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20086 *ret_conv = CResult_WarningMessageDecodeErrorZ_err(e_conv);
20087 return (uint32_t)ret_conv;
20090 jboolean __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_is_ok"))) TS_CResult_WarningMessageDecodeErrorZ_is_ok(uint32_t o) {
20091 LDKCResult_WarningMessageDecodeErrorZ* o_conv = (LDKCResult_WarningMessageDecodeErrorZ*)(o & ~1);
20092 jboolean ret_conv = CResult_WarningMessageDecodeErrorZ_is_ok(o_conv);
20096 void __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_free"))) TS_CResult_WarningMessageDecodeErrorZ_free(uint32_t _res) {
20097 if ((_res & 1) != 0) return;
20098 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20099 CHECK_ACCESS(_res_ptr);
20100 LDKCResult_WarningMessageDecodeErrorZ _res_conv = *(LDKCResult_WarningMessageDecodeErrorZ*)(_res_ptr);
20102 CResult_WarningMessageDecodeErrorZ_free(_res_conv);
20105 static inline uintptr_t CResult_WarningMessageDecodeErrorZ_clone_ptr(LDKCResult_WarningMessageDecodeErrorZ *NONNULL_PTR arg) {
20106 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20107 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(arg);
20108 return (uint32_t)ret_conv;
20110 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone_ptr"))) TS_CResult_WarningMessageDecodeErrorZ_clone_ptr(uint32_t arg) {
20111 LDKCResult_WarningMessageDecodeErrorZ* arg_conv = (LDKCResult_WarningMessageDecodeErrorZ*)(arg & ~1);
20112 uint32_t ret_conv = CResult_WarningMessageDecodeErrorZ_clone_ptr(arg_conv);
20116 uint32_t __attribute__((export_name("TS_CResult_WarningMessageDecodeErrorZ_clone"))) TS_CResult_WarningMessageDecodeErrorZ_clone(uint32_t orig) {
20117 LDKCResult_WarningMessageDecodeErrorZ* orig_conv = (LDKCResult_WarningMessageDecodeErrorZ*)(orig & ~1);
20118 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
20119 *ret_conv = CResult_WarningMessageDecodeErrorZ_clone(orig_conv);
20120 return (uint32_t)ret_conv;
20123 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
20124 LDKUnsignedNodeAnnouncement o_conv;
20125 o_conv.inner = (void*)(o & (~1));
20126 o_conv.is_owned = (o & 1) || (o == 0);
20127 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20128 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
20129 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
20130 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
20131 return (uint32_t)ret_conv;
20134 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint32_t e) {
20135 LDKDecodeError e_conv;
20136 e_conv.inner = (void*)(e & (~1));
20137 e_conv.is_owned = (e & 1) || (e == 0);
20138 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20139 e_conv = DecodeError_clone(&e_conv);
20140 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
20141 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
20142 return (uint32_t)ret_conv;
20145 jboolean __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
20146 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(o & ~1);
20147 jboolean ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_is_ok(o_conv);
20151 void __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
20152 if ((_res & 1) != 0) return;
20153 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20154 CHECK_ACCESS(_res_ptr);
20155 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(_res_ptr);
20157 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
20160 static inline uintptr_t CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
20161 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
20162 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(arg);
20163 return (uint32_t)ret_conv;
20165 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
20166 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
20167 uint32_t ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
20171 uint32_t __attribute__((export_name("TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
20172 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
20173 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
20174 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
20175 return (uint32_t)ret_conv;
20178 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
20179 LDKNodeAnnouncement o_conv;
20180 o_conv.inner = (void*)(o & (~1));
20181 o_conv.is_owned = (o & 1) || (o == 0);
20182 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20183 o_conv = NodeAnnouncement_clone(&o_conv);
20184 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
20185 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
20186 return (uint32_t)ret_conv;
20189 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_err"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint32_t e) {
20190 LDKDecodeError e_conv;
20191 e_conv.inner = (void*)(e & (~1));
20192 e_conv.is_owned = (e & 1) || (e == 0);
20193 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20194 e_conv = DecodeError_clone(&e_conv);
20195 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
20196 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
20197 return (uint32_t)ret_conv;
20200 jboolean __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok"))) TS_CResult_NodeAnnouncementDecodeErrorZ_is_ok(uint32_t o) {
20201 LDKCResult_NodeAnnouncementDecodeErrorZ* o_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(o & ~1);
20202 jboolean ret_conv = CResult_NodeAnnouncementDecodeErrorZ_is_ok(o_conv);
20206 void __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_free"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
20207 if ((_res & 1) != 0) return;
20208 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20209 CHECK_ACCESS(_res_ptr);
20210 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(_res_ptr);
20212 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
20215 static inline uintptr_t CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(LDKCResult_NodeAnnouncementDecodeErrorZ *NONNULL_PTR arg) {
20216 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
20217 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(arg);
20218 return (uint32_t)ret_conv;
20220 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(uint32_t arg) {
20221 LDKCResult_NodeAnnouncementDecodeErrorZ* arg_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
20222 uint32_t ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone_ptr(arg_conv);
20226 uint32_t __attribute__((export_name("TS_CResult_NodeAnnouncementDecodeErrorZ_clone"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
20227 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
20228 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
20229 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
20230 return (uint32_t)ret_conv;
20233 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint32_t o) {
20234 LDKQueryShortChannelIds o_conv;
20235 o_conv.inner = (void*)(o & (~1));
20236 o_conv.is_owned = (o & 1) || (o == 0);
20237 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20238 o_conv = QueryShortChannelIds_clone(&o_conv);
20239 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
20240 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
20241 return (uint32_t)ret_conv;
20244 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_err"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint32_t e) {
20245 LDKDecodeError e_conv;
20246 e_conv.inner = (void*)(e & (~1));
20247 e_conv.is_owned = (e & 1) || (e == 0);
20248 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20249 e_conv = DecodeError_clone(&e_conv);
20250 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
20251 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
20252 return (uint32_t)ret_conv;
20255 jboolean __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(uint32_t o) {
20256 LDKCResult_QueryShortChannelIdsDecodeErrorZ* o_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(o & ~1);
20257 jboolean ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_is_ok(o_conv);
20261 void __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_free"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint32_t _res) {
20262 if ((_res & 1) != 0) return;
20263 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20264 CHECK_ACCESS(_res_ptr);
20265 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(_res_ptr);
20267 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
20270 static inline uintptr_t CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(LDKCResult_QueryShortChannelIdsDecodeErrorZ *NONNULL_PTR arg) {
20271 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
20272 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(arg);
20273 return (uint32_t)ret_conv;
20275 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(uint32_t arg) {
20276 LDKCResult_QueryShortChannelIdsDecodeErrorZ* arg_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
20277 uint32_t ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone_ptr(arg_conv);
20281 uint32_t __attribute__((export_name("TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint32_t orig) {
20282 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
20283 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
20284 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
20285 return (uint32_t)ret_conv;
20288 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint32_t o) {
20289 LDKReplyShortChannelIdsEnd o_conv;
20290 o_conv.inner = (void*)(o & (~1));
20291 o_conv.is_owned = (o & 1) || (o == 0);
20292 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20293 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
20294 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
20295 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
20296 return (uint32_t)ret_conv;
20299 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint32_t e) {
20300 LDKDecodeError e_conv;
20301 e_conv.inner = (void*)(e & (~1));
20302 e_conv.is_owned = (e & 1) || (e == 0);
20303 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20304 e_conv = DecodeError_clone(&e_conv);
20305 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
20306 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
20307 return (uint32_t)ret_conv;
20310 jboolean __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(uint32_t o) {
20311 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* o_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(o & ~1);
20312 jboolean ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_is_ok(o_conv);
20316 void __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint32_t _res) {
20317 if ((_res & 1) != 0) return;
20318 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20319 CHECK_ACCESS(_res_ptr);
20320 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(_res_ptr);
20322 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
20325 static inline uintptr_t CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *NONNULL_PTR arg) {
20326 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
20327 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(arg);
20328 return (uint32_t)ret_conv;
20330 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(uint32_t arg) {
20331 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* arg_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
20332 uint32_t ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone_ptr(arg_conv);
20336 uint32_t __attribute__((export_name("TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint32_t orig) {
20337 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
20338 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
20339 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
20340 return (uint32_t)ret_conv;
20343 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint32_t o) {
20344 LDKQueryChannelRange o_conv;
20345 o_conv.inner = (void*)(o & (~1));
20346 o_conv.is_owned = (o & 1) || (o == 0);
20347 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20348 o_conv = QueryChannelRange_clone(&o_conv);
20349 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
20350 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
20351 return (uint32_t)ret_conv;
20354 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_err"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint32_t e) {
20355 LDKDecodeError e_conv;
20356 e_conv.inner = (void*)(e & (~1));
20357 e_conv.is_owned = (e & 1) || (e == 0);
20358 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20359 e_conv = DecodeError_clone(&e_conv);
20360 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
20361 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
20362 return (uint32_t)ret_conv;
20365 jboolean __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_QueryChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
20366 LDKCResult_QueryChannelRangeDecodeErrorZ* o_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(o & ~1);
20367 jboolean ret_conv = CResult_QueryChannelRangeDecodeErrorZ_is_ok(o_conv);
20371 void __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_free"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint32_t _res) {
20372 if ((_res & 1) != 0) return;
20373 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20374 CHECK_ACCESS(_res_ptr);
20375 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(_res_ptr);
20377 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
20380 static inline uintptr_t CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_QueryChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
20381 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
20382 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(arg);
20383 return (uint32_t)ret_conv;
20385 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
20386 LDKCResult_QueryChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
20387 uint32_t ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
20391 uint32_t __attribute__((export_name("TS_CResult_QueryChannelRangeDecodeErrorZ_clone"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint32_t orig) {
20392 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
20393 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
20394 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
20395 return (uint32_t)ret_conv;
20398 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint32_t o) {
20399 LDKReplyChannelRange o_conv;
20400 o_conv.inner = (void*)(o & (~1));
20401 o_conv.is_owned = (o & 1) || (o == 0);
20402 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20403 o_conv = ReplyChannelRange_clone(&o_conv);
20404 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
20405 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
20406 return (uint32_t)ret_conv;
20409 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_err"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint32_t e) {
20410 LDKDecodeError e_conv;
20411 e_conv.inner = (void*)(e & (~1));
20412 e_conv.is_owned = (e & 1) || (e == 0);
20413 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20414 e_conv = DecodeError_clone(&e_conv);
20415 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
20416 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
20417 return (uint32_t)ret_conv;
20420 jboolean __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_is_ok(uint32_t o) {
20421 LDKCResult_ReplyChannelRangeDecodeErrorZ* o_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(o & ~1);
20422 jboolean ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_is_ok(o_conv);
20426 void __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_free"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint32_t _res) {
20427 if ((_res & 1) != 0) return;
20428 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20429 CHECK_ACCESS(_res_ptr);
20430 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(_res_ptr);
20432 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
20435 static inline uintptr_t CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(LDKCResult_ReplyChannelRangeDecodeErrorZ *NONNULL_PTR arg) {
20436 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
20437 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(arg);
20438 return (uint32_t)ret_conv;
20440 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(uint32_t arg) {
20441 LDKCResult_ReplyChannelRangeDecodeErrorZ* arg_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
20442 uint32_t ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone_ptr(arg_conv);
20446 uint32_t __attribute__((export_name("TS_CResult_ReplyChannelRangeDecodeErrorZ_clone"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint32_t orig) {
20447 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
20448 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
20449 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
20450 return (uint32_t)ret_conv;
20453 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint32_t o) {
20454 LDKGossipTimestampFilter o_conv;
20455 o_conv.inner = (void*)(o & (~1));
20456 o_conv.is_owned = (o & 1) || (o == 0);
20457 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20458 o_conv = GossipTimestampFilter_clone(&o_conv);
20459 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
20460 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
20461 return (uint32_t)ret_conv;
20464 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_err"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint32_t e) {
20465 LDKDecodeError e_conv;
20466 e_conv.inner = (void*)(e & (~1));
20467 e_conv.is_owned = (e & 1) || (e == 0);
20468 CHECK_INNER_FIELD_ACCESS_OR_NULL(e_conv);
20469 e_conv = DecodeError_clone(&e_conv);
20470 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
20471 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
20472 return (uint32_t)ret_conv;
20475 jboolean __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_is_ok(uint32_t o) {
20476 LDKCResult_GossipTimestampFilterDecodeErrorZ* o_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(o & ~1);
20477 jboolean ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_is_ok(o_conv);
20481 void __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_free"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint32_t _res) {
20482 if ((_res & 1) != 0) return;
20483 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20484 CHECK_ACCESS(_res_ptr);
20485 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(_res_ptr);
20487 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
20490 static inline uintptr_t CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(LDKCResult_GossipTimestampFilterDecodeErrorZ *NONNULL_PTR arg) {
20491 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
20492 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(arg);
20493 return (uint32_t)ret_conv;
20495 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(uint32_t arg) {
20496 LDKCResult_GossipTimestampFilterDecodeErrorZ* arg_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
20497 uint32_t ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone_ptr(arg_conv);
20501 uint32_t __attribute__((export_name("TS_CResult_GossipTimestampFilterDecodeErrorZ_clone"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint32_t orig) {
20502 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
20503 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
20504 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
20505 return (uint32_t)ret_conv;
20508 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint32_t o) {
20510 o_conv.inner = (void*)(o & (~1));
20511 o_conv.is_owned = (o & 1) || (o == 0);
20512 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20513 o_conv = Invoice_clone(&o_conv);
20514 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
20515 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
20516 return (uint32_t)ret_conv;
20519 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_err"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint32_t e) {
20520 void* e_ptr = (void*)(((uintptr_t)e) & ~1);
20521 CHECK_ACCESS(e_ptr);
20522 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(e_ptr);
20523 e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)(((uintptr_t)e) & ~1));
20524 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
20525 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
20526 return (uint32_t)ret_conv;
20529 jboolean __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_is_ok"))) TS_CResult_InvoiceSignOrCreationErrorZ_is_ok(uint32_t o) {
20530 LDKCResult_InvoiceSignOrCreationErrorZ* o_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(o & ~1);
20531 jboolean ret_conv = CResult_InvoiceSignOrCreationErrorZ_is_ok(o_conv);
20535 void __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_free"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint32_t _res) {
20536 if ((_res & 1) != 0) return;
20537 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20538 CHECK_ACCESS(_res_ptr);
20539 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(_res_ptr);
20541 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
20544 static inline uintptr_t CResult_InvoiceSignOrCreationErrorZ_clone_ptr(LDKCResult_InvoiceSignOrCreationErrorZ *NONNULL_PTR arg) {
20545 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
20546 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(arg);
20547 return (uint32_t)ret_conv;
20549 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone_ptr(uint32_t arg) {
20550 LDKCResult_InvoiceSignOrCreationErrorZ* arg_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
20551 uint32_t ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone_ptr(arg_conv);
20555 uint32_t __attribute__((export_name("TS_CResult_InvoiceSignOrCreationErrorZ_clone"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint32_t orig) {
20556 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
20557 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
20558 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
20559 return (uint32_t)ret_conv;
20562 uint32_t __attribute__((export_name("TS_COption_FilterZ_some"))) TS_COption_FilterZ_some(uint32_t o) {
20563 void* o_ptr = (void*)(((uintptr_t)o) & ~1);
20564 CHECK_ACCESS(o_ptr);
20565 LDKFilter o_conv = *(LDKFilter*)(o_ptr);
20566 if (o_conv.free == LDKFilter_JCalls_free) {
20567 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
20568 LDKFilter_JCalls_cloned(&o_conv);
20570 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
20571 *ret_copy = COption_FilterZ_some(o_conv);
20572 uint32_t ret_ref = (uintptr_t)ret_copy;
20576 uint32_t __attribute__((export_name("TS_COption_FilterZ_none"))) TS_COption_FilterZ_none() {
20577 LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ");
20578 *ret_copy = COption_FilterZ_none();
20579 uint32_t ret_ref = (uintptr_t)ret_copy;
20583 void __attribute__((export_name("TS_COption_FilterZ_free"))) TS_COption_FilterZ_free(uint32_t _res) {
20584 if ((_res & 1) != 0) return;
20585 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20586 CHECK_ACCESS(_res_ptr);
20587 LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(_res_ptr);
20589 COption_FilterZ_free(_res_conv);
20592 uint32_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_ok"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint32_t o) {
20593 LDKLockedChannelMonitor o_conv;
20594 o_conv.inner = (void*)(o & (~1));
20595 o_conv.is_owned = (o & 1) || (o == 0);
20596 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
20597 // WARNING: we need a move here but no clone is available for LDKLockedChannelMonitor
20598 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
20599 *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv);
20600 return (uint32_t)ret_conv;
20603 uint32_t __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_err"))) TS_CResult_LockedChannelMonitorNoneZ_err() {
20604 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
20605 *ret_conv = CResult_LockedChannelMonitorNoneZ_err();
20606 return (uint32_t)ret_conv;
20609 jboolean __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_is_ok"))) TS_CResult_LockedChannelMonitorNoneZ_is_ok(uint32_t o) {
20610 LDKCResult_LockedChannelMonitorNoneZ* o_conv = (LDKCResult_LockedChannelMonitorNoneZ*)(o & ~1);
20611 jboolean ret_conv = CResult_LockedChannelMonitorNoneZ_is_ok(o_conv);
20615 void __attribute__((export_name("TS_CResult_LockedChannelMonitorNoneZ_free"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint32_t _res) {
20616 if ((_res & 1) != 0) return;
20617 void* _res_ptr = (void*)(((uintptr_t)_res) & ~1);
20618 CHECK_ACCESS(_res_ptr);
20619 LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(_res_ptr);
20621 CResult_LockedChannelMonitorNoneZ_free(_res_conv);
20624 void __attribute__((export_name("TS_CVec_OutPointZ_free"))) TS_CVec_OutPointZ_free(uint32_tArray _res) {
20625 LDKCVec_OutPointZ _res_constr;
20626 _res_constr.datalen = _res->arr_len;
20627 if (_res_constr.datalen > 0)
20628 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements");
20630 _res_constr.data = NULL;
20631 uint32_t* _res_vals = _res->elems;
20632 for (size_t k = 0; k < _res_constr.datalen; k++) {
20633 uint32_t _res_conv_10 = _res_vals[k];
20634 LDKOutPoint _res_conv_10_conv;
20635 _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
20636 _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
20637 CHECK_INNER_FIELD_ACCESS_OR_NULL(_res_conv_10_conv);
20638 _res_constr.data[k] = _res_conv_10_conv;
20641 CVec_OutPointZ_free(_res_constr);
20644 void __attribute__((export_name("TS_PaymentPurpose_free"))) TS_PaymentPurpose_free(uint32_t this_ptr) {
20645 if ((this_ptr & 1) != 0) return;
20646 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
20647 CHECK_ACCESS(this_ptr_ptr);
20648 LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(this_ptr_ptr);
20649 FREE((void*)this_ptr);
20650 PaymentPurpose_free(this_ptr_conv);
20653 static inline uintptr_t PaymentPurpose_clone_ptr(LDKPaymentPurpose *NONNULL_PTR arg) {
20654 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
20655 *ret_copy = PaymentPurpose_clone(arg);
20656 uint32_t ret_ref = (uintptr_t)ret_copy;
20659 uint32_t __attribute__((export_name("TS_PaymentPurpose_clone_ptr"))) TS_PaymentPurpose_clone_ptr(uint32_t arg) {
20660 LDKPaymentPurpose* arg_conv = (LDKPaymentPurpose*)arg;
20661 uint32_t ret_conv = PaymentPurpose_clone_ptr(arg_conv);
20665 uint32_t __attribute__((export_name("TS_PaymentPurpose_clone"))) TS_PaymentPurpose_clone(uint32_t orig) {
20666 LDKPaymentPurpose* orig_conv = (LDKPaymentPurpose*)orig;
20667 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
20668 *ret_copy = PaymentPurpose_clone(orig_conv);
20669 uint32_t ret_ref = (uintptr_t)ret_copy;
20673 uint32_t __attribute__((export_name("TS_PaymentPurpose_invoice_payment"))) TS_PaymentPurpose_invoice_payment(int8_tArray payment_preimage, int8_tArray payment_secret) {
20674 LDKThirtyTwoBytes payment_preimage_ref;
20675 CHECK(payment_preimage->arr_len == 32);
20676 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
20677 LDKThirtyTwoBytes payment_secret_ref;
20678 CHECK(payment_secret->arr_len == 32);
20679 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
20680 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
20681 *ret_copy = PaymentPurpose_invoice_payment(payment_preimage_ref, payment_secret_ref);
20682 uint32_t ret_ref = (uintptr_t)ret_copy;
20686 uint32_t __attribute__((export_name("TS_PaymentPurpose_spontaneous_payment"))) TS_PaymentPurpose_spontaneous_payment(int8_tArray a) {
20687 LDKThirtyTwoBytes a_ref;
20688 CHECK(a->arr_len == 32);
20689 memcpy(a_ref.data, a->elems, 32); FREE(a);
20690 LDKPaymentPurpose *ret_copy = MALLOC(sizeof(LDKPaymentPurpose), "LDKPaymentPurpose");
20691 *ret_copy = PaymentPurpose_spontaneous_payment(a_ref);
20692 uint32_t ret_ref = (uintptr_t)ret_copy;
20696 int8_tArray __attribute__((export_name("TS_PaymentPurpose_write"))) TS_PaymentPurpose_write(uint32_t obj) {
20697 LDKPaymentPurpose* obj_conv = (LDKPaymentPurpose*)obj;
20698 LDKCVec_u8Z ret_var = PaymentPurpose_write(obj_conv);
20699 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
20700 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
20701 CVec_u8Z_free(ret_var);
20705 uint32_t __attribute__((export_name("TS_PaymentPurpose_read"))) TS_PaymentPurpose_read(int8_tArray ser) {
20706 LDKu8slice ser_ref;
20707 ser_ref.datalen = ser->arr_len;
20708 ser_ref.data = ser->elems;
20709 LDKCResult_PaymentPurposeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPurposeDecodeErrorZ), "LDKCResult_PaymentPurposeDecodeErrorZ");
20710 *ret_conv = PaymentPurpose_read(ser_ref);
20712 return (uint32_t)ret_conv;
20715 void __attribute__((export_name("TS_ClosureReason_free"))) TS_ClosureReason_free(uint32_t this_ptr) {
20716 if ((this_ptr & 1) != 0) return;
20717 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
20718 CHECK_ACCESS(this_ptr_ptr);
20719 LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(this_ptr_ptr);
20720 FREE((void*)this_ptr);
20721 ClosureReason_free(this_ptr_conv);
20724 static inline uintptr_t ClosureReason_clone_ptr(LDKClosureReason *NONNULL_PTR arg) {
20725 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20726 *ret_copy = ClosureReason_clone(arg);
20727 uint32_t ret_ref = (uintptr_t)ret_copy;
20730 uint32_t __attribute__((export_name("TS_ClosureReason_clone_ptr"))) TS_ClosureReason_clone_ptr(uint32_t arg) {
20731 LDKClosureReason* arg_conv = (LDKClosureReason*)arg;
20732 uint32_t ret_conv = ClosureReason_clone_ptr(arg_conv);
20736 uint32_t __attribute__((export_name("TS_ClosureReason_clone"))) TS_ClosureReason_clone(uint32_t orig) {
20737 LDKClosureReason* orig_conv = (LDKClosureReason*)orig;
20738 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20739 *ret_copy = ClosureReason_clone(orig_conv);
20740 uint32_t ret_ref = (uintptr_t)ret_copy;
20744 uint32_t __attribute__((export_name("TS_ClosureReason_counterparty_force_closed"))) TS_ClosureReason_counterparty_force_closed(jstring peer_msg) {
20745 LDKStr peer_msg_conv = str_ref_to_owned_c(peer_msg);
20746 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20747 *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv);
20748 uint32_t ret_ref = (uintptr_t)ret_copy;
20752 uint32_t __attribute__((export_name("TS_ClosureReason_holder_force_closed"))) TS_ClosureReason_holder_force_closed() {
20753 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20754 *ret_copy = ClosureReason_holder_force_closed();
20755 uint32_t ret_ref = (uintptr_t)ret_copy;
20759 uint32_t __attribute__((export_name("TS_ClosureReason_cooperative_closure"))) TS_ClosureReason_cooperative_closure() {
20760 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20761 *ret_copy = ClosureReason_cooperative_closure();
20762 uint32_t ret_ref = (uintptr_t)ret_copy;
20766 uint32_t __attribute__((export_name("TS_ClosureReason_commitment_tx_confirmed"))) TS_ClosureReason_commitment_tx_confirmed() {
20767 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20768 *ret_copy = ClosureReason_commitment_tx_confirmed();
20769 uint32_t ret_ref = (uintptr_t)ret_copy;
20773 uint32_t __attribute__((export_name("TS_ClosureReason_funding_timed_out"))) TS_ClosureReason_funding_timed_out() {
20774 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20775 *ret_copy = ClosureReason_funding_timed_out();
20776 uint32_t ret_ref = (uintptr_t)ret_copy;
20780 uint32_t __attribute__((export_name("TS_ClosureReason_processing_error"))) TS_ClosureReason_processing_error(jstring err) {
20781 LDKStr err_conv = str_ref_to_owned_c(err);
20782 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20783 *ret_copy = ClosureReason_processing_error(err_conv);
20784 uint32_t ret_ref = (uintptr_t)ret_copy;
20788 uint32_t __attribute__((export_name("TS_ClosureReason_disconnected_peer"))) TS_ClosureReason_disconnected_peer() {
20789 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20790 *ret_copy = ClosureReason_disconnected_peer();
20791 uint32_t ret_ref = (uintptr_t)ret_copy;
20795 uint32_t __attribute__((export_name("TS_ClosureReason_outdated_channel_manager"))) TS_ClosureReason_outdated_channel_manager() {
20796 LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason");
20797 *ret_copy = ClosureReason_outdated_channel_manager();
20798 uint32_t ret_ref = (uintptr_t)ret_copy;
20802 int8_tArray __attribute__((export_name("TS_ClosureReason_write"))) TS_ClosureReason_write(uint32_t obj) {
20803 LDKClosureReason* obj_conv = (LDKClosureReason*)obj;
20804 LDKCVec_u8Z ret_var = ClosureReason_write(obj_conv);
20805 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
20806 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
20807 CVec_u8Z_free(ret_var);
20811 uint32_t __attribute__((export_name("TS_ClosureReason_read"))) TS_ClosureReason_read(int8_tArray ser) {
20812 LDKu8slice ser_ref;
20813 ser_ref.datalen = ser->arr_len;
20814 ser_ref.data = ser->elems;
20815 LDKCResult_COption_ClosureReasonZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_ClosureReasonZDecodeErrorZ), "LDKCResult_COption_ClosureReasonZDecodeErrorZ");
20816 *ret_conv = ClosureReason_read(ser_ref);
20818 return (uint32_t)ret_conv;
20821 void __attribute__((export_name("TS_HTLCDestination_free"))) TS_HTLCDestination_free(uint32_t this_ptr) {
20822 if ((this_ptr & 1) != 0) return;
20823 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
20824 CHECK_ACCESS(this_ptr_ptr);
20825 LDKHTLCDestination this_ptr_conv = *(LDKHTLCDestination*)(this_ptr_ptr);
20826 FREE((void*)this_ptr);
20827 HTLCDestination_free(this_ptr_conv);
20830 static inline uintptr_t HTLCDestination_clone_ptr(LDKHTLCDestination *NONNULL_PTR arg) {
20831 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
20832 *ret_copy = HTLCDestination_clone(arg);
20833 uint32_t ret_ref = (uintptr_t)ret_copy;
20836 uint32_t __attribute__((export_name("TS_HTLCDestination_clone_ptr"))) TS_HTLCDestination_clone_ptr(uint32_t arg) {
20837 LDKHTLCDestination* arg_conv = (LDKHTLCDestination*)arg;
20838 uint32_t ret_conv = HTLCDestination_clone_ptr(arg_conv);
20842 uint32_t __attribute__((export_name("TS_HTLCDestination_clone"))) TS_HTLCDestination_clone(uint32_t orig) {
20843 LDKHTLCDestination* orig_conv = (LDKHTLCDestination*)orig;
20844 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
20845 *ret_copy = HTLCDestination_clone(orig_conv);
20846 uint32_t ret_ref = (uintptr_t)ret_copy;
20850 uint32_t __attribute__((export_name("TS_HTLCDestination_next_hop_channel"))) TS_HTLCDestination_next_hop_channel(int8_tArray node_id, int8_tArray channel_id) {
20851 LDKPublicKey node_id_ref;
20852 CHECK(node_id->arr_len == 33);
20853 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
20854 LDKThirtyTwoBytes channel_id_ref;
20855 CHECK(channel_id->arr_len == 32);
20856 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
20857 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
20858 *ret_copy = HTLCDestination_next_hop_channel(node_id_ref, channel_id_ref);
20859 uint32_t ret_ref = (uintptr_t)ret_copy;
20863 uint32_t __attribute__((export_name("TS_HTLCDestination_unknown_next_hop"))) TS_HTLCDestination_unknown_next_hop(int64_t requested_forward_scid) {
20864 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
20865 *ret_copy = HTLCDestination_unknown_next_hop(requested_forward_scid);
20866 uint32_t ret_ref = (uintptr_t)ret_copy;
20870 uint32_t __attribute__((export_name("TS_HTLCDestination_failed_payment"))) TS_HTLCDestination_failed_payment(int8_tArray payment_hash) {
20871 LDKThirtyTwoBytes payment_hash_ref;
20872 CHECK(payment_hash->arr_len == 32);
20873 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
20874 LDKHTLCDestination *ret_copy = MALLOC(sizeof(LDKHTLCDestination), "LDKHTLCDestination");
20875 *ret_copy = HTLCDestination_failed_payment(payment_hash_ref);
20876 uint32_t ret_ref = (uintptr_t)ret_copy;
20880 int8_tArray __attribute__((export_name("TS_HTLCDestination_write"))) TS_HTLCDestination_write(uint32_t obj) {
20881 LDKHTLCDestination* obj_conv = (LDKHTLCDestination*)obj;
20882 LDKCVec_u8Z ret_var = HTLCDestination_write(obj_conv);
20883 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
20884 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
20885 CVec_u8Z_free(ret_var);
20889 uint32_t __attribute__((export_name("TS_HTLCDestination_read"))) TS_HTLCDestination_read(int8_tArray ser) {
20890 LDKu8slice ser_ref;
20891 ser_ref.datalen = ser->arr_len;
20892 ser_ref.data = ser->elems;
20893 LDKCResult_COption_HTLCDestinationZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_HTLCDestinationZDecodeErrorZ), "LDKCResult_COption_HTLCDestinationZDecodeErrorZ");
20894 *ret_conv = HTLCDestination_read(ser_ref);
20896 return (uint32_t)ret_conv;
20899 void __attribute__((export_name("TS_Event_free"))) TS_Event_free(uint32_t this_ptr) {
20900 if ((this_ptr & 1) != 0) return;
20901 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
20902 CHECK_ACCESS(this_ptr_ptr);
20903 LDKEvent this_ptr_conv = *(LDKEvent*)(this_ptr_ptr);
20904 FREE((void*)this_ptr);
20905 Event_free(this_ptr_conv);
20908 static inline uintptr_t Event_clone_ptr(LDKEvent *NONNULL_PTR arg) {
20909 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20910 *ret_copy = Event_clone(arg);
20911 uint32_t ret_ref = (uintptr_t)ret_copy;
20914 uint32_t __attribute__((export_name("TS_Event_clone_ptr"))) TS_Event_clone_ptr(uint32_t arg) {
20915 LDKEvent* arg_conv = (LDKEvent*)arg;
20916 uint32_t ret_conv = Event_clone_ptr(arg_conv);
20920 uint32_t __attribute__((export_name("TS_Event_clone"))) TS_Event_clone(uint32_t orig) {
20921 LDKEvent* orig_conv = (LDKEvent*)orig;
20922 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20923 *ret_copy = Event_clone(orig_conv);
20924 uint32_t ret_ref = (uintptr_t)ret_copy;
20928 uint32_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, int64_t user_channel_id) {
20929 LDKThirtyTwoBytes temporary_channel_id_ref;
20930 CHECK(temporary_channel_id->arr_len == 32);
20931 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
20932 LDKPublicKey counterparty_node_id_ref;
20933 CHECK(counterparty_node_id->arr_len == 33);
20934 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
20935 LDKCVec_u8Z output_script_ref;
20936 output_script_ref.datalen = output_script->arr_len;
20937 output_script_ref.data = MALLOC(output_script_ref.datalen, "LDKCVec_u8Z Bytes");
20938 memcpy(output_script_ref.data, output_script->elems, output_script_ref.datalen); FREE(output_script);
20939 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20940 *ret_copy = Event_funding_generation_ready(temporary_channel_id_ref, counterparty_node_id_ref, channel_value_satoshis, output_script_ref, user_channel_id);
20941 uint32_t ret_ref = (uintptr_t)ret_copy;
20945 uint32_t __attribute__((export_name("TS_Event_payment_received"))) TS_Event_payment_received(int8_tArray payment_hash, int64_t amount_msat, uint32_t purpose) {
20946 LDKThirtyTwoBytes payment_hash_ref;
20947 CHECK(payment_hash->arr_len == 32);
20948 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
20949 void* purpose_ptr = (void*)(((uintptr_t)purpose) & ~1);
20950 CHECK_ACCESS(purpose_ptr);
20951 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
20952 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)(((uintptr_t)purpose) & ~1));
20953 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20954 *ret_copy = Event_payment_received(payment_hash_ref, amount_msat, purpose_conv);
20955 uint32_t ret_ref = (uintptr_t)ret_copy;
20959 uint32_t __attribute__((export_name("TS_Event_payment_claimed"))) TS_Event_payment_claimed(int8_tArray payment_hash, int64_t amount_msat, uint32_t purpose) {
20960 LDKThirtyTwoBytes payment_hash_ref;
20961 CHECK(payment_hash->arr_len == 32);
20962 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
20963 void* purpose_ptr = (void*)(((uintptr_t)purpose) & ~1);
20964 CHECK_ACCESS(purpose_ptr);
20965 LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(purpose_ptr);
20966 purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)(((uintptr_t)purpose) & ~1));
20967 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20968 *ret_copy = Event_payment_claimed(payment_hash_ref, amount_msat, purpose_conv);
20969 uint32_t ret_ref = (uintptr_t)ret_copy;
20973 uint32_t __attribute__((export_name("TS_Event_payment_sent"))) TS_Event_payment_sent(int8_tArray payment_id, int8_tArray payment_preimage, int8_tArray payment_hash, uint32_t fee_paid_msat) {
20974 LDKThirtyTwoBytes payment_id_ref;
20975 CHECK(payment_id->arr_len == 32);
20976 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
20977 LDKThirtyTwoBytes payment_preimage_ref;
20978 CHECK(payment_preimage->arr_len == 32);
20979 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
20980 LDKThirtyTwoBytes payment_hash_ref;
20981 CHECK(payment_hash->arr_len == 32);
20982 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
20983 void* fee_paid_msat_ptr = (void*)(((uintptr_t)fee_paid_msat) & ~1);
20984 CHECK_ACCESS(fee_paid_msat_ptr);
20985 LDKCOption_u64Z fee_paid_msat_conv = *(LDKCOption_u64Z*)(fee_paid_msat_ptr);
20986 fee_paid_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)fee_paid_msat) & ~1));
20987 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
20988 *ret_copy = Event_payment_sent(payment_id_ref, payment_preimage_ref, payment_hash_ref, fee_paid_msat_conv);
20989 uint32_t ret_ref = (uintptr_t)ret_copy;
20993 uint32_t __attribute__((export_name("TS_Event_payment_failed"))) TS_Event_payment_failed(int8_tArray payment_id, int8_tArray payment_hash) {
20994 LDKThirtyTwoBytes payment_id_ref;
20995 CHECK(payment_id->arr_len == 32);
20996 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
20997 LDKThirtyTwoBytes payment_hash_ref;
20998 CHECK(payment_hash->arr_len == 32);
20999 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21000 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21001 *ret_copy = Event_payment_failed(payment_id_ref, payment_hash_ref);
21002 uint32_t ret_ref = (uintptr_t)ret_copy;
21006 uint32_t __attribute__((export_name("TS_Event_payment_path_successful"))) TS_Event_payment_path_successful(int8_tArray payment_id, int8_tArray payment_hash, uint32_tArray path) {
21007 LDKThirtyTwoBytes payment_id_ref;
21008 CHECK(payment_id->arr_len == 32);
21009 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
21010 LDKThirtyTwoBytes payment_hash_ref;
21011 CHECK(payment_hash->arr_len == 32);
21012 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21013 LDKCVec_RouteHopZ path_constr;
21014 path_constr.datalen = path->arr_len;
21015 if (path_constr.datalen > 0)
21016 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
21018 path_constr.data = NULL;
21019 uint32_t* path_vals = path->elems;
21020 for (size_t k = 0; k < path_constr.datalen; k++) {
21021 uint32_t path_conv_10 = path_vals[k];
21022 LDKRouteHop path_conv_10_conv;
21023 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
21024 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
21025 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
21026 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
21027 path_constr.data[k] = path_conv_10_conv;
21030 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21031 *ret_copy = Event_payment_path_successful(payment_id_ref, payment_hash_ref, path_constr);
21032 uint32_t ret_ref = (uintptr_t)ret_copy;
21036 uint32_t __attribute__((export_name("TS_Event_payment_path_failed"))) TS_Event_payment_path_failed(int8_tArray payment_id, int8_tArray payment_hash, jboolean rejected_by_dest, uint32_t network_update, jboolean all_paths_failed, uint32_tArray path, uint32_t short_channel_id, uint32_t retry) {
21037 LDKThirtyTwoBytes payment_id_ref;
21038 CHECK(payment_id->arr_len == 32);
21039 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
21040 LDKThirtyTwoBytes payment_hash_ref;
21041 CHECK(payment_hash->arr_len == 32);
21042 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21043 void* network_update_ptr = (void*)(((uintptr_t)network_update) & ~1);
21044 CHECK_ACCESS(network_update_ptr);
21045 LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(network_update_ptr);
21046 network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uintptr_t)network_update) & ~1));
21047 LDKCVec_RouteHopZ path_constr;
21048 path_constr.datalen = path->arr_len;
21049 if (path_constr.datalen > 0)
21050 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
21052 path_constr.data = NULL;
21053 uint32_t* path_vals = path->elems;
21054 for (size_t k = 0; k < path_constr.datalen; k++) {
21055 uint32_t path_conv_10 = path_vals[k];
21056 LDKRouteHop path_conv_10_conv;
21057 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
21058 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
21059 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
21060 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
21061 path_constr.data[k] = path_conv_10_conv;
21064 void* short_channel_id_ptr = (void*)(((uintptr_t)short_channel_id) & ~1);
21065 CHECK_ACCESS(short_channel_id_ptr);
21066 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
21067 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)short_channel_id) & ~1));
21068 LDKRouteParameters retry_conv;
21069 retry_conv.inner = (void*)(retry & (~1));
21070 retry_conv.is_owned = (retry & 1) || (retry == 0);
21071 CHECK_INNER_FIELD_ACCESS_OR_NULL(retry_conv);
21072 retry_conv = RouteParameters_clone(&retry_conv);
21073 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21074 *ret_copy = Event_payment_path_failed(payment_id_ref, payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv, retry_conv);
21075 uint32_t ret_ref = (uintptr_t)ret_copy;
21079 uint32_t __attribute__((export_name("TS_Event_probe_successful"))) TS_Event_probe_successful(int8_tArray payment_id, int8_tArray payment_hash, uint32_tArray path) {
21080 LDKThirtyTwoBytes payment_id_ref;
21081 CHECK(payment_id->arr_len == 32);
21082 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
21083 LDKThirtyTwoBytes payment_hash_ref;
21084 CHECK(payment_hash->arr_len == 32);
21085 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21086 LDKCVec_RouteHopZ path_constr;
21087 path_constr.datalen = path->arr_len;
21088 if (path_constr.datalen > 0)
21089 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
21091 path_constr.data = NULL;
21092 uint32_t* path_vals = path->elems;
21093 for (size_t k = 0; k < path_constr.datalen; k++) {
21094 uint32_t path_conv_10 = path_vals[k];
21095 LDKRouteHop path_conv_10_conv;
21096 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
21097 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
21098 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
21099 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
21100 path_constr.data[k] = path_conv_10_conv;
21103 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21104 *ret_copy = Event_probe_successful(payment_id_ref, payment_hash_ref, path_constr);
21105 uint32_t ret_ref = (uintptr_t)ret_copy;
21109 uint32_t __attribute__((export_name("TS_Event_probe_failed"))) TS_Event_probe_failed(int8_tArray payment_id, int8_tArray payment_hash, uint32_tArray path, uint32_t short_channel_id) {
21110 LDKThirtyTwoBytes payment_id_ref;
21111 CHECK(payment_id->arr_len == 32);
21112 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
21113 LDKThirtyTwoBytes payment_hash_ref;
21114 CHECK(payment_hash->arr_len == 32);
21115 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
21116 LDKCVec_RouteHopZ path_constr;
21117 path_constr.datalen = path->arr_len;
21118 if (path_constr.datalen > 0)
21119 path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
21121 path_constr.data = NULL;
21122 uint32_t* path_vals = path->elems;
21123 for (size_t k = 0; k < path_constr.datalen; k++) {
21124 uint32_t path_conv_10 = path_vals[k];
21125 LDKRouteHop path_conv_10_conv;
21126 path_conv_10_conv.inner = (void*)(path_conv_10 & (~1));
21127 path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0);
21128 CHECK_INNER_FIELD_ACCESS_OR_NULL(path_conv_10_conv);
21129 path_conv_10_conv = RouteHop_clone(&path_conv_10_conv);
21130 path_constr.data[k] = path_conv_10_conv;
21133 void* short_channel_id_ptr = (void*)(((uintptr_t)short_channel_id) & ~1);
21134 CHECK_ACCESS(short_channel_id_ptr);
21135 LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(short_channel_id_ptr);
21136 short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)short_channel_id) & ~1));
21137 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21138 *ret_copy = Event_probe_failed(payment_id_ref, payment_hash_ref, path_constr, short_channel_id_conv);
21139 uint32_t ret_ref = (uintptr_t)ret_copy;
21143 uint32_t __attribute__((export_name("TS_Event_pending_htlcs_forwardable"))) TS_Event_pending_htlcs_forwardable(int64_t time_forwardable) {
21144 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21145 *ret_copy = Event_pending_htlcs_forwardable(time_forwardable);
21146 uint32_t ret_ref = (uintptr_t)ret_copy;
21150 uint32_t __attribute__((export_name("TS_Event_spendable_outputs"))) TS_Event_spendable_outputs(uint32_tArray outputs) {
21151 LDKCVec_SpendableOutputDescriptorZ outputs_constr;
21152 outputs_constr.datalen = outputs->arr_len;
21153 if (outputs_constr.datalen > 0)
21154 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
21156 outputs_constr.data = NULL;
21157 uint32_t* outputs_vals = outputs->elems;
21158 for (size_t b = 0; b < outputs_constr.datalen; b++) {
21159 uint32_t outputs_conv_27 = outputs_vals[b];
21160 void* outputs_conv_27_ptr = (void*)(((uintptr_t)outputs_conv_27) & ~1);
21161 CHECK_ACCESS(outputs_conv_27_ptr);
21162 LDKSpendableOutputDescriptor outputs_conv_27_conv = *(LDKSpendableOutputDescriptor*)(outputs_conv_27_ptr);
21163 outputs_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uintptr_t)outputs_conv_27) & ~1));
21164 outputs_constr.data[b] = outputs_conv_27_conv;
21167 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21168 *ret_copy = Event_spendable_outputs(outputs_constr);
21169 uint32_t ret_ref = (uintptr_t)ret_copy;
21173 uint32_t __attribute__((export_name("TS_Event_payment_forwarded"))) TS_Event_payment_forwarded(int8_tArray prev_channel_id, int8_tArray next_channel_id, uint32_t fee_earned_msat, jboolean claim_from_onchain_tx) {
21174 LDKThirtyTwoBytes prev_channel_id_ref;
21175 CHECK(prev_channel_id->arr_len == 32);
21176 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
21177 LDKThirtyTwoBytes next_channel_id_ref;
21178 CHECK(next_channel_id->arr_len == 32);
21179 memcpy(next_channel_id_ref.data, next_channel_id->elems, 32); FREE(next_channel_id);
21180 void* fee_earned_msat_ptr = (void*)(((uintptr_t)fee_earned_msat) & ~1);
21181 CHECK_ACCESS(fee_earned_msat_ptr);
21182 LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(fee_earned_msat_ptr);
21183 fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)fee_earned_msat) & ~1));
21184 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21185 *ret_copy = Event_payment_forwarded(prev_channel_id_ref, next_channel_id_ref, fee_earned_msat_conv, claim_from_onchain_tx);
21186 uint32_t ret_ref = (uintptr_t)ret_copy;
21190 uint32_t __attribute__((export_name("TS_Event_channel_closed"))) TS_Event_channel_closed(int8_tArray channel_id, int64_t user_channel_id, uint32_t reason) {
21191 LDKThirtyTwoBytes channel_id_ref;
21192 CHECK(channel_id->arr_len == 32);
21193 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
21194 void* reason_ptr = (void*)(((uintptr_t)reason) & ~1);
21195 CHECK_ACCESS(reason_ptr);
21196 LDKClosureReason reason_conv = *(LDKClosureReason*)(reason_ptr);
21197 reason_conv = ClosureReason_clone((LDKClosureReason*)(((uintptr_t)reason) & ~1));
21198 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21199 *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id, reason_conv);
21200 uint32_t ret_ref = (uintptr_t)ret_copy;
21204 uint32_t __attribute__((export_name("TS_Event_discard_funding"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) {
21205 LDKThirtyTwoBytes channel_id_ref;
21206 CHECK(channel_id->arr_len == 32);
21207 memcpy(channel_id_ref.data, channel_id->elems, 32); FREE(channel_id);
21208 LDKTransaction transaction_ref;
21209 transaction_ref.datalen = transaction->arr_len;
21210 transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes");
21211 memcpy(transaction_ref.data, transaction->elems, transaction_ref.datalen); FREE(transaction);
21212 transaction_ref.data_is_owned = true;
21213 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21214 *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref);
21215 uint32_t ret_ref = (uintptr_t)ret_copy;
21219 uint32_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, uint32_t channel_type) {
21220 LDKThirtyTwoBytes temporary_channel_id_ref;
21221 CHECK(temporary_channel_id->arr_len == 32);
21222 memcpy(temporary_channel_id_ref.data, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
21223 LDKPublicKey counterparty_node_id_ref;
21224 CHECK(counterparty_node_id->arr_len == 33);
21225 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
21226 LDKChannelTypeFeatures channel_type_conv;
21227 channel_type_conv.inner = (void*)(channel_type & (~1));
21228 channel_type_conv.is_owned = (channel_type & 1) || (channel_type == 0);
21229 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_conv);
21230 channel_type_conv = ChannelTypeFeatures_clone(&channel_type_conv);
21231 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21232 *ret_copy = Event_open_channel_request(temporary_channel_id_ref, counterparty_node_id_ref, funding_satoshis, push_msat, channel_type_conv);
21233 uint32_t ret_ref = (uintptr_t)ret_copy;
21237 uint32_t __attribute__((export_name("TS_Event_htlchandling_failed"))) TS_Event_htlchandling_failed(int8_tArray prev_channel_id, uint32_t failed_next_destination) {
21238 LDKThirtyTwoBytes prev_channel_id_ref;
21239 CHECK(prev_channel_id->arr_len == 32);
21240 memcpy(prev_channel_id_ref.data, prev_channel_id->elems, 32); FREE(prev_channel_id);
21241 void* failed_next_destination_ptr = (void*)(((uintptr_t)failed_next_destination) & ~1);
21242 CHECK_ACCESS(failed_next_destination_ptr);
21243 LDKHTLCDestination failed_next_destination_conv = *(LDKHTLCDestination*)(failed_next_destination_ptr);
21244 failed_next_destination_conv = HTLCDestination_clone((LDKHTLCDestination*)(((uintptr_t)failed_next_destination) & ~1));
21245 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
21246 *ret_copy = Event_htlchandling_failed(prev_channel_id_ref, failed_next_destination_conv);
21247 uint32_t ret_ref = (uintptr_t)ret_copy;
21251 int8_tArray __attribute__((export_name("TS_Event_write"))) TS_Event_write(uint32_t obj) {
21252 LDKEvent* obj_conv = (LDKEvent*)obj;
21253 LDKCVec_u8Z ret_var = Event_write(obj_conv);
21254 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
21255 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
21256 CVec_u8Z_free(ret_var);
21260 uint32_t __attribute__((export_name("TS_Event_read"))) TS_Event_read(int8_tArray ser) {
21261 LDKu8slice ser_ref;
21262 ser_ref.datalen = ser->arr_len;
21263 ser_ref.data = ser->elems;
21264 LDKCResult_COption_EventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_EventZDecodeErrorZ), "LDKCResult_COption_EventZDecodeErrorZ");
21265 *ret_conv = Event_read(ser_ref);
21267 return (uint32_t)ret_conv;
21270 void __attribute__((export_name("TS_MessageSendEvent_free"))) TS_MessageSendEvent_free(uint32_t this_ptr) {
21271 if ((this_ptr & 1) != 0) return;
21272 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21273 CHECK_ACCESS(this_ptr_ptr);
21274 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(this_ptr_ptr);
21275 FREE((void*)this_ptr);
21276 MessageSendEvent_free(this_ptr_conv);
21279 static inline uintptr_t MessageSendEvent_clone_ptr(LDKMessageSendEvent *NONNULL_PTR arg) {
21280 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21281 *ret_copy = MessageSendEvent_clone(arg);
21282 uint32_t ret_ref = (uintptr_t)ret_copy;
21285 uint32_t __attribute__((export_name("TS_MessageSendEvent_clone_ptr"))) TS_MessageSendEvent_clone_ptr(uint32_t arg) {
21286 LDKMessageSendEvent* arg_conv = (LDKMessageSendEvent*)arg;
21287 uint32_t ret_conv = MessageSendEvent_clone_ptr(arg_conv);
21291 uint32_t __attribute__((export_name("TS_MessageSendEvent_clone"))) TS_MessageSendEvent_clone(uint32_t orig) {
21292 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
21293 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21294 *ret_copy = MessageSendEvent_clone(orig_conv);
21295 uint32_t ret_ref = (uintptr_t)ret_copy;
21299 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_accept_channel"))) TS_MessageSendEvent_send_accept_channel(int8_tArray node_id, uint32_t msg) {
21300 LDKPublicKey node_id_ref;
21301 CHECK(node_id->arr_len == 33);
21302 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21303 LDKAcceptChannel msg_conv;
21304 msg_conv.inner = (void*)(msg & (~1));
21305 msg_conv.is_owned = (msg & 1) || (msg == 0);
21306 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21307 msg_conv = AcceptChannel_clone(&msg_conv);
21308 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21309 *ret_copy = MessageSendEvent_send_accept_channel(node_id_ref, msg_conv);
21310 uint32_t ret_ref = (uintptr_t)ret_copy;
21314 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_open_channel"))) TS_MessageSendEvent_send_open_channel(int8_tArray node_id, uint32_t msg) {
21315 LDKPublicKey node_id_ref;
21316 CHECK(node_id->arr_len == 33);
21317 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21318 LDKOpenChannel msg_conv;
21319 msg_conv.inner = (void*)(msg & (~1));
21320 msg_conv.is_owned = (msg & 1) || (msg == 0);
21321 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21322 msg_conv = OpenChannel_clone(&msg_conv);
21323 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21324 *ret_copy = MessageSendEvent_send_open_channel(node_id_ref, msg_conv);
21325 uint32_t ret_ref = (uintptr_t)ret_copy;
21329 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_funding_created"))) TS_MessageSendEvent_send_funding_created(int8_tArray node_id, uint32_t msg) {
21330 LDKPublicKey node_id_ref;
21331 CHECK(node_id->arr_len == 33);
21332 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21333 LDKFundingCreated msg_conv;
21334 msg_conv.inner = (void*)(msg & (~1));
21335 msg_conv.is_owned = (msg & 1) || (msg == 0);
21336 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21337 msg_conv = FundingCreated_clone(&msg_conv);
21338 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21339 *ret_copy = MessageSendEvent_send_funding_created(node_id_ref, msg_conv);
21340 uint32_t ret_ref = (uintptr_t)ret_copy;
21344 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_funding_signed"))) TS_MessageSendEvent_send_funding_signed(int8_tArray node_id, uint32_t msg) {
21345 LDKPublicKey node_id_ref;
21346 CHECK(node_id->arr_len == 33);
21347 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21348 LDKFundingSigned msg_conv;
21349 msg_conv.inner = (void*)(msg & (~1));
21350 msg_conv.is_owned = (msg & 1) || (msg == 0);
21351 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21352 msg_conv = FundingSigned_clone(&msg_conv);
21353 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21354 *ret_copy = MessageSendEvent_send_funding_signed(node_id_ref, msg_conv);
21355 uint32_t ret_ref = (uintptr_t)ret_copy;
21359 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_channel_ready"))) TS_MessageSendEvent_send_channel_ready(int8_tArray node_id, uint32_t msg) {
21360 LDKPublicKey node_id_ref;
21361 CHECK(node_id->arr_len == 33);
21362 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21363 LDKChannelReady msg_conv;
21364 msg_conv.inner = (void*)(msg & (~1));
21365 msg_conv.is_owned = (msg & 1) || (msg == 0);
21366 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21367 msg_conv = ChannelReady_clone(&msg_conv);
21368 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21369 *ret_copy = MessageSendEvent_send_channel_ready(node_id_ref, msg_conv);
21370 uint32_t ret_ref = (uintptr_t)ret_copy;
21374 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_announcement_signatures"))) TS_MessageSendEvent_send_announcement_signatures(int8_tArray node_id, uint32_t msg) {
21375 LDKPublicKey node_id_ref;
21376 CHECK(node_id->arr_len == 33);
21377 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21378 LDKAnnouncementSignatures msg_conv;
21379 msg_conv.inner = (void*)(msg & (~1));
21380 msg_conv.is_owned = (msg & 1) || (msg == 0);
21381 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21382 msg_conv = AnnouncementSignatures_clone(&msg_conv);
21383 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21384 *ret_copy = MessageSendEvent_send_announcement_signatures(node_id_ref, msg_conv);
21385 uint32_t ret_ref = (uintptr_t)ret_copy;
21389 uint32_t __attribute__((export_name("TS_MessageSendEvent_update_htlcs"))) TS_MessageSendEvent_update_htlcs(int8_tArray node_id, uint32_t updates) {
21390 LDKPublicKey node_id_ref;
21391 CHECK(node_id->arr_len == 33);
21392 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21393 LDKCommitmentUpdate updates_conv;
21394 updates_conv.inner = (void*)(updates & (~1));
21395 updates_conv.is_owned = (updates & 1) || (updates == 0);
21396 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
21397 updates_conv = CommitmentUpdate_clone(&updates_conv);
21398 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21399 *ret_copy = MessageSendEvent_update_htlcs(node_id_ref, updates_conv);
21400 uint32_t ret_ref = (uintptr_t)ret_copy;
21404 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_revoke_and_ack"))) TS_MessageSendEvent_send_revoke_and_ack(int8_tArray node_id, uint32_t msg) {
21405 LDKPublicKey node_id_ref;
21406 CHECK(node_id->arr_len == 33);
21407 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21408 LDKRevokeAndACK msg_conv;
21409 msg_conv.inner = (void*)(msg & (~1));
21410 msg_conv.is_owned = (msg & 1) || (msg == 0);
21411 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21412 msg_conv = RevokeAndACK_clone(&msg_conv);
21413 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21414 *ret_copy = MessageSendEvent_send_revoke_and_ack(node_id_ref, msg_conv);
21415 uint32_t ret_ref = (uintptr_t)ret_copy;
21419 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_closing_signed"))) TS_MessageSendEvent_send_closing_signed(int8_tArray node_id, uint32_t msg) {
21420 LDKPublicKey node_id_ref;
21421 CHECK(node_id->arr_len == 33);
21422 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21423 LDKClosingSigned msg_conv;
21424 msg_conv.inner = (void*)(msg & (~1));
21425 msg_conv.is_owned = (msg & 1) || (msg == 0);
21426 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21427 msg_conv = ClosingSigned_clone(&msg_conv);
21428 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21429 *ret_copy = MessageSendEvent_send_closing_signed(node_id_ref, msg_conv);
21430 uint32_t ret_ref = (uintptr_t)ret_copy;
21434 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_shutdown"))) TS_MessageSendEvent_send_shutdown(int8_tArray node_id, uint32_t msg) {
21435 LDKPublicKey node_id_ref;
21436 CHECK(node_id->arr_len == 33);
21437 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21438 LDKShutdown msg_conv;
21439 msg_conv.inner = (void*)(msg & (~1));
21440 msg_conv.is_owned = (msg & 1) || (msg == 0);
21441 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21442 msg_conv = Shutdown_clone(&msg_conv);
21443 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21444 *ret_copy = MessageSendEvent_send_shutdown(node_id_ref, msg_conv);
21445 uint32_t ret_ref = (uintptr_t)ret_copy;
21449 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_channel_reestablish"))) TS_MessageSendEvent_send_channel_reestablish(int8_tArray node_id, uint32_t msg) {
21450 LDKPublicKey node_id_ref;
21451 CHECK(node_id->arr_len == 33);
21452 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21453 LDKChannelReestablish msg_conv;
21454 msg_conv.inner = (void*)(msg & (~1));
21455 msg_conv.is_owned = (msg & 1) || (msg == 0);
21456 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21457 msg_conv = ChannelReestablish_clone(&msg_conv);
21458 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21459 *ret_copy = MessageSendEvent_send_channel_reestablish(node_id_ref, msg_conv);
21460 uint32_t ret_ref = (uintptr_t)ret_copy;
21464 uint32_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_announcement"))) TS_MessageSendEvent_broadcast_channel_announcement(uint32_t msg, uint32_t update_msg) {
21465 LDKChannelAnnouncement msg_conv;
21466 msg_conv.inner = (void*)(msg & (~1));
21467 msg_conv.is_owned = (msg & 1) || (msg == 0);
21468 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21469 msg_conv = ChannelAnnouncement_clone(&msg_conv);
21470 LDKChannelUpdate update_msg_conv;
21471 update_msg_conv.inner = (void*)(update_msg & (~1));
21472 update_msg_conv.is_owned = (update_msg & 1) || (update_msg == 0);
21473 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_msg_conv);
21474 update_msg_conv = ChannelUpdate_clone(&update_msg_conv);
21475 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21476 *ret_copy = MessageSendEvent_broadcast_channel_announcement(msg_conv, update_msg_conv);
21477 uint32_t ret_ref = (uintptr_t)ret_copy;
21481 uint32_t __attribute__((export_name("TS_MessageSendEvent_broadcast_node_announcement"))) TS_MessageSendEvent_broadcast_node_announcement(uint32_t msg) {
21482 LDKNodeAnnouncement msg_conv;
21483 msg_conv.inner = (void*)(msg & (~1));
21484 msg_conv.is_owned = (msg & 1) || (msg == 0);
21485 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21486 msg_conv = NodeAnnouncement_clone(&msg_conv);
21487 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21488 *ret_copy = MessageSendEvent_broadcast_node_announcement(msg_conv);
21489 uint32_t ret_ref = (uintptr_t)ret_copy;
21493 uint32_t __attribute__((export_name("TS_MessageSendEvent_broadcast_channel_update"))) TS_MessageSendEvent_broadcast_channel_update(uint32_t msg) {
21494 LDKChannelUpdate msg_conv;
21495 msg_conv.inner = (void*)(msg & (~1));
21496 msg_conv.is_owned = (msg & 1) || (msg == 0);
21497 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21498 msg_conv = ChannelUpdate_clone(&msg_conv);
21499 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21500 *ret_copy = MessageSendEvent_broadcast_channel_update(msg_conv);
21501 uint32_t ret_ref = (uintptr_t)ret_copy;
21505 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_channel_update"))) TS_MessageSendEvent_send_channel_update(int8_tArray node_id, uint32_t msg) {
21506 LDKPublicKey node_id_ref;
21507 CHECK(node_id->arr_len == 33);
21508 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21509 LDKChannelUpdate msg_conv;
21510 msg_conv.inner = (void*)(msg & (~1));
21511 msg_conv.is_owned = (msg & 1) || (msg == 0);
21512 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21513 msg_conv = ChannelUpdate_clone(&msg_conv);
21514 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21515 *ret_copy = MessageSendEvent_send_channel_update(node_id_ref, msg_conv);
21516 uint32_t ret_ref = (uintptr_t)ret_copy;
21520 uint32_t __attribute__((export_name("TS_MessageSendEvent_handle_error"))) TS_MessageSendEvent_handle_error(int8_tArray node_id, uint32_t action) {
21521 LDKPublicKey node_id_ref;
21522 CHECK(node_id->arr_len == 33);
21523 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21524 void* action_ptr = (void*)(((uintptr_t)action) & ~1);
21525 CHECK_ACCESS(action_ptr);
21526 LDKErrorAction action_conv = *(LDKErrorAction*)(action_ptr);
21527 action_conv = ErrorAction_clone((LDKErrorAction*)(((uintptr_t)action) & ~1));
21528 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21529 *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv);
21530 uint32_t ret_ref = (uintptr_t)ret_copy;
21534 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_channel_range_query"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint32_t msg) {
21535 LDKPublicKey node_id_ref;
21536 CHECK(node_id->arr_len == 33);
21537 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21538 LDKQueryChannelRange msg_conv;
21539 msg_conv.inner = (void*)(msg & (~1));
21540 msg_conv.is_owned = (msg & 1) || (msg == 0);
21541 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21542 msg_conv = QueryChannelRange_clone(&msg_conv);
21543 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21544 *ret_copy = MessageSendEvent_send_channel_range_query(node_id_ref, msg_conv);
21545 uint32_t ret_ref = (uintptr_t)ret_copy;
21549 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_short_ids_query"))) TS_MessageSendEvent_send_short_ids_query(int8_tArray node_id, uint32_t msg) {
21550 LDKPublicKey node_id_ref;
21551 CHECK(node_id->arr_len == 33);
21552 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21553 LDKQueryShortChannelIds msg_conv;
21554 msg_conv.inner = (void*)(msg & (~1));
21555 msg_conv.is_owned = (msg & 1) || (msg == 0);
21556 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21557 msg_conv = QueryShortChannelIds_clone(&msg_conv);
21558 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21559 *ret_copy = MessageSendEvent_send_short_ids_query(node_id_ref, msg_conv);
21560 uint32_t ret_ref = (uintptr_t)ret_copy;
21564 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_reply_channel_range"))) TS_MessageSendEvent_send_reply_channel_range(int8_tArray node_id, uint32_t msg) {
21565 LDKPublicKey node_id_ref;
21566 CHECK(node_id->arr_len == 33);
21567 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21568 LDKReplyChannelRange msg_conv;
21569 msg_conv.inner = (void*)(msg & (~1));
21570 msg_conv.is_owned = (msg & 1) || (msg == 0);
21571 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21572 msg_conv = ReplyChannelRange_clone(&msg_conv);
21573 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21574 *ret_copy = MessageSendEvent_send_reply_channel_range(node_id_ref, msg_conv);
21575 uint32_t ret_ref = (uintptr_t)ret_copy;
21579 uint32_t __attribute__((export_name("TS_MessageSendEvent_send_gossip_timestamp_filter"))) TS_MessageSendEvent_send_gossip_timestamp_filter(int8_tArray node_id, uint32_t msg) {
21580 LDKPublicKey node_id_ref;
21581 CHECK(node_id->arr_len == 33);
21582 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
21583 LDKGossipTimestampFilter msg_conv;
21584 msg_conv.inner = (void*)(msg & (~1));
21585 msg_conv.is_owned = (msg & 1) || (msg == 0);
21586 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
21587 msg_conv = GossipTimestampFilter_clone(&msg_conv);
21588 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
21589 *ret_copy = MessageSendEvent_send_gossip_timestamp_filter(node_id_ref, msg_conv);
21590 uint32_t ret_ref = (uintptr_t)ret_copy;
21594 void __attribute__((export_name("TS_MessageSendEventsProvider_free"))) TS_MessageSendEventsProvider_free(uint32_t this_ptr) {
21595 if ((this_ptr & 1) != 0) return;
21596 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21597 CHECK_ACCESS(this_ptr_ptr);
21598 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(this_ptr_ptr);
21599 FREE((void*)this_ptr);
21600 MessageSendEventsProvider_free(this_ptr_conv);
21603 void __attribute__((export_name("TS_EventsProvider_free"))) TS_EventsProvider_free(uint32_t this_ptr) {
21604 if ((this_ptr & 1) != 0) return;
21605 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21606 CHECK_ACCESS(this_ptr_ptr);
21607 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(this_ptr_ptr);
21608 FREE((void*)this_ptr);
21609 EventsProvider_free(this_ptr_conv);
21612 void __attribute__((export_name("TS_EventHandler_free"))) TS_EventHandler_free(uint32_t this_ptr) {
21613 if ((this_ptr & 1) != 0) return;
21614 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21615 CHECK_ACCESS(this_ptr_ptr);
21616 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(this_ptr_ptr);
21617 FREE((void*)this_ptr);
21618 EventHandler_free(this_ptr_conv);
21621 void __attribute__((export_name("TS_APIError_free"))) TS_APIError_free(uint32_t this_ptr) {
21622 if ((this_ptr & 1) != 0) return;
21623 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21624 CHECK_ACCESS(this_ptr_ptr);
21625 LDKAPIError this_ptr_conv = *(LDKAPIError*)(this_ptr_ptr);
21626 FREE((void*)this_ptr);
21627 APIError_free(this_ptr_conv);
21630 static inline uintptr_t APIError_clone_ptr(LDKAPIError *NONNULL_PTR arg) {
21631 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21632 *ret_copy = APIError_clone(arg);
21633 uint32_t ret_ref = (uintptr_t)ret_copy;
21636 uint32_t __attribute__((export_name("TS_APIError_clone_ptr"))) TS_APIError_clone_ptr(uint32_t arg) {
21637 LDKAPIError* arg_conv = (LDKAPIError*)arg;
21638 uint32_t ret_conv = APIError_clone_ptr(arg_conv);
21642 uint32_t __attribute__((export_name("TS_APIError_clone"))) TS_APIError_clone(uint32_t orig) {
21643 LDKAPIError* orig_conv = (LDKAPIError*)orig;
21644 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21645 *ret_copy = APIError_clone(orig_conv);
21646 uint32_t ret_ref = (uintptr_t)ret_copy;
21650 uint32_t __attribute__((export_name("TS_APIError_apimisuse_error"))) TS_APIError_apimisuse_error(jstring err) {
21651 LDKStr err_conv = str_ref_to_owned_c(err);
21652 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21653 *ret_copy = APIError_apimisuse_error(err_conv);
21654 uint32_t ret_ref = (uintptr_t)ret_copy;
21658 uint32_t __attribute__((export_name("TS_APIError_fee_rate_too_high"))) TS_APIError_fee_rate_too_high(jstring err, int32_t feerate) {
21659 LDKStr err_conv = str_ref_to_owned_c(err);
21660 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21661 *ret_copy = APIError_fee_rate_too_high(err_conv, feerate);
21662 uint32_t ret_ref = (uintptr_t)ret_copy;
21666 uint32_t __attribute__((export_name("TS_APIError_route_error"))) TS_APIError_route_error(jstring err) {
21667 LDKStr err_conv = str_ref_to_owned_c(err);
21668 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21669 *ret_copy = APIError_route_error(err_conv);
21670 uint32_t ret_ref = (uintptr_t)ret_copy;
21674 uint32_t __attribute__((export_name("TS_APIError_channel_unavailable"))) TS_APIError_channel_unavailable(jstring err) {
21675 LDKStr err_conv = str_ref_to_owned_c(err);
21676 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21677 *ret_copy = APIError_channel_unavailable(err_conv);
21678 uint32_t ret_ref = (uintptr_t)ret_copy;
21682 uint32_t __attribute__((export_name("TS_APIError_monitor_update_failed"))) TS_APIError_monitor_update_failed() {
21683 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21684 *ret_copy = APIError_monitor_update_failed();
21685 uint32_t ret_ref = (uintptr_t)ret_copy;
21689 uint32_t __attribute__((export_name("TS_APIError_incompatible_shutdown_script"))) TS_APIError_incompatible_shutdown_script(uint32_t script) {
21690 LDKShutdownScript script_conv;
21691 script_conv.inner = (void*)(script & (~1));
21692 script_conv.is_owned = (script & 1) || (script == 0);
21693 CHECK_INNER_FIELD_ACCESS_OR_NULL(script_conv);
21694 script_conv = ShutdownScript_clone(&script_conv);
21695 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
21696 *ret_copy = APIError_incompatible_shutdown_script(script_conv);
21697 uint32_t ret_ref = (uintptr_t)ret_copy;
21701 void __attribute__((export_name("TS_BigSize_free"))) TS_BigSize_free(uint32_t this_obj) {
21702 LDKBigSize this_obj_conv;
21703 this_obj_conv.inner = (void*)(this_obj & (~1));
21704 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
21706 BigSize_free(this_obj_conv);
21709 int64_t __attribute__((export_name("TS_BigSize_get_a"))) TS_BigSize_get_a(uint32_t this_ptr) {
21710 LDKBigSize this_ptr_conv;
21711 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21712 this_ptr_conv.is_owned = false;
21713 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21714 int64_t ret_conv = BigSize_get_a(&this_ptr_conv);
21718 void __attribute__((export_name("TS_BigSize_set_a"))) TS_BigSize_set_a(uint32_t this_ptr, int64_t val) {
21719 LDKBigSize this_ptr_conv;
21720 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21721 this_ptr_conv.is_owned = false;
21722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21723 BigSize_set_a(&this_ptr_conv, val);
21726 uint32_t __attribute__((export_name("TS_BigSize_new"))) TS_BigSize_new(int64_t a_arg) {
21727 LDKBigSize ret_var = BigSize_new(a_arg);
21728 uint32_t ret_ref = 0;
21729 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21730 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21731 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
21732 ret_ref = (uintptr_t)ret_var.inner;
21733 if (ret_var.is_owned) {
21739 void __attribute__((export_name("TS_Hostname_free"))) TS_Hostname_free(uint32_t this_obj) {
21740 LDKHostname this_obj_conv;
21741 this_obj_conv.inner = (void*)(this_obj & (~1));
21742 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21743 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
21744 Hostname_free(this_obj_conv);
21747 static inline uintptr_t Hostname_clone_ptr(LDKHostname *NONNULL_PTR arg) {
21748 LDKHostname ret_var = Hostname_clone(arg);
21749 uint32_t ret_ref = 0;
21750 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21751 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21752 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
21753 ret_ref = (uintptr_t)ret_var.inner;
21754 if (ret_var.is_owned) {
21759 uint32_t __attribute__((export_name("TS_Hostname_clone_ptr"))) TS_Hostname_clone_ptr(uint32_t arg) {
21760 LDKHostname arg_conv;
21761 arg_conv.inner = (void*)(arg & (~1));
21762 arg_conv.is_owned = false;
21763 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
21764 uint32_t ret_conv = Hostname_clone_ptr(&arg_conv);
21768 uint32_t __attribute__((export_name("TS_Hostname_clone"))) TS_Hostname_clone(uint32_t orig) {
21769 LDKHostname orig_conv;
21770 orig_conv.inner = (void*)(orig & (~1));
21771 orig_conv.is_owned = false;
21772 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
21773 LDKHostname ret_var = Hostname_clone(&orig_conv);
21774 uint32_t ret_ref = 0;
21775 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21776 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21777 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
21778 ret_ref = (uintptr_t)ret_var.inner;
21779 if (ret_var.is_owned) {
21785 int8_t __attribute__((export_name("TS_Hostname_len"))) TS_Hostname_len(uint32_t this_arg) {
21786 LDKHostname this_arg_conv;
21787 this_arg_conv.inner = (void*)(this_arg & (~1));
21788 this_arg_conv.is_owned = false;
21789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
21790 int8_t ret_conv = Hostname_len(&this_arg_conv);
21794 uint32_t __attribute__((export_name("TS_sign"))) TS_sign(int8_tArray msg, int8_tArray sk) {
21795 LDKu8slice msg_ref;
21796 msg_ref.datalen = msg->arr_len;
21797 msg_ref.data = msg->elems;
21798 unsigned char sk_arr[32];
21799 CHECK(sk->arr_len == 32);
21800 memcpy(sk_arr, sk->elems, 32); FREE(sk);
21801 unsigned char (*sk_ref)[32] = &sk_arr;
21802 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
21803 *ret_conv = sign(msg_ref, sk_ref);
21805 return (uint32_t)ret_conv;
21808 uint32_t __attribute__((export_name("TS_recover_pk"))) TS_recover_pk(int8_tArray msg, jstring sig) {
21809 LDKu8slice msg_ref;
21810 msg_ref.datalen = msg->arr_len;
21811 msg_ref.data = msg->elems;
21812 LDKStr sig_conv = str_ref_to_owned_c(sig);
21813 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
21814 *ret_conv = recover_pk(msg_ref, sig_conv);
21816 return (uint32_t)ret_conv;
21819 jboolean __attribute__((export_name("TS_verify"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
21820 LDKu8slice msg_ref;
21821 msg_ref.datalen = msg->arr_len;
21822 msg_ref.data = msg->elems;
21823 LDKStr sig_conv = str_ref_to_owned_c(sig);
21824 LDKPublicKey pk_ref;
21825 CHECK(pk->arr_len == 33);
21826 memcpy(pk_ref.compressed_form, pk->elems, 33); FREE(pk);
21827 jboolean ret_conv = verify(msg_ref, sig_conv, pk_ref);
21832 int8_tArray __attribute__((export_name("TS_construct_invoice_preimage"))) TS_construct_invoice_preimage(int8_tArray hrp_bytes, ptrArray data_without_signature) {
21833 LDKu8slice hrp_bytes_ref;
21834 hrp_bytes_ref.datalen = hrp_bytes->arr_len;
21835 hrp_bytes_ref.data = hrp_bytes->elems;
21836 LDKCVec_u5Z data_without_signature_constr;
21837 data_without_signature_constr.datalen = data_without_signature->arr_len;
21838 if (data_without_signature_constr.datalen > 0)
21839 data_without_signature_constr.data = MALLOC(data_without_signature_constr.datalen * sizeof(LDKu5), "LDKCVec_u5Z Elements");
21841 data_without_signature_constr.data = NULL;
21842 int8_t* data_without_signature_vals = (void*) data_without_signature->elems;
21843 for (size_t h = 0; h < data_without_signature_constr.datalen; h++) {
21844 int8_t data_without_signature_conv_7 = data_without_signature_vals[h];
21846 data_without_signature_constr.data[h] = (LDKu5){ ._0 = data_without_signature_conv_7 };
21848 FREE(data_without_signature);
21849 LDKCVec_u8Z ret_var = construct_invoice_preimage(hrp_bytes_ref, data_without_signature_constr);
21850 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
21851 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
21852 CVec_u8Z_free(ret_var);
21857 void __attribute__((export_name("TS_Persister_free"))) TS_Persister_free(uint32_t this_ptr) {
21858 if ((this_ptr & 1) != 0) return;
21859 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
21860 CHECK_ACCESS(this_ptr_ptr);
21861 LDKPersister this_ptr_conv = *(LDKPersister*)(this_ptr_ptr);
21862 FREE((void*)this_ptr);
21863 Persister_free(this_ptr_conv);
21866 uint32_t __attribute__((export_name("TS_Level_clone"))) TS_Level_clone(uint32_t orig) {
21867 LDKLevel* orig_conv = (LDKLevel*)(orig & ~1);
21868 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
21872 uint32_t __attribute__((export_name("TS_Level_gossip"))) TS_Level_gossip() {
21873 uint32_t ret_conv = LDKLevel_to_js(Level_gossip());
21877 uint32_t __attribute__((export_name("TS_Level_trace"))) TS_Level_trace() {
21878 uint32_t ret_conv = LDKLevel_to_js(Level_trace());
21882 uint32_t __attribute__((export_name("TS_Level_debug"))) TS_Level_debug() {
21883 uint32_t ret_conv = LDKLevel_to_js(Level_debug());
21887 uint32_t __attribute__((export_name("TS_Level_info"))) TS_Level_info() {
21888 uint32_t ret_conv = LDKLevel_to_js(Level_info());
21892 uint32_t __attribute__((export_name("TS_Level_warn"))) TS_Level_warn() {
21893 uint32_t ret_conv = LDKLevel_to_js(Level_warn());
21897 uint32_t __attribute__((export_name("TS_Level_error"))) TS_Level_error() {
21898 uint32_t ret_conv = LDKLevel_to_js(Level_error());
21902 jboolean __attribute__((export_name("TS_Level_eq"))) TS_Level_eq(uint32_t a, uint32_t b) {
21903 LDKLevel* a_conv = (LDKLevel*)(a & ~1);
21904 LDKLevel* b_conv = (LDKLevel*)(b & ~1);
21905 jboolean ret_conv = Level_eq(a_conv, b_conv);
21909 int64_t __attribute__((export_name("TS_Level_hash"))) TS_Level_hash(uint32_t o) {
21910 LDKLevel* o_conv = (LDKLevel*)(o & ~1);
21911 int64_t ret_conv = Level_hash(o_conv);
21915 uint32_t __attribute__((export_name("TS_Level_max"))) TS_Level_max() {
21916 uint32_t ret_conv = LDKLevel_to_js(Level_max());
21920 void __attribute__((export_name("TS_Record_free"))) TS_Record_free(uint32_t this_obj) {
21921 LDKRecord this_obj_conv;
21922 this_obj_conv.inner = (void*)(this_obj & (~1));
21923 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
21925 Record_free(this_obj_conv);
21928 uint32_t __attribute__((export_name("TS_Record_get_level"))) TS_Record_get_level(uint32_t this_ptr) {
21929 LDKRecord this_ptr_conv;
21930 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21931 this_ptr_conv.is_owned = false;
21932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21933 uint32_t ret_conv = LDKLevel_to_js(Record_get_level(&this_ptr_conv));
21937 void __attribute__((export_name("TS_Record_set_level"))) TS_Record_set_level(uint32_t this_ptr, uint32_t val) {
21938 LDKRecord this_ptr_conv;
21939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21940 this_ptr_conv.is_owned = false;
21941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21942 LDKLevel val_conv = LDKLevel_from_js(val);
21943 Record_set_level(&this_ptr_conv, val_conv);
21946 jstring __attribute__((export_name("TS_Record_get_args"))) TS_Record_get_args(uint32_t this_ptr) {
21947 LDKRecord this_ptr_conv;
21948 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21949 this_ptr_conv.is_owned = false;
21950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21951 LDKStr ret_str = Record_get_args(&this_ptr_conv);
21952 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
21957 void __attribute__((export_name("TS_Record_set_args"))) TS_Record_set_args(uint32_t this_ptr, jstring val) {
21958 LDKRecord this_ptr_conv;
21959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21960 this_ptr_conv.is_owned = false;
21961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21962 LDKStr val_conv = str_ref_to_owned_c(val);
21963 Record_set_args(&this_ptr_conv, val_conv);
21966 jstring __attribute__((export_name("TS_Record_get_module_path"))) TS_Record_get_module_path(uint32_t this_ptr) {
21967 LDKRecord this_ptr_conv;
21968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21969 this_ptr_conv.is_owned = false;
21970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21971 LDKStr ret_str = Record_get_module_path(&this_ptr_conv);
21972 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
21977 void __attribute__((export_name("TS_Record_set_module_path"))) TS_Record_set_module_path(uint32_t this_ptr, jstring val) {
21978 LDKRecord this_ptr_conv;
21979 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21980 this_ptr_conv.is_owned = false;
21981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21982 LDKStr val_conv = str_ref_to_owned_c(val);
21983 Record_set_module_path(&this_ptr_conv, val_conv);
21986 jstring __attribute__((export_name("TS_Record_get_file"))) TS_Record_get_file(uint32_t this_ptr) {
21987 LDKRecord this_ptr_conv;
21988 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21989 this_ptr_conv.is_owned = false;
21990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
21991 LDKStr ret_str = Record_get_file(&this_ptr_conv);
21992 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
21997 void __attribute__((export_name("TS_Record_set_file"))) TS_Record_set_file(uint32_t this_ptr, jstring val) {
21998 LDKRecord this_ptr_conv;
21999 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22000 this_ptr_conv.is_owned = false;
22001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22002 LDKStr val_conv = str_ref_to_owned_c(val);
22003 Record_set_file(&this_ptr_conv, val_conv);
22006 int32_t __attribute__((export_name("TS_Record_get_line"))) TS_Record_get_line(uint32_t this_ptr) {
22007 LDKRecord this_ptr_conv;
22008 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22009 this_ptr_conv.is_owned = false;
22010 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22011 int32_t ret_conv = Record_get_line(&this_ptr_conv);
22015 void __attribute__((export_name("TS_Record_set_line"))) TS_Record_set_line(uint32_t this_ptr, int32_t val) {
22016 LDKRecord this_ptr_conv;
22017 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22018 this_ptr_conv.is_owned = false;
22019 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22020 Record_set_line(&this_ptr_conv, val);
22023 static inline uintptr_t Record_clone_ptr(LDKRecord *NONNULL_PTR arg) {
22024 LDKRecord ret_var = Record_clone(arg);
22025 uint32_t ret_ref = 0;
22026 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22027 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22028 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22029 ret_ref = (uintptr_t)ret_var.inner;
22030 if (ret_var.is_owned) {
22035 uint32_t __attribute__((export_name("TS_Record_clone_ptr"))) TS_Record_clone_ptr(uint32_t arg) {
22036 LDKRecord arg_conv;
22037 arg_conv.inner = (void*)(arg & (~1));
22038 arg_conv.is_owned = false;
22039 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22040 uint32_t ret_conv = Record_clone_ptr(&arg_conv);
22044 uint32_t __attribute__((export_name("TS_Record_clone"))) TS_Record_clone(uint32_t orig) {
22045 LDKRecord orig_conv;
22046 orig_conv.inner = (void*)(orig & (~1));
22047 orig_conv.is_owned = false;
22048 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22049 LDKRecord ret_var = Record_clone(&orig_conv);
22050 uint32_t ret_ref = 0;
22051 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22052 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22053 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22054 ret_ref = (uintptr_t)ret_var.inner;
22055 if (ret_var.is_owned) {
22061 void __attribute__((export_name("TS_Logger_free"))) TS_Logger_free(uint32_t this_ptr) {
22062 if ((this_ptr & 1) != 0) return;
22063 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
22064 CHECK_ACCESS(this_ptr_ptr);
22065 LDKLogger this_ptr_conv = *(LDKLogger*)(this_ptr_ptr);
22066 FREE((void*)this_ptr);
22067 Logger_free(this_ptr_conv);
22070 void __attribute__((export_name("TS_ChannelHandshakeConfig_free"))) TS_ChannelHandshakeConfig_free(uint32_t this_obj) {
22071 LDKChannelHandshakeConfig this_obj_conv;
22072 this_obj_conv.inner = (void*)(this_obj & (~1));
22073 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22075 ChannelHandshakeConfig_free(this_obj_conv);
22078 int32_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_minimum_depth"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint32_t this_ptr) {
22079 LDKChannelHandshakeConfig this_ptr_conv;
22080 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22081 this_ptr_conv.is_owned = false;
22082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22083 int32_t ret_conv = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
22087 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_minimum_depth"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint32_t this_ptr, int32_t val) {
22088 LDKChannelHandshakeConfig this_ptr_conv;
22089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22090 this_ptr_conv.is_owned = false;
22091 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22092 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
22095 int16_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_to_self_delay"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint32_t this_ptr) {
22096 LDKChannelHandshakeConfig this_ptr_conv;
22097 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22098 this_ptr_conv.is_owned = false;
22099 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22100 int16_t ret_conv = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
22104 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_our_to_self_delay"))) TS_ChannelHandshakeConfig_set_our_to_self_delay(uint32_t this_ptr, int16_t val) {
22105 LDKChannelHandshakeConfig this_ptr_conv;
22106 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22107 this_ptr_conv.is_owned = false;
22108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22109 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
22112 int64_t __attribute__((export_name("TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint32_t this_ptr) {
22113 LDKChannelHandshakeConfig this_ptr_conv;
22114 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22115 this_ptr_conv.is_owned = false;
22116 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22117 int64_t ret_conv = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
22121 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat"))) TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
22122 LDKChannelHandshakeConfig this_ptr_conv;
22123 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22124 this_ptr_conv.is_owned = false;
22125 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22126 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
22129 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(uint32_t this_ptr) {
22130 LDKChannelHandshakeConfig this_ptr_conv;
22131 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22132 this_ptr_conv.is_owned = false;
22133 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22134 int8_t ret_conv = ChannelHandshakeConfig_get_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv);
22138 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(uint32_t this_ptr, int8_t val) {
22139 LDKChannelHandshakeConfig this_ptr_conv;
22140 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22141 this_ptr_conv.is_owned = false;
22142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22143 ChannelHandshakeConfig_set_max_inbound_htlc_value_in_flight_percent_of_channel(&this_ptr_conv, val);
22146 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_get_negotiate_scid_privacy(uint32_t this_ptr) {
22147 LDKChannelHandshakeConfig this_ptr_conv;
22148 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22149 this_ptr_conv.is_owned = false;
22150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22151 jboolean ret_conv = ChannelHandshakeConfig_get_negotiate_scid_privacy(&this_ptr_conv);
22155 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_negotiate_scid_privacy"))) TS_ChannelHandshakeConfig_set_negotiate_scid_privacy(uint32_t this_ptr, jboolean val) {
22156 LDKChannelHandshakeConfig this_ptr_conv;
22157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22158 this_ptr_conv.is_owned = false;
22159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22160 ChannelHandshakeConfig_set_negotiate_scid_privacy(&this_ptr_conv, val);
22163 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_announced_channel"))) TS_ChannelHandshakeConfig_get_announced_channel(uint32_t this_ptr) {
22164 LDKChannelHandshakeConfig this_ptr_conv;
22165 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22166 this_ptr_conv.is_owned = false;
22167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22168 jboolean ret_conv = ChannelHandshakeConfig_get_announced_channel(&this_ptr_conv);
22172 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_announced_channel"))) TS_ChannelHandshakeConfig_set_announced_channel(uint32_t this_ptr, jboolean val) {
22173 LDKChannelHandshakeConfig this_ptr_conv;
22174 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22175 this_ptr_conv.is_owned = false;
22176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22177 ChannelHandshakeConfig_set_announced_channel(&this_ptr_conv, val);
22180 jboolean __attribute__((export_name("TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(uint32_t this_ptr) {
22181 LDKChannelHandshakeConfig this_ptr_conv;
22182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22183 this_ptr_conv.is_owned = false;
22184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22185 jboolean ret_conv = ChannelHandshakeConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
22189 void __attribute__((export_name("TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey"))) TS_ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(uint32_t this_ptr, jboolean val) {
22190 LDKChannelHandshakeConfig this_ptr_conv;
22191 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22192 this_ptr_conv.is_owned = false;
22193 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22194 ChannelHandshakeConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
22197 uint32_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) {
22198 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);
22199 uint32_t ret_ref = 0;
22200 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22201 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22203 ret_ref = (uintptr_t)ret_var.inner;
22204 if (ret_var.is_owned) {
22210 static inline uintptr_t ChannelHandshakeConfig_clone_ptr(LDKChannelHandshakeConfig *NONNULL_PTR arg) {
22211 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(arg);
22212 uint32_t ret_ref = 0;
22213 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22214 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22216 ret_ref = (uintptr_t)ret_var.inner;
22217 if (ret_var.is_owned) {
22222 uint32_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone_ptr"))) TS_ChannelHandshakeConfig_clone_ptr(uint32_t arg) {
22223 LDKChannelHandshakeConfig arg_conv;
22224 arg_conv.inner = (void*)(arg & (~1));
22225 arg_conv.is_owned = false;
22226 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22227 uint32_t ret_conv = ChannelHandshakeConfig_clone_ptr(&arg_conv);
22231 uint32_t __attribute__((export_name("TS_ChannelHandshakeConfig_clone"))) TS_ChannelHandshakeConfig_clone(uint32_t orig) {
22232 LDKChannelHandshakeConfig orig_conv;
22233 orig_conv.inner = (void*)(orig & (~1));
22234 orig_conv.is_owned = false;
22235 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22236 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
22237 uint32_t ret_ref = 0;
22238 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22239 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22241 ret_ref = (uintptr_t)ret_var.inner;
22242 if (ret_var.is_owned) {
22248 uint32_t __attribute__((export_name("TS_ChannelHandshakeConfig_default"))) TS_ChannelHandshakeConfig_default() {
22249 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
22250 uint32_t ret_ref = 0;
22251 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22252 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22253 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22254 ret_ref = (uintptr_t)ret_var.inner;
22255 if (ret_var.is_owned) {
22261 void __attribute__((export_name("TS_ChannelHandshakeLimits_free"))) TS_ChannelHandshakeLimits_free(uint32_t this_obj) {
22262 LDKChannelHandshakeLimits this_obj_conv;
22263 this_obj_conv.inner = (void*)(this_obj & (~1));
22264 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22265 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22266 ChannelHandshakeLimits_free(this_obj_conv);
22269 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_funding_satoshis"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint32_t this_ptr) {
22270 LDKChannelHandshakeLimits this_ptr_conv;
22271 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22272 this_ptr_conv.is_owned = false;
22273 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22274 int64_t ret_conv = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
22278 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_funding_satoshis"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint32_t this_ptr, int64_t val) {
22279 LDKChannelHandshakeLimits this_ptr_conv;
22280 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22281 this_ptr_conv.is_owned = false;
22282 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22283 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
22286 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_funding_satoshis"))) TS_ChannelHandshakeLimits_get_max_funding_satoshis(uint32_t this_ptr) {
22287 LDKChannelHandshakeLimits this_ptr_conv;
22288 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22289 this_ptr_conv.is_owned = false;
22290 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22291 int64_t ret_conv = ChannelHandshakeLimits_get_max_funding_satoshis(&this_ptr_conv);
22295 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_funding_satoshis"))) TS_ChannelHandshakeLimits_set_max_funding_satoshis(uint32_t this_ptr, int64_t val) {
22296 LDKChannelHandshakeLimits this_ptr_conv;
22297 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22298 this_ptr_conv.is_owned = false;
22299 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22300 ChannelHandshakeLimits_set_max_funding_satoshis(&this_ptr_conv, val);
22303 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint32_t this_ptr) {
22304 LDKChannelHandshakeLimits this_ptr_conv;
22305 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22306 this_ptr_conv.is_owned = false;
22307 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22308 int64_t ret_conv = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
22312 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat"))) TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
22313 LDKChannelHandshakeLimits this_ptr_conv;
22314 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22315 this_ptr_conv.is_owned = false;
22316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22317 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
22320 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(uint32_t this_ptr) {
22321 LDKChannelHandshakeLimits this_ptr_conv;
22322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22323 this_ptr_conv.is_owned = false;
22324 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22325 int64_t ret_conv = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
22329 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat"))) TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
22330 LDKChannelHandshakeLimits this_ptr_conv;
22331 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22332 this_ptr_conv.is_owned = false;
22333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22334 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
22337 int64_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint32_t this_ptr) {
22338 LDKChannelHandshakeLimits this_ptr_conv;
22339 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22340 this_ptr_conv.is_owned = false;
22341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22342 int64_t ret_conv = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
22346 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis"))) TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
22347 LDKChannelHandshakeLimits this_ptr_conv;
22348 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22349 this_ptr_conv.is_owned = false;
22350 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22351 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
22354 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint32_t this_ptr) {
22355 LDKChannelHandshakeLimits this_ptr_conv;
22356 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22357 this_ptr_conv.is_owned = false;
22358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22359 int16_t ret_conv = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
22363 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs"))) TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
22364 LDKChannelHandshakeLimits this_ptr_conv;
22365 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22366 this_ptr_conv.is_owned = false;
22367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22368 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
22371 int32_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_max_minimum_depth"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint32_t this_ptr) {
22372 LDKChannelHandshakeLimits this_ptr_conv;
22373 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22374 this_ptr_conv.is_owned = false;
22375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22376 int32_t ret_conv = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
22380 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_max_minimum_depth"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint32_t this_ptr, int32_t val) {
22381 LDKChannelHandshakeLimits this_ptr_conv;
22382 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22383 this_ptr_conv.is_owned = false;
22384 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22385 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
22388 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_get_trust_own_funding_0conf(uint32_t this_ptr) {
22389 LDKChannelHandshakeLimits this_ptr_conv;
22390 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22391 this_ptr_conv.is_owned = false;
22392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22393 jboolean ret_conv = ChannelHandshakeLimits_get_trust_own_funding_0conf(&this_ptr_conv);
22397 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_trust_own_funding_0conf"))) TS_ChannelHandshakeLimits_set_trust_own_funding_0conf(uint32_t this_ptr, jboolean val) {
22398 LDKChannelHandshakeLimits this_ptr_conv;
22399 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22400 this_ptr_conv.is_owned = false;
22401 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22402 ChannelHandshakeLimits_set_trust_own_funding_0conf(&this_ptr_conv, val);
22405 jboolean __attribute__((export_name("TS_ChannelHandshakeLimits_get_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint32_t this_ptr) {
22406 LDKChannelHandshakeLimits this_ptr_conv;
22407 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22408 this_ptr_conv.is_owned = false;
22409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22410 jboolean ret_conv = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
22414 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_force_announced_channel_preference"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint32_t this_ptr, jboolean val) {
22415 LDKChannelHandshakeLimits this_ptr_conv;
22416 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22417 this_ptr_conv.is_owned = false;
22418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22419 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
22422 int16_t __attribute__((export_name("TS_ChannelHandshakeLimits_get_their_to_self_delay"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint32_t this_ptr) {
22423 LDKChannelHandshakeLimits this_ptr_conv;
22424 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22425 this_ptr_conv.is_owned = false;
22426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22427 int16_t ret_conv = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
22431 void __attribute__((export_name("TS_ChannelHandshakeLimits_set_their_to_self_delay"))) TS_ChannelHandshakeLimits_set_their_to_self_delay(uint32_t this_ptr, int16_t val) {
22432 LDKChannelHandshakeLimits this_ptr_conv;
22433 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22434 this_ptr_conv.is_owned = false;
22435 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22436 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
22439 uint32_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) {
22440 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);
22441 uint32_t ret_ref = 0;
22442 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22443 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22444 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22445 ret_ref = (uintptr_t)ret_var.inner;
22446 if (ret_var.is_owned) {
22452 static inline uintptr_t ChannelHandshakeLimits_clone_ptr(LDKChannelHandshakeLimits *NONNULL_PTR arg) {
22453 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(arg);
22454 uint32_t ret_ref = 0;
22455 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22456 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22457 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22458 ret_ref = (uintptr_t)ret_var.inner;
22459 if (ret_var.is_owned) {
22464 uint32_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone_ptr"))) TS_ChannelHandshakeLimits_clone_ptr(uint32_t arg) {
22465 LDKChannelHandshakeLimits arg_conv;
22466 arg_conv.inner = (void*)(arg & (~1));
22467 arg_conv.is_owned = false;
22468 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22469 uint32_t ret_conv = ChannelHandshakeLimits_clone_ptr(&arg_conv);
22473 uint32_t __attribute__((export_name("TS_ChannelHandshakeLimits_clone"))) TS_ChannelHandshakeLimits_clone(uint32_t orig) {
22474 LDKChannelHandshakeLimits orig_conv;
22475 orig_conv.inner = (void*)(orig & (~1));
22476 orig_conv.is_owned = false;
22477 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22478 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
22479 uint32_t ret_ref = 0;
22480 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22481 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22482 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22483 ret_ref = (uintptr_t)ret_var.inner;
22484 if (ret_var.is_owned) {
22490 uint32_t __attribute__((export_name("TS_ChannelHandshakeLimits_default"))) TS_ChannelHandshakeLimits_default() {
22491 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
22492 uint32_t ret_ref = 0;
22493 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22494 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22495 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22496 ret_ref = (uintptr_t)ret_var.inner;
22497 if (ret_var.is_owned) {
22503 void __attribute__((export_name("TS_ChannelConfig_free"))) TS_ChannelConfig_free(uint32_t this_obj) {
22504 LDKChannelConfig this_obj_conv;
22505 this_obj_conv.inner = (void*)(this_obj & (~1));
22506 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22507 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22508 ChannelConfig_free(this_obj_conv);
22511 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint32_t this_ptr) {
22512 LDKChannelConfig this_ptr_conv;
22513 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22514 this_ptr_conv.is_owned = false;
22515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22516 int32_t ret_conv = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
22520 void __attribute__((export_name("TS_ChannelConfig_set_forwarding_fee_proportional_millionths"))) TS_ChannelConfig_set_forwarding_fee_proportional_millionths(uint32_t this_ptr, int32_t val) {
22521 LDKChannelConfig this_ptr_conv;
22522 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22523 this_ptr_conv.is_owned = false;
22524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22525 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
22528 int32_t __attribute__((export_name("TS_ChannelConfig_get_forwarding_fee_base_msat"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint32_t this_ptr) {
22529 LDKChannelConfig this_ptr_conv;
22530 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22531 this_ptr_conv.is_owned = false;
22532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22533 int32_t ret_conv = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
22537 void __attribute__((export_name("TS_ChannelConfig_set_forwarding_fee_base_msat"))) TS_ChannelConfig_set_forwarding_fee_base_msat(uint32_t this_ptr, int32_t val) {
22538 LDKChannelConfig this_ptr_conv;
22539 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22540 this_ptr_conv.is_owned = false;
22541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22542 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
22545 int16_t __attribute__((export_name("TS_ChannelConfig_get_cltv_expiry_delta"))) TS_ChannelConfig_get_cltv_expiry_delta(uint32_t this_ptr) {
22546 LDKChannelConfig this_ptr_conv;
22547 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22548 this_ptr_conv.is_owned = false;
22549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22550 int16_t ret_conv = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
22554 void __attribute__((export_name("TS_ChannelConfig_set_cltv_expiry_delta"))) TS_ChannelConfig_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
22555 LDKChannelConfig this_ptr_conv;
22556 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22557 this_ptr_conv.is_owned = false;
22558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22559 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
22562 int64_t __attribute__((export_name("TS_ChannelConfig_get_max_dust_htlc_exposure_msat"))) TS_ChannelConfig_get_max_dust_htlc_exposure_msat(uint32_t this_ptr) {
22563 LDKChannelConfig this_ptr_conv;
22564 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22565 this_ptr_conv.is_owned = false;
22566 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22567 int64_t ret_conv = ChannelConfig_get_max_dust_htlc_exposure_msat(&this_ptr_conv);
22571 void __attribute__((export_name("TS_ChannelConfig_set_max_dust_htlc_exposure_msat"))) TS_ChannelConfig_set_max_dust_htlc_exposure_msat(uint32_t this_ptr, int64_t val) {
22572 LDKChannelConfig this_ptr_conv;
22573 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22574 this_ptr_conv.is_owned = false;
22575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22576 ChannelConfig_set_max_dust_htlc_exposure_msat(&this_ptr_conv, val);
22579 int64_t __attribute__((export_name("TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfig_get_force_close_avoidance_max_fee_satoshis(uint32_t this_ptr) {
22580 LDKChannelConfig this_ptr_conv;
22581 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22582 this_ptr_conv.is_owned = false;
22583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22584 int64_t ret_conv = ChannelConfig_get_force_close_avoidance_max_fee_satoshis(&this_ptr_conv);
22588 void __attribute__((export_name("TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis"))) TS_ChannelConfig_set_force_close_avoidance_max_fee_satoshis(uint32_t this_ptr, int64_t val) {
22589 LDKChannelConfig this_ptr_conv;
22590 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22591 this_ptr_conv.is_owned = false;
22592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22593 ChannelConfig_set_force_close_avoidance_max_fee_satoshis(&this_ptr_conv, val);
22596 uint32_t __attribute__((export_name("TS_ChannelConfig_new"))) TS_ChannelConfig_new(int32_t forwarding_fee_proportional_millionths_arg, int32_t forwarding_fee_base_msat_arg, int16_t cltv_expiry_delta_arg, int64_t max_dust_htlc_exposure_msat_arg, int64_t force_close_avoidance_max_fee_satoshis_arg) {
22597 LDKChannelConfig ret_var = ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, max_dust_htlc_exposure_msat_arg, force_close_avoidance_max_fee_satoshis_arg);
22598 uint32_t ret_ref = 0;
22599 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22600 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22601 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22602 ret_ref = (uintptr_t)ret_var.inner;
22603 if (ret_var.is_owned) {
22609 static inline uintptr_t ChannelConfig_clone_ptr(LDKChannelConfig *NONNULL_PTR arg) {
22610 LDKChannelConfig ret_var = ChannelConfig_clone(arg);
22611 uint32_t ret_ref = 0;
22612 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22613 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22614 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22615 ret_ref = (uintptr_t)ret_var.inner;
22616 if (ret_var.is_owned) {
22621 uint32_t __attribute__((export_name("TS_ChannelConfig_clone_ptr"))) TS_ChannelConfig_clone_ptr(uint32_t arg) {
22622 LDKChannelConfig arg_conv;
22623 arg_conv.inner = (void*)(arg & (~1));
22624 arg_conv.is_owned = false;
22625 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22626 uint32_t ret_conv = ChannelConfig_clone_ptr(&arg_conv);
22630 uint32_t __attribute__((export_name("TS_ChannelConfig_clone"))) TS_ChannelConfig_clone(uint32_t orig) {
22631 LDKChannelConfig orig_conv;
22632 orig_conv.inner = (void*)(orig & (~1));
22633 orig_conv.is_owned = false;
22634 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22635 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
22636 uint32_t ret_ref = 0;
22637 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22638 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22639 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22640 ret_ref = (uintptr_t)ret_var.inner;
22641 if (ret_var.is_owned) {
22647 uint32_t __attribute__((export_name("TS_ChannelConfig_default"))) TS_ChannelConfig_default() {
22648 LDKChannelConfig ret_var = ChannelConfig_default();
22649 uint32_t ret_ref = 0;
22650 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22651 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22652 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22653 ret_ref = (uintptr_t)ret_var.inner;
22654 if (ret_var.is_owned) {
22660 int8_tArray __attribute__((export_name("TS_ChannelConfig_write"))) TS_ChannelConfig_write(uint32_t obj) {
22661 LDKChannelConfig obj_conv;
22662 obj_conv.inner = (void*)(obj & (~1));
22663 obj_conv.is_owned = false;
22664 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
22665 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
22666 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
22667 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
22668 CVec_u8Z_free(ret_var);
22672 uint32_t __attribute__((export_name("TS_ChannelConfig_read"))) TS_ChannelConfig_read(int8_tArray ser) {
22673 LDKu8slice ser_ref;
22674 ser_ref.datalen = ser->arr_len;
22675 ser_ref.data = ser->elems;
22676 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
22677 *ret_conv = ChannelConfig_read(ser_ref);
22679 return (uint32_t)ret_conv;
22682 void __attribute__((export_name("TS_UserConfig_free"))) TS_UserConfig_free(uint32_t this_obj) {
22683 LDKUserConfig this_obj_conv;
22684 this_obj_conv.inner = (void*)(this_obj & (~1));
22685 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22687 UserConfig_free(this_obj_conv);
22690 uint32_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_config"))) TS_UserConfig_get_channel_handshake_config(uint32_t this_ptr) {
22691 LDKUserConfig this_ptr_conv;
22692 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22693 this_ptr_conv.is_owned = false;
22694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22695 LDKChannelHandshakeConfig ret_var = UserConfig_get_channel_handshake_config(&this_ptr_conv);
22696 uint32_t ret_ref = 0;
22697 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22698 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22699 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22700 ret_ref = (uintptr_t)ret_var.inner;
22701 if (ret_var.is_owned) {
22707 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_config"))) TS_UserConfig_set_channel_handshake_config(uint32_t this_ptr, uint32_t val) {
22708 LDKUserConfig this_ptr_conv;
22709 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22710 this_ptr_conv.is_owned = false;
22711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22712 LDKChannelHandshakeConfig val_conv;
22713 val_conv.inner = (void*)(val & (~1));
22714 val_conv.is_owned = (val & 1) || (val == 0);
22715 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
22716 val_conv = ChannelHandshakeConfig_clone(&val_conv);
22717 UserConfig_set_channel_handshake_config(&this_ptr_conv, val_conv);
22720 uint32_t __attribute__((export_name("TS_UserConfig_get_channel_handshake_limits"))) TS_UserConfig_get_channel_handshake_limits(uint32_t this_ptr) {
22721 LDKUserConfig this_ptr_conv;
22722 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22723 this_ptr_conv.is_owned = false;
22724 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22725 LDKChannelHandshakeLimits ret_var = UserConfig_get_channel_handshake_limits(&this_ptr_conv);
22726 uint32_t ret_ref = 0;
22727 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22728 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22729 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22730 ret_ref = (uintptr_t)ret_var.inner;
22731 if (ret_var.is_owned) {
22737 void __attribute__((export_name("TS_UserConfig_set_channel_handshake_limits"))) TS_UserConfig_set_channel_handshake_limits(uint32_t this_ptr, uint32_t val) {
22738 LDKUserConfig this_ptr_conv;
22739 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22740 this_ptr_conv.is_owned = false;
22741 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22742 LDKChannelHandshakeLimits val_conv;
22743 val_conv.inner = (void*)(val & (~1));
22744 val_conv.is_owned = (val & 1) || (val == 0);
22745 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
22746 val_conv = ChannelHandshakeLimits_clone(&val_conv);
22747 UserConfig_set_channel_handshake_limits(&this_ptr_conv, val_conv);
22750 uint32_t __attribute__((export_name("TS_UserConfig_get_channel_config"))) TS_UserConfig_get_channel_config(uint32_t this_ptr) {
22751 LDKUserConfig this_ptr_conv;
22752 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22753 this_ptr_conv.is_owned = false;
22754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22755 LDKChannelConfig ret_var = UserConfig_get_channel_config(&this_ptr_conv);
22756 uint32_t ret_ref = 0;
22757 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22758 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22759 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22760 ret_ref = (uintptr_t)ret_var.inner;
22761 if (ret_var.is_owned) {
22767 void __attribute__((export_name("TS_UserConfig_set_channel_config"))) TS_UserConfig_set_channel_config(uint32_t this_ptr, uint32_t val) {
22768 LDKUserConfig this_ptr_conv;
22769 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22770 this_ptr_conv.is_owned = false;
22771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22772 LDKChannelConfig val_conv;
22773 val_conv.inner = (void*)(val & (~1));
22774 val_conv.is_owned = (val & 1) || (val == 0);
22775 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
22776 val_conv = ChannelConfig_clone(&val_conv);
22777 UserConfig_set_channel_config(&this_ptr_conv, val_conv);
22780 jboolean __attribute__((export_name("TS_UserConfig_get_accept_forwards_to_priv_channels"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint32_t this_ptr) {
22781 LDKUserConfig this_ptr_conv;
22782 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22783 this_ptr_conv.is_owned = false;
22784 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22785 jboolean ret_conv = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
22789 void __attribute__((export_name("TS_UserConfig_set_accept_forwards_to_priv_channels"))) TS_UserConfig_set_accept_forwards_to_priv_channels(uint32_t this_ptr, jboolean val) {
22790 LDKUserConfig this_ptr_conv;
22791 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22792 this_ptr_conv.is_owned = false;
22793 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22794 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
22797 jboolean __attribute__((export_name("TS_UserConfig_get_accept_inbound_channels"))) TS_UserConfig_get_accept_inbound_channels(uint32_t this_ptr) {
22798 LDKUserConfig this_ptr_conv;
22799 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22800 this_ptr_conv.is_owned = false;
22801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22802 jboolean ret_conv = UserConfig_get_accept_inbound_channels(&this_ptr_conv);
22806 void __attribute__((export_name("TS_UserConfig_set_accept_inbound_channels"))) TS_UserConfig_set_accept_inbound_channels(uint32_t this_ptr, jboolean val) {
22807 LDKUserConfig this_ptr_conv;
22808 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22809 this_ptr_conv.is_owned = false;
22810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22811 UserConfig_set_accept_inbound_channels(&this_ptr_conv, val);
22814 jboolean __attribute__((export_name("TS_UserConfig_get_manually_accept_inbound_channels"))) TS_UserConfig_get_manually_accept_inbound_channels(uint32_t this_ptr) {
22815 LDKUserConfig this_ptr_conv;
22816 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22817 this_ptr_conv.is_owned = false;
22818 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22819 jboolean ret_conv = UserConfig_get_manually_accept_inbound_channels(&this_ptr_conv);
22823 void __attribute__((export_name("TS_UserConfig_set_manually_accept_inbound_channels"))) TS_UserConfig_set_manually_accept_inbound_channels(uint32_t this_ptr, jboolean val) {
22824 LDKUserConfig this_ptr_conv;
22825 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22826 this_ptr_conv.is_owned = false;
22827 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
22828 UserConfig_set_manually_accept_inbound_channels(&this_ptr_conv, val);
22831 uint32_t __attribute__((export_name("TS_UserConfig_new"))) TS_UserConfig_new(uint32_t channel_handshake_config_arg, uint32_t channel_handshake_limits_arg, uint32_t channel_config_arg, jboolean accept_forwards_to_priv_channels_arg, jboolean accept_inbound_channels_arg, jboolean manually_accept_inbound_channels_arg) {
22832 LDKChannelHandshakeConfig channel_handshake_config_arg_conv;
22833 channel_handshake_config_arg_conv.inner = (void*)(channel_handshake_config_arg & (~1));
22834 channel_handshake_config_arg_conv.is_owned = (channel_handshake_config_arg & 1) || (channel_handshake_config_arg == 0);
22835 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_config_arg_conv);
22836 channel_handshake_config_arg_conv = ChannelHandshakeConfig_clone(&channel_handshake_config_arg_conv);
22837 LDKChannelHandshakeLimits channel_handshake_limits_arg_conv;
22838 channel_handshake_limits_arg_conv.inner = (void*)(channel_handshake_limits_arg & (~1));
22839 channel_handshake_limits_arg_conv.is_owned = (channel_handshake_limits_arg & 1) || (channel_handshake_limits_arg == 0);
22840 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_handshake_limits_arg_conv);
22841 channel_handshake_limits_arg_conv = ChannelHandshakeLimits_clone(&channel_handshake_limits_arg_conv);
22842 LDKChannelConfig channel_config_arg_conv;
22843 channel_config_arg_conv.inner = (void*)(channel_config_arg & (~1));
22844 channel_config_arg_conv.is_owned = (channel_config_arg & 1) || (channel_config_arg == 0);
22845 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_config_arg_conv);
22846 channel_config_arg_conv = ChannelConfig_clone(&channel_config_arg_conv);
22847 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);
22848 uint32_t ret_ref = 0;
22849 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22850 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22851 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22852 ret_ref = (uintptr_t)ret_var.inner;
22853 if (ret_var.is_owned) {
22859 static inline uintptr_t UserConfig_clone_ptr(LDKUserConfig *NONNULL_PTR arg) {
22860 LDKUserConfig ret_var = UserConfig_clone(arg);
22861 uint32_t ret_ref = 0;
22862 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22863 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22864 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22865 ret_ref = (uintptr_t)ret_var.inner;
22866 if (ret_var.is_owned) {
22871 uint32_t __attribute__((export_name("TS_UserConfig_clone_ptr"))) TS_UserConfig_clone_ptr(uint32_t arg) {
22872 LDKUserConfig arg_conv;
22873 arg_conv.inner = (void*)(arg & (~1));
22874 arg_conv.is_owned = false;
22875 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22876 uint32_t ret_conv = UserConfig_clone_ptr(&arg_conv);
22880 uint32_t __attribute__((export_name("TS_UserConfig_clone"))) TS_UserConfig_clone(uint32_t orig) {
22881 LDKUserConfig orig_conv;
22882 orig_conv.inner = (void*)(orig & (~1));
22883 orig_conv.is_owned = false;
22884 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22885 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
22886 uint32_t ret_ref = 0;
22887 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22888 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22889 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22890 ret_ref = (uintptr_t)ret_var.inner;
22891 if (ret_var.is_owned) {
22897 uint32_t __attribute__((export_name("TS_UserConfig_default"))) TS_UserConfig_default() {
22898 LDKUserConfig ret_var = UserConfig_default();
22899 uint32_t ret_ref = 0;
22900 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22901 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22902 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22903 ret_ref = (uintptr_t)ret_var.inner;
22904 if (ret_var.is_owned) {
22910 void __attribute__((export_name("TS_BestBlock_free"))) TS_BestBlock_free(uint32_t this_obj) {
22911 LDKBestBlock this_obj_conv;
22912 this_obj_conv.inner = (void*)(this_obj & (~1));
22913 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22914 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
22915 BestBlock_free(this_obj_conv);
22918 static inline uintptr_t BestBlock_clone_ptr(LDKBestBlock *NONNULL_PTR arg) {
22919 LDKBestBlock ret_var = BestBlock_clone(arg);
22920 uint32_t ret_ref = 0;
22921 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22922 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22923 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22924 ret_ref = (uintptr_t)ret_var.inner;
22925 if (ret_var.is_owned) {
22930 uint32_t __attribute__((export_name("TS_BestBlock_clone_ptr"))) TS_BestBlock_clone_ptr(uint32_t arg) {
22931 LDKBestBlock arg_conv;
22932 arg_conv.inner = (void*)(arg & (~1));
22933 arg_conv.is_owned = false;
22934 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
22935 uint32_t ret_conv = BestBlock_clone_ptr(&arg_conv);
22939 uint32_t __attribute__((export_name("TS_BestBlock_clone"))) TS_BestBlock_clone(uint32_t orig) {
22940 LDKBestBlock orig_conv;
22941 orig_conv.inner = (void*)(orig & (~1));
22942 orig_conv.is_owned = false;
22943 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
22944 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
22945 uint32_t ret_ref = 0;
22946 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22947 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22948 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22949 ret_ref = (uintptr_t)ret_var.inner;
22950 if (ret_var.is_owned) {
22956 uint32_t __attribute__((export_name("TS_BestBlock_from_genesis"))) TS_BestBlock_from_genesis(uint32_t network) {
22957 LDKNetwork network_conv = LDKNetwork_from_js(network);
22958 LDKBestBlock ret_var = BestBlock_from_genesis(network_conv);
22959 uint32_t ret_ref = 0;
22960 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22961 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22962 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22963 ret_ref = (uintptr_t)ret_var.inner;
22964 if (ret_var.is_owned) {
22970 uint32_t __attribute__((export_name("TS_BestBlock_new"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
22971 LDKThirtyTwoBytes block_hash_ref;
22972 CHECK(block_hash->arr_len == 32);
22973 memcpy(block_hash_ref.data, block_hash->elems, 32); FREE(block_hash);
22974 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
22975 uint32_t ret_ref = 0;
22976 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22977 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22978 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
22979 ret_ref = (uintptr_t)ret_var.inner;
22980 if (ret_var.is_owned) {
22986 int8_tArray __attribute__((export_name("TS_BestBlock_block_hash"))) TS_BestBlock_block_hash(uint32_t this_arg) {
22987 LDKBestBlock this_arg_conv;
22988 this_arg_conv.inner = (void*)(this_arg & (~1));
22989 this_arg_conv.is_owned = false;
22990 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
22991 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
22992 memcpy(ret_arr->elems, BestBlock_block_hash(&this_arg_conv).data, 32);
22996 int32_t __attribute__((export_name("TS_BestBlock_height"))) TS_BestBlock_height(uint32_t this_arg) {
22997 LDKBestBlock this_arg_conv;
22998 this_arg_conv.inner = (void*)(this_arg & (~1));
22999 this_arg_conv.is_owned = false;
23000 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23001 int32_t ret_conv = BestBlock_height(&this_arg_conv);
23005 uint32_t __attribute__((export_name("TS_AccessError_clone"))) TS_AccessError_clone(uint32_t orig) {
23006 LDKAccessError* orig_conv = (LDKAccessError*)(orig & ~1);
23007 uint32_t ret_conv = LDKAccessError_to_js(AccessError_clone(orig_conv));
23011 uint32_t __attribute__((export_name("TS_AccessError_unknown_chain"))) TS_AccessError_unknown_chain() {
23012 uint32_t ret_conv = LDKAccessError_to_js(AccessError_unknown_chain());
23016 uint32_t __attribute__((export_name("TS_AccessError_unknown_tx"))) TS_AccessError_unknown_tx() {
23017 uint32_t ret_conv = LDKAccessError_to_js(AccessError_unknown_tx());
23021 void __attribute__((export_name("TS_Access_free"))) TS_Access_free(uint32_t this_ptr) {
23022 if ((this_ptr & 1) != 0) return;
23023 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23024 CHECK_ACCESS(this_ptr_ptr);
23025 LDKAccess this_ptr_conv = *(LDKAccess*)(this_ptr_ptr);
23026 FREE((void*)this_ptr);
23027 Access_free(this_ptr_conv);
23030 void __attribute__((export_name("TS_Listen_free"))) TS_Listen_free(uint32_t this_ptr) {
23031 if ((this_ptr & 1) != 0) return;
23032 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23033 CHECK_ACCESS(this_ptr_ptr);
23034 LDKListen this_ptr_conv = *(LDKListen*)(this_ptr_ptr);
23035 FREE((void*)this_ptr);
23036 Listen_free(this_ptr_conv);
23039 void __attribute__((export_name("TS_Confirm_free"))) TS_Confirm_free(uint32_t this_ptr) {
23040 if ((this_ptr & 1) != 0) return;
23041 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23042 CHECK_ACCESS(this_ptr_ptr);
23043 LDKConfirm this_ptr_conv = *(LDKConfirm*)(this_ptr_ptr);
23044 FREE((void*)this_ptr);
23045 Confirm_free(this_ptr_conv);
23048 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateErr_clone"))) TS_ChannelMonitorUpdateErr_clone(uint32_t orig) {
23049 LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1);
23050 uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_clone(orig_conv));
23054 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateErr_temporary_failure"))) TS_ChannelMonitorUpdateErr_temporary_failure() {
23055 uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_temporary_failure());
23059 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdateErr_permanent_failure"))) TS_ChannelMonitorUpdateErr_permanent_failure() {
23060 uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_permanent_failure());
23064 void __attribute__((export_name("TS_Watch_free"))) TS_Watch_free(uint32_t this_ptr) {
23065 if ((this_ptr & 1) != 0) return;
23066 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23067 CHECK_ACCESS(this_ptr_ptr);
23068 LDKWatch this_ptr_conv = *(LDKWatch*)(this_ptr_ptr);
23069 FREE((void*)this_ptr);
23070 Watch_free(this_ptr_conv);
23073 void __attribute__((export_name("TS_Filter_free"))) TS_Filter_free(uint32_t this_ptr) {
23074 if ((this_ptr & 1) != 0) return;
23075 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23076 CHECK_ACCESS(this_ptr_ptr);
23077 LDKFilter this_ptr_conv = *(LDKFilter*)(this_ptr_ptr);
23078 FREE((void*)this_ptr);
23079 Filter_free(this_ptr_conv);
23082 void __attribute__((export_name("TS_WatchedOutput_free"))) TS_WatchedOutput_free(uint32_t this_obj) {
23083 LDKWatchedOutput this_obj_conv;
23084 this_obj_conv.inner = (void*)(this_obj & (~1));
23085 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23087 WatchedOutput_free(this_obj_conv);
23090 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_block_hash"))) TS_WatchedOutput_get_block_hash(uint32_t this_ptr) {
23091 LDKWatchedOutput this_ptr_conv;
23092 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23093 this_ptr_conv.is_owned = false;
23094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23095 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
23096 memcpy(ret_arr->elems, WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
23100 void __attribute__((export_name("TS_WatchedOutput_set_block_hash"))) TS_WatchedOutput_set_block_hash(uint32_t this_ptr, int8_tArray val) {
23101 LDKWatchedOutput this_ptr_conv;
23102 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23103 this_ptr_conv.is_owned = false;
23104 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23105 LDKThirtyTwoBytes val_ref;
23106 CHECK(val->arr_len == 32);
23107 memcpy(val_ref.data, val->elems, 32); FREE(val);
23108 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
23111 uint32_t __attribute__((export_name("TS_WatchedOutput_get_outpoint"))) TS_WatchedOutput_get_outpoint(uint32_t this_ptr) {
23112 LDKWatchedOutput this_ptr_conv;
23113 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23114 this_ptr_conv.is_owned = false;
23115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23116 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
23117 uint32_t ret_ref = 0;
23118 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23119 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23120 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23121 ret_ref = (uintptr_t)ret_var.inner;
23122 if (ret_var.is_owned) {
23128 void __attribute__((export_name("TS_WatchedOutput_set_outpoint"))) TS_WatchedOutput_set_outpoint(uint32_t this_ptr, uint32_t val) {
23129 LDKWatchedOutput this_ptr_conv;
23130 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23131 this_ptr_conv.is_owned = false;
23132 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23133 LDKOutPoint val_conv;
23134 val_conv.inner = (void*)(val & (~1));
23135 val_conv.is_owned = (val & 1) || (val == 0);
23136 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
23137 val_conv = OutPoint_clone(&val_conv);
23138 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
23141 int8_tArray __attribute__((export_name("TS_WatchedOutput_get_script_pubkey"))) TS_WatchedOutput_get_script_pubkey(uint32_t this_ptr) {
23142 LDKWatchedOutput this_ptr_conv;
23143 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23144 this_ptr_conv.is_owned = false;
23145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23146 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
23147 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23148 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23152 void __attribute__((export_name("TS_WatchedOutput_set_script_pubkey"))) TS_WatchedOutput_set_script_pubkey(uint32_t this_ptr, int8_tArray val) {
23153 LDKWatchedOutput this_ptr_conv;
23154 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23155 this_ptr_conv.is_owned = false;
23156 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23157 LDKCVec_u8Z val_ref;
23158 val_ref.datalen = val->arr_len;
23159 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
23160 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
23161 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
23164 uint32_t __attribute__((export_name("TS_WatchedOutput_new"))) TS_WatchedOutput_new(int8_tArray block_hash_arg, uint32_t outpoint_arg, int8_tArray script_pubkey_arg) {
23165 LDKThirtyTwoBytes block_hash_arg_ref;
23166 CHECK(block_hash_arg->arr_len == 32);
23167 memcpy(block_hash_arg_ref.data, block_hash_arg->elems, 32); FREE(block_hash_arg);
23168 LDKOutPoint outpoint_arg_conv;
23169 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
23170 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
23171 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
23172 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
23173 LDKCVec_u8Z script_pubkey_arg_ref;
23174 script_pubkey_arg_ref.datalen = script_pubkey_arg->arr_len;
23175 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
23176 memcpy(script_pubkey_arg_ref.data, script_pubkey_arg->elems, script_pubkey_arg_ref.datalen); FREE(script_pubkey_arg);
23177 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
23178 uint32_t ret_ref = 0;
23179 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23180 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23181 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23182 ret_ref = (uintptr_t)ret_var.inner;
23183 if (ret_var.is_owned) {
23189 static inline uintptr_t WatchedOutput_clone_ptr(LDKWatchedOutput *NONNULL_PTR arg) {
23190 LDKWatchedOutput ret_var = WatchedOutput_clone(arg);
23191 uint32_t ret_ref = 0;
23192 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23193 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23195 ret_ref = (uintptr_t)ret_var.inner;
23196 if (ret_var.is_owned) {
23201 uint32_t __attribute__((export_name("TS_WatchedOutput_clone_ptr"))) TS_WatchedOutput_clone_ptr(uint32_t arg) {
23202 LDKWatchedOutput arg_conv;
23203 arg_conv.inner = (void*)(arg & (~1));
23204 arg_conv.is_owned = false;
23205 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23206 uint32_t ret_conv = WatchedOutput_clone_ptr(&arg_conv);
23210 uint32_t __attribute__((export_name("TS_WatchedOutput_clone"))) TS_WatchedOutput_clone(uint32_t orig) {
23211 LDKWatchedOutput orig_conv;
23212 orig_conv.inner = (void*)(orig & (~1));
23213 orig_conv.is_owned = false;
23214 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23215 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
23216 uint32_t ret_ref = 0;
23217 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23218 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23219 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23220 ret_ref = (uintptr_t)ret_var.inner;
23221 if (ret_var.is_owned) {
23227 int64_t __attribute__((export_name("TS_WatchedOutput_hash"))) TS_WatchedOutput_hash(uint32_t o) {
23228 LDKWatchedOutput o_conv;
23229 o_conv.inner = (void*)(o & (~1));
23230 o_conv.is_owned = false;
23231 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23232 int64_t ret_conv = WatchedOutput_hash(&o_conv);
23236 void __attribute__((export_name("TS_BroadcasterInterface_free"))) TS_BroadcasterInterface_free(uint32_t this_ptr) {
23237 if ((this_ptr & 1) != 0) return;
23238 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23239 CHECK_ACCESS(this_ptr_ptr);
23240 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(this_ptr_ptr);
23241 FREE((void*)this_ptr);
23242 BroadcasterInterface_free(this_ptr_conv);
23245 uint32_t __attribute__((export_name("TS_ConfirmationTarget_clone"))) TS_ConfirmationTarget_clone(uint32_t orig) {
23246 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)(orig & ~1);
23247 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
23251 uint32_t __attribute__((export_name("TS_ConfirmationTarget_background"))) TS_ConfirmationTarget_background() {
23252 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_background());
23256 uint32_t __attribute__((export_name("TS_ConfirmationTarget_normal"))) TS_ConfirmationTarget_normal() {
23257 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_normal());
23261 uint32_t __attribute__((export_name("TS_ConfirmationTarget_high_priority"))) TS_ConfirmationTarget_high_priority() {
23262 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_high_priority());
23266 jboolean __attribute__((export_name("TS_ConfirmationTarget_eq"))) TS_ConfirmationTarget_eq(uint32_t a, uint32_t b) {
23267 LDKConfirmationTarget* a_conv = (LDKConfirmationTarget*)(a & ~1);
23268 LDKConfirmationTarget* b_conv = (LDKConfirmationTarget*)(b & ~1);
23269 jboolean ret_conv = ConfirmationTarget_eq(a_conv, b_conv);
23273 void __attribute__((export_name("TS_FeeEstimator_free"))) TS_FeeEstimator_free(uint32_t this_ptr) {
23274 if ((this_ptr & 1) != 0) return;
23275 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23276 CHECK_ACCESS(this_ptr_ptr);
23277 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(this_ptr_ptr);
23278 FREE((void*)this_ptr);
23279 FeeEstimator_free(this_ptr_conv);
23282 void __attribute__((export_name("TS_MonitorUpdateId_free"))) TS_MonitorUpdateId_free(uint32_t this_obj) {
23283 LDKMonitorUpdateId this_obj_conv;
23284 this_obj_conv.inner = (void*)(this_obj & (~1));
23285 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23287 MonitorUpdateId_free(this_obj_conv);
23290 static inline uintptr_t MonitorUpdateId_clone_ptr(LDKMonitorUpdateId *NONNULL_PTR arg) {
23291 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(arg);
23292 uint32_t ret_ref = 0;
23293 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23294 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23295 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23296 ret_ref = (uintptr_t)ret_var.inner;
23297 if (ret_var.is_owned) {
23302 uint32_t __attribute__((export_name("TS_MonitorUpdateId_clone_ptr"))) TS_MonitorUpdateId_clone_ptr(uint32_t arg) {
23303 LDKMonitorUpdateId arg_conv;
23304 arg_conv.inner = (void*)(arg & (~1));
23305 arg_conv.is_owned = false;
23306 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23307 uint32_t ret_conv = MonitorUpdateId_clone_ptr(&arg_conv);
23311 uint32_t __attribute__((export_name("TS_MonitorUpdateId_clone"))) TS_MonitorUpdateId_clone(uint32_t orig) {
23312 LDKMonitorUpdateId orig_conv;
23313 orig_conv.inner = (void*)(orig & (~1));
23314 orig_conv.is_owned = false;
23315 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23316 LDKMonitorUpdateId ret_var = MonitorUpdateId_clone(&orig_conv);
23317 uint32_t ret_ref = 0;
23318 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23319 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23320 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23321 ret_ref = (uintptr_t)ret_var.inner;
23322 if (ret_var.is_owned) {
23328 int64_t __attribute__((export_name("TS_MonitorUpdateId_hash"))) TS_MonitorUpdateId_hash(uint32_t o) {
23329 LDKMonitorUpdateId o_conv;
23330 o_conv.inner = (void*)(o & (~1));
23331 o_conv.is_owned = false;
23332 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
23333 int64_t ret_conv = MonitorUpdateId_hash(&o_conv);
23337 jboolean __attribute__((export_name("TS_MonitorUpdateId_eq"))) TS_MonitorUpdateId_eq(uint32_t a, uint32_t b) {
23338 LDKMonitorUpdateId a_conv;
23339 a_conv.inner = (void*)(a & (~1));
23340 a_conv.is_owned = false;
23341 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23342 LDKMonitorUpdateId b_conv;
23343 b_conv.inner = (void*)(b & (~1));
23344 b_conv.is_owned = false;
23345 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
23346 jboolean ret_conv = MonitorUpdateId_eq(&a_conv, &b_conv);
23350 void __attribute__((export_name("TS_Persist_free"))) TS_Persist_free(uint32_t this_ptr) {
23351 if ((this_ptr & 1) != 0) return;
23352 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23353 CHECK_ACCESS(this_ptr_ptr);
23354 LDKPersist this_ptr_conv = *(LDKPersist*)(this_ptr_ptr);
23355 FREE((void*)this_ptr);
23356 Persist_free(this_ptr_conv);
23359 void __attribute__((export_name("TS_LockedChannelMonitor_free"))) TS_LockedChannelMonitor_free(uint32_t this_obj) {
23360 LDKLockedChannelMonitor this_obj_conv;
23361 this_obj_conv.inner = (void*)(this_obj & (~1));
23362 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23363 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23364 LockedChannelMonitor_free(this_obj_conv);
23367 void __attribute__((export_name("TS_ChainMonitor_free"))) TS_ChainMonitor_free(uint32_t this_obj) {
23368 LDKChainMonitor this_obj_conv;
23369 this_obj_conv.inner = (void*)(this_obj & (~1));
23370 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23372 ChainMonitor_free(this_obj_conv);
23375 uint32_t __attribute__((export_name("TS_ChainMonitor_new"))) TS_ChainMonitor_new(uint32_t chain_source, uint32_t broadcaster, uint32_t logger, uint32_t feeest, uint32_t persister) {
23376 void* chain_source_ptr = (void*)(((uintptr_t)chain_source) & ~1);
23377 CHECK_ACCESS(chain_source_ptr);
23378 LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(chain_source_ptr);
23379 // WARNING: we may need a move here but no clone is available for LDKCOption_FilterZ
23380 if (chain_source_conv.tag == LDKCOption_FilterZ_Some) {
23381 // Manually implement clone for Java trait instances
23382 if (chain_source_conv.some.free == LDKFilter_JCalls_free) {
23383 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23384 LDKFilter_JCalls_cloned(&chain_source_conv.some);
23387 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
23388 CHECK_ACCESS(broadcaster_ptr);
23389 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
23390 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
23391 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23392 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
23394 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
23395 CHECK_ACCESS(logger_ptr);
23396 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
23397 if (logger_conv.free == LDKLogger_JCalls_free) {
23398 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23399 LDKLogger_JCalls_cloned(&logger_conv);
23401 void* feeest_ptr = (void*)(((uintptr_t)feeest) & ~1);
23402 CHECK_ACCESS(feeest_ptr);
23403 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(feeest_ptr);
23404 if (feeest_conv.free == LDKFeeEstimator_JCalls_free) {
23405 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23406 LDKFeeEstimator_JCalls_cloned(&feeest_conv);
23408 void* persister_ptr = (void*)(((uintptr_t)persister) & ~1);
23409 CHECK_ACCESS(persister_ptr);
23410 LDKPersist persister_conv = *(LDKPersist*)(persister_ptr);
23411 if (persister_conv.free == LDKPersist_JCalls_free) {
23412 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23413 LDKPersist_JCalls_cloned(&persister_conv);
23415 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
23416 uint32_t ret_ref = 0;
23417 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23418 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23419 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23420 ret_ref = (uintptr_t)ret_var.inner;
23421 if (ret_var.is_owned) {
23427 uint32_tArray __attribute__((export_name("TS_ChainMonitor_get_claimable_balances"))) TS_ChainMonitor_get_claimable_balances(uint32_t this_arg, uint32_tArray ignored_channels) {
23428 LDKChainMonitor this_arg_conv;
23429 this_arg_conv.inner = (void*)(this_arg & (~1));
23430 this_arg_conv.is_owned = false;
23431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23432 LDKCVec_ChannelDetailsZ ignored_channels_constr;
23433 ignored_channels_constr.datalen = ignored_channels->arr_len;
23434 if (ignored_channels_constr.datalen > 0)
23435 ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
23437 ignored_channels_constr.data = NULL;
23438 uint32_t* ignored_channels_vals = ignored_channels->elems;
23439 for (size_t q = 0; q < ignored_channels_constr.datalen; q++) {
23440 uint32_t ignored_channels_conv_16 = ignored_channels_vals[q];
23441 LDKChannelDetails ignored_channels_conv_16_conv;
23442 ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1));
23443 ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0);
23444 CHECK_INNER_FIELD_ACCESS_OR_NULL(ignored_channels_conv_16_conv);
23445 ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv);
23446 ignored_channels_constr.data[q] = ignored_channels_conv_16_conv;
23448 FREE(ignored_channels);
23449 LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr);
23450 uint32_tArray ret_arr = NULL;
23451 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
23452 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
23453 for (size_t j = 0; j < ret_var.datalen; j++) {
23454 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23455 *ret_conv_9_copy = ret_var.data[j];
23456 uint32_t ret_conv_9_ref = (uintptr_t)ret_conv_9_copy;
23457 ret_arr_ptr[j] = ret_conv_9_ref;
23460 FREE(ret_var.data);
23464 uint32_t __attribute__((export_name("TS_ChainMonitor_get_monitor"))) TS_ChainMonitor_get_monitor(uint32_t this_arg, uint32_t funding_txo) {
23465 LDKChainMonitor this_arg_conv;
23466 this_arg_conv.inner = (void*)(this_arg & (~1));
23467 this_arg_conv.is_owned = false;
23468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23469 LDKOutPoint funding_txo_conv;
23470 funding_txo_conv.inner = (void*)(funding_txo & (~1));
23471 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
23472 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
23473 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
23474 LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ");
23475 *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv);
23476 return (uint32_t)ret_conv;
23479 uint32_tArray __attribute__((export_name("TS_ChainMonitor_list_monitors"))) TS_ChainMonitor_list_monitors(uint32_t this_arg) {
23480 LDKChainMonitor this_arg_conv;
23481 this_arg_conv.inner = (void*)(this_arg & (~1));
23482 this_arg_conv.is_owned = false;
23483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23484 LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&this_arg_conv);
23485 uint32_tArray ret_arr = NULL;
23486 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
23487 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
23488 for (size_t k = 0; k < ret_var.datalen; k++) {
23489 LDKOutPoint ret_conv_10_var = ret_var.data[k];
23490 uint32_t ret_conv_10_ref = 0;
23491 CHECK((((uintptr_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23492 CHECK((((uintptr_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23493 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_10_var);
23494 ret_conv_10_ref = (uintptr_t)ret_conv_10_var.inner;
23495 if (ret_conv_10_var.is_owned) {
23496 ret_conv_10_ref |= 1;
23498 ret_arr_ptr[k] = ret_conv_10_ref;
23501 FREE(ret_var.data);
23505 uint32_t __attribute__((export_name("TS_ChainMonitor_channel_monitor_updated"))) TS_ChainMonitor_channel_monitor_updated(uint32_t this_arg, uint32_t funding_txo, uint32_t completed_update_id) {
23506 LDKChainMonitor this_arg_conv;
23507 this_arg_conv.inner = (void*)(this_arg & (~1));
23508 this_arg_conv.is_owned = false;
23509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23510 LDKOutPoint funding_txo_conv;
23511 funding_txo_conv.inner = (void*)(funding_txo & (~1));
23512 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
23513 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
23514 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
23515 LDKMonitorUpdateId completed_update_id_conv;
23516 completed_update_id_conv.inner = (void*)(completed_update_id & (~1));
23517 completed_update_id_conv.is_owned = (completed_update_id & 1) || (completed_update_id == 0);
23518 CHECK_INNER_FIELD_ACCESS_OR_NULL(completed_update_id_conv);
23519 completed_update_id_conv = MonitorUpdateId_clone(&completed_update_id_conv);
23520 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
23521 *ret_conv = ChainMonitor_channel_monitor_updated(&this_arg_conv, funding_txo_conv, completed_update_id_conv);
23522 return (uint32_t)ret_conv;
23525 uint32_t __attribute__((export_name("TS_ChainMonitor_as_Listen"))) TS_ChainMonitor_as_Listen(uint32_t this_arg) {
23526 LDKChainMonitor this_arg_conv;
23527 this_arg_conv.inner = (void*)(this_arg & (~1));
23528 this_arg_conv.is_owned = false;
23529 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23530 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
23531 *ret_ret = ChainMonitor_as_Listen(&this_arg_conv);
23532 return (uint32_t)ret_ret;
23535 uint32_t __attribute__((export_name("TS_ChainMonitor_as_Confirm"))) TS_ChainMonitor_as_Confirm(uint32_t this_arg) {
23536 LDKChainMonitor this_arg_conv;
23537 this_arg_conv.inner = (void*)(this_arg & (~1));
23538 this_arg_conv.is_owned = false;
23539 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23540 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
23541 *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv);
23542 return (uint32_t)ret_ret;
23545 uint32_t __attribute__((export_name("TS_ChainMonitor_as_Watch"))) TS_ChainMonitor_as_Watch(uint32_t this_arg) {
23546 LDKChainMonitor this_arg_conv;
23547 this_arg_conv.inner = (void*)(this_arg & (~1));
23548 this_arg_conv.is_owned = false;
23549 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23550 LDKWatch* ret_ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
23551 *ret_ret = ChainMonitor_as_Watch(&this_arg_conv);
23552 return (uint32_t)ret_ret;
23555 uint32_t __attribute__((export_name("TS_ChainMonitor_as_EventsProvider"))) TS_ChainMonitor_as_EventsProvider(uint32_t this_arg) {
23556 LDKChainMonitor this_arg_conv;
23557 this_arg_conv.inner = (void*)(this_arg & (~1));
23558 this_arg_conv.is_owned = false;
23559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23560 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
23561 *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
23562 return (uint32_t)ret_ret;
23565 void __attribute__((export_name("TS_ChannelMonitorUpdate_free"))) TS_ChannelMonitorUpdate_free(uint32_t this_obj) {
23566 LDKChannelMonitorUpdate this_obj_conv;
23567 this_obj_conv.inner = (void*)(this_obj & (~1));
23568 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23569 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23570 ChannelMonitorUpdate_free(this_obj_conv);
23573 int64_t __attribute__((export_name("TS_ChannelMonitorUpdate_get_update_id"))) TS_ChannelMonitorUpdate_get_update_id(uint32_t this_ptr) {
23574 LDKChannelMonitorUpdate this_ptr_conv;
23575 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23576 this_ptr_conv.is_owned = false;
23577 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23578 int64_t ret_conv = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
23582 void __attribute__((export_name("TS_ChannelMonitorUpdate_set_update_id"))) TS_ChannelMonitorUpdate_set_update_id(uint32_t this_ptr, int64_t val) {
23583 LDKChannelMonitorUpdate this_ptr_conv;
23584 this_ptr_conv.inner = (void*)(this_ptr & (~1));
23585 this_ptr_conv.is_owned = false;
23586 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
23587 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
23590 static inline uintptr_t ChannelMonitorUpdate_clone_ptr(LDKChannelMonitorUpdate *NONNULL_PTR arg) {
23591 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(arg);
23592 uint32_t ret_ref = 0;
23593 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23594 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23595 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23596 ret_ref = (uintptr_t)ret_var.inner;
23597 if (ret_var.is_owned) {
23602 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone_ptr"))) TS_ChannelMonitorUpdate_clone_ptr(uint32_t arg) {
23603 LDKChannelMonitorUpdate arg_conv;
23604 arg_conv.inner = (void*)(arg & (~1));
23605 arg_conv.is_owned = false;
23606 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23607 uint32_t ret_conv = ChannelMonitorUpdate_clone_ptr(&arg_conv);
23611 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdate_clone"))) TS_ChannelMonitorUpdate_clone(uint32_t orig) {
23612 LDKChannelMonitorUpdate orig_conv;
23613 orig_conv.inner = (void*)(orig & (~1));
23614 orig_conv.is_owned = false;
23615 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23616 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
23617 uint32_t ret_ref = 0;
23618 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23619 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23620 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23621 ret_ref = (uintptr_t)ret_var.inner;
23622 if (ret_var.is_owned) {
23628 int8_tArray __attribute__((export_name("TS_ChannelMonitorUpdate_write"))) TS_ChannelMonitorUpdate_write(uint32_t obj) {
23629 LDKChannelMonitorUpdate obj_conv;
23630 obj_conv.inner = (void*)(obj & (~1));
23631 obj_conv.is_owned = false;
23632 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23633 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
23634 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23635 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23636 CVec_u8Z_free(ret_var);
23640 uint32_t __attribute__((export_name("TS_ChannelMonitorUpdate_read"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
23641 LDKu8slice ser_ref;
23642 ser_ref.datalen = ser->arr_len;
23643 ser_ref.data = ser->elems;
23644 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
23645 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
23647 return (uint32_t)ret_conv;
23650 void __attribute__((export_name("TS_MonitorEvent_free"))) TS_MonitorEvent_free(uint32_t this_ptr) {
23651 if ((this_ptr & 1) != 0) return;
23652 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23653 CHECK_ACCESS(this_ptr_ptr);
23654 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(this_ptr_ptr);
23655 FREE((void*)this_ptr);
23656 MonitorEvent_free(this_ptr_conv);
23659 static inline uintptr_t MonitorEvent_clone_ptr(LDKMonitorEvent *NONNULL_PTR arg) {
23660 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23661 *ret_copy = MonitorEvent_clone(arg);
23662 uint32_t ret_ref = (uintptr_t)ret_copy;
23665 uint32_t __attribute__((export_name("TS_MonitorEvent_clone_ptr"))) TS_MonitorEvent_clone_ptr(uint32_t arg) {
23666 LDKMonitorEvent* arg_conv = (LDKMonitorEvent*)arg;
23667 uint32_t ret_conv = MonitorEvent_clone_ptr(arg_conv);
23671 uint32_t __attribute__((export_name("TS_MonitorEvent_clone"))) TS_MonitorEvent_clone(uint32_t orig) {
23672 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
23673 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23674 *ret_copy = MonitorEvent_clone(orig_conv);
23675 uint32_t ret_ref = (uintptr_t)ret_copy;
23679 uint32_t __attribute__((export_name("TS_MonitorEvent_htlcevent"))) TS_MonitorEvent_htlcevent(uint32_t a) {
23680 LDKHTLCUpdate a_conv;
23681 a_conv.inner = (void*)(a & (~1));
23682 a_conv.is_owned = (a & 1) || (a == 0);
23683 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23684 a_conv = HTLCUpdate_clone(&a_conv);
23685 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23686 *ret_copy = MonitorEvent_htlcevent(a_conv);
23687 uint32_t ret_ref = (uintptr_t)ret_copy;
23691 uint32_t __attribute__((export_name("TS_MonitorEvent_commitment_tx_confirmed"))) TS_MonitorEvent_commitment_tx_confirmed(uint32_t a) {
23692 LDKOutPoint a_conv;
23693 a_conv.inner = (void*)(a & (~1));
23694 a_conv.is_owned = (a & 1) || (a == 0);
23695 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23696 a_conv = OutPoint_clone(&a_conv);
23697 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23698 *ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv);
23699 uint32_t ret_ref = (uintptr_t)ret_copy;
23703 uint32_t __attribute__((export_name("TS_MonitorEvent_update_completed"))) TS_MonitorEvent_update_completed(uint32_t funding_txo, int64_t monitor_update_id) {
23704 LDKOutPoint funding_txo_conv;
23705 funding_txo_conv.inner = (void*)(funding_txo & (~1));
23706 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
23707 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_conv);
23708 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
23709 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23710 *ret_copy = MonitorEvent_update_completed(funding_txo_conv, monitor_update_id);
23711 uint32_t ret_ref = (uintptr_t)ret_copy;
23715 uint32_t __attribute__((export_name("TS_MonitorEvent_update_failed"))) TS_MonitorEvent_update_failed(uint32_t a) {
23716 LDKOutPoint a_conv;
23717 a_conv.inner = (void*)(a & (~1));
23718 a_conv.is_owned = (a & 1) || (a == 0);
23719 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
23720 a_conv = OutPoint_clone(&a_conv);
23721 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
23722 *ret_copy = MonitorEvent_update_failed(a_conv);
23723 uint32_t ret_ref = (uintptr_t)ret_copy;
23727 int8_tArray __attribute__((export_name("TS_MonitorEvent_write"))) TS_MonitorEvent_write(uint32_t obj) {
23728 LDKMonitorEvent* obj_conv = (LDKMonitorEvent*)obj;
23729 LDKCVec_u8Z ret_var = MonitorEvent_write(obj_conv);
23730 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23731 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23732 CVec_u8Z_free(ret_var);
23736 uint32_t __attribute__((export_name("TS_MonitorEvent_read"))) TS_MonitorEvent_read(int8_tArray ser) {
23737 LDKu8slice ser_ref;
23738 ser_ref.datalen = ser->arr_len;
23739 ser_ref.data = ser->elems;
23740 LDKCResult_COption_MonitorEventZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_MonitorEventZDecodeErrorZ), "LDKCResult_COption_MonitorEventZDecodeErrorZ");
23741 *ret_conv = MonitorEvent_read(ser_ref);
23743 return (uint32_t)ret_conv;
23746 void __attribute__((export_name("TS_HTLCUpdate_free"))) TS_HTLCUpdate_free(uint32_t this_obj) {
23747 LDKHTLCUpdate this_obj_conv;
23748 this_obj_conv.inner = (void*)(this_obj & (~1));
23749 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23750 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23751 HTLCUpdate_free(this_obj_conv);
23754 static inline uintptr_t HTLCUpdate_clone_ptr(LDKHTLCUpdate *NONNULL_PTR arg) {
23755 LDKHTLCUpdate ret_var = HTLCUpdate_clone(arg);
23756 uint32_t ret_ref = 0;
23757 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23758 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23759 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23760 ret_ref = (uintptr_t)ret_var.inner;
23761 if (ret_var.is_owned) {
23766 uint32_t __attribute__((export_name("TS_HTLCUpdate_clone_ptr"))) TS_HTLCUpdate_clone_ptr(uint32_t arg) {
23767 LDKHTLCUpdate arg_conv;
23768 arg_conv.inner = (void*)(arg & (~1));
23769 arg_conv.is_owned = false;
23770 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23771 uint32_t ret_conv = HTLCUpdate_clone_ptr(&arg_conv);
23775 uint32_t __attribute__((export_name("TS_HTLCUpdate_clone"))) TS_HTLCUpdate_clone(uint32_t orig) {
23776 LDKHTLCUpdate orig_conv;
23777 orig_conv.inner = (void*)(orig & (~1));
23778 orig_conv.is_owned = false;
23779 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23780 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
23781 uint32_t ret_ref = 0;
23782 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23783 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23784 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23785 ret_ref = (uintptr_t)ret_var.inner;
23786 if (ret_var.is_owned) {
23792 int8_tArray __attribute__((export_name("TS_HTLCUpdate_write"))) TS_HTLCUpdate_write(uint32_t obj) {
23793 LDKHTLCUpdate obj_conv;
23794 obj_conv.inner = (void*)(obj & (~1));
23795 obj_conv.is_owned = false;
23796 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23797 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
23798 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23799 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23800 CVec_u8Z_free(ret_var);
23804 uint32_t __attribute__((export_name("TS_HTLCUpdate_read"))) TS_HTLCUpdate_read(int8_tArray ser) {
23805 LDKu8slice ser_ref;
23806 ser_ref.datalen = ser->arr_len;
23807 ser_ref.data = ser->elems;
23808 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
23809 *ret_conv = HTLCUpdate_read(ser_ref);
23811 return (uint32_t)ret_conv;
23814 void __attribute__((export_name("TS_Balance_free"))) TS_Balance_free(uint32_t this_ptr) {
23815 if ((this_ptr & 1) != 0) return;
23816 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
23817 CHECK_ACCESS(this_ptr_ptr);
23818 LDKBalance this_ptr_conv = *(LDKBalance*)(this_ptr_ptr);
23819 FREE((void*)this_ptr);
23820 Balance_free(this_ptr_conv);
23823 static inline uintptr_t Balance_clone_ptr(LDKBalance *NONNULL_PTR arg) {
23824 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23825 *ret_copy = Balance_clone(arg);
23826 uint32_t ret_ref = (uintptr_t)ret_copy;
23829 uint32_t __attribute__((export_name("TS_Balance_clone_ptr"))) TS_Balance_clone_ptr(uint32_t arg) {
23830 LDKBalance* arg_conv = (LDKBalance*)arg;
23831 uint32_t ret_conv = Balance_clone_ptr(arg_conv);
23835 uint32_t __attribute__((export_name("TS_Balance_clone"))) TS_Balance_clone(uint32_t orig) {
23836 LDKBalance* orig_conv = (LDKBalance*)orig;
23837 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23838 *ret_copy = Balance_clone(orig_conv);
23839 uint32_t ret_ref = (uintptr_t)ret_copy;
23843 uint32_t __attribute__((export_name("TS_Balance_claimable_on_channel_close"))) TS_Balance_claimable_on_channel_close(int64_t claimable_amount_satoshis) {
23844 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23845 *ret_copy = Balance_claimable_on_channel_close(claimable_amount_satoshis);
23846 uint32_t ret_ref = (uintptr_t)ret_copy;
23850 uint32_t __attribute__((export_name("TS_Balance_claimable_awaiting_confirmations"))) TS_Balance_claimable_awaiting_confirmations(int64_t claimable_amount_satoshis, int32_t confirmation_height) {
23851 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23852 *ret_copy = Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height);
23853 uint32_t ret_ref = (uintptr_t)ret_copy;
23857 uint32_t __attribute__((export_name("TS_Balance_contentious_claimable"))) TS_Balance_contentious_claimable(int64_t claimable_amount_satoshis, int32_t timeout_height) {
23858 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23859 *ret_copy = Balance_contentious_claimable(claimable_amount_satoshis, timeout_height);
23860 uint32_t ret_ref = (uintptr_t)ret_copy;
23864 uint32_t __attribute__((export_name("TS_Balance_maybe_claimable_htlcawaiting_timeout"))) TS_Balance_maybe_claimable_htlcawaiting_timeout(int64_t claimable_amount_satoshis, int32_t claimable_height) {
23865 LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
23866 *ret_copy = Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height);
23867 uint32_t ret_ref = (uintptr_t)ret_copy;
23871 jboolean __attribute__((export_name("TS_Balance_eq"))) TS_Balance_eq(uint32_t a, uint32_t b) {
23872 LDKBalance* a_conv = (LDKBalance*)a;
23873 LDKBalance* b_conv = (LDKBalance*)b;
23874 jboolean ret_conv = Balance_eq(a_conv, b_conv);
23878 void __attribute__((export_name("TS_ChannelMonitor_free"))) TS_ChannelMonitor_free(uint32_t this_obj) {
23879 LDKChannelMonitor this_obj_conv;
23880 this_obj_conv.inner = (void*)(this_obj & (~1));
23881 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
23882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
23883 ChannelMonitor_free(this_obj_conv);
23886 static inline uintptr_t ChannelMonitor_clone_ptr(LDKChannelMonitor *NONNULL_PTR arg) {
23887 LDKChannelMonitor ret_var = ChannelMonitor_clone(arg);
23888 uint32_t ret_ref = 0;
23889 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23890 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23891 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23892 ret_ref = (uintptr_t)ret_var.inner;
23893 if (ret_var.is_owned) {
23898 uint32_t __attribute__((export_name("TS_ChannelMonitor_clone_ptr"))) TS_ChannelMonitor_clone_ptr(uint32_t arg) {
23899 LDKChannelMonitor arg_conv;
23900 arg_conv.inner = (void*)(arg & (~1));
23901 arg_conv.is_owned = false;
23902 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
23903 uint32_t ret_conv = ChannelMonitor_clone_ptr(&arg_conv);
23907 uint32_t __attribute__((export_name("TS_ChannelMonitor_clone"))) TS_ChannelMonitor_clone(uint32_t orig) {
23908 LDKChannelMonitor orig_conv;
23909 orig_conv.inner = (void*)(orig & (~1));
23910 orig_conv.is_owned = false;
23911 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
23912 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
23913 uint32_t ret_ref = 0;
23914 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23915 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23916 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
23917 ret_ref = (uintptr_t)ret_var.inner;
23918 if (ret_var.is_owned) {
23924 int8_tArray __attribute__((export_name("TS_ChannelMonitor_write"))) TS_ChannelMonitor_write(uint32_t obj) {
23925 LDKChannelMonitor obj_conv;
23926 obj_conv.inner = (void*)(obj & (~1));
23927 obj_conv.is_owned = false;
23928 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
23929 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
23930 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
23931 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
23932 CVec_u8Z_free(ret_var);
23936 uint32_t __attribute__((export_name("TS_ChannelMonitor_update_monitor"))) TS_ChannelMonitor_update_monitor(uint32_t this_arg, uint32_t updates, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
23937 LDKChannelMonitor this_arg_conv;
23938 this_arg_conv.inner = (void*)(this_arg & (~1));
23939 this_arg_conv.is_owned = false;
23940 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23941 LDKChannelMonitorUpdate updates_conv;
23942 updates_conv.inner = (void*)(updates & (~1));
23943 updates_conv.is_owned = false;
23944 CHECK_INNER_FIELD_ACCESS_OR_NULL(updates_conv);
23945 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
23946 if (!(broadcaster & 1)) { CHECK_ACCESS(broadcaster_ptr); }
23947 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)broadcaster_ptr;
23948 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
23949 CHECK_ACCESS(fee_estimator_ptr);
23950 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
23951 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
23952 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
23953 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
23955 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
23956 if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
23957 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
23958 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
23959 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
23960 return (uint32_t)ret_conv;
23963 int64_t __attribute__((export_name("TS_ChannelMonitor_get_latest_update_id"))) TS_ChannelMonitor_get_latest_update_id(uint32_t this_arg) {
23964 LDKChannelMonitor this_arg_conv;
23965 this_arg_conv.inner = (void*)(this_arg & (~1));
23966 this_arg_conv.is_owned = false;
23967 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23968 int64_t ret_conv = ChannelMonitor_get_latest_update_id(&this_arg_conv);
23972 uint32_t __attribute__((export_name("TS_ChannelMonitor_get_funding_txo"))) TS_ChannelMonitor_get_funding_txo(uint32_t this_arg) {
23973 LDKChannelMonitor this_arg_conv;
23974 this_arg_conv.inner = (void*)(this_arg & (~1));
23975 this_arg_conv.is_owned = false;
23976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23977 LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
23978 *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv);
23979 return ((uint32_t)ret_conv);
23982 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_get_outputs_to_watch"))) TS_ChannelMonitor_get_outputs_to_watch(uint32_t this_arg) {
23983 LDKChannelMonitor this_arg_conv;
23984 this_arg_conv.inner = (void*)(this_arg & (~1));
23985 this_arg_conv.is_owned = false;
23986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
23987 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
23988 uint32_tArray ret_arr = NULL;
23989 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
23990 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
23991 for (size_t o = 0; o < ret_var.datalen; o++) {
23992 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
23993 *ret_conv_40_conv = ret_var.data[o];
23994 ret_arr_ptr[o] = ((uint32_t)ret_conv_40_conv);
23997 FREE(ret_var.data);
24001 void __attribute__((export_name("TS_ChannelMonitor_load_outputs_to_watch"))) TS_ChannelMonitor_load_outputs_to_watch(uint32_t this_arg, uint32_t filter) {
24002 LDKChannelMonitor this_arg_conv;
24003 this_arg_conv.inner = (void*)(this_arg & (~1));
24004 this_arg_conv.is_owned = false;
24005 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24006 void* filter_ptr = (void*)(((uintptr_t)filter) & ~1);
24007 if (!(filter & 1)) { CHECK_ACCESS(filter_ptr); }
24008 LDKFilter* filter_conv = (LDKFilter*)filter_ptr;
24009 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
24012 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_monitor_events"))) TS_ChannelMonitor_get_and_clear_pending_monitor_events(uint32_t this_arg) {
24013 LDKChannelMonitor this_arg_conv;
24014 this_arg_conv.inner = (void*)(this_arg & (~1));
24015 this_arg_conv.is_owned = false;
24016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24017 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
24018 uint32_tArray ret_arr = NULL;
24019 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24020 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24021 for (size_t o = 0; o < ret_var.datalen; o++) {
24022 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
24023 *ret_conv_14_copy = ret_var.data[o];
24024 uint32_t ret_conv_14_ref = (uintptr_t)ret_conv_14_copy;
24025 ret_arr_ptr[o] = ret_conv_14_ref;
24028 FREE(ret_var.data);
24032 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_get_and_clear_pending_events"))) TS_ChannelMonitor_get_and_clear_pending_events(uint32_t this_arg) {
24033 LDKChannelMonitor this_arg_conv;
24034 this_arg_conv.inner = (void*)(this_arg & (~1));
24035 this_arg_conv.is_owned = false;
24036 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24037 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
24038 uint32_tArray ret_arr = NULL;
24039 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24040 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24041 for (size_t h = 0; h < ret_var.datalen; h++) {
24042 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
24043 *ret_conv_7_copy = ret_var.data[h];
24044 uint32_t ret_conv_7_ref = (uintptr_t)ret_conv_7_copy;
24045 ret_arr_ptr[h] = ret_conv_7_ref;
24048 FREE(ret_var.data);
24052 int8_tArray __attribute__((export_name("TS_ChannelMonitor_get_counterparty_node_id"))) TS_ChannelMonitor_get_counterparty_node_id(uint32_t this_arg) {
24053 LDKChannelMonitor this_arg_conv;
24054 this_arg_conv.inner = (void*)(this_arg & (~1));
24055 this_arg_conv.is_owned = false;
24056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24057 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
24058 memcpy(ret_arr->elems, ChannelMonitor_get_counterparty_node_id(&this_arg_conv).compressed_form, 33);
24062 ptrArray __attribute__((export_name("TS_ChannelMonitor_get_latest_holder_commitment_txn"))) TS_ChannelMonitor_get_latest_holder_commitment_txn(uint32_t this_arg, uint32_t logger) {
24063 LDKChannelMonitor this_arg_conv;
24064 this_arg_conv.inner = (void*)(this_arg & (~1));
24065 this_arg_conv.is_owned = false;
24066 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24067 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24068 if (!(logger & 1)) { CHECK_ACCESS(logger_ptr); }
24069 LDKLogger* logger_conv = (LDKLogger*)logger_ptr;
24070 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
24071 ptrArray ret_arr = NULL;
24072 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
24073 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
24074 for (size_t m = 0; m < ret_var.datalen; m++) {
24075 LDKTransaction ret_conv_12_var = ret_var.data[m];
24076 int8_tArray ret_conv_12_arr = init_int8_tArray(ret_conv_12_var.datalen, __LINE__);
24077 memcpy(ret_conv_12_arr->elems, ret_conv_12_var.data, ret_conv_12_var.datalen);
24078 Transaction_free(ret_conv_12_var);
24079 ret_arr_ptr[m] = ret_conv_12_arr;
24082 FREE(ret_var.data);
24086 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_block_connected"))) TS_ChannelMonitor_block_connected(uint32_t this_arg, int8_tArray header, uint32_tArray txdata, int32_t height, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
24087 LDKChannelMonitor this_arg_conv;
24088 this_arg_conv.inner = (void*)(this_arg & (~1));
24089 this_arg_conv.is_owned = false;
24090 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24091 unsigned char header_arr[80];
24092 CHECK(header->arr_len == 80);
24093 memcpy(header_arr, header->elems, 80); FREE(header);
24094 unsigned char (*header_ref)[80] = &header_arr;
24095 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
24096 txdata_constr.datalen = txdata->arr_len;
24097 if (txdata_constr.datalen > 0)
24098 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
24100 txdata_constr.data = NULL;
24101 uint32_t* txdata_vals = txdata->elems;
24102 for (size_t c = 0; c < txdata_constr.datalen; c++) {
24103 uint32_t txdata_conv_28 = txdata_vals[c];
24104 void* txdata_conv_28_ptr = (void*)(((uintptr_t)txdata_conv_28) & ~1);
24105 CHECK_ACCESS(txdata_conv_28_ptr);
24106 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
24107 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uintptr_t)txdata_conv_28) & ~1));
24108 txdata_constr.data[c] = txdata_conv_28_conv;
24111 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
24112 CHECK_ACCESS(broadcaster_ptr);
24113 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24114 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24115 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24116 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24118 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
24119 CHECK_ACCESS(fee_estimator_ptr);
24120 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
24121 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
24122 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24123 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
24125 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24126 CHECK_ACCESS(logger_ptr);
24127 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24128 if (logger_conv.free == LDKLogger_JCalls_free) {
24129 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24130 LDKLogger_JCalls_cloned(&logger_conv);
24132 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_block_connected(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
24133 uint32_tArray ret_arr = NULL;
24134 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24135 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24136 for (size_t n = 0; n < ret_var.datalen; n++) {
24137 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
24138 *ret_conv_39_conv = ret_var.data[n];
24139 ret_arr_ptr[n] = ((uint32_t)ret_conv_39_conv);
24142 FREE(ret_var.data);
24146 void __attribute__((export_name("TS_ChannelMonitor_block_disconnected"))) TS_ChannelMonitor_block_disconnected(uint32_t this_arg, int8_tArray header, int32_t height, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
24147 LDKChannelMonitor this_arg_conv;
24148 this_arg_conv.inner = (void*)(this_arg & (~1));
24149 this_arg_conv.is_owned = false;
24150 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24151 unsigned char header_arr[80];
24152 CHECK(header->arr_len == 80);
24153 memcpy(header_arr, header->elems, 80); FREE(header);
24154 unsigned char (*header_ref)[80] = &header_arr;
24155 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
24156 CHECK_ACCESS(broadcaster_ptr);
24157 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24158 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24159 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24160 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24162 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
24163 CHECK_ACCESS(fee_estimator_ptr);
24164 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
24165 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
24166 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24167 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
24169 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24170 CHECK_ACCESS(logger_ptr);
24171 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24172 if (logger_conv.free == LDKLogger_JCalls_free) {
24173 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24174 LDKLogger_JCalls_cloned(&logger_conv);
24176 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
24179 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_transactions_confirmed"))) TS_ChannelMonitor_transactions_confirmed(uint32_t this_arg, int8_tArray header, uint32_tArray txdata, int32_t height, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
24180 LDKChannelMonitor this_arg_conv;
24181 this_arg_conv.inner = (void*)(this_arg & (~1));
24182 this_arg_conv.is_owned = false;
24183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24184 unsigned char header_arr[80];
24185 CHECK(header->arr_len == 80);
24186 memcpy(header_arr, header->elems, 80); FREE(header);
24187 unsigned char (*header_ref)[80] = &header_arr;
24188 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
24189 txdata_constr.datalen = txdata->arr_len;
24190 if (txdata_constr.datalen > 0)
24191 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
24193 txdata_constr.data = NULL;
24194 uint32_t* txdata_vals = txdata->elems;
24195 for (size_t c = 0; c < txdata_constr.datalen; c++) {
24196 uint32_t txdata_conv_28 = txdata_vals[c];
24197 void* txdata_conv_28_ptr = (void*)(((uintptr_t)txdata_conv_28) & ~1);
24198 CHECK_ACCESS(txdata_conv_28_ptr);
24199 LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(txdata_conv_28_ptr);
24200 txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uintptr_t)txdata_conv_28) & ~1));
24201 txdata_constr.data[c] = txdata_conv_28_conv;
24204 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
24205 CHECK_ACCESS(broadcaster_ptr);
24206 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24207 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24208 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24209 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24211 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
24212 CHECK_ACCESS(fee_estimator_ptr);
24213 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
24214 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
24215 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24216 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
24218 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24219 CHECK_ACCESS(logger_ptr);
24220 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24221 if (logger_conv.free == LDKLogger_JCalls_free) {
24222 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24223 LDKLogger_JCalls_cloned(&logger_conv);
24225 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_transactions_confirmed(&this_arg_conv, header_ref, txdata_constr, height, broadcaster_conv, fee_estimator_conv, logger_conv);
24226 uint32_tArray ret_arr = NULL;
24227 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24228 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24229 for (size_t n = 0; n < ret_var.datalen; n++) {
24230 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
24231 *ret_conv_39_conv = ret_var.data[n];
24232 ret_arr_ptr[n] = ((uint32_t)ret_conv_39_conv);
24235 FREE(ret_var.data);
24239 void __attribute__((export_name("TS_ChannelMonitor_transaction_unconfirmed"))) TS_ChannelMonitor_transaction_unconfirmed(uint32_t this_arg, int8_tArray txid, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
24240 LDKChannelMonitor this_arg_conv;
24241 this_arg_conv.inner = (void*)(this_arg & (~1));
24242 this_arg_conv.is_owned = false;
24243 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24244 unsigned char txid_arr[32];
24245 CHECK(txid->arr_len == 32);
24246 memcpy(txid_arr, txid->elems, 32); FREE(txid);
24247 unsigned char (*txid_ref)[32] = &txid_arr;
24248 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
24249 CHECK_ACCESS(broadcaster_ptr);
24250 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24251 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24252 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24253 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24255 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
24256 CHECK_ACCESS(fee_estimator_ptr);
24257 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
24258 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
24259 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24260 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
24262 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24263 CHECK_ACCESS(logger_ptr);
24264 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24265 if (logger_conv.free == LDKLogger_JCalls_free) {
24266 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24267 LDKLogger_JCalls_cloned(&logger_conv);
24269 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
24272 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_best_block_updated"))) TS_ChannelMonitor_best_block_updated(uint32_t this_arg, int8_tArray header, int32_t height, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
24273 LDKChannelMonitor this_arg_conv;
24274 this_arg_conv.inner = (void*)(this_arg & (~1));
24275 this_arg_conv.is_owned = false;
24276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24277 unsigned char header_arr[80];
24278 CHECK(header->arr_len == 80);
24279 memcpy(header_arr, header->elems, 80); FREE(header);
24280 unsigned char (*header_ref)[80] = &header_arr;
24281 void* broadcaster_ptr = (void*)(((uintptr_t)broadcaster) & ~1);
24282 CHECK_ACCESS(broadcaster_ptr);
24283 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(broadcaster_ptr);
24284 if (broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
24285 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24286 LDKBroadcasterInterface_JCalls_cloned(&broadcaster_conv);
24288 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
24289 CHECK_ACCESS(fee_estimator_ptr);
24290 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
24291 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
24292 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24293 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
24295 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
24296 CHECK_ACCESS(logger_ptr);
24297 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
24298 if (logger_conv.free == LDKLogger_JCalls_free) {
24299 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
24300 LDKLogger_JCalls_cloned(&logger_conv);
24302 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
24303 uint32_tArray ret_arr = NULL;
24304 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24305 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24306 for (size_t n = 0; n < ret_var.datalen; n++) {
24307 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
24308 *ret_conv_39_conv = ret_var.data[n];
24309 ret_arr_ptr[n] = ((uint32_t)ret_conv_39_conv);
24312 FREE(ret_var.data);
24316 ptrArray __attribute__((export_name("TS_ChannelMonitor_get_relevant_txids"))) TS_ChannelMonitor_get_relevant_txids(uint32_t this_arg) {
24317 LDKChannelMonitor this_arg_conv;
24318 this_arg_conv.inner = (void*)(this_arg & (~1));
24319 this_arg_conv.is_owned = false;
24320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24321 LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
24322 ptrArray ret_arr = NULL;
24323 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
24324 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
24325 for (size_t m = 0; m < ret_var.datalen; m++) {
24326 int8_tArray ret_conv_12_arr = init_int8_tArray(32, __LINE__);
24327 memcpy(ret_conv_12_arr->elems, ret_var.data[m].data, 32);
24328 ret_arr_ptr[m] = ret_conv_12_arr;
24331 FREE(ret_var.data);
24335 uint32_t __attribute__((export_name("TS_ChannelMonitor_current_best_block"))) TS_ChannelMonitor_current_best_block(uint32_t this_arg) {
24336 LDKChannelMonitor this_arg_conv;
24337 this_arg_conv.inner = (void*)(this_arg & (~1));
24338 this_arg_conv.is_owned = false;
24339 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24340 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
24341 uint32_t ret_ref = 0;
24342 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24343 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24345 ret_ref = (uintptr_t)ret_var.inner;
24346 if (ret_var.is_owned) {
24352 uint32_tArray __attribute__((export_name("TS_ChannelMonitor_get_claimable_balances"))) TS_ChannelMonitor_get_claimable_balances(uint32_t this_arg) {
24353 LDKChannelMonitor this_arg_conv;
24354 this_arg_conv.inner = (void*)(this_arg & (~1));
24355 this_arg_conv.is_owned = false;
24356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24357 LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&this_arg_conv);
24358 uint32_tArray ret_arr = NULL;
24359 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
24360 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
24361 for (size_t j = 0; j < ret_var.datalen; j++) {
24362 LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance");
24363 *ret_conv_9_copy = ret_var.data[j];
24364 uint32_t ret_conv_9_ref = (uintptr_t)ret_conv_9_copy;
24365 ret_arr_ptr[j] = ret_conv_9_ref;
24368 FREE(ret_var.data);
24372 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelMonitorZ_read"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint32_t arg) {
24373 LDKu8slice ser_ref;
24374 ser_ref.datalen = ser->arr_len;
24375 ser_ref.data = ser->elems;
24376 void* arg_ptr = (void*)(((uintptr_t)arg) & ~1);
24377 if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
24378 LDKKeysInterface* arg_conv = (LDKKeysInterface*)arg_ptr;
24379 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
24380 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_conv);
24382 return (uint32_t)ret_conv;
24385 void __attribute__((export_name("TS_OutPoint_free"))) TS_OutPoint_free(uint32_t this_obj) {
24386 LDKOutPoint this_obj_conv;
24387 this_obj_conv.inner = (void*)(this_obj & (~1));
24388 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24390 OutPoint_free(this_obj_conv);
24393 int8_tArray __attribute__((export_name("TS_OutPoint_get_txid"))) TS_OutPoint_get_txid(uint32_t this_ptr) {
24394 LDKOutPoint this_ptr_conv;
24395 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24396 this_ptr_conv.is_owned = false;
24397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24398 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24399 memcpy(ret_arr->elems, *OutPoint_get_txid(&this_ptr_conv), 32);
24403 void __attribute__((export_name("TS_OutPoint_set_txid"))) TS_OutPoint_set_txid(uint32_t this_ptr, int8_tArray val) {
24404 LDKOutPoint this_ptr_conv;
24405 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24406 this_ptr_conv.is_owned = false;
24407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24408 LDKThirtyTwoBytes val_ref;
24409 CHECK(val->arr_len == 32);
24410 memcpy(val_ref.data, val->elems, 32); FREE(val);
24411 OutPoint_set_txid(&this_ptr_conv, val_ref);
24414 int16_t __attribute__((export_name("TS_OutPoint_get_index"))) TS_OutPoint_get_index(uint32_t this_ptr) {
24415 LDKOutPoint this_ptr_conv;
24416 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24417 this_ptr_conv.is_owned = false;
24418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24419 int16_t ret_conv = OutPoint_get_index(&this_ptr_conv);
24423 void __attribute__((export_name("TS_OutPoint_set_index"))) TS_OutPoint_set_index(uint32_t this_ptr, int16_t val) {
24424 LDKOutPoint this_ptr_conv;
24425 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24426 this_ptr_conv.is_owned = false;
24427 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24428 OutPoint_set_index(&this_ptr_conv, val);
24431 uint32_t __attribute__((export_name("TS_OutPoint_new"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
24432 LDKThirtyTwoBytes txid_arg_ref;
24433 CHECK(txid_arg->arr_len == 32);
24434 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
24435 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
24436 uint32_t ret_ref = 0;
24437 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24438 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24439 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24440 ret_ref = (uintptr_t)ret_var.inner;
24441 if (ret_var.is_owned) {
24447 static inline uintptr_t OutPoint_clone_ptr(LDKOutPoint *NONNULL_PTR arg) {
24448 LDKOutPoint ret_var = OutPoint_clone(arg);
24449 uint32_t ret_ref = 0;
24450 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24451 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24452 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24453 ret_ref = (uintptr_t)ret_var.inner;
24454 if (ret_var.is_owned) {
24459 uint32_t __attribute__((export_name("TS_OutPoint_clone_ptr"))) TS_OutPoint_clone_ptr(uint32_t arg) {
24460 LDKOutPoint arg_conv;
24461 arg_conv.inner = (void*)(arg & (~1));
24462 arg_conv.is_owned = false;
24463 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24464 uint32_t ret_conv = OutPoint_clone_ptr(&arg_conv);
24468 uint32_t __attribute__((export_name("TS_OutPoint_clone"))) TS_OutPoint_clone(uint32_t orig) {
24469 LDKOutPoint orig_conv;
24470 orig_conv.inner = (void*)(orig & (~1));
24471 orig_conv.is_owned = false;
24472 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24473 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
24474 uint32_t ret_ref = 0;
24475 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24476 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24477 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24478 ret_ref = (uintptr_t)ret_var.inner;
24479 if (ret_var.is_owned) {
24485 jboolean __attribute__((export_name("TS_OutPoint_eq"))) TS_OutPoint_eq(uint32_t a, uint32_t b) {
24486 LDKOutPoint a_conv;
24487 a_conv.inner = (void*)(a & (~1));
24488 a_conv.is_owned = false;
24489 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
24490 LDKOutPoint b_conv;
24491 b_conv.inner = (void*)(b & (~1));
24492 b_conv.is_owned = false;
24493 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
24494 jboolean ret_conv = OutPoint_eq(&a_conv, &b_conv);
24498 int64_t __attribute__((export_name("TS_OutPoint_hash"))) TS_OutPoint_hash(uint32_t o) {
24499 LDKOutPoint o_conv;
24500 o_conv.inner = (void*)(o & (~1));
24501 o_conv.is_owned = false;
24502 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
24503 int64_t ret_conv = OutPoint_hash(&o_conv);
24507 int8_tArray __attribute__((export_name("TS_OutPoint_to_channel_id"))) TS_OutPoint_to_channel_id(uint32_t this_arg) {
24508 LDKOutPoint this_arg_conv;
24509 this_arg_conv.inner = (void*)(this_arg & (~1));
24510 this_arg_conv.is_owned = false;
24511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
24512 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24513 memcpy(ret_arr->elems, OutPoint_to_channel_id(&this_arg_conv).data, 32);
24517 int8_tArray __attribute__((export_name("TS_OutPoint_write"))) TS_OutPoint_write(uint32_t obj) {
24518 LDKOutPoint obj_conv;
24519 obj_conv.inner = (void*)(obj & (~1));
24520 obj_conv.is_owned = false;
24521 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24522 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
24523 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24524 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24525 CVec_u8Z_free(ret_var);
24529 uint32_t __attribute__((export_name("TS_OutPoint_read"))) TS_OutPoint_read(int8_tArray ser) {
24530 LDKu8slice ser_ref;
24531 ser_ref.datalen = ser->arr_len;
24532 ser_ref.data = ser->elems;
24533 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
24534 *ret_conv = OutPoint_read(ser_ref);
24536 return (uint32_t)ret_conv;
24539 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_free"))) TS_DelayedPaymentOutputDescriptor_free(uint32_t this_obj) {
24540 LDKDelayedPaymentOutputDescriptor this_obj_conv;
24541 this_obj_conv.inner = (void*)(this_obj & (~1));
24542 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24543 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24544 DelayedPaymentOutputDescriptor_free(this_obj_conv);
24547 uint32_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_outpoint"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint32_t this_ptr) {
24548 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24549 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24550 this_ptr_conv.is_owned = false;
24551 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24552 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
24553 uint32_t ret_ref = 0;
24554 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24555 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24556 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24557 ret_ref = (uintptr_t)ret_var.inner;
24558 if (ret_var.is_owned) {
24564 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_outpoint"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint32_t this_ptr, uint32_t val) {
24565 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24566 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24567 this_ptr_conv.is_owned = false;
24568 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24569 LDKOutPoint val_conv;
24570 val_conv.inner = (void*)(val & (~1));
24571 val_conv.is_owned = (val & 1) || (val == 0);
24572 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24573 val_conv = OutPoint_clone(&val_conv);
24574 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
24577 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint32_t this_ptr) {
24578 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24579 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24580 this_ptr_conv.is_owned = false;
24581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24582 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
24583 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
24587 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_per_commitment_point"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
24588 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24589 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24590 this_ptr_conv.is_owned = false;
24591 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24592 LDKPublicKey val_ref;
24593 CHECK(val->arr_len == 33);
24594 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
24595 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
24598 int16_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint32_t this_ptr) {
24599 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24600 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24601 this_ptr_conv.is_owned = false;
24602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24603 int16_t ret_conv = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
24607 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_to_self_delay"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint32_t this_ptr, int16_t val) {
24608 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24609 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24610 this_ptr_conv.is_owned = false;
24611 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24612 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
24615 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_output"))) TS_DelayedPaymentOutputDescriptor_set_output(uint32_t this_ptr, uint32_t val) {
24616 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24617 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24618 this_ptr_conv.is_owned = false;
24619 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24620 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
24621 CHECK_ACCESS(val_ptr);
24622 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
24623 val_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)val) & ~1));
24624 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
24627 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint32_t this_ptr) {
24628 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24629 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24630 this_ptr_conv.is_owned = false;
24631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24632 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
24633 memcpy(ret_arr->elems, DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
24637 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint32_t this_ptr, int8_tArray val) {
24638 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24639 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24640 this_ptr_conv.is_owned = false;
24641 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24642 LDKPublicKey val_ref;
24643 CHECK(val->arr_len == 33);
24644 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
24645 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
24648 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint32_t this_ptr) {
24649 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24650 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24651 this_ptr_conv.is_owned = false;
24652 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24653 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24654 memcpy(ret_arr->elems, *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
24658 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_keys_id"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint32_t this_ptr, int8_tArray val) {
24659 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24660 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24661 this_ptr_conv.is_owned = false;
24662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24663 LDKThirtyTwoBytes val_ref;
24664 CHECK(val->arr_len == 32);
24665 memcpy(val_ref.data, val->elems, 32); FREE(val);
24666 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
24669 int64_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint32_t this_ptr) {
24670 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24671 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24672 this_ptr_conv.is_owned = false;
24673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24674 int64_t ret_conv = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
24678 void __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
24679 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
24680 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24681 this_ptr_conv.is_owned = false;
24682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24683 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
24686 uint32_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_new"))) TS_DelayedPaymentOutputDescriptor_new(uint32_t outpoint_arg, int8_tArray per_commitment_point_arg, int16_t to_self_delay_arg, uint32_t output_arg, int8_tArray revocation_pubkey_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
24687 LDKOutPoint outpoint_arg_conv;
24688 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
24689 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
24690 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
24691 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
24692 LDKPublicKey per_commitment_point_arg_ref;
24693 CHECK(per_commitment_point_arg->arr_len == 33);
24694 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
24695 void* output_arg_ptr = (void*)(((uintptr_t)output_arg) & ~1);
24696 CHECK_ACCESS(output_arg_ptr);
24697 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
24698 output_arg_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)output_arg) & ~1));
24699 LDKPublicKey revocation_pubkey_arg_ref;
24700 CHECK(revocation_pubkey_arg->arr_len == 33);
24701 memcpy(revocation_pubkey_arg_ref.compressed_form, revocation_pubkey_arg->elems, 33); FREE(revocation_pubkey_arg);
24702 LDKThirtyTwoBytes channel_keys_id_arg_ref;
24703 CHECK(channel_keys_id_arg->arr_len == 32);
24704 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
24705 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);
24706 uint32_t ret_ref = 0;
24707 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24708 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24709 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24710 ret_ref = (uintptr_t)ret_var.inner;
24711 if (ret_var.is_owned) {
24717 static inline uintptr_t DelayedPaymentOutputDescriptor_clone_ptr(LDKDelayedPaymentOutputDescriptor *NONNULL_PTR arg) {
24718 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(arg);
24719 uint32_t ret_ref = 0;
24720 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24721 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24722 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24723 ret_ref = (uintptr_t)ret_var.inner;
24724 if (ret_var.is_owned) {
24729 uint32_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone_ptr"))) TS_DelayedPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
24730 LDKDelayedPaymentOutputDescriptor arg_conv;
24731 arg_conv.inner = (void*)(arg & (~1));
24732 arg_conv.is_owned = false;
24733 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24734 uint32_t ret_conv = DelayedPaymentOutputDescriptor_clone_ptr(&arg_conv);
24738 uint32_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_clone"))) TS_DelayedPaymentOutputDescriptor_clone(uint32_t orig) {
24739 LDKDelayedPaymentOutputDescriptor orig_conv;
24740 orig_conv.inner = (void*)(orig & (~1));
24741 orig_conv.is_owned = false;
24742 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24743 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
24744 uint32_t ret_ref = 0;
24745 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24746 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24747 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24748 ret_ref = (uintptr_t)ret_var.inner;
24749 if (ret_var.is_owned) {
24755 int8_tArray __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_write"))) TS_DelayedPaymentOutputDescriptor_write(uint32_t obj) {
24756 LDKDelayedPaymentOutputDescriptor obj_conv;
24757 obj_conv.inner = (void*)(obj & (~1));
24758 obj_conv.is_owned = false;
24759 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24760 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
24761 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24762 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24763 CVec_u8Z_free(ret_var);
24767 uint32_t __attribute__((export_name("TS_DelayedPaymentOutputDescriptor_read"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
24768 LDKu8slice ser_ref;
24769 ser_ref.datalen = ser->arr_len;
24770 ser_ref.data = ser->elems;
24771 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
24772 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
24774 return (uint32_t)ret_conv;
24777 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_free"))) TS_StaticPaymentOutputDescriptor_free(uint32_t this_obj) {
24778 LDKStaticPaymentOutputDescriptor this_obj_conv;
24779 this_obj_conv.inner = (void*)(this_obj & (~1));
24780 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
24781 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
24782 StaticPaymentOutputDescriptor_free(this_obj_conv);
24785 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_outpoint"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint32_t this_ptr) {
24786 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24787 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24788 this_ptr_conv.is_owned = false;
24789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24790 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
24791 uint32_t ret_ref = 0;
24792 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24793 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24794 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24795 ret_ref = (uintptr_t)ret_var.inner;
24796 if (ret_var.is_owned) {
24802 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_outpoint"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint32_t this_ptr, uint32_t val) {
24803 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24804 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24805 this_ptr_conv.is_owned = false;
24806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24807 LDKOutPoint val_conv;
24808 val_conv.inner = (void*)(val & (~1));
24809 val_conv.is_owned = (val & 1) || (val == 0);
24810 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
24811 val_conv = OutPoint_clone(&val_conv);
24812 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
24815 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_output"))) TS_StaticPaymentOutputDescriptor_set_output(uint32_t this_ptr, uint32_t val) {
24816 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24817 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24818 this_ptr_conv.is_owned = false;
24819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24820 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
24821 CHECK_ACCESS(val_ptr);
24822 LDKTxOut val_conv = *(LDKTxOut*)(val_ptr);
24823 val_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)val) & ~1));
24824 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
24827 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint32_t this_ptr) {
24828 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24829 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24830 this_ptr_conv.is_owned = false;
24831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24832 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
24833 memcpy(ret_arr->elems, *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
24837 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_keys_id"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint32_t this_ptr, int8_tArray val) {
24838 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24839 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24840 this_ptr_conv.is_owned = false;
24841 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24842 LDKThirtyTwoBytes val_ref;
24843 CHECK(val->arr_len == 32);
24844 memcpy(val_ref.data, val->elems, 32); FREE(val);
24845 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
24848 int64_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint32_t this_ptr) {
24849 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24850 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24851 this_ptr_conv.is_owned = false;
24852 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24853 int64_t ret_conv = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
24857 void __attribute__((export_name("TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
24858 LDKStaticPaymentOutputDescriptor this_ptr_conv;
24859 this_ptr_conv.inner = (void*)(this_ptr & (~1));
24860 this_ptr_conv.is_owned = false;
24861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
24862 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
24865 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_new"))) TS_StaticPaymentOutputDescriptor_new(uint32_t outpoint_arg, uint32_t output_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
24866 LDKOutPoint outpoint_arg_conv;
24867 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
24868 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
24869 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_arg_conv);
24870 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
24871 void* output_arg_ptr = (void*)(((uintptr_t)output_arg) & ~1);
24872 CHECK_ACCESS(output_arg_ptr);
24873 LDKTxOut output_arg_conv = *(LDKTxOut*)(output_arg_ptr);
24874 output_arg_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)output_arg) & ~1));
24875 LDKThirtyTwoBytes channel_keys_id_arg_ref;
24876 CHECK(channel_keys_id_arg->arr_len == 32);
24877 memcpy(channel_keys_id_arg_ref.data, channel_keys_id_arg->elems, 32); FREE(channel_keys_id_arg);
24878 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
24879 uint32_t ret_ref = 0;
24880 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24881 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24883 ret_ref = (uintptr_t)ret_var.inner;
24884 if (ret_var.is_owned) {
24890 static inline uintptr_t StaticPaymentOutputDescriptor_clone_ptr(LDKStaticPaymentOutputDescriptor *NONNULL_PTR arg) {
24891 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(arg);
24892 uint32_t ret_ref = 0;
24893 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24894 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24895 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24896 ret_ref = (uintptr_t)ret_var.inner;
24897 if (ret_var.is_owned) {
24902 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone_ptr"))) TS_StaticPaymentOutputDescriptor_clone_ptr(uint32_t arg) {
24903 LDKStaticPaymentOutputDescriptor arg_conv;
24904 arg_conv.inner = (void*)(arg & (~1));
24905 arg_conv.is_owned = false;
24906 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
24907 uint32_t ret_conv = StaticPaymentOutputDescriptor_clone_ptr(&arg_conv);
24911 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_clone"))) TS_StaticPaymentOutputDescriptor_clone(uint32_t orig) {
24912 LDKStaticPaymentOutputDescriptor orig_conv;
24913 orig_conv.inner = (void*)(orig & (~1));
24914 orig_conv.is_owned = false;
24915 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
24916 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
24917 uint32_t ret_ref = 0;
24918 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
24919 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
24920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
24921 ret_ref = (uintptr_t)ret_var.inner;
24922 if (ret_var.is_owned) {
24928 int8_tArray __attribute__((export_name("TS_StaticPaymentOutputDescriptor_write"))) TS_StaticPaymentOutputDescriptor_write(uint32_t obj) {
24929 LDKStaticPaymentOutputDescriptor obj_conv;
24930 obj_conv.inner = (void*)(obj & (~1));
24931 obj_conv.is_owned = false;
24932 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
24933 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
24934 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
24935 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
24936 CVec_u8Z_free(ret_var);
24940 uint32_t __attribute__((export_name("TS_StaticPaymentOutputDescriptor_read"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
24941 LDKu8slice ser_ref;
24942 ser_ref.datalen = ser->arr_len;
24943 ser_ref.data = ser->elems;
24944 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
24945 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
24947 return (uint32_t)ret_conv;
24950 void __attribute__((export_name("TS_SpendableOutputDescriptor_free"))) TS_SpendableOutputDescriptor_free(uint32_t this_ptr) {
24951 if ((this_ptr & 1) != 0) return;
24952 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
24953 CHECK_ACCESS(this_ptr_ptr);
24954 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(this_ptr_ptr);
24955 FREE((void*)this_ptr);
24956 SpendableOutputDescriptor_free(this_ptr_conv);
24959 static inline uintptr_t SpendableOutputDescriptor_clone_ptr(LDKSpendableOutputDescriptor *NONNULL_PTR arg) {
24960 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
24961 *ret_copy = SpendableOutputDescriptor_clone(arg);
24962 uint32_t ret_ref = (uintptr_t)ret_copy;
24965 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone_ptr"))) TS_SpendableOutputDescriptor_clone_ptr(uint32_t arg) {
24966 LDKSpendableOutputDescriptor* arg_conv = (LDKSpendableOutputDescriptor*)arg;
24967 uint32_t ret_conv = SpendableOutputDescriptor_clone_ptr(arg_conv);
24971 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_clone"))) TS_SpendableOutputDescriptor_clone(uint32_t orig) {
24972 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
24973 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
24974 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
24975 uint32_t ret_ref = (uintptr_t)ret_copy;
24979 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_output"))) TS_SpendableOutputDescriptor_static_output(uint32_t outpoint, uint32_t output) {
24980 LDKOutPoint outpoint_conv;
24981 outpoint_conv.inner = (void*)(outpoint & (~1));
24982 outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0);
24983 CHECK_INNER_FIELD_ACCESS_OR_NULL(outpoint_conv);
24984 outpoint_conv = OutPoint_clone(&outpoint_conv);
24985 void* output_ptr = (void*)(((uintptr_t)output) & ~1);
24986 CHECK_ACCESS(output_ptr);
24987 LDKTxOut output_conv = *(LDKTxOut*)(output_ptr);
24988 output_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)output) & ~1));
24989 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
24990 *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv);
24991 uint32_t ret_ref = (uintptr_t)ret_copy;
24995 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_delayed_payment_output"))) TS_SpendableOutputDescriptor_delayed_payment_output(uint32_t a) {
24996 LDKDelayedPaymentOutputDescriptor a_conv;
24997 a_conv.inner = (void*)(a & (~1));
24998 a_conv.is_owned = (a & 1) || (a == 0);
24999 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25000 a_conv = DelayedPaymentOutputDescriptor_clone(&a_conv);
25001 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
25002 *ret_copy = SpendableOutputDescriptor_delayed_payment_output(a_conv);
25003 uint32_t ret_ref = (uintptr_t)ret_copy;
25007 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_static_payment_output"))) TS_SpendableOutputDescriptor_static_payment_output(uint32_t a) {
25008 LDKStaticPaymentOutputDescriptor a_conv;
25009 a_conv.inner = (void*)(a & (~1));
25010 a_conv.is_owned = (a & 1) || (a == 0);
25011 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
25012 a_conv = StaticPaymentOutputDescriptor_clone(&a_conv);
25013 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
25014 *ret_copy = SpendableOutputDescriptor_static_payment_output(a_conv);
25015 uint32_t ret_ref = (uintptr_t)ret_copy;
25019 int8_tArray __attribute__((export_name("TS_SpendableOutputDescriptor_write"))) TS_SpendableOutputDescriptor_write(uint32_t obj) {
25020 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)obj;
25021 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
25022 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25023 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25024 CVec_u8Z_free(ret_var);
25028 uint32_t __attribute__((export_name("TS_SpendableOutputDescriptor_read"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
25029 LDKu8slice ser_ref;
25030 ser_ref.datalen = ser->arr_len;
25031 ser_ref.data = ser->elems;
25032 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
25033 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
25035 return (uint32_t)ret_conv;
25038 void __attribute__((export_name("TS_BaseSign_free"))) TS_BaseSign_free(uint32_t this_ptr) {
25039 if ((this_ptr & 1) != 0) return;
25040 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
25041 CHECK_ACCESS(this_ptr_ptr);
25042 LDKBaseSign this_ptr_conv = *(LDKBaseSign*)(this_ptr_ptr);
25043 FREE((void*)this_ptr);
25044 BaseSign_free(this_ptr_conv);
25047 static inline uintptr_t Sign_clone_ptr(LDKSign *NONNULL_PTR arg) {
25048 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
25049 *ret_ret = Sign_clone(arg);
25050 return (uint32_t)ret_ret;
25052 uint32_t __attribute__((export_name("TS_Sign_clone_ptr"))) TS_Sign_clone_ptr(uint32_t arg) {
25053 void* arg_ptr = (void*)(((uintptr_t)arg) & ~1);
25054 if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
25055 LDKSign* arg_conv = (LDKSign*)arg_ptr;
25056 uint32_t ret_conv = Sign_clone_ptr(arg_conv);
25060 uint32_t __attribute__((export_name("TS_Sign_clone"))) TS_Sign_clone(uint32_t orig) {
25061 void* orig_ptr = (void*)(((uintptr_t)orig) & ~1);
25062 if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
25063 LDKSign* orig_conv = (LDKSign*)orig_ptr;
25064 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
25065 *ret_ret = Sign_clone(orig_conv);
25066 return (uint32_t)ret_ret;
25069 void __attribute__((export_name("TS_Sign_free"))) TS_Sign_free(uint32_t this_ptr) {
25070 if ((this_ptr & 1) != 0) return;
25071 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
25072 CHECK_ACCESS(this_ptr_ptr);
25073 LDKSign this_ptr_conv = *(LDKSign*)(this_ptr_ptr);
25074 FREE((void*)this_ptr);
25075 Sign_free(this_ptr_conv);
25078 uint32_t __attribute__((export_name("TS_Recipient_clone"))) TS_Recipient_clone(uint32_t orig) {
25079 LDKRecipient* orig_conv = (LDKRecipient*)(orig & ~1);
25080 uint32_t ret_conv = LDKRecipient_to_js(Recipient_clone(orig_conv));
25084 uint32_t __attribute__((export_name("TS_Recipient_node"))) TS_Recipient_node() {
25085 uint32_t ret_conv = LDKRecipient_to_js(Recipient_node());
25089 uint32_t __attribute__((export_name("TS_Recipient_phantom_node"))) TS_Recipient_phantom_node() {
25090 uint32_t ret_conv = LDKRecipient_to_js(Recipient_phantom_node());
25094 void __attribute__((export_name("TS_KeysInterface_free"))) TS_KeysInterface_free(uint32_t this_ptr) {
25095 if ((this_ptr & 1) != 0) return;
25096 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
25097 CHECK_ACCESS(this_ptr_ptr);
25098 LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)(this_ptr_ptr);
25099 FREE((void*)this_ptr);
25100 KeysInterface_free(this_ptr_conv);
25103 void __attribute__((export_name("TS_InMemorySigner_free"))) TS_InMemorySigner_free(uint32_t this_obj) {
25104 LDKInMemorySigner this_obj_conv;
25105 this_obj_conv.inner = (void*)(this_obj & (~1));
25106 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25107 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25108 InMemorySigner_free(this_obj_conv);
25111 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_funding_key"))) TS_InMemorySigner_get_funding_key(uint32_t this_ptr) {
25112 LDKInMemorySigner this_ptr_conv;
25113 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25114 this_ptr_conv.is_owned = false;
25115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25116 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25117 memcpy(ret_arr->elems, *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
25121 void __attribute__((export_name("TS_InMemorySigner_set_funding_key"))) TS_InMemorySigner_set_funding_key(uint32_t this_ptr, int8_tArray val) {
25122 LDKInMemorySigner this_ptr_conv;
25123 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25124 this_ptr_conv.is_owned = false;
25125 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25126 LDKSecretKey val_ref;
25127 CHECK(val->arr_len == 32);
25128 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
25129 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
25132 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_revocation_base_key"))) TS_InMemorySigner_get_revocation_base_key(uint32_t this_ptr) {
25133 LDKInMemorySigner this_ptr_conv;
25134 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25135 this_ptr_conv.is_owned = false;
25136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25137 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25138 memcpy(ret_arr->elems, *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
25142 void __attribute__((export_name("TS_InMemorySigner_set_revocation_base_key"))) TS_InMemorySigner_set_revocation_base_key(uint32_t this_ptr, int8_tArray val) {
25143 LDKInMemorySigner this_ptr_conv;
25144 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25145 this_ptr_conv.is_owned = false;
25146 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25147 LDKSecretKey val_ref;
25148 CHECK(val->arr_len == 32);
25149 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
25150 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
25153 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_payment_key"))) TS_InMemorySigner_get_payment_key(uint32_t this_ptr) {
25154 LDKInMemorySigner this_ptr_conv;
25155 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25156 this_ptr_conv.is_owned = false;
25157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25158 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25159 memcpy(ret_arr->elems, *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
25163 void __attribute__((export_name("TS_InMemorySigner_set_payment_key"))) TS_InMemorySigner_set_payment_key(uint32_t this_ptr, int8_tArray val) {
25164 LDKInMemorySigner this_ptr_conv;
25165 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25166 this_ptr_conv.is_owned = false;
25167 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25168 LDKSecretKey val_ref;
25169 CHECK(val->arr_len == 32);
25170 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
25171 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
25174 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_delayed_payment_base_key"))) TS_InMemorySigner_get_delayed_payment_base_key(uint32_t this_ptr) {
25175 LDKInMemorySigner this_ptr_conv;
25176 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25177 this_ptr_conv.is_owned = false;
25178 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25179 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25180 memcpy(ret_arr->elems, *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
25184 void __attribute__((export_name("TS_InMemorySigner_set_delayed_payment_base_key"))) TS_InMemorySigner_set_delayed_payment_base_key(uint32_t this_ptr, int8_tArray val) {
25185 LDKInMemorySigner this_ptr_conv;
25186 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25187 this_ptr_conv.is_owned = false;
25188 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25189 LDKSecretKey val_ref;
25190 CHECK(val->arr_len == 32);
25191 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
25192 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
25195 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_htlc_base_key"))) TS_InMemorySigner_get_htlc_base_key(uint32_t this_ptr) {
25196 LDKInMemorySigner this_ptr_conv;
25197 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25198 this_ptr_conv.is_owned = false;
25199 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25200 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25201 memcpy(ret_arr->elems, *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
25205 void __attribute__((export_name("TS_InMemorySigner_set_htlc_base_key"))) TS_InMemorySigner_set_htlc_base_key(uint32_t this_ptr, int8_tArray val) {
25206 LDKInMemorySigner this_ptr_conv;
25207 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25208 this_ptr_conv.is_owned = false;
25209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25210 LDKSecretKey val_ref;
25211 CHECK(val->arr_len == 32);
25212 memcpy(val_ref.bytes, val->elems, 32); FREE(val);
25213 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
25216 int8_tArray __attribute__((export_name("TS_InMemorySigner_get_commitment_seed"))) TS_InMemorySigner_get_commitment_seed(uint32_t this_ptr) {
25217 LDKInMemorySigner this_ptr_conv;
25218 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25219 this_ptr_conv.is_owned = false;
25220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25221 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
25222 memcpy(ret_arr->elems, *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
25226 void __attribute__((export_name("TS_InMemorySigner_set_commitment_seed"))) TS_InMemorySigner_set_commitment_seed(uint32_t this_ptr, int8_tArray val) {
25227 LDKInMemorySigner this_ptr_conv;
25228 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25229 this_ptr_conv.is_owned = false;
25230 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25231 LDKThirtyTwoBytes val_ref;
25232 CHECK(val->arr_len == 32);
25233 memcpy(val_ref.data, val->elems, 32); FREE(val);
25234 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
25237 static inline uintptr_t InMemorySigner_clone_ptr(LDKInMemorySigner *NONNULL_PTR arg) {
25238 LDKInMemorySigner ret_var = InMemorySigner_clone(arg);
25239 uint32_t ret_ref = 0;
25240 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25241 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25242 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25243 ret_ref = (uintptr_t)ret_var.inner;
25244 if (ret_var.is_owned) {
25249 uint32_t __attribute__((export_name("TS_InMemorySigner_clone_ptr"))) TS_InMemorySigner_clone_ptr(uint32_t arg) {
25250 LDKInMemorySigner arg_conv;
25251 arg_conv.inner = (void*)(arg & (~1));
25252 arg_conv.is_owned = false;
25253 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25254 uint32_t ret_conv = InMemorySigner_clone_ptr(&arg_conv);
25258 uint32_t __attribute__((export_name("TS_InMemorySigner_clone"))) TS_InMemorySigner_clone(uint32_t orig) {
25259 LDKInMemorySigner orig_conv;
25260 orig_conv.inner = (void*)(orig & (~1));
25261 orig_conv.is_owned = false;
25262 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25263 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
25264 uint32_t ret_ref = 0;
25265 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25266 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25267 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25268 ret_ref = (uintptr_t)ret_var.inner;
25269 if (ret_var.is_owned) {
25275 uint32_t __attribute__((export_name("TS_InMemorySigner_new"))) TS_InMemorySigner_new(int8_tArray node_secret, int8_tArray funding_key, int8_tArray revocation_base_key, int8_tArray payment_key, int8_tArray delayed_payment_base_key, int8_tArray htlc_base_key, int8_tArray commitment_seed, int64_t channel_value_satoshis, int8_tArray channel_keys_id) {
25276 LDKSecretKey node_secret_ref;
25277 CHECK(node_secret->arr_len == 32);
25278 memcpy(node_secret_ref.bytes, node_secret->elems, 32); FREE(node_secret);
25279 LDKSecretKey funding_key_ref;
25280 CHECK(funding_key->arr_len == 32);
25281 memcpy(funding_key_ref.bytes, funding_key->elems, 32); FREE(funding_key);
25282 LDKSecretKey revocation_base_key_ref;
25283 CHECK(revocation_base_key->arr_len == 32);
25284 memcpy(revocation_base_key_ref.bytes, revocation_base_key->elems, 32); FREE(revocation_base_key);
25285 LDKSecretKey payment_key_ref;
25286 CHECK(payment_key->arr_len == 32);
25287 memcpy(payment_key_ref.bytes, payment_key->elems, 32); FREE(payment_key);
25288 LDKSecretKey delayed_payment_base_key_ref;
25289 CHECK(delayed_payment_base_key->arr_len == 32);
25290 memcpy(delayed_payment_base_key_ref.bytes, delayed_payment_base_key->elems, 32); FREE(delayed_payment_base_key);
25291 LDKSecretKey htlc_base_key_ref;
25292 CHECK(htlc_base_key->arr_len == 32);
25293 memcpy(htlc_base_key_ref.bytes, htlc_base_key->elems, 32); FREE(htlc_base_key);
25294 LDKThirtyTwoBytes commitment_seed_ref;
25295 CHECK(commitment_seed->arr_len == 32);
25296 memcpy(commitment_seed_ref.data, commitment_seed->elems, 32); FREE(commitment_seed);
25297 LDKThirtyTwoBytes channel_keys_id_ref;
25298 CHECK(channel_keys_id->arr_len == 32);
25299 memcpy(channel_keys_id_ref.data, channel_keys_id->elems, 32); FREE(channel_keys_id);
25300 LDKInMemorySigner ret_var = InMemorySigner_new(node_secret_ref, funding_key_ref, revocation_base_key_ref, payment_key_ref, delayed_payment_base_key_ref, htlc_base_key_ref, commitment_seed_ref, channel_value_satoshis, channel_keys_id_ref);
25301 uint32_t ret_ref = 0;
25302 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25303 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25304 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25305 ret_ref = (uintptr_t)ret_var.inner;
25306 if (ret_var.is_owned) {
25312 uint32_t __attribute__((export_name("TS_InMemorySigner_counterparty_pubkeys"))) TS_InMemorySigner_counterparty_pubkeys(uint32_t this_arg) {
25313 LDKInMemorySigner this_arg_conv;
25314 this_arg_conv.inner = (void*)(this_arg & (~1));
25315 this_arg_conv.is_owned = false;
25316 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25317 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
25318 uint32_t ret_ref = 0;
25319 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25320 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25322 ret_ref = (uintptr_t)ret_var.inner;
25323 if (ret_var.is_owned) {
25329 int16_t __attribute__((export_name("TS_InMemorySigner_counterparty_selected_contest_delay"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint32_t this_arg) {
25330 LDKInMemorySigner this_arg_conv;
25331 this_arg_conv.inner = (void*)(this_arg & (~1));
25332 this_arg_conv.is_owned = false;
25333 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25334 int16_t ret_conv = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
25338 int16_t __attribute__((export_name("TS_InMemorySigner_holder_selected_contest_delay"))) TS_InMemorySigner_holder_selected_contest_delay(uint32_t this_arg) {
25339 LDKInMemorySigner this_arg_conv;
25340 this_arg_conv.inner = (void*)(this_arg & (~1));
25341 this_arg_conv.is_owned = false;
25342 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25343 int16_t ret_conv = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
25347 jboolean __attribute__((export_name("TS_InMemorySigner_is_outbound"))) TS_InMemorySigner_is_outbound(uint32_t this_arg) {
25348 LDKInMemorySigner this_arg_conv;
25349 this_arg_conv.inner = (void*)(this_arg & (~1));
25350 this_arg_conv.is_owned = false;
25351 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25352 jboolean ret_conv = InMemorySigner_is_outbound(&this_arg_conv);
25356 uint32_t __attribute__((export_name("TS_InMemorySigner_funding_outpoint"))) TS_InMemorySigner_funding_outpoint(uint32_t this_arg) {
25357 LDKInMemorySigner this_arg_conv;
25358 this_arg_conv.inner = (void*)(this_arg & (~1));
25359 this_arg_conv.is_owned = false;
25360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25361 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
25362 uint32_t ret_ref = 0;
25363 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25364 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25365 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25366 ret_ref = (uintptr_t)ret_var.inner;
25367 if (ret_var.is_owned) {
25373 uint32_t __attribute__((export_name("TS_InMemorySigner_get_channel_parameters"))) TS_InMemorySigner_get_channel_parameters(uint32_t this_arg) {
25374 LDKInMemorySigner this_arg_conv;
25375 this_arg_conv.inner = (void*)(this_arg & (~1));
25376 this_arg_conv.is_owned = false;
25377 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25378 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
25379 uint32_t ret_ref = 0;
25380 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25381 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25382 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25383 ret_ref = (uintptr_t)ret_var.inner;
25384 if (ret_var.is_owned) {
25390 jboolean __attribute__((export_name("TS_InMemorySigner_opt_anchors"))) TS_InMemorySigner_opt_anchors(uint32_t this_arg) {
25391 LDKInMemorySigner this_arg_conv;
25392 this_arg_conv.inner = (void*)(this_arg & (~1));
25393 this_arg_conv.is_owned = false;
25394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25395 jboolean ret_conv = InMemorySigner_opt_anchors(&this_arg_conv);
25399 uint32_t __attribute__((export_name("TS_InMemorySigner_sign_counterparty_payment_input"))) TS_InMemorySigner_sign_counterparty_payment_input(uint32_t this_arg, int8_tArray spend_tx, uint32_t input_idx, uint32_t descriptor) {
25400 LDKInMemorySigner this_arg_conv;
25401 this_arg_conv.inner = (void*)(this_arg & (~1));
25402 this_arg_conv.is_owned = false;
25403 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25404 LDKTransaction spend_tx_ref;
25405 spend_tx_ref.datalen = spend_tx->arr_len;
25406 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
25407 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
25408 spend_tx_ref.data_is_owned = true;
25409 LDKStaticPaymentOutputDescriptor descriptor_conv;
25410 descriptor_conv.inner = (void*)(descriptor & (~1));
25411 descriptor_conv.is_owned = false;
25412 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
25413 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
25414 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
25415 return (uint32_t)ret_conv;
25418 uint32_t __attribute__((export_name("TS_InMemorySigner_sign_dynamic_p2wsh_input"))) TS_InMemorySigner_sign_dynamic_p2wsh_input(uint32_t this_arg, int8_tArray spend_tx, uint32_t input_idx, uint32_t descriptor) {
25419 LDKInMemorySigner this_arg_conv;
25420 this_arg_conv.inner = (void*)(this_arg & (~1));
25421 this_arg_conv.is_owned = false;
25422 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25423 LDKTransaction spend_tx_ref;
25424 spend_tx_ref.datalen = spend_tx->arr_len;
25425 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
25426 memcpy(spend_tx_ref.data, spend_tx->elems, spend_tx_ref.datalen); FREE(spend_tx);
25427 spend_tx_ref.data_is_owned = true;
25428 LDKDelayedPaymentOutputDescriptor descriptor_conv;
25429 descriptor_conv.inner = (void*)(descriptor & (~1));
25430 descriptor_conv.is_owned = false;
25431 CHECK_INNER_FIELD_ACCESS_OR_NULL(descriptor_conv);
25432 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
25433 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
25434 return (uint32_t)ret_conv;
25437 uint32_t __attribute__((export_name("TS_InMemorySigner_as_BaseSign"))) TS_InMemorySigner_as_BaseSign(uint32_t this_arg) {
25438 LDKInMemorySigner this_arg_conv;
25439 this_arg_conv.inner = (void*)(this_arg & (~1));
25440 this_arg_conv.is_owned = false;
25441 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25442 LDKBaseSign* ret_ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
25443 *ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv);
25444 return (uint32_t)ret_ret;
25447 uint32_t __attribute__((export_name("TS_InMemorySigner_as_Sign"))) TS_InMemorySigner_as_Sign(uint32_t this_arg) {
25448 LDKInMemorySigner this_arg_conv;
25449 this_arg_conv.inner = (void*)(this_arg & (~1));
25450 this_arg_conv.is_owned = false;
25451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25452 LDKSign* ret_ret = MALLOC(sizeof(LDKSign), "LDKSign");
25453 *ret_ret = InMemorySigner_as_Sign(&this_arg_conv);
25454 return (uint32_t)ret_ret;
25457 int8_tArray __attribute__((export_name("TS_InMemorySigner_write"))) TS_InMemorySigner_write(uint32_t obj) {
25458 LDKInMemorySigner obj_conv;
25459 obj_conv.inner = (void*)(obj & (~1));
25460 obj_conv.is_owned = false;
25461 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
25462 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
25463 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
25464 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
25465 CVec_u8Z_free(ret_var);
25469 uint32_t __attribute__((export_name("TS_InMemorySigner_read"))) TS_InMemorySigner_read(int8_tArray ser, int8_tArray arg) {
25470 LDKu8slice ser_ref;
25471 ser_ref.datalen = ser->arr_len;
25472 ser_ref.data = ser->elems;
25473 LDKSecretKey arg_ref;
25474 CHECK(arg->arr_len == 32);
25475 memcpy(arg_ref.bytes, arg->elems, 32); FREE(arg);
25476 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
25477 *ret_conv = InMemorySigner_read(ser_ref, arg_ref);
25479 return (uint32_t)ret_conv;
25482 void __attribute__((export_name("TS_KeysManager_free"))) TS_KeysManager_free(uint32_t this_obj) {
25483 LDKKeysManager this_obj_conv;
25484 this_obj_conv.inner = (void*)(this_obj & (~1));
25485 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25486 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25487 KeysManager_free(this_obj_conv);
25490 uint32_t __attribute__((export_name("TS_KeysManager_new"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
25491 unsigned char seed_arr[32];
25492 CHECK(seed->arr_len == 32);
25493 memcpy(seed_arr, seed->elems, 32); FREE(seed);
25494 unsigned char (*seed_ref)[32] = &seed_arr;
25495 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
25496 uint32_t ret_ref = 0;
25497 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25498 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25499 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25500 ret_ref = (uintptr_t)ret_var.inner;
25501 if (ret_var.is_owned) {
25507 uint32_t __attribute__((export_name("TS_KeysManager_derive_channel_keys"))) TS_KeysManager_derive_channel_keys(uint32_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
25508 LDKKeysManager this_arg_conv;
25509 this_arg_conv.inner = (void*)(this_arg & (~1));
25510 this_arg_conv.is_owned = false;
25511 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25512 unsigned char params_arr[32];
25513 CHECK(params->arr_len == 32);
25514 memcpy(params_arr, params->elems, 32); FREE(params);
25515 unsigned char (*params_ref)[32] = ¶ms_arr;
25516 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
25517 uint32_t ret_ref = 0;
25518 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25519 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25520 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25521 ret_ref = (uintptr_t)ret_var.inner;
25522 if (ret_var.is_owned) {
25528 uint32_t __attribute__((export_name("TS_KeysManager_spend_spendable_outputs"))) TS_KeysManager_spend_spendable_outputs(uint32_t this_arg, uint32_tArray descriptors, uint32_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight) {
25529 LDKKeysManager this_arg_conv;
25530 this_arg_conv.inner = (void*)(this_arg & (~1));
25531 this_arg_conv.is_owned = false;
25532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25533 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
25534 descriptors_constr.datalen = descriptors->arr_len;
25535 if (descriptors_constr.datalen > 0)
25536 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
25538 descriptors_constr.data = NULL;
25539 uint32_t* descriptors_vals = descriptors->elems;
25540 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
25541 uint32_t descriptors_conv_27 = descriptors_vals[b];
25542 void* descriptors_conv_27_ptr = (void*)(((uintptr_t)descriptors_conv_27) & ~1);
25543 CHECK_ACCESS(descriptors_conv_27_ptr);
25544 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
25545 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uintptr_t)descriptors_conv_27) & ~1));
25546 descriptors_constr.data[b] = descriptors_conv_27_conv;
25549 LDKCVec_TxOutZ outputs_constr;
25550 outputs_constr.datalen = outputs->arr_len;
25551 if (outputs_constr.datalen > 0)
25552 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
25554 outputs_constr.data = NULL;
25555 uint32_t* outputs_vals = outputs->elems;
25556 for (size_t h = 0; h < outputs_constr.datalen; h++) {
25557 uint32_t outputs_conv_7 = outputs_vals[h];
25558 void* outputs_conv_7_ptr = (void*)(((uintptr_t)outputs_conv_7) & ~1);
25559 CHECK_ACCESS(outputs_conv_7_ptr);
25560 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
25561 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)outputs_conv_7) & ~1));
25562 outputs_constr.data[h] = outputs_conv_7_conv;
25565 LDKCVec_u8Z change_destination_script_ref;
25566 change_destination_script_ref.datalen = change_destination_script->arr_len;
25567 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
25568 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
25569 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
25570 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
25571 return (uint32_t)ret_conv;
25574 uint32_t __attribute__((export_name("TS_KeysManager_as_KeysInterface"))) TS_KeysManager_as_KeysInterface(uint32_t this_arg) {
25575 LDKKeysManager this_arg_conv;
25576 this_arg_conv.inner = (void*)(this_arg & (~1));
25577 this_arg_conv.is_owned = false;
25578 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25579 LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
25580 *ret_ret = KeysManager_as_KeysInterface(&this_arg_conv);
25581 return (uint32_t)ret_ret;
25584 void __attribute__((export_name("TS_PhantomKeysManager_free"))) TS_PhantomKeysManager_free(uint32_t this_obj) {
25585 LDKPhantomKeysManager this_obj_conv;
25586 this_obj_conv.inner = (void*)(this_obj & (~1));
25587 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25588 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25589 PhantomKeysManager_free(this_obj_conv);
25592 uint32_t __attribute__((export_name("TS_PhantomKeysManager_as_KeysInterface"))) TS_PhantomKeysManager_as_KeysInterface(uint32_t this_arg) {
25593 LDKPhantomKeysManager this_arg_conv;
25594 this_arg_conv.inner = (void*)(this_arg & (~1));
25595 this_arg_conv.is_owned = false;
25596 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25597 LDKKeysInterface* ret_ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
25598 *ret_ret = PhantomKeysManager_as_KeysInterface(&this_arg_conv);
25599 return (uint32_t)ret_ret;
25602 uint32_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) {
25603 unsigned char seed_arr[32];
25604 CHECK(seed->arr_len == 32);
25605 memcpy(seed_arr, seed->elems, 32); FREE(seed);
25606 unsigned char (*seed_ref)[32] = &seed_arr;
25607 unsigned char cross_node_seed_arr[32];
25608 CHECK(cross_node_seed->arr_len == 32);
25609 memcpy(cross_node_seed_arr, cross_node_seed->elems, 32); FREE(cross_node_seed);
25610 unsigned char (*cross_node_seed_ref)[32] = &cross_node_seed_arr;
25611 LDKPhantomKeysManager ret_var = PhantomKeysManager_new(seed_ref, starting_time_secs, starting_time_nanos, cross_node_seed_ref);
25612 uint32_t ret_ref = 0;
25613 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25614 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25615 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25616 ret_ref = (uintptr_t)ret_var.inner;
25617 if (ret_var.is_owned) {
25623 uint32_t __attribute__((export_name("TS_PhantomKeysManager_spend_spendable_outputs"))) TS_PhantomKeysManager_spend_spendable_outputs(uint32_t this_arg, uint32_tArray descriptors, uint32_tArray outputs, int8_tArray change_destination_script, int32_t feerate_sat_per_1000_weight) {
25624 LDKPhantomKeysManager this_arg_conv;
25625 this_arg_conv.inner = (void*)(this_arg & (~1));
25626 this_arg_conv.is_owned = false;
25627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25628 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
25629 descriptors_constr.datalen = descriptors->arr_len;
25630 if (descriptors_constr.datalen > 0)
25631 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
25633 descriptors_constr.data = NULL;
25634 uint32_t* descriptors_vals = descriptors->elems;
25635 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
25636 uint32_t descriptors_conv_27 = descriptors_vals[b];
25637 void* descriptors_conv_27_ptr = (void*)(((uintptr_t)descriptors_conv_27) & ~1);
25638 CHECK_ACCESS(descriptors_conv_27_ptr);
25639 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(descriptors_conv_27_ptr);
25640 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uintptr_t)descriptors_conv_27) & ~1));
25641 descriptors_constr.data[b] = descriptors_conv_27_conv;
25644 LDKCVec_TxOutZ outputs_constr;
25645 outputs_constr.datalen = outputs->arr_len;
25646 if (outputs_constr.datalen > 0)
25647 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
25649 outputs_constr.data = NULL;
25650 uint32_t* outputs_vals = outputs->elems;
25651 for (size_t h = 0; h < outputs_constr.datalen; h++) {
25652 uint32_t outputs_conv_7 = outputs_vals[h];
25653 void* outputs_conv_7_ptr = (void*)(((uintptr_t)outputs_conv_7) & ~1);
25654 CHECK_ACCESS(outputs_conv_7_ptr);
25655 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(outputs_conv_7_ptr);
25656 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)(((uintptr_t)outputs_conv_7) & ~1));
25657 outputs_constr.data[h] = outputs_conv_7_conv;
25660 LDKCVec_u8Z change_destination_script_ref;
25661 change_destination_script_ref.datalen = change_destination_script->arr_len;
25662 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
25663 memcpy(change_destination_script_ref.data, change_destination_script->elems, change_destination_script_ref.datalen); FREE(change_destination_script);
25664 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
25665 *ret_conv = PhantomKeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
25666 return (uint32_t)ret_conv;
25669 uint32_t __attribute__((export_name("TS_PhantomKeysManager_derive_channel_keys"))) TS_PhantomKeysManager_derive_channel_keys(uint32_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
25670 LDKPhantomKeysManager this_arg_conv;
25671 this_arg_conv.inner = (void*)(this_arg & (~1));
25672 this_arg_conv.is_owned = false;
25673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
25674 unsigned char params_arr[32];
25675 CHECK(params->arr_len == 32);
25676 memcpy(params_arr, params->elems, 32); FREE(params);
25677 unsigned char (*params_ref)[32] = ¶ms_arr;
25678 LDKInMemorySigner ret_var = PhantomKeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
25679 uint32_t ret_ref = 0;
25680 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25681 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25682 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25683 ret_ref = (uintptr_t)ret_var.inner;
25684 if (ret_var.is_owned) {
25690 void __attribute__((export_name("TS_ChannelManager_free"))) TS_ChannelManager_free(uint32_t this_obj) {
25691 LDKChannelManager this_obj_conv;
25692 this_obj_conv.inner = (void*)(this_obj & (~1));
25693 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25695 ChannelManager_free(this_obj_conv);
25698 void __attribute__((export_name("TS_ChainParameters_free"))) TS_ChainParameters_free(uint32_t this_obj) {
25699 LDKChainParameters this_obj_conv;
25700 this_obj_conv.inner = (void*)(this_obj & (~1));
25701 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25703 ChainParameters_free(this_obj_conv);
25706 uint32_t __attribute__((export_name("TS_ChainParameters_get_network"))) TS_ChainParameters_get_network(uint32_t this_ptr) {
25707 LDKChainParameters this_ptr_conv;
25708 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25709 this_ptr_conv.is_owned = false;
25710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25711 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
25715 void __attribute__((export_name("TS_ChainParameters_set_network"))) TS_ChainParameters_set_network(uint32_t this_ptr, uint32_t val) {
25716 LDKChainParameters this_ptr_conv;
25717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25718 this_ptr_conv.is_owned = false;
25719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25720 LDKNetwork val_conv = LDKNetwork_from_js(val);
25721 ChainParameters_set_network(&this_ptr_conv, val_conv);
25724 uint32_t __attribute__((export_name("TS_ChainParameters_get_best_block"))) TS_ChainParameters_get_best_block(uint32_t this_ptr) {
25725 LDKChainParameters this_ptr_conv;
25726 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25727 this_ptr_conv.is_owned = false;
25728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25729 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
25730 uint32_t ret_ref = 0;
25731 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25732 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25733 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25734 ret_ref = (uintptr_t)ret_var.inner;
25735 if (ret_var.is_owned) {
25741 void __attribute__((export_name("TS_ChainParameters_set_best_block"))) TS_ChainParameters_set_best_block(uint32_t this_ptr, uint32_t val) {
25742 LDKChainParameters this_ptr_conv;
25743 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25744 this_ptr_conv.is_owned = false;
25745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25746 LDKBestBlock val_conv;
25747 val_conv.inner = (void*)(val & (~1));
25748 val_conv.is_owned = (val & 1) || (val == 0);
25749 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
25750 val_conv = BestBlock_clone(&val_conv);
25751 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
25754 uint32_t __attribute__((export_name("TS_ChainParameters_new"))) TS_ChainParameters_new(uint32_t network_arg, uint32_t best_block_arg) {
25755 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
25756 LDKBestBlock best_block_arg_conv;
25757 best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
25758 best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
25759 CHECK_INNER_FIELD_ACCESS_OR_NULL(best_block_arg_conv);
25760 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
25761 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
25762 uint32_t ret_ref = 0;
25763 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25764 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25766 ret_ref = (uintptr_t)ret_var.inner;
25767 if (ret_var.is_owned) {
25773 static inline uintptr_t ChainParameters_clone_ptr(LDKChainParameters *NONNULL_PTR arg) {
25774 LDKChainParameters ret_var = ChainParameters_clone(arg);
25775 uint32_t ret_ref = 0;
25776 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25777 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25778 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25779 ret_ref = (uintptr_t)ret_var.inner;
25780 if (ret_var.is_owned) {
25785 uint32_t __attribute__((export_name("TS_ChainParameters_clone_ptr"))) TS_ChainParameters_clone_ptr(uint32_t arg) {
25786 LDKChainParameters arg_conv;
25787 arg_conv.inner = (void*)(arg & (~1));
25788 arg_conv.is_owned = false;
25789 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25790 uint32_t ret_conv = ChainParameters_clone_ptr(&arg_conv);
25794 uint32_t __attribute__((export_name("TS_ChainParameters_clone"))) TS_ChainParameters_clone(uint32_t orig) {
25795 LDKChainParameters orig_conv;
25796 orig_conv.inner = (void*)(orig & (~1));
25797 orig_conv.is_owned = false;
25798 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25799 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
25800 uint32_t ret_ref = 0;
25801 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25802 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25803 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25804 ret_ref = (uintptr_t)ret_var.inner;
25805 if (ret_var.is_owned) {
25811 void __attribute__((export_name("TS_CounterpartyForwardingInfo_free"))) TS_CounterpartyForwardingInfo_free(uint32_t this_obj) {
25812 LDKCounterpartyForwardingInfo this_obj_conv;
25813 this_obj_conv.inner = (void*)(this_obj & (~1));
25814 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25816 CounterpartyForwardingInfo_free(this_obj_conv);
25819 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_base_msat"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint32_t this_ptr) {
25820 LDKCounterpartyForwardingInfo this_ptr_conv;
25821 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25822 this_ptr_conv.is_owned = false;
25823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25824 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv);
25828 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_base_msat"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint32_t this_ptr, int32_t val) {
25829 LDKCounterpartyForwardingInfo this_ptr_conv;
25830 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25831 this_ptr_conv.is_owned = false;
25832 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25833 CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val);
25836 int32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint32_t this_ptr) {
25837 LDKCounterpartyForwardingInfo this_ptr_conv;
25838 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25839 this_ptr_conv.is_owned = false;
25840 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25841 int32_t ret_conv = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv);
25845 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_fee_proportional_millionths"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint32_t this_ptr, int32_t val) {
25846 LDKCounterpartyForwardingInfo this_ptr_conv;
25847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25848 this_ptr_conv.is_owned = false;
25849 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25850 CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val);
25853 int16_t __attribute__((export_name("TS_CounterpartyForwardingInfo_get_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint32_t this_ptr) {
25854 LDKCounterpartyForwardingInfo this_ptr_conv;
25855 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25856 this_ptr_conv.is_owned = false;
25857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25858 int16_t ret_conv = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv);
25862 void __attribute__((export_name("TS_CounterpartyForwardingInfo_set_cltv_expiry_delta"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
25863 LDKCounterpartyForwardingInfo this_ptr_conv;
25864 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25865 this_ptr_conv.is_owned = false;
25866 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25867 CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
25870 uint32_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) {
25871 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg);
25872 uint32_t ret_ref = 0;
25873 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25874 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25875 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25876 ret_ref = (uintptr_t)ret_var.inner;
25877 if (ret_var.is_owned) {
25883 static inline uintptr_t CounterpartyForwardingInfo_clone_ptr(LDKCounterpartyForwardingInfo *NONNULL_PTR arg) {
25884 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(arg);
25885 uint32_t ret_ref = 0;
25886 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25887 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25888 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25889 ret_ref = (uintptr_t)ret_var.inner;
25890 if (ret_var.is_owned) {
25895 uint32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone_ptr"))) TS_CounterpartyForwardingInfo_clone_ptr(uint32_t arg) {
25896 LDKCounterpartyForwardingInfo arg_conv;
25897 arg_conv.inner = (void*)(arg & (~1));
25898 arg_conv.is_owned = false;
25899 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
25900 uint32_t ret_conv = CounterpartyForwardingInfo_clone_ptr(&arg_conv);
25904 uint32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_clone"))) TS_CounterpartyForwardingInfo_clone(uint32_t orig) {
25905 LDKCounterpartyForwardingInfo orig_conv;
25906 orig_conv.inner = (void*)(orig & (~1));
25907 orig_conv.is_owned = false;
25908 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
25909 LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_clone(&orig_conv);
25910 uint32_t ret_ref = 0;
25911 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25912 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25913 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25914 ret_ref = (uintptr_t)ret_var.inner;
25915 if (ret_var.is_owned) {
25921 void __attribute__((export_name("TS_ChannelCounterparty_free"))) TS_ChannelCounterparty_free(uint32_t this_obj) {
25922 LDKChannelCounterparty this_obj_conv;
25923 this_obj_conv.inner = (void*)(this_obj & (~1));
25924 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
25925 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
25926 ChannelCounterparty_free(this_obj_conv);
25929 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_get_node_id"))) TS_ChannelCounterparty_get_node_id(uint32_t this_ptr) {
25930 LDKChannelCounterparty this_ptr_conv;
25931 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25932 this_ptr_conv.is_owned = false;
25933 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25934 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
25935 memcpy(ret_arr->elems, ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
25939 void __attribute__((export_name("TS_ChannelCounterparty_set_node_id"))) TS_ChannelCounterparty_set_node_id(uint32_t this_ptr, int8_tArray val) {
25940 LDKChannelCounterparty this_ptr_conv;
25941 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25942 this_ptr_conv.is_owned = false;
25943 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25944 LDKPublicKey val_ref;
25945 CHECK(val->arr_len == 33);
25946 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
25947 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
25950 uint32_t __attribute__((export_name("TS_ChannelCounterparty_get_features"))) TS_ChannelCounterparty_get_features(uint32_t this_ptr) {
25951 LDKChannelCounterparty this_ptr_conv;
25952 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25953 this_ptr_conv.is_owned = false;
25954 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25955 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
25956 uint32_t ret_ref = 0;
25957 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
25958 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
25959 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
25960 ret_ref = (uintptr_t)ret_var.inner;
25961 if (ret_var.is_owned) {
25967 void __attribute__((export_name("TS_ChannelCounterparty_set_features"))) TS_ChannelCounterparty_set_features(uint32_t this_ptr, uint32_t val) {
25968 LDKChannelCounterparty this_ptr_conv;
25969 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25970 this_ptr_conv.is_owned = false;
25971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25972 LDKInitFeatures val_conv;
25973 val_conv.inner = (void*)(val & (~1));
25974 val_conv.is_owned = (val & 1) || (val == 0);
25975 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
25976 val_conv = InitFeatures_clone(&val_conv);
25977 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
25980 int64_t __attribute__((export_name("TS_ChannelCounterparty_get_unspendable_punishment_reserve"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint32_t this_ptr) {
25981 LDKChannelCounterparty this_ptr_conv;
25982 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25983 this_ptr_conv.is_owned = false;
25984 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25985 int64_t ret_conv = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
25989 void __attribute__((export_name("TS_ChannelCounterparty_set_unspendable_punishment_reserve"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint32_t this_ptr, int64_t val) {
25990 LDKChannelCounterparty this_ptr_conv;
25991 this_ptr_conv.inner = (void*)(this_ptr & (~1));
25992 this_ptr_conv.is_owned = false;
25993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
25994 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
25997 uint32_t __attribute__((export_name("TS_ChannelCounterparty_get_forwarding_info"))) TS_ChannelCounterparty_get_forwarding_info(uint32_t this_ptr) {
25998 LDKChannelCounterparty this_ptr_conv;
25999 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26000 this_ptr_conv.is_owned = false;
26001 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26002 LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_conv);
26003 uint32_t ret_ref = 0;
26004 if ((uintptr_t)ret_var.inner > 4096) {
26005 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26006 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26007 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26008 ret_ref = (uintptr_t)ret_var.inner;
26009 if (ret_var.is_owned) {
26016 void __attribute__((export_name("TS_ChannelCounterparty_set_forwarding_info"))) TS_ChannelCounterparty_set_forwarding_info(uint32_t this_ptr, uint32_t val) {
26017 LDKChannelCounterparty this_ptr_conv;
26018 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26019 this_ptr_conv.is_owned = false;
26020 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26021 LDKCounterpartyForwardingInfo val_conv;
26022 val_conv.inner = (void*)(val & (~1));
26023 val_conv.is_owned = (val & 1) || (val == 0);
26024 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26025 val_conv = CounterpartyForwardingInfo_clone(&val_conv);
26026 ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv);
26029 uint32_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_minimum_msat(uint32_t this_ptr) {
26030 LDKChannelCounterparty this_ptr_conv;
26031 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26032 this_ptr_conv.is_owned = false;
26033 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26034 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26035 *ret_copy = ChannelCounterparty_get_outbound_htlc_minimum_msat(&this_ptr_conv);
26036 uint32_t ret_ref = (uintptr_t)ret_copy;
26040 void __attribute__((export_name("TS_ChannelCounterparty_set_outbound_htlc_minimum_msat"))) TS_ChannelCounterparty_set_outbound_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) {
26041 LDKChannelCounterparty this_ptr_conv;
26042 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26043 this_ptr_conv.is_owned = false;
26044 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26045 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26046 CHECK_ACCESS(val_ptr);
26047 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26048 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26049 ChannelCounterparty_set_outbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
26052 uint32_t __attribute__((export_name("TS_ChannelCounterparty_get_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_get_outbound_htlc_maximum_msat(uint32_t this_ptr) {
26053 LDKChannelCounterparty this_ptr_conv;
26054 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26055 this_ptr_conv.is_owned = false;
26056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26057 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26058 *ret_copy = ChannelCounterparty_get_outbound_htlc_maximum_msat(&this_ptr_conv);
26059 uint32_t ret_ref = (uintptr_t)ret_copy;
26063 void __attribute__((export_name("TS_ChannelCounterparty_set_outbound_htlc_maximum_msat"))) TS_ChannelCounterparty_set_outbound_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) {
26064 LDKChannelCounterparty this_ptr_conv;
26065 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26066 this_ptr_conv.is_owned = false;
26067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26068 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26069 CHECK_ACCESS(val_ptr);
26070 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26071 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26072 ChannelCounterparty_set_outbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
26075 uint32_t __attribute__((export_name("TS_ChannelCounterparty_new"))) TS_ChannelCounterparty_new(int8_tArray node_id_arg, uint32_t features_arg, int64_t unspendable_punishment_reserve_arg, uint32_t forwarding_info_arg, uint32_t outbound_htlc_minimum_msat_arg, uint32_t outbound_htlc_maximum_msat_arg) {
26076 LDKPublicKey node_id_arg_ref;
26077 CHECK(node_id_arg->arr_len == 33);
26078 memcpy(node_id_arg_ref.compressed_form, node_id_arg->elems, 33); FREE(node_id_arg);
26079 LDKInitFeatures features_arg_conv;
26080 features_arg_conv.inner = (void*)(features_arg & (~1));
26081 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
26082 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
26083 features_arg_conv = InitFeatures_clone(&features_arg_conv);
26084 LDKCounterpartyForwardingInfo forwarding_info_arg_conv;
26085 forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1));
26086 forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0);
26087 CHECK_INNER_FIELD_ACCESS_OR_NULL(forwarding_info_arg_conv);
26088 forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv);
26089 void* outbound_htlc_minimum_msat_arg_ptr = (void*)(((uintptr_t)outbound_htlc_minimum_msat_arg) & ~1);
26090 CHECK_ACCESS(outbound_htlc_minimum_msat_arg_ptr);
26091 LDKCOption_u64Z outbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_minimum_msat_arg_ptr);
26092 outbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)outbound_htlc_minimum_msat_arg) & ~1));
26093 void* outbound_htlc_maximum_msat_arg_ptr = (void*)(((uintptr_t)outbound_htlc_maximum_msat_arg) & ~1);
26094 CHECK_ACCESS(outbound_htlc_maximum_msat_arg_ptr);
26095 LDKCOption_u64Z outbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(outbound_htlc_maximum_msat_arg_ptr);
26096 outbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)outbound_htlc_maximum_msat_arg) & ~1));
26097 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);
26098 uint32_t ret_ref = 0;
26099 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26100 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26101 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26102 ret_ref = (uintptr_t)ret_var.inner;
26103 if (ret_var.is_owned) {
26109 static inline uintptr_t ChannelCounterparty_clone_ptr(LDKChannelCounterparty *NONNULL_PTR arg) {
26110 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(arg);
26111 uint32_t ret_ref = 0;
26112 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26113 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26114 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26115 ret_ref = (uintptr_t)ret_var.inner;
26116 if (ret_var.is_owned) {
26121 uint32_t __attribute__((export_name("TS_ChannelCounterparty_clone_ptr"))) TS_ChannelCounterparty_clone_ptr(uint32_t arg) {
26122 LDKChannelCounterparty arg_conv;
26123 arg_conv.inner = (void*)(arg & (~1));
26124 arg_conv.is_owned = false;
26125 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26126 uint32_t ret_conv = ChannelCounterparty_clone_ptr(&arg_conv);
26130 uint32_t __attribute__((export_name("TS_ChannelCounterparty_clone"))) TS_ChannelCounterparty_clone(uint32_t orig) {
26131 LDKChannelCounterparty orig_conv;
26132 orig_conv.inner = (void*)(orig & (~1));
26133 orig_conv.is_owned = false;
26134 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26135 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
26136 uint32_t ret_ref = 0;
26137 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26138 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26139 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26140 ret_ref = (uintptr_t)ret_var.inner;
26141 if (ret_var.is_owned) {
26147 void __attribute__((export_name("TS_ChannelDetails_free"))) TS_ChannelDetails_free(uint32_t this_obj) {
26148 LDKChannelDetails this_obj_conv;
26149 this_obj_conv.inner = (void*)(this_obj & (~1));
26150 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
26151 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26152 ChannelDetails_free(this_obj_conv);
26155 int8_tArray __attribute__((export_name("TS_ChannelDetails_get_channel_id"))) TS_ChannelDetails_get_channel_id(uint32_t this_ptr) {
26156 LDKChannelDetails this_ptr_conv;
26157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26158 this_ptr_conv.is_owned = false;
26159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26160 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
26161 memcpy(ret_arr->elems, *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
26165 void __attribute__((export_name("TS_ChannelDetails_set_channel_id"))) TS_ChannelDetails_set_channel_id(uint32_t this_ptr, int8_tArray val) {
26166 LDKChannelDetails this_ptr_conv;
26167 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26168 this_ptr_conv.is_owned = false;
26169 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26170 LDKThirtyTwoBytes val_ref;
26171 CHECK(val->arr_len == 32);
26172 memcpy(val_ref.data, val->elems, 32); FREE(val);
26173 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
26176 uint32_t __attribute__((export_name("TS_ChannelDetails_get_counterparty"))) TS_ChannelDetails_get_counterparty(uint32_t this_ptr) {
26177 LDKChannelDetails this_ptr_conv;
26178 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26179 this_ptr_conv.is_owned = false;
26180 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26181 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
26182 uint32_t ret_ref = 0;
26183 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26184 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26185 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26186 ret_ref = (uintptr_t)ret_var.inner;
26187 if (ret_var.is_owned) {
26193 void __attribute__((export_name("TS_ChannelDetails_set_counterparty"))) TS_ChannelDetails_set_counterparty(uint32_t this_ptr, uint32_t val) {
26194 LDKChannelDetails this_ptr_conv;
26195 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26196 this_ptr_conv.is_owned = false;
26197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26198 LDKChannelCounterparty val_conv;
26199 val_conv.inner = (void*)(val & (~1));
26200 val_conv.is_owned = (val & 1) || (val == 0);
26201 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26202 val_conv = ChannelCounterparty_clone(&val_conv);
26203 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
26206 uint32_t __attribute__((export_name("TS_ChannelDetails_get_funding_txo"))) TS_ChannelDetails_get_funding_txo(uint32_t this_ptr) {
26207 LDKChannelDetails this_ptr_conv;
26208 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26209 this_ptr_conv.is_owned = false;
26210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26211 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
26212 uint32_t ret_ref = 0;
26213 if ((uintptr_t)ret_var.inner > 4096) {
26214 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26215 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26216 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26217 ret_ref = (uintptr_t)ret_var.inner;
26218 if (ret_var.is_owned) {
26225 void __attribute__((export_name("TS_ChannelDetails_set_funding_txo"))) TS_ChannelDetails_set_funding_txo(uint32_t this_ptr, uint32_t val) {
26226 LDKChannelDetails this_ptr_conv;
26227 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26228 this_ptr_conv.is_owned = false;
26229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26230 LDKOutPoint val_conv;
26231 val_conv.inner = (void*)(val & (~1));
26232 val_conv.is_owned = (val & 1) || (val == 0);
26233 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26234 val_conv = OutPoint_clone(&val_conv);
26235 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
26238 uint32_t __attribute__((export_name("TS_ChannelDetails_get_channel_type"))) TS_ChannelDetails_get_channel_type(uint32_t this_ptr) {
26239 LDKChannelDetails this_ptr_conv;
26240 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26241 this_ptr_conv.is_owned = false;
26242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26243 LDKChannelTypeFeatures ret_var = ChannelDetails_get_channel_type(&this_ptr_conv);
26244 uint32_t ret_ref = 0;
26245 if ((uintptr_t)ret_var.inner > 4096) {
26246 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26247 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26248 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26249 ret_ref = (uintptr_t)ret_var.inner;
26250 if (ret_var.is_owned) {
26257 void __attribute__((export_name("TS_ChannelDetails_set_channel_type"))) TS_ChannelDetails_set_channel_type(uint32_t this_ptr, uint32_t val) {
26258 LDKChannelDetails this_ptr_conv;
26259 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26260 this_ptr_conv.is_owned = false;
26261 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26262 LDKChannelTypeFeatures val_conv;
26263 val_conv.inner = (void*)(val & (~1));
26264 val_conv.is_owned = (val & 1) || (val == 0);
26265 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26266 val_conv = ChannelTypeFeatures_clone(&val_conv);
26267 ChannelDetails_set_channel_type(&this_ptr_conv, val_conv);
26270 uint32_t __attribute__((export_name("TS_ChannelDetails_get_short_channel_id"))) TS_ChannelDetails_get_short_channel_id(uint32_t this_ptr) {
26271 LDKChannelDetails this_ptr_conv;
26272 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26273 this_ptr_conv.is_owned = false;
26274 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26275 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26276 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
26277 uint32_t ret_ref = (uintptr_t)ret_copy;
26281 void __attribute__((export_name("TS_ChannelDetails_set_short_channel_id"))) TS_ChannelDetails_set_short_channel_id(uint32_t this_ptr, uint32_t val) {
26282 LDKChannelDetails this_ptr_conv;
26283 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26284 this_ptr_conv.is_owned = false;
26285 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26286 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26287 CHECK_ACCESS(val_ptr);
26288 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26289 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26290 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
26293 uint32_t __attribute__((export_name("TS_ChannelDetails_get_outbound_scid_alias"))) TS_ChannelDetails_get_outbound_scid_alias(uint32_t this_ptr) {
26294 LDKChannelDetails this_ptr_conv;
26295 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26296 this_ptr_conv.is_owned = false;
26297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26298 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26299 *ret_copy = ChannelDetails_get_outbound_scid_alias(&this_ptr_conv);
26300 uint32_t ret_ref = (uintptr_t)ret_copy;
26304 void __attribute__((export_name("TS_ChannelDetails_set_outbound_scid_alias"))) TS_ChannelDetails_set_outbound_scid_alias(uint32_t this_ptr, uint32_t val) {
26305 LDKChannelDetails this_ptr_conv;
26306 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26307 this_ptr_conv.is_owned = false;
26308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26309 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26310 CHECK_ACCESS(val_ptr);
26311 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26312 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26313 ChannelDetails_set_outbound_scid_alias(&this_ptr_conv, val_conv);
26316 uint32_t __attribute__((export_name("TS_ChannelDetails_get_inbound_scid_alias"))) TS_ChannelDetails_get_inbound_scid_alias(uint32_t this_ptr) {
26317 LDKChannelDetails this_ptr_conv;
26318 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26319 this_ptr_conv.is_owned = false;
26320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26321 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26322 *ret_copy = ChannelDetails_get_inbound_scid_alias(&this_ptr_conv);
26323 uint32_t ret_ref = (uintptr_t)ret_copy;
26327 void __attribute__((export_name("TS_ChannelDetails_set_inbound_scid_alias"))) TS_ChannelDetails_set_inbound_scid_alias(uint32_t this_ptr, uint32_t val) {
26328 LDKChannelDetails this_ptr_conv;
26329 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26330 this_ptr_conv.is_owned = false;
26331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26332 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26333 CHECK_ACCESS(val_ptr);
26334 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26335 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26336 ChannelDetails_set_inbound_scid_alias(&this_ptr_conv, val_conv);
26339 int64_t __attribute__((export_name("TS_ChannelDetails_get_channel_value_satoshis"))) TS_ChannelDetails_get_channel_value_satoshis(uint32_t this_ptr) {
26340 LDKChannelDetails this_ptr_conv;
26341 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26342 this_ptr_conv.is_owned = false;
26343 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26344 int64_t ret_conv = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
26348 void __attribute__((export_name("TS_ChannelDetails_set_channel_value_satoshis"))) TS_ChannelDetails_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
26349 LDKChannelDetails this_ptr_conv;
26350 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26351 this_ptr_conv.is_owned = false;
26352 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26353 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
26356 uint32_t __attribute__((export_name("TS_ChannelDetails_get_unspendable_punishment_reserve"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint32_t this_ptr) {
26357 LDKChannelDetails this_ptr_conv;
26358 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26359 this_ptr_conv.is_owned = false;
26360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26361 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26362 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
26363 uint32_t ret_ref = (uintptr_t)ret_copy;
26367 void __attribute__((export_name("TS_ChannelDetails_set_unspendable_punishment_reserve"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint32_t this_ptr, uint32_t val) {
26368 LDKChannelDetails this_ptr_conv;
26369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26370 this_ptr_conv.is_owned = false;
26371 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26372 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26373 CHECK_ACCESS(val_ptr);
26374 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26375 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26376 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
26379 int64_t __attribute__((export_name("TS_ChannelDetails_get_user_channel_id"))) TS_ChannelDetails_get_user_channel_id(uint32_t this_ptr) {
26380 LDKChannelDetails this_ptr_conv;
26381 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26382 this_ptr_conv.is_owned = false;
26383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26384 int64_t ret_conv = ChannelDetails_get_user_channel_id(&this_ptr_conv);
26388 void __attribute__((export_name("TS_ChannelDetails_set_user_channel_id"))) TS_ChannelDetails_set_user_channel_id(uint32_t this_ptr, int64_t val) {
26389 LDKChannelDetails this_ptr_conv;
26390 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26391 this_ptr_conv.is_owned = false;
26392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26393 ChannelDetails_set_user_channel_id(&this_ptr_conv, val);
26396 int64_t __attribute__((export_name("TS_ChannelDetails_get_balance_msat"))) TS_ChannelDetails_get_balance_msat(uint32_t this_ptr) {
26397 LDKChannelDetails this_ptr_conv;
26398 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26399 this_ptr_conv.is_owned = false;
26400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26401 int64_t ret_conv = ChannelDetails_get_balance_msat(&this_ptr_conv);
26405 void __attribute__((export_name("TS_ChannelDetails_set_balance_msat"))) TS_ChannelDetails_set_balance_msat(uint32_t this_ptr, int64_t val) {
26406 LDKChannelDetails this_ptr_conv;
26407 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26408 this_ptr_conv.is_owned = false;
26409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26410 ChannelDetails_set_balance_msat(&this_ptr_conv, val);
26413 int64_t __attribute__((export_name("TS_ChannelDetails_get_outbound_capacity_msat"))) TS_ChannelDetails_get_outbound_capacity_msat(uint32_t this_ptr) {
26414 LDKChannelDetails this_ptr_conv;
26415 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26416 this_ptr_conv.is_owned = false;
26417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26418 int64_t ret_conv = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
26422 void __attribute__((export_name("TS_ChannelDetails_set_outbound_capacity_msat"))) TS_ChannelDetails_set_outbound_capacity_msat(uint32_t this_ptr, int64_t val) {
26423 LDKChannelDetails this_ptr_conv;
26424 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26425 this_ptr_conv.is_owned = false;
26426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26427 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
26430 int64_t __attribute__((export_name("TS_ChannelDetails_get_next_outbound_htlc_limit_msat"))) TS_ChannelDetails_get_next_outbound_htlc_limit_msat(uint32_t this_ptr) {
26431 LDKChannelDetails this_ptr_conv;
26432 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26433 this_ptr_conv.is_owned = false;
26434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26435 int64_t ret_conv = ChannelDetails_get_next_outbound_htlc_limit_msat(&this_ptr_conv);
26439 void __attribute__((export_name("TS_ChannelDetails_set_next_outbound_htlc_limit_msat"))) TS_ChannelDetails_set_next_outbound_htlc_limit_msat(uint32_t this_ptr, int64_t val) {
26440 LDKChannelDetails this_ptr_conv;
26441 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26442 this_ptr_conv.is_owned = false;
26443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26444 ChannelDetails_set_next_outbound_htlc_limit_msat(&this_ptr_conv, val);
26447 int64_t __attribute__((export_name("TS_ChannelDetails_get_inbound_capacity_msat"))) TS_ChannelDetails_get_inbound_capacity_msat(uint32_t this_ptr) {
26448 LDKChannelDetails this_ptr_conv;
26449 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26450 this_ptr_conv.is_owned = false;
26451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26452 int64_t ret_conv = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
26456 void __attribute__((export_name("TS_ChannelDetails_set_inbound_capacity_msat"))) TS_ChannelDetails_set_inbound_capacity_msat(uint32_t this_ptr, int64_t val) {
26457 LDKChannelDetails this_ptr_conv;
26458 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26459 this_ptr_conv.is_owned = false;
26460 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26461 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
26464 uint32_t __attribute__((export_name("TS_ChannelDetails_get_confirmations_required"))) TS_ChannelDetails_get_confirmations_required(uint32_t this_ptr) {
26465 LDKChannelDetails this_ptr_conv;
26466 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26467 this_ptr_conv.is_owned = false;
26468 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26469 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
26470 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
26471 uint32_t ret_ref = (uintptr_t)ret_copy;
26475 void __attribute__((export_name("TS_ChannelDetails_set_confirmations_required"))) TS_ChannelDetails_set_confirmations_required(uint32_t this_ptr, uint32_t val) {
26476 LDKChannelDetails this_ptr_conv;
26477 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26478 this_ptr_conv.is_owned = false;
26479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26480 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26481 CHECK_ACCESS(val_ptr);
26482 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
26483 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uintptr_t)val) & ~1));
26484 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
26487 uint32_t __attribute__((export_name("TS_ChannelDetails_get_force_close_spend_delay"))) TS_ChannelDetails_get_force_close_spend_delay(uint32_t this_ptr) {
26488 LDKChannelDetails this_ptr_conv;
26489 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26490 this_ptr_conv.is_owned = false;
26491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26492 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
26493 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
26494 uint32_t ret_ref = (uintptr_t)ret_copy;
26498 void __attribute__((export_name("TS_ChannelDetails_set_force_close_spend_delay"))) TS_ChannelDetails_set_force_close_spend_delay(uint32_t this_ptr, uint32_t val) {
26499 LDKChannelDetails this_ptr_conv;
26500 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26501 this_ptr_conv.is_owned = false;
26502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26503 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26504 CHECK_ACCESS(val_ptr);
26505 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(val_ptr);
26506 val_conv = COption_u16Z_clone((LDKCOption_u16Z*)(((uintptr_t)val) & ~1));
26507 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
26510 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_outbound"))) TS_ChannelDetails_get_is_outbound(uint32_t this_ptr) {
26511 LDKChannelDetails this_ptr_conv;
26512 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26513 this_ptr_conv.is_owned = false;
26514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26515 jboolean ret_conv = ChannelDetails_get_is_outbound(&this_ptr_conv);
26519 void __attribute__((export_name("TS_ChannelDetails_set_is_outbound"))) TS_ChannelDetails_set_is_outbound(uint32_t this_ptr, jboolean val) {
26520 LDKChannelDetails this_ptr_conv;
26521 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26522 this_ptr_conv.is_owned = false;
26523 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26524 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
26527 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_channel_ready"))) TS_ChannelDetails_get_is_channel_ready(uint32_t this_ptr) {
26528 LDKChannelDetails this_ptr_conv;
26529 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26530 this_ptr_conv.is_owned = false;
26531 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26532 jboolean ret_conv = ChannelDetails_get_is_channel_ready(&this_ptr_conv);
26536 void __attribute__((export_name("TS_ChannelDetails_set_is_channel_ready"))) TS_ChannelDetails_set_is_channel_ready(uint32_t this_ptr, jboolean val) {
26537 LDKChannelDetails this_ptr_conv;
26538 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26539 this_ptr_conv.is_owned = false;
26540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26541 ChannelDetails_set_is_channel_ready(&this_ptr_conv, val);
26544 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_usable"))) TS_ChannelDetails_get_is_usable(uint32_t this_ptr) {
26545 LDKChannelDetails this_ptr_conv;
26546 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26547 this_ptr_conv.is_owned = false;
26548 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26549 jboolean ret_conv = ChannelDetails_get_is_usable(&this_ptr_conv);
26553 void __attribute__((export_name("TS_ChannelDetails_set_is_usable"))) TS_ChannelDetails_set_is_usable(uint32_t this_ptr, jboolean val) {
26554 LDKChannelDetails this_ptr_conv;
26555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26556 this_ptr_conv.is_owned = false;
26557 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26558 ChannelDetails_set_is_usable(&this_ptr_conv, val);
26561 jboolean __attribute__((export_name("TS_ChannelDetails_get_is_public"))) TS_ChannelDetails_get_is_public(uint32_t this_ptr) {
26562 LDKChannelDetails this_ptr_conv;
26563 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26564 this_ptr_conv.is_owned = false;
26565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26566 jboolean ret_conv = ChannelDetails_get_is_public(&this_ptr_conv);
26570 void __attribute__((export_name("TS_ChannelDetails_set_is_public"))) TS_ChannelDetails_set_is_public(uint32_t this_ptr, jboolean val) {
26571 LDKChannelDetails this_ptr_conv;
26572 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26573 this_ptr_conv.is_owned = false;
26574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26575 ChannelDetails_set_is_public(&this_ptr_conv, val);
26578 uint32_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_minimum_msat"))) TS_ChannelDetails_get_inbound_htlc_minimum_msat(uint32_t this_ptr) {
26579 LDKChannelDetails this_ptr_conv;
26580 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26581 this_ptr_conv.is_owned = false;
26582 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26583 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26584 *ret_copy = ChannelDetails_get_inbound_htlc_minimum_msat(&this_ptr_conv);
26585 uint32_t ret_ref = (uintptr_t)ret_copy;
26589 void __attribute__((export_name("TS_ChannelDetails_set_inbound_htlc_minimum_msat"))) TS_ChannelDetails_set_inbound_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) {
26590 LDKChannelDetails this_ptr_conv;
26591 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26592 this_ptr_conv.is_owned = false;
26593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26594 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26595 CHECK_ACCESS(val_ptr);
26596 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26597 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26598 ChannelDetails_set_inbound_htlc_minimum_msat(&this_ptr_conv, val_conv);
26601 uint32_t __attribute__((export_name("TS_ChannelDetails_get_inbound_htlc_maximum_msat"))) TS_ChannelDetails_get_inbound_htlc_maximum_msat(uint32_t this_ptr) {
26602 LDKChannelDetails this_ptr_conv;
26603 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26604 this_ptr_conv.is_owned = false;
26605 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26606 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26607 *ret_copy = ChannelDetails_get_inbound_htlc_maximum_msat(&this_ptr_conv);
26608 uint32_t ret_ref = (uintptr_t)ret_copy;
26612 void __attribute__((export_name("TS_ChannelDetails_set_inbound_htlc_maximum_msat"))) TS_ChannelDetails_set_inbound_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) {
26613 LDKChannelDetails this_ptr_conv;
26614 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26615 this_ptr_conv.is_owned = false;
26616 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26617 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
26618 CHECK_ACCESS(val_ptr);
26619 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
26620 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
26621 ChannelDetails_set_inbound_htlc_maximum_msat(&this_ptr_conv, val_conv);
26624 uint32_t __attribute__((export_name("TS_ChannelDetails_get_config"))) TS_ChannelDetails_get_config(uint32_t this_ptr) {
26625 LDKChannelDetails this_ptr_conv;
26626 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26627 this_ptr_conv.is_owned = false;
26628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26629 LDKChannelConfig ret_var = ChannelDetails_get_config(&this_ptr_conv);
26630 uint32_t ret_ref = 0;
26631 if ((uintptr_t)ret_var.inner > 4096) {
26632 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26633 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26634 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26635 ret_ref = (uintptr_t)ret_var.inner;
26636 if (ret_var.is_owned) {
26643 void __attribute__((export_name("TS_ChannelDetails_set_config"))) TS_ChannelDetails_set_config(uint32_t this_ptr, uint32_t val) {
26644 LDKChannelDetails this_ptr_conv;
26645 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26646 this_ptr_conv.is_owned = false;
26647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26648 LDKChannelConfig val_conv;
26649 val_conv.inner = (void*)(val & (~1));
26650 val_conv.is_owned = (val & 1) || (val == 0);
26651 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
26652 val_conv = ChannelConfig_clone(&val_conv);
26653 ChannelDetails_set_config(&this_ptr_conv, val_conv);
26656 uint32_t __attribute__((export_name("TS_ChannelDetails_new"))) TS_ChannelDetails_new(int8_tArray channel_id_arg, uint32_t counterparty_arg, uint32_t funding_txo_arg, uint32_t channel_type_arg, uint32_t short_channel_id_arg, uint32_t outbound_scid_alias_arg, uint32_t inbound_scid_alias_arg, int64_t channel_value_satoshis_arg, uint32_t unspendable_punishment_reserve_arg, int64_t user_channel_id_arg, int64_t balance_msat_arg, int64_t outbound_capacity_msat_arg, int64_t next_outbound_htlc_limit_msat_arg, int64_t inbound_capacity_msat_arg, uint32_t confirmations_required_arg, uint32_t force_close_spend_delay_arg, jboolean is_outbound_arg, jboolean is_channel_ready_arg, jboolean is_usable_arg, jboolean is_public_arg, uint32_t inbound_htlc_minimum_msat_arg, uint32_t inbound_htlc_maximum_msat_arg, uint32_t config_arg) {
26657 LDKThirtyTwoBytes channel_id_arg_ref;
26658 CHECK(channel_id_arg->arr_len == 32);
26659 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
26660 LDKChannelCounterparty counterparty_arg_conv;
26661 counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
26662 counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
26663 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_arg_conv);
26664 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
26665 LDKOutPoint funding_txo_arg_conv;
26666 funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
26667 funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
26668 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_txo_arg_conv);
26669 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
26670 LDKChannelTypeFeatures channel_type_arg_conv;
26671 channel_type_arg_conv.inner = (void*)(channel_type_arg & (~1));
26672 channel_type_arg_conv.is_owned = (channel_type_arg & 1) || (channel_type_arg == 0);
26673 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_type_arg_conv);
26674 channel_type_arg_conv = ChannelTypeFeatures_clone(&channel_type_arg_conv);
26675 void* short_channel_id_arg_ptr = (void*)(((uintptr_t)short_channel_id_arg) & ~1);
26676 CHECK_ACCESS(short_channel_id_arg_ptr);
26677 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_arg_ptr);
26678 short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)short_channel_id_arg) & ~1));
26679 void* outbound_scid_alias_arg_ptr = (void*)(((uintptr_t)outbound_scid_alias_arg) & ~1);
26680 CHECK_ACCESS(outbound_scid_alias_arg_ptr);
26681 LDKCOption_u64Z outbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(outbound_scid_alias_arg_ptr);
26682 outbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)outbound_scid_alias_arg) & ~1));
26683 void* inbound_scid_alias_arg_ptr = (void*)(((uintptr_t)inbound_scid_alias_arg) & ~1);
26684 CHECK_ACCESS(inbound_scid_alias_arg_ptr);
26685 LDKCOption_u64Z inbound_scid_alias_arg_conv = *(LDKCOption_u64Z*)(inbound_scid_alias_arg_ptr);
26686 inbound_scid_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)inbound_scid_alias_arg) & ~1));
26687 void* unspendable_punishment_reserve_arg_ptr = (void*)(((uintptr_t)unspendable_punishment_reserve_arg) & ~1);
26688 CHECK_ACCESS(unspendable_punishment_reserve_arg_ptr);
26689 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(unspendable_punishment_reserve_arg_ptr);
26690 void* confirmations_required_arg_ptr = (void*)(((uintptr_t)confirmations_required_arg) & ~1);
26691 CHECK_ACCESS(confirmations_required_arg_ptr);
26692 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(confirmations_required_arg_ptr);
26693 confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uintptr_t)confirmations_required_arg) & ~1));
26694 void* force_close_spend_delay_arg_ptr = (void*)(((uintptr_t)force_close_spend_delay_arg) & ~1);
26695 CHECK_ACCESS(force_close_spend_delay_arg_ptr);
26696 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(force_close_spend_delay_arg_ptr);
26697 force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)(((uintptr_t)force_close_spend_delay_arg) & ~1));
26698 void* inbound_htlc_minimum_msat_arg_ptr = (void*)(((uintptr_t)inbound_htlc_minimum_msat_arg) & ~1);
26699 CHECK_ACCESS(inbound_htlc_minimum_msat_arg_ptr);
26700 LDKCOption_u64Z inbound_htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_minimum_msat_arg_ptr);
26701 inbound_htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)inbound_htlc_minimum_msat_arg) & ~1));
26702 void* inbound_htlc_maximum_msat_arg_ptr = (void*)(((uintptr_t)inbound_htlc_maximum_msat_arg) & ~1);
26703 CHECK_ACCESS(inbound_htlc_maximum_msat_arg_ptr);
26704 LDKCOption_u64Z inbound_htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(inbound_htlc_maximum_msat_arg_ptr);
26705 inbound_htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)inbound_htlc_maximum_msat_arg) & ~1));
26706 LDKChannelConfig config_arg_conv;
26707 config_arg_conv.inner = (void*)(config_arg & (~1));
26708 config_arg_conv.is_owned = (config_arg & 1) || (config_arg == 0);
26709 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_arg_conv);
26710 config_arg_conv = ChannelConfig_clone(&config_arg_conv);
26711 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, balance_msat_arg, outbound_capacity_msat_arg, next_outbound_htlc_limit_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_channel_ready_arg, is_usable_arg, is_public_arg, inbound_htlc_minimum_msat_arg_conv, inbound_htlc_maximum_msat_arg_conv, config_arg_conv);
26712 uint32_t ret_ref = 0;
26713 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26714 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26715 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26716 ret_ref = (uintptr_t)ret_var.inner;
26717 if (ret_var.is_owned) {
26723 static inline uintptr_t ChannelDetails_clone_ptr(LDKChannelDetails *NONNULL_PTR arg) {
26724 LDKChannelDetails ret_var = ChannelDetails_clone(arg);
26725 uint32_t ret_ref = 0;
26726 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26727 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26728 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26729 ret_ref = (uintptr_t)ret_var.inner;
26730 if (ret_var.is_owned) {
26735 uint32_t __attribute__((export_name("TS_ChannelDetails_clone_ptr"))) TS_ChannelDetails_clone_ptr(uint32_t arg) {
26736 LDKChannelDetails arg_conv;
26737 arg_conv.inner = (void*)(arg & (~1));
26738 arg_conv.is_owned = false;
26739 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
26740 uint32_t ret_conv = ChannelDetails_clone_ptr(&arg_conv);
26744 uint32_t __attribute__((export_name("TS_ChannelDetails_clone"))) TS_ChannelDetails_clone(uint32_t orig) {
26745 LDKChannelDetails orig_conv;
26746 orig_conv.inner = (void*)(orig & (~1));
26747 orig_conv.is_owned = false;
26748 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
26749 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
26750 uint32_t ret_ref = 0;
26751 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26752 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26753 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
26754 ret_ref = (uintptr_t)ret_var.inner;
26755 if (ret_var.is_owned) {
26761 uint32_t __attribute__((export_name("TS_ChannelDetails_get_inbound_payment_scid"))) TS_ChannelDetails_get_inbound_payment_scid(uint32_t this_arg) {
26762 LDKChannelDetails this_arg_conv;
26763 this_arg_conv.inner = (void*)(this_arg & (~1));
26764 this_arg_conv.is_owned = false;
26765 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26766 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26767 *ret_copy = ChannelDetails_get_inbound_payment_scid(&this_arg_conv);
26768 uint32_t ret_ref = (uintptr_t)ret_copy;
26772 uint32_t __attribute__((export_name("TS_ChannelDetails_get_outbound_payment_scid"))) TS_ChannelDetails_get_outbound_payment_scid(uint32_t this_arg) {
26773 LDKChannelDetails this_arg_conv;
26774 this_arg_conv.inner = (void*)(this_arg & (~1));
26775 this_arg_conv.is_owned = false;
26776 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
26777 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
26778 *ret_copy = ChannelDetails_get_outbound_payment_scid(&this_arg_conv);
26779 uint32_t ret_ref = (uintptr_t)ret_copy;
26783 void __attribute__((export_name("TS_PaymentSendFailure_free"))) TS_PaymentSendFailure_free(uint32_t this_ptr) {
26784 if ((this_ptr & 1) != 0) return;
26785 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
26786 CHECK_ACCESS(this_ptr_ptr);
26787 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(this_ptr_ptr);
26788 FREE((void*)this_ptr);
26789 PaymentSendFailure_free(this_ptr_conv);
26792 static inline uintptr_t PaymentSendFailure_clone_ptr(LDKPaymentSendFailure *NONNULL_PTR arg) {
26793 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26794 *ret_copy = PaymentSendFailure_clone(arg);
26795 uint32_t ret_ref = (uintptr_t)ret_copy;
26798 uint32_t __attribute__((export_name("TS_PaymentSendFailure_clone_ptr"))) TS_PaymentSendFailure_clone_ptr(uint32_t arg) {
26799 LDKPaymentSendFailure* arg_conv = (LDKPaymentSendFailure*)arg;
26800 uint32_t ret_conv = PaymentSendFailure_clone_ptr(arg_conv);
26804 uint32_t __attribute__((export_name("TS_PaymentSendFailure_clone"))) TS_PaymentSendFailure_clone(uint32_t orig) {
26805 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
26806 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26807 *ret_copy = PaymentSendFailure_clone(orig_conv);
26808 uint32_t ret_ref = (uintptr_t)ret_copy;
26812 uint32_t __attribute__((export_name("TS_PaymentSendFailure_parameter_error"))) TS_PaymentSendFailure_parameter_error(uint32_t a) {
26813 void* a_ptr = (void*)(((uintptr_t)a) & ~1);
26814 CHECK_ACCESS(a_ptr);
26815 LDKAPIError a_conv = *(LDKAPIError*)(a_ptr);
26816 a_conv = APIError_clone((LDKAPIError*)(((uintptr_t)a) & ~1));
26817 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26818 *ret_copy = PaymentSendFailure_parameter_error(a_conv);
26819 uint32_t ret_ref = (uintptr_t)ret_copy;
26823 uint32_t __attribute__((export_name("TS_PaymentSendFailure_path_parameter_error"))) TS_PaymentSendFailure_path_parameter_error(uint32_tArray a) {
26824 LDKCVec_CResult_NoneAPIErrorZZ a_constr;
26825 a_constr.datalen = a->arr_len;
26826 if (a_constr.datalen > 0)
26827 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
26829 a_constr.data = NULL;
26830 uint32_t* a_vals = a->elems;
26831 for (size_t w = 0; w < a_constr.datalen; w++) {
26832 uint32_t a_conv_22 = a_vals[w];
26833 void* a_conv_22_ptr = (void*)(((uintptr_t)a_conv_22) & ~1);
26834 CHECK_ACCESS(a_conv_22_ptr);
26835 LDKCResult_NoneAPIErrorZ a_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(a_conv_22_ptr);
26836 a_conv_22_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uintptr_t)a_conv_22) & ~1));
26837 a_constr.data[w] = a_conv_22_conv;
26840 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26841 *ret_copy = PaymentSendFailure_path_parameter_error(a_constr);
26842 uint32_t ret_ref = (uintptr_t)ret_copy;
26846 uint32_t __attribute__((export_name("TS_PaymentSendFailure_all_failed_retry_safe"))) TS_PaymentSendFailure_all_failed_retry_safe(uint32_tArray a) {
26847 LDKCVec_APIErrorZ a_constr;
26848 a_constr.datalen = a->arr_len;
26849 if (a_constr.datalen > 0)
26850 a_constr.data = MALLOC(a_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
26852 a_constr.data = NULL;
26853 uint32_t* a_vals = a->elems;
26854 for (size_t k = 0; k < a_constr.datalen; k++) {
26855 uint32_t a_conv_10 = a_vals[k];
26856 void* a_conv_10_ptr = (void*)(((uintptr_t)a_conv_10) & ~1);
26857 CHECK_ACCESS(a_conv_10_ptr);
26858 LDKAPIError a_conv_10_conv = *(LDKAPIError*)(a_conv_10_ptr);
26859 a_conv_10_conv = APIError_clone((LDKAPIError*)(((uintptr_t)a_conv_10) & ~1));
26860 a_constr.data[k] = a_conv_10_conv;
26863 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26864 *ret_copy = PaymentSendFailure_all_failed_retry_safe(a_constr);
26865 uint32_t ret_ref = (uintptr_t)ret_copy;
26869 uint32_t __attribute__((export_name("TS_PaymentSendFailure_partial_failure"))) TS_PaymentSendFailure_partial_failure(uint32_tArray results, uint32_t failed_paths_retry, int8_tArray payment_id) {
26870 LDKCVec_CResult_NoneAPIErrorZZ results_constr;
26871 results_constr.datalen = results->arr_len;
26872 if (results_constr.datalen > 0)
26873 results_constr.data = MALLOC(results_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
26875 results_constr.data = NULL;
26876 uint32_t* results_vals = results->elems;
26877 for (size_t w = 0; w < results_constr.datalen; w++) {
26878 uint32_t results_conv_22 = results_vals[w];
26879 void* results_conv_22_ptr = (void*)(((uintptr_t)results_conv_22) & ~1);
26880 CHECK_ACCESS(results_conv_22_ptr);
26881 LDKCResult_NoneAPIErrorZ results_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(results_conv_22_ptr);
26882 results_constr.data[w] = results_conv_22_conv;
26885 LDKRouteParameters failed_paths_retry_conv;
26886 failed_paths_retry_conv.inner = (void*)(failed_paths_retry & (~1));
26887 failed_paths_retry_conv.is_owned = (failed_paths_retry & 1) || (failed_paths_retry == 0);
26888 CHECK_INNER_FIELD_ACCESS_OR_NULL(failed_paths_retry_conv);
26889 failed_paths_retry_conv = RouteParameters_clone(&failed_paths_retry_conv);
26890 LDKThirtyTwoBytes payment_id_ref;
26891 CHECK(payment_id->arr_len == 32);
26892 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
26893 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
26894 *ret_copy = PaymentSendFailure_partial_failure(results_constr, failed_paths_retry_conv, payment_id_ref);
26895 uint32_t ret_ref = (uintptr_t)ret_copy;
26899 void __attribute__((export_name("TS_PhantomRouteHints_free"))) TS_PhantomRouteHints_free(uint32_t this_obj) {
26900 LDKPhantomRouteHints this_obj_conv;
26901 this_obj_conv.inner = (void*)(this_obj & (~1));
26902 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
26903 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
26904 PhantomRouteHints_free(this_obj_conv);
26907 uint32_tArray __attribute__((export_name("TS_PhantomRouteHints_get_channels"))) TS_PhantomRouteHints_get_channels(uint32_t this_ptr) {
26908 LDKPhantomRouteHints this_ptr_conv;
26909 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26910 this_ptr_conv.is_owned = false;
26911 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26912 LDKCVec_ChannelDetailsZ ret_var = PhantomRouteHints_get_channels(&this_ptr_conv);
26913 uint32_tArray ret_arr = NULL;
26914 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
26915 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
26916 for (size_t q = 0; q < ret_var.datalen; q++) {
26917 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
26918 uint32_t ret_conv_16_ref = 0;
26919 CHECK((((uintptr_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
26920 CHECK((((uintptr_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
26921 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
26922 ret_conv_16_ref = (uintptr_t)ret_conv_16_var.inner;
26923 if (ret_conv_16_var.is_owned) {
26924 ret_conv_16_ref |= 1;
26926 ret_arr_ptr[q] = ret_conv_16_ref;
26929 FREE(ret_var.data);
26933 void __attribute__((export_name("TS_PhantomRouteHints_set_channels"))) TS_PhantomRouteHints_set_channels(uint32_t this_ptr, uint32_tArray val) {
26934 LDKPhantomRouteHints this_ptr_conv;
26935 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26936 this_ptr_conv.is_owned = false;
26937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26938 LDKCVec_ChannelDetailsZ val_constr;
26939 val_constr.datalen = val->arr_len;
26940 if (val_constr.datalen > 0)
26941 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
26943 val_constr.data = NULL;
26944 uint32_t* val_vals = val->elems;
26945 for (size_t q = 0; q < val_constr.datalen; q++) {
26946 uint32_t val_conv_16 = val_vals[q];
26947 LDKChannelDetails val_conv_16_conv;
26948 val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
26949 val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
26950 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
26951 val_conv_16_conv = ChannelDetails_clone(&val_conv_16_conv);
26952 val_constr.data[q] = val_conv_16_conv;
26955 PhantomRouteHints_set_channels(&this_ptr_conv, val_constr);
26958 int64_t __attribute__((export_name("TS_PhantomRouteHints_get_phantom_scid"))) TS_PhantomRouteHints_get_phantom_scid(uint32_t this_ptr) {
26959 LDKPhantomRouteHints this_ptr_conv;
26960 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26961 this_ptr_conv.is_owned = false;
26962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26963 int64_t ret_conv = PhantomRouteHints_get_phantom_scid(&this_ptr_conv);
26967 void __attribute__((export_name("TS_PhantomRouteHints_set_phantom_scid"))) TS_PhantomRouteHints_set_phantom_scid(uint32_t this_ptr, int64_t val) {
26968 LDKPhantomRouteHints this_ptr_conv;
26969 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26970 this_ptr_conv.is_owned = false;
26971 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26972 PhantomRouteHints_set_phantom_scid(&this_ptr_conv, val);
26975 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_get_real_node_pubkey"))) TS_PhantomRouteHints_get_real_node_pubkey(uint32_t this_ptr) {
26976 LDKPhantomRouteHints this_ptr_conv;
26977 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26978 this_ptr_conv.is_owned = false;
26979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26980 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
26981 memcpy(ret_arr->elems, PhantomRouteHints_get_real_node_pubkey(&this_ptr_conv).compressed_form, 33);
26985 void __attribute__((export_name("TS_PhantomRouteHints_set_real_node_pubkey"))) TS_PhantomRouteHints_set_real_node_pubkey(uint32_t this_ptr, int8_tArray val) {
26986 LDKPhantomRouteHints this_ptr_conv;
26987 this_ptr_conv.inner = (void*)(this_ptr & (~1));
26988 this_ptr_conv.is_owned = false;
26989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
26990 LDKPublicKey val_ref;
26991 CHECK(val->arr_len == 33);
26992 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
26993 PhantomRouteHints_set_real_node_pubkey(&this_ptr_conv, val_ref);
26996 uint32_t __attribute__((export_name("TS_PhantomRouteHints_new"))) TS_PhantomRouteHints_new(uint32_tArray channels_arg, int64_t phantom_scid_arg, int8_tArray real_node_pubkey_arg) {
26997 LDKCVec_ChannelDetailsZ channels_arg_constr;
26998 channels_arg_constr.datalen = channels_arg->arr_len;
26999 if (channels_arg_constr.datalen > 0)
27000 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
27002 channels_arg_constr.data = NULL;
27003 uint32_t* channels_arg_vals = channels_arg->elems;
27004 for (size_t q = 0; q < channels_arg_constr.datalen; q++) {
27005 uint32_t channels_arg_conv_16 = channels_arg_vals[q];
27006 LDKChannelDetails channels_arg_conv_16_conv;
27007 channels_arg_conv_16_conv.inner = (void*)(channels_arg_conv_16 & (~1));
27008 channels_arg_conv_16_conv.is_owned = (channels_arg_conv_16 & 1) || (channels_arg_conv_16 == 0);
27009 CHECK_INNER_FIELD_ACCESS_OR_NULL(channels_arg_conv_16_conv);
27010 channels_arg_conv_16_conv = ChannelDetails_clone(&channels_arg_conv_16_conv);
27011 channels_arg_constr.data[q] = channels_arg_conv_16_conv;
27013 FREE(channels_arg);
27014 LDKPublicKey real_node_pubkey_arg_ref;
27015 CHECK(real_node_pubkey_arg->arr_len == 33);
27016 memcpy(real_node_pubkey_arg_ref.compressed_form, real_node_pubkey_arg->elems, 33); FREE(real_node_pubkey_arg);
27017 LDKPhantomRouteHints ret_var = PhantomRouteHints_new(channels_arg_constr, phantom_scid_arg, real_node_pubkey_arg_ref);
27018 uint32_t ret_ref = 0;
27019 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27020 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27021 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27022 ret_ref = (uintptr_t)ret_var.inner;
27023 if (ret_var.is_owned) {
27029 static inline uintptr_t PhantomRouteHints_clone_ptr(LDKPhantomRouteHints *NONNULL_PTR arg) {
27030 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(arg);
27031 uint32_t ret_ref = 0;
27032 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27033 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27034 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27035 ret_ref = (uintptr_t)ret_var.inner;
27036 if (ret_var.is_owned) {
27041 uint32_t __attribute__((export_name("TS_PhantomRouteHints_clone_ptr"))) TS_PhantomRouteHints_clone_ptr(uint32_t arg) {
27042 LDKPhantomRouteHints arg_conv;
27043 arg_conv.inner = (void*)(arg & (~1));
27044 arg_conv.is_owned = false;
27045 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
27046 uint32_t ret_conv = PhantomRouteHints_clone_ptr(&arg_conv);
27050 uint32_t __attribute__((export_name("TS_PhantomRouteHints_clone"))) TS_PhantomRouteHints_clone(uint32_t orig) {
27051 LDKPhantomRouteHints orig_conv;
27052 orig_conv.inner = (void*)(orig & (~1));
27053 orig_conv.is_owned = false;
27054 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
27055 LDKPhantomRouteHints ret_var = PhantomRouteHints_clone(&orig_conv);
27056 uint32_t ret_ref = 0;
27057 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27058 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27059 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27060 ret_ref = (uintptr_t)ret_var.inner;
27061 if (ret_var.is_owned) {
27067 uint32_t __attribute__((export_name("TS_ChannelManager_new"))) TS_ChannelManager_new(uint32_t fee_est, uint32_t chain_monitor, uint32_t tx_broadcaster, uint32_t logger, uint32_t keys_manager, uint32_t config, uint32_t params) {
27068 void* fee_est_ptr = (void*)(((uintptr_t)fee_est) & ~1);
27069 CHECK_ACCESS(fee_est_ptr);
27070 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(fee_est_ptr);
27071 if (fee_est_conv.free == LDKFeeEstimator_JCalls_free) {
27072 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27073 LDKFeeEstimator_JCalls_cloned(&fee_est_conv);
27075 void* chain_monitor_ptr = (void*)(((uintptr_t)chain_monitor) & ~1);
27076 CHECK_ACCESS(chain_monitor_ptr);
27077 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
27078 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
27079 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27080 LDKWatch_JCalls_cloned(&chain_monitor_conv);
27082 void* tx_broadcaster_ptr = (void*)(((uintptr_t)tx_broadcaster) & ~1);
27083 CHECK_ACCESS(tx_broadcaster_ptr);
27084 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
27085 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
27086 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27087 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
27089 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
27090 CHECK_ACCESS(logger_ptr);
27091 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
27092 if (logger_conv.free == LDKLogger_JCalls_free) {
27093 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27094 LDKLogger_JCalls_cloned(&logger_conv);
27096 void* keys_manager_ptr = (void*)(((uintptr_t)keys_manager) & ~1);
27097 CHECK_ACCESS(keys_manager_ptr);
27098 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
27099 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
27100 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27101 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
27103 LDKUserConfig config_conv;
27104 config_conv.inner = (void*)(config & (~1));
27105 config_conv.is_owned = (config & 1) || (config == 0);
27106 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
27107 config_conv = UserConfig_clone(&config_conv);
27108 LDKChainParameters params_conv;
27109 params_conv.inner = (void*)(params & (~1));
27110 params_conv.is_owned = (params & 1) || (params == 0);
27111 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
27112 params_conv = ChainParameters_clone(¶ms_conv);
27113 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
27114 uint32_t ret_ref = 0;
27115 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27116 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27117 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27118 ret_ref = (uintptr_t)ret_var.inner;
27119 if (ret_var.is_owned) {
27125 uint32_t __attribute__((export_name("TS_ChannelManager_get_current_default_configuration"))) TS_ChannelManager_get_current_default_configuration(uint32_t this_arg) {
27126 LDKChannelManager this_arg_conv;
27127 this_arg_conv.inner = (void*)(this_arg & (~1));
27128 this_arg_conv.is_owned = false;
27129 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27130 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
27131 uint32_t ret_ref = 0;
27132 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27133 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27134 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27135 ret_ref = (uintptr_t)ret_var.inner;
27136 if (ret_var.is_owned) {
27142 uint32_t __attribute__((export_name("TS_ChannelManager_create_channel"))) TS_ChannelManager_create_channel(uint32_t this_arg, int8_tArray their_network_key, int64_t channel_value_satoshis, int64_t push_msat, int64_t user_channel_id, uint32_t override_config) {
27143 LDKChannelManager this_arg_conv;
27144 this_arg_conv.inner = (void*)(this_arg & (~1));
27145 this_arg_conv.is_owned = false;
27146 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27147 LDKPublicKey their_network_key_ref;
27148 CHECK(their_network_key->arr_len == 33);
27149 memcpy(their_network_key_ref.compressed_form, their_network_key->elems, 33); FREE(their_network_key);
27150 LDKUserConfig override_config_conv;
27151 override_config_conv.inner = (void*)(override_config & (~1));
27152 override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
27153 CHECK_INNER_FIELD_ACCESS_OR_NULL(override_config_conv);
27154 override_config_conv = UserConfig_clone(&override_config_conv);
27155 LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ");
27156 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv);
27157 return (uint32_t)ret_conv;
27160 uint32_tArray __attribute__((export_name("TS_ChannelManager_list_channels"))) TS_ChannelManager_list_channels(uint32_t this_arg) {
27161 LDKChannelManager this_arg_conv;
27162 this_arg_conv.inner = (void*)(this_arg & (~1));
27163 this_arg_conv.is_owned = false;
27164 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27165 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
27166 uint32_tArray ret_arr = NULL;
27167 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
27168 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
27169 for (size_t q = 0; q < ret_var.datalen; q++) {
27170 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
27171 uint32_t ret_conv_16_ref = 0;
27172 CHECK((((uintptr_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27173 CHECK((((uintptr_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27174 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
27175 ret_conv_16_ref = (uintptr_t)ret_conv_16_var.inner;
27176 if (ret_conv_16_var.is_owned) {
27177 ret_conv_16_ref |= 1;
27179 ret_arr_ptr[q] = ret_conv_16_ref;
27182 FREE(ret_var.data);
27186 uint32_tArray __attribute__((export_name("TS_ChannelManager_list_usable_channels"))) TS_ChannelManager_list_usable_channels(uint32_t this_arg) {
27187 LDKChannelManager this_arg_conv;
27188 this_arg_conv.inner = (void*)(this_arg & (~1));
27189 this_arg_conv.is_owned = false;
27190 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27191 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
27192 uint32_tArray ret_arr = NULL;
27193 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
27194 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
27195 for (size_t q = 0; q < ret_var.datalen; q++) {
27196 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
27197 uint32_t ret_conv_16_ref = 0;
27198 CHECK((((uintptr_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27199 CHECK((((uintptr_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27200 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
27201 ret_conv_16_ref = (uintptr_t)ret_conv_16_var.inner;
27202 if (ret_conv_16_var.is_owned) {
27203 ret_conv_16_ref |= 1;
27205 ret_arr_ptr[q] = ret_conv_16_ref;
27208 FREE(ret_var.data);
27212 uint32_t __attribute__((export_name("TS_ChannelManager_close_channel"))) TS_ChannelManager_close_channel(uint32_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
27213 LDKChannelManager this_arg_conv;
27214 this_arg_conv.inner = (void*)(this_arg & (~1));
27215 this_arg_conv.is_owned = false;
27216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27217 unsigned char channel_id_arr[32];
27218 CHECK(channel_id->arr_len == 32);
27219 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
27220 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
27221 LDKPublicKey counterparty_node_id_ref;
27222 CHECK(counterparty_node_id->arr_len == 33);
27223 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27224 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27225 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
27226 return (uint32_t)ret_conv;
27229 uint32_t __attribute__((export_name("TS_ChannelManager_close_channel_with_target_feerate"))) TS_ChannelManager_close_channel_with_target_feerate(uint32_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id, int32_t target_feerate_sats_per_1000_weight) {
27230 LDKChannelManager this_arg_conv;
27231 this_arg_conv.inner = (void*)(this_arg & (~1));
27232 this_arg_conv.is_owned = false;
27233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27234 unsigned char channel_id_arr[32];
27235 CHECK(channel_id->arr_len == 32);
27236 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
27237 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
27238 LDKPublicKey counterparty_node_id_ref;
27239 CHECK(counterparty_node_id->arr_len == 33);
27240 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27241 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27242 *ret_conv = ChannelManager_close_channel_with_target_feerate(&this_arg_conv, channel_id_ref, counterparty_node_id_ref, target_feerate_sats_per_1000_weight);
27243 return (uint32_t)ret_conv;
27246 uint32_t __attribute__((export_name("TS_ChannelManager_force_close_broadcasting_latest_txn"))) TS_ChannelManager_force_close_broadcasting_latest_txn(uint32_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
27247 LDKChannelManager this_arg_conv;
27248 this_arg_conv.inner = (void*)(this_arg & (~1));
27249 this_arg_conv.is_owned = false;
27250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27251 unsigned char channel_id_arr[32];
27252 CHECK(channel_id->arr_len == 32);
27253 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
27254 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
27255 LDKPublicKey counterparty_node_id_ref;
27256 CHECK(counterparty_node_id->arr_len == 33);
27257 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27258 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27259 *ret_conv = ChannelManager_force_close_broadcasting_latest_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
27260 return (uint32_t)ret_conv;
27263 uint32_t __attribute__((export_name("TS_ChannelManager_force_close_without_broadcasting_txn"))) TS_ChannelManager_force_close_without_broadcasting_txn(uint32_t this_arg, int8_tArray channel_id, int8_tArray counterparty_node_id) {
27264 LDKChannelManager this_arg_conv;
27265 this_arg_conv.inner = (void*)(this_arg & (~1));
27266 this_arg_conv.is_owned = false;
27267 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27268 unsigned char channel_id_arr[32];
27269 CHECK(channel_id->arr_len == 32);
27270 memcpy(channel_id_arr, channel_id->elems, 32); FREE(channel_id);
27271 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
27272 LDKPublicKey counterparty_node_id_ref;
27273 CHECK(counterparty_node_id->arr_len == 33);
27274 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27275 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27276 *ret_conv = ChannelManager_force_close_without_broadcasting_txn(&this_arg_conv, channel_id_ref, counterparty_node_id_ref);
27277 return (uint32_t)ret_conv;
27280 void __attribute__((export_name("TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn"))) TS_ChannelManager_force_close_all_channels_broadcasting_latest_txn(uint32_t this_arg) {
27281 LDKChannelManager this_arg_conv;
27282 this_arg_conv.inner = (void*)(this_arg & (~1));
27283 this_arg_conv.is_owned = false;
27284 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27285 ChannelManager_force_close_all_channels_broadcasting_latest_txn(&this_arg_conv);
27288 void __attribute__((export_name("TS_ChannelManager_force_close_all_channels_without_broadcasting_txn"))) TS_ChannelManager_force_close_all_channels_without_broadcasting_txn(uint32_t this_arg) {
27289 LDKChannelManager this_arg_conv;
27290 this_arg_conv.inner = (void*)(this_arg & (~1));
27291 this_arg_conv.is_owned = false;
27292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27293 ChannelManager_force_close_all_channels_without_broadcasting_txn(&this_arg_conv);
27296 uint32_t __attribute__((export_name("TS_ChannelManager_send_payment"))) TS_ChannelManager_send_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_hash, int8_tArray payment_secret) {
27297 LDKChannelManager this_arg_conv;
27298 this_arg_conv.inner = (void*)(this_arg & (~1));
27299 this_arg_conv.is_owned = false;
27300 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27301 LDKRoute route_conv;
27302 route_conv.inner = (void*)(route & (~1));
27303 route_conv.is_owned = false;
27304 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
27305 LDKThirtyTwoBytes payment_hash_ref;
27306 CHECK(payment_hash->arr_len == 32);
27307 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
27308 LDKThirtyTwoBytes payment_secret_ref;
27309 CHECK(payment_secret->arr_len == 32);
27310 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
27311 LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ");
27312 *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref);
27313 return (uint32_t)ret_conv;
27316 uint32_t __attribute__((export_name("TS_ChannelManager_retry_payment"))) TS_ChannelManager_retry_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_id) {
27317 LDKChannelManager this_arg_conv;
27318 this_arg_conv.inner = (void*)(this_arg & (~1));
27319 this_arg_conv.is_owned = false;
27320 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27321 LDKRoute route_conv;
27322 route_conv.inner = (void*)(route & (~1));
27323 route_conv.is_owned = false;
27324 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
27325 LDKThirtyTwoBytes payment_id_ref;
27326 CHECK(payment_id->arr_len == 32);
27327 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
27328 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
27329 *ret_conv = ChannelManager_retry_payment(&this_arg_conv, &route_conv, payment_id_ref);
27330 return (uint32_t)ret_conv;
27333 void __attribute__((export_name("TS_ChannelManager_abandon_payment"))) TS_ChannelManager_abandon_payment(uint32_t this_arg, int8_tArray payment_id) {
27334 LDKChannelManager this_arg_conv;
27335 this_arg_conv.inner = (void*)(this_arg & (~1));
27336 this_arg_conv.is_owned = false;
27337 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27338 LDKThirtyTwoBytes payment_id_ref;
27339 CHECK(payment_id->arr_len == 32);
27340 memcpy(payment_id_ref.data, payment_id->elems, 32); FREE(payment_id);
27341 ChannelManager_abandon_payment(&this_arg_conv, payment_id_ref);
27344 uint32_t __attribute__((export_name("TS_ChannelManager_send_spontaneous_payment"))) TS_ChannelManager_send_spontaneous_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_preimage) {
27345 LDKChannelManager this_arg_conv;
27346 this_arg_conv.inner = (void*)(this_arg & (~1));
27347 this_arg_conv.is_owned = false;
27348 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27349 LDKRoute route_conv;
27350 route_conv.inner = (void*)(route & (~1));
27351 route_conv.is_owned = false;
27352 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_conv);
27353 LDKThirtyTwoBytes payment_preimage_ref;
27354 CHECK(payment_preimage->arr_len == 32);
27355 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
27356 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
27357 *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_ref);
27358 return (uint32_t)ret_conv;
27361 uint32_t __attribute__((export_name("TS_ChannelManager_send_probe"))) TS_ChannelManager_send_probe(uint32_t this_arg, uint32_tArray hops) {
27362 LDKChannelManager this_arg_conv;
27363 this_arg_conv.inner = (void*)(this_arg & (~1));
27364 this_arg_conv.is_owned = false;
27365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27366 LDKCVec_RouteHopZ hops_constr;
27367 hops_constr.datalen = hops->arr_len;
27368 if (hops_constr.datalen > 0)
27369 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
27371 hops_constr.data = NULL;
27372 uint32_t* hops_vals = hops->elems;
27373 for (size_t k = 0; k < hops_constr.datalen; k++) {
27374 uint32_t hops_conv_10 = hops_vals[k];
27375 LDKRouteHop hops_conv_10_conv;
27376 hops_conv_10_conv.inner = (void*)(hops_conv_10 & (~1));
27377 hops_conv_10_conv.is_owned = (hops_conv_10 & 1) || (hops_conv_10 == 0);
27378 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv_10_conv);
27379 hops_conv_10_conv = RouteHop_clone(&hops_conv_10_conv);
27380 hops_constr.data[k] = hops_conv_10_conv;
27383 LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ");
27384 *ret_conv = ChannelManager_send_probe(&this_arg_conv, hops_constr);
27385 return (uint32_t)ret_conv;
27388 uint32_t __attribute__((export_name("TS_ChannelManager_funding_transaction_generated"))) TS_ChannelManager_funding_transaction_generated(uint32_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int8_tArray funding_transaction) {
27389 LDKChannelManager this_arg_conv;
27390 this_arg_conv.inner = (void*)(this_arg & (~1));
27391 this_arg_conv.is_owned = false;
27392 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27393 unsigned char temporary_channel_id_arr[32];
27394 CHECK(temporary_channel_id->arr_len == 32);
27395 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
27396 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
27397 LDKPublicKey counterparty_node_id_ref;
27398 CHECK(counterparty_node_id->arr_len == 33);
27399 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27400 LDKTransaction funding_transaction_ref;
27401 funding_transaction_ref.datalen = funding_transaction->arr_len;
27402 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
27403 memcpy(funding_transaction_ref.data, funding_transaction->elems, funding_transaction_ref.datalen); FREE(funding_transaction);
27404 funding_transaction_ref.data_is_owned = true;
27405 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27406 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, funding_transaction_ref);
27407 return (uint32_t)ret_conv;
27410 void __attribute__((export_name("TS_ChannelManager_broadcast_node_announcement"))) TS_ChannelManager_broadcast_node_announcement(uint32_t this_arg, int8_tArray rgb, int8_tArray alias, uint32_tArray addresses) {
27411 LDKChannelManager this_arg_conv;
27412 this_arg_conv.inner = (void*)(this_arg & (~1));
27413 this_arg_conv.is_owned = false;
27414 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27415 LDKThreeBytes rgb_ref;
27416 CHECK(rgb->arr_len == 3);
27417 memcpy(rgb_ref.data, rgb->elems, 3); FREE(rgb);
27418 LDKThirtyTwoBytes alias_ref;
27419 CHECK(alias->arr_len == 32);
27420 memcpy(alias_ref.data, alias->elems, 32); FREE(alias);
27421 LDKCVec_NetAddressZ addresses_constr;
27422 addresses_constr.datalen = addresses->arr_len;
27423 if (addresses_constr.datalen > 0)
27424 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
27426 addresses_constr.data = NULL;
27427 uint32_t* addresses_vals = addresses->elems;
27428 for (size_t m = 0; m < addresses_constr.datalen; m++) {
27429 uint32_t addresses_conv_12 = addresses_vals[m];
27430 void* addresses_conv_12_ptr = (void*)(((uintptr_t)addresses_conv_12) & ~1);
27431 CHECK_ACCESS(addresses_conv_12_ptr);
27432 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(addresses_conv_12_ptr);
27433 addresses_constr.data[m] = addresses_conv_12_conv;
27436 ChannelManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
27439 uint32_t __attribute__((export_name("TS_ChannelManager_update_channel_config"))) TS_ChannelManager_update_channel_config(uint32_t this_arg, int8_tArray counterparty_node_id, ptrArray channel_ids, uint32_t config) {
27440 LDKChannelManager this_arg_conv;
27441 this_arg_conv.inner = (void*)(this_arg & (~1));
27442 this_arg_conv.is_owned = false;
27443 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27444 LDKPublicKey counterparty_node_id_ref;
27445 CHECK(counterparty_node_id->arr_len == 33);
27446 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27447 LDKCVec_ThirtyTwoBytesZ channel_ids_constr;
27448 channel_ids_constr.datalen = channel_ids->arr_len;
27449 if (channel_ids_constr.datalen > 0)
27450 channel_ids_constr.data = MALLOC(channel_ids_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_ThirtyTwoBytesZ Elements");
27452 channel_ids_constr.data = NULL;
27453 int8_tArray* channel_ids_vals = (void*) channel_ids->elems;
27454 for (size_t m = 0; m < channel_ids_constr.datalen; m++) {
27455 int8_tArray channel_ids_conv_12 = channel_ids_vals[m];
27456 LDKThirtyTwoBytes channel_ids_conv_12_ref;
27457 CHECK(channel_ids_conv_12->arr_len == 32);
27458 memcpy(channel_ids_conv_12_ref.data, channel_ids_conv_12->elems, 32); FREE(channel_ids_conv_12);
27459 channel_ids_constr.data[m] = channel_ids_conv_12_ref;
27462 LDKChannelConfig config_conv;
27463 config_conv.inner = (void*)(config & (~1));
27464 config_conv.is_owned = false;
27465 CHECK_INNER_FIELD_ACCESS_OR_NULL(config_conv);
27466 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27467 *ret_conv = ChannelManager_update_channel_config(&this_arg_conv, counterparty_node_id_ref, channel_ids_constr, &config_conv);
27468 return (uint32_t)ret_conv;
27471 void __attribute__((export_name("TS_ChannelManager_process_pending_htlc_forwards"))) TS_ChannelManager_process_pending_htlc_forwards(uint32_t this_arg) {
27472 LDKChannelManager this_arg_conv;
27473 this_arg_conv.inner = (void*)(this_arg & (~1));
27474 this_arg_conv.is_owned = false;
27475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27476 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
27479 void __attribute__((export_name("TS_ChannelManager_timer_tick_occurred"))) TS_ChannelManager_timer_tick_occurred(uint32_t this_arg) {
27480 LDKChannelManager this_arg_conv;
27481 this_arg_conv.inner = (void*)(this_arg & (~1));
27482 this_arg_conv.is_owned = false;
27483 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27484 ChannelManager_timer_tick_occurred(&this_arg_conv);
27487 void __attribute__((export_name("TS_ChannelManager_fail_htlc_backwards"))) TS_ChannelManager_fail_htlc_backwards(uint32_t this_arg, int8_tArray payment_hash) {
27488 LDKChannelManager this_arg_conv;
27489 this_arg_conv.inner = (void*)(this_arg & (~1));
27490 this_arg_conv.is_owned = false;
27491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27492 unsigned char payment_hash_arr[32];
27493 CHECK(payment_hash->arr_len == 32);
27494 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
27495 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
27496 ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
27499 void __attribute__((export_name("TS_ChannelManager_claim_funds"))) TS_ChannelManager_claim_funds(uint32_t this_arg, int8_tArray payment_preimage) {
27500 LDKChannelManager this_arg_conv;
27501 this_arg_conv.inner = (void*)(this_arg & (~1));
27502 this_arg_conv.is_owned = false;
27503 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27504 LDKThirtyTwoBytes payment_preimage_ref;
27505 CHECK(payment_preimage->arr_len == 32);
27506 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
27507 ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
27510 int8_tArray __attribute__((export_name("TS_ChannelManager_get_our_node_id"))) TS_ChannelManager_get_our_node_id(uint32_t this_arg) {
27511 LDKChannelManager this_arg_conv;
27512 this_arg_conv.inner = (void*)(this_arg & (~1));
27513 this_arg_conv.is_owned = false;
27514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27515 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
27516 memcpy(ret_arr->elems, ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
27520 uint32_t __attribute__((export_name("TS_ChannelManager_accept_inbound_channel"))) TS_ChannelManager_accept_inbound_channel(uint32_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int64_t user_channel_id) {
27521 LDKChannelManager this_arg_conv;
27522 this_arg_conv.inner = (void*)(this_arg & (~1));
27523 this_arg_conv.is_owned = false;
27524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27525 unsigned char temporary_channel_id_arr[32];
27526 CHECK(temporary_channel_id->arr_len == 32);
27527 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
27528 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
27529 LDKPublicKey counterparty_node_id_ref;
27530 CHECK(counterparty_node_id->arr_len == 33);
27531 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27532 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27533 *ret_conv = ChannelManager_accept_inbound_channel(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id);
27534 return (uint32_t)ret_conv;
27537 uint32_t __attribute__((export_name("TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf"))) TS_ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(uint32_t this_arg, int8_tArray temporary_channel_id, int8_tArray counterparty_node_id, int64_t user_channel_id) {
27538 LDKChannelManager this_arg_conv;
27539 this_arg_conv.inner = (void*)(this_arg & (~1));
27540 this_arg_conv.is_owned = false;
27541 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27542 unsigned char temporary_channel_id_arr[32];
27543 CHECK(temporary_channel_id->arr_len == 32);
27544 memcpy(temporary_channel_id_arr, temporary_channel_id->elems, 32); FREE(temporary_channel_id);
27545 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
27546 LDKPublicKey counterparty_node_id_ref;
27547 CHECK(counterparty_node_id->arr_len == 33);
27548 memcpy(counterparty_node_id_ref.compressed_form, counterparty_node_id->elems, 33); FREE(counterparty_node_id);
27549 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
27550 *ret_conv = ChannelManager_accept_inbound_channel_from_trusted_peer_0conf(&this_arg_conv, temporary_channel_id_ref, counterparty_node_id_ref, user_channel_id);
27551 return (uint32_t)ret_conv;
27554 uint32_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment"))) TS_ChannelManager_create_inbound_payment(uint32_t this_arg, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs) {
27555 LDKChannelManager this_arg_conv;
27556 this_arg_conv.inner = (void*)(this_arg & (~1));
27557 this_arg_conv.is_owned = false;
27558 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27559 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
27560 CHECK_ACCESS(min_value_msat_ptr);
27561 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
27562 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
27563 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
27564 *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
27565 return (uint32_t)ret_conv;
27568 uint32_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_legacy"))) TS_ChannelManager_create_inbound_payment_legacy(uint32_t this_arg, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs) {
27569 LDKChannelManager this_arg_conv;
27570 this_arg_conv.inner = (void*)(this_arg & (~1));
27571 this_arg_conv.is_owned = false;
27572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27573 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
27574 CHECK_ACCESS(min_value_msat_ptr);
27575 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
27576 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
27577 LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZAPIErrorZ");
27578 *ret_conv = ChannelManager_create_inbound_payment_legacy(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs);
27579 return (uint32_t)ret_conv;
27582 uint32_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_for_hash"))) TS_ChannelManager_create_inbound_payment_for_hash(uint32_t this_arg, int8_tArray payment_hash, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs) {
27583 LDKChannelManager this_arg_conv;
27584 this_arg_conv.inner = (void*)(this_arg & (~1));
27585 this_arg_conv.is_owned = false;
27586 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27587 LDKThirtyTwoBytes payment_hash_ref;
27588 CHECK(payment_hash->arr_len == 32);
27589 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
27590 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
27591 CHECK_ACCESS(min_value_msat_ptr);
27592 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
27593 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
27594 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
27595 *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
27596 return (uint32_t)ret_conv;
27599 uint32_t __attribute__((export_name("TS_ChannelManager_create_inbound_payment_for_hash_legacy"))) TS_ChannelManager_create_inbound_payment_for_hash_legacy(uint32_t this_arg, int8_tArray payment_hash, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs) {
27600 LDKChannelManager this_arg_conv;
27601 this_arg_conv.inner = (void*)(this_arg & (~1));
27602 this_arg_conv.is_owned = false;
27603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27604 LDKThirtyTwoBytes payment_hash_ref;
27605 CHECK(payment_hash->arr_len == 32);
27606 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
27607 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
27608 CHECK_ACCESS(min_value_msat_ptr);
27609 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
27610 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
27611 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
27612 *ret_conv = ChannelManager_create_inbound_payment_for_hash_legacy(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs);
27613 return (uint32_t)ret_conv;
27616 uint32_t __attribute__((export_name("TS_ChannelManager_get_payment_preimage"))) TS_ChannelManager_get_payment_preimage(uint32_t this_arg, int8_tArray payment_hash, int8_tArray payment_secret) {
27617 LDKChannelManager this_arg_conv;
27618 this_arg_conv.inner = (void*)(this_arg & (~1));
27619 this_arg_conv.is_owned = false;
27620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27621 LDKThirtyTwoBytes payment_hash_ref;
27622 CHECK(payment_hash->arr_len == 32);
27623 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
27624 LDKThirtyTwoBytes payment_secret_ref;
27625 CHECK(payment_secret->arr_len == 32);
27626 memcpy(payment_secret_ref.data, payment_secret->elems, 32); FREE(payment_secret);
27627 LDKCResult_PaymentPreimageAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentPreimageAPIErrorZ), "LDKCResult_PaymentPreimageAPIErrorZ");
27628 *ret_conv = ChannelManager_get_payment_preimage(&this_arg_conv, payment_hash_ref, payment_secret_ref);
27629 return (uint32_t)ret_conv;
27632 int64_t __attribute__((export_name("TS_ChannelManager_get_phantom_scid"))) TS_ChannelManager_get_phantom_scid(uint32_t this_arg) {
27633 LDKChannelManager this_arg_conv;
27634 this_arg_conv.inner = (void*)(this_arg & (~1));
27635 this_arg_conv.is_owned = false;
27636 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27637 int64_t ret_conv = ChannelManager_get_phantom_scid(&this_arg_conv);
27641 uint32_t __attribute__((export_name("TS_ChannelManager_get_phantom_route_hints"))) TS_ChannelManager_get_phantom_route_hints(uint32_t this_arg) {
27642 LDKChannelManager this_arg_conv;
27643 this_arg_conv.inner = (void*)(this_arg & (~1));
27644 this_arg_conv.is_owned = false;
27645 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27646 LDKPhantomRouteHints ret_var = ChannelManager_get_phantom_route_hints(&this_arg_conv);
27647 uint32_t ret_ref = 0;
27648 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27649 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27650 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27651 ret_ref = (uintptr_t)ret_var.inner;
27652 if (ret_var.is_owned) {
27658 uint32_t __attribute__((export_name("TS_ChannelManager_as_MessageSendEventsProvider"))) TS_ChannelManager_as_MessageSendEventsProvider(uint32_t this_arg) {
27659 LDKChannelManager this_arg_conv;
27660 this_arg_conv.inner = (void*)(this_arg & (~1));
27661 this_arg_conv.is_owned = false;
27662 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27663 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
27664 *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
27665 return (uint32_t)ret_ret;
27668 uint32_t __attribute__((export_name("TS_ChannelManager_as_EventsProvider"))) TS_ChannelManager_as_EventsProvider(uint32_t this_arg) {
27669 LDKChannelManager this_arg_conv;
27670 this_arg_conv.inner = (void*)(this_arg & (~1));
27671 this_arg_conv.is_owned = false;
27672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27673 LDKEventsProvider* ret_ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
27674 *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv);
27675 return (uint32_t)ret_ret;
27678 uint32_t __attribute__((export_name("TS_ChannelManager_as_Listen"))) TS_ChannelManager_as_Listen(uint32_t this_arg) {
27679 LDKChannelManager this_arg_conv;
27680 this_arg_conv.inner = (void*)(this_arg & (~1));
27681 this_arg_conv.is_owned = false;
27682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27683 LDKListen* ret_ret = MALLOC(sizeof(LDKListen), "LDKListen");
27684 *ret_ret = ChannelManager_as_Listen(&this_arg_conv);
27685 return (uint32_t)ret_ret;
27688 uint32_t __attribute__((export_name("TS_ChannelManager_as_Confirm"))) TS_ChannelManager_as_Confirm(uint32_t this_arg) {
27689 LDKChannelManager this_arg_conv;
27690 this_arg_conv.inner = (void*)(this_arg & (~1));
27691 this_arg_conv.is_owned = false;
27692 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27693 LDKConfirm* ret_ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
27694 *ret_ret = ChannelManager_as_Confirm(&this_arg_conv);
27695 return (uint32_t)ret_ret;
27698 void __attribute__((export_name("TS_ChannelManager_await_persistable_update"))) TS_ChannelManager_await_persistable_update(uint32_t this_arg) {
27699 LDKChannelManager this_arg_conv;
27700 this_arg_conv.inner = (void*)(this_arg & (~1));
27701 this_arg_conv.is_owned = false;
27702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27703 ChannelManager_await_persistable_update(&this_arg_conv);
27706 uint32_t __attribute__((export_name("TS_ChannelManager_current_best_block"))) TS_ChannelManager_current_best_block(uint32_t this_arg) {
27707 LDKChannelManager this_arg_conv;
27708 this_arg_conv.inner = (void*)(this_arg & (~1));
27709 this_arg_conv.is_owned = false;
27710 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27711 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
27712 uint32_t ret_ref = 0;
27713 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27714 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27715 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27716 ret_ref = (uintptr_t)ret_var.inner;
27717 if (ret_var.is_owned) {
27723 uint32_t __attribute__((export_name("TS_ChannelManager_as_ChannelMessageHandler"))) TS_ChannelManager_as_ChannelMessageHandler(uint32_t this_arg) {
27724 LDKChannelManager this_arg_conv;
27725 this_arg_conv.inner = (void*)(this_arg & (~1));
27726 this_arg_conv.is_owned = false;
27727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
27728 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
27729 *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
27730 return (uint32_t)ret_ret;
27733 int8_tArray __attribute__((export_name("TS_CounterpartyForwardingInfo_write"))) TS_CounterpartyForwardingInfo_write(uint32_t obj) {
27734 LDKCounterpartyForwardingInfo obj_conv;
27735 obj_conv.inner = (void*)(obj & (~1));
27736 obj_conv.is_owned = false;
27737 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27738 LDKCVec_u8Z ret_var = CounterpartyForwardingInfo_write(&obj_conv);
27739 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27740 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27741 CVec_u8Z_free(ret_var);
27745 uint32_t __attribute__((export_name("TS_CounterpartyForwardingInfo_read"))) TS_CounterpartyForwardingInfo_read(int8_tArray ser) {
27746 LDKu8slice ser_ref;
27747 ser_ref.datalen = ser->arr_len;
27748 ser_ref.data = ser->elems;
27749 LDKCResult_CounterpartyForwardingInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyForwardingInfoDecodeErrorZ), "LDKCResult_CounterpartyForwardingInfoDecodeErrorZ");
27750 *ret_conv = CounterpartyForwardingInfo_read(ser_ref);
27752 return (uint32_t)ret_conv;
27755 int8_tArray __attribute__((export_name("TS_ChannelCounterparty_write"))) TS_ChannelCounterparty_write(uint32_t obj) {
27756 LDKChannelCounterparty obj_conv;
27757 obj_conv.inner = (void*)(obj & (~1));
27758 obj_conv.is_owned = false;
27759 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27760 LDKCVec_u8Z ret_var = ChannelCounterparty_write(&obj_conv);
27761 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27762 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27763 CVec_u8Z_free(ret_var);
27767 uint32_t __attribute__((export_name("TS_ChannelCounterparty_read"))) TS_ChannelCounterparty_read(int8_tArray ser) {
27768 LDKu8slice ser_ref;
27769 ser_ref.datalen = ser->arr_len;
27770 ser_ref.data = ser->elems;
27771 LDKCResult_ChannelCounterpartyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelCounterpartyDecodeErrorZ), "LDKCResult_ChannelCounterpartyDecodeErrorZ");
27772 *ret_conv = ChannelCounterparty_read(ser_ref);
27774 return (uint32_t)ret_conv;
27777 int8_tArray __attribute__((export_name("TS_ChannelDetails_write"))) TS_ChannelDetails_write(uint32_t obj) {
27778 LDKChannelDetails obj_conv;
27779 obj_conv.inner = (void*)(obj & (~1));
27780 obj_conv.is_owned = false;
27781 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27782 LDKCVec_u8Z ret_var = ChannelDetails_write(&obj_conv);
27783 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27784 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27785 CVec_u8Z_free(ret_var);
27789 uint32_t __attribute__((export_name("TS_ChannelDetails_read"))) TS_ChannelDetails_read(int8_tArray ser) {
27790 LDKu8slice ser_ref;
27791 ser_ref.datalen = ser->arr_len;
27792 ser_ref.data = ser->elems;
27793 LDKCResult_ChannelDetailsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelDetailsDecodeErrorZ), "LDKCResult_ChannelDetailsDecodeErrorZ");
27794 *ret_conv = ChannelDetails_read(ser_ref);
27796 return (uint32_t)ret_conv;
27799 int8_tArray __attribute__((export_name("TS_PhantomRouteHints_write"))) TS_PhantomRouteHints_write(uint32_t obj) {
27800 LDKPhantomRouteHints obj_conv;
27801 obj_conv.inner = (void*)(obj & (~1));
27802 obj_conv.is_owned = false;
27803 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27804 LDKCVec_u8Z ret_var = PhantomRouteHints_write(&obj_conv);
27805 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27806 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27807 CVec_u8Z_free(ret_var);
27811 uint32_t __attribute__((export_name("TS_PhantomRouteHints_read"))) TS_PhantomRouteHints_read(int8_tArray ser) {
27812 LDKu8slice ser_ref;
27813 ser_ref.datalen = ser->arr_len;
27814 ser_ref.data = ser->elems;
27815 LDKCResult_PhantomRouteHintsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PhantomRouteHintsDecodeErrorZ), "LDKCResult_PhantomRouteHintsDecodeErrorZ");
27816 *ret_conv = PhantomRouteHints_read(ser_ref);
27818 return (uint32_t)ret_conv;
27821 int8_tArray __attribute__((export_name("TS_ChannelManager_write"))) TS_ChannelManager_write(uint32_t obj) {
27822 LDKChannelManager obj_conv;
27823 obj_conv.inner = (void*)(obj & (~1));
27824 obj_conv.is_owned = false;
27825 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
27826 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
27827 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
27828 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
27829 CVec_u8Z_free(ret_var);
27833 void __attribute__((export_name("TS_ChannelManagerReadArgs_free"))) TS_ChannelManagerReadArgs_free(uint32_t this_obj) {
27834 LDKChannelManagerReadArgs this_obj_conv;
27835 this_obj_conv.inner = (void*)(this_obj & (~1));
27836 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
27837 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
27838 ChannelManagerReadArgs_free(this_obj_conv);
27841 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_keys_manager"))) TS_ChannelManagerReadArgs_get_keys_manager(uint32_t this_ptr) {
27842 LDKChannelManagerReadArgs this_ptr_conv;
27843 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27844 this_ptr_conv.is_owned = false;
27845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27846 // WARNING: This object doesn't live past this scope, needs clone!
27847 uint32_t ret_ret = ((uintptr_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv)) | 1;
27851 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_keys_manager"))) TS_ChannelManagerReadArgs_set_keys_manager(uint32_t this_ptr, uint32_t val) {
27852 LDKChannelManagerReadArgs this_ptr_conv;
27853 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27854 this_ptr_conv.is_owned = false;
27855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27856 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
27857 CHECK_ACCESS(val_ptr);
27858 LDKKeysInterface val_conv = *(LDKKeysInterface*)(val_ptr);
27859 if (val_conv.free == LDKKeysInterface_JCalls_free) {
27860 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27861 LDKKeysInterface_JCalls_cloned(&val_conv);
27863 ChannelManagerReadArgs_set_keys_manager(&this_ptr_conv, val_conv);
27866 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_fee_estimator"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint32_t this_ptr) {
27867 LDKChannelManagerReadArgs this_ptr_conv;
27868 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27869 this_ptr_conv.is_owned = false;
27870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27871 // WARNING: This object doesn't live past this scope, needs clone!
27872 uint32_t ret_ret = ((uintptr_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv)) | 1;
27876 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_fee_estimator"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint32_t this_ptr, uint32_t val) {
27877 LDKChannelManagerReadArgs this_ptr_conv;
27878 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27879 this_ptr_conv.is_owned = false;
27880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27881 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
27882 CHECK_ACCESS(val_ptr);
27883 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(val_ptr);
27884 if (val_conv.free == LDKFeeEstimator_JCalls_free) {
27885 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27886 LDKFeeEstimator_JCalls_cloned(&val_conv);
27888 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
27891 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_chain_monitor"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint32_t this_ptr) {
27892 LDKChannelManagerReadArgs this_ptr_conv;
27893 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27894 this_ptr_conv.is_owned = false;
27895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27896 // WARNING: This object doesn't live past this scope, needs clone!
27897 uint32_t ret_ret = ((uintptr_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv)) | 1;
27901 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_chain_monitor"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint32_t this_ptr, uint32_t val) {
27902 LDKChannelManagerReadArgs this_ptr_conv;
27903 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27904 this_ptr_conv.is_owned = false;
27905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27906 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
27907 CHECK_ACCESS(val_ptr);
27908 LDKWatch val_conv = *(LDKWatch*)(val_ptr);
27909 if (val_conv.free == LDKWatch_JCalls_free) {
27910 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27911 LDKWatch_JCalls_cloned(&val_conv);
27913 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
27916 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_tx_broadcaster"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint32_t this_ptr) {
27917 LDKChannelManagerReadArgs this_ptr_conv;
27918 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27919 this_ptr_conv.is_owned = false;
27920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27921 // WARNING: This object doesn't live past this scope, needs clone!
27922 uint32_t ret_ret = ((uintptr_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv)) | 1;
27926 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_tx_broadcaster"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint32_t this_ptr, uint32_t val) {
27927 LDKChannelManagerReadArgs this_ptr_conv;
27928 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27929 this_ptr_conv.is_owned = false;
27930 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27931 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
27932 CHECK_ACCESS(val_ptr);
27933 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(val_ptr);
27934 if (val_conv.free == LDKBroadcasterInterface_JCalls_free) {
27935 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27936 LDKBroadcasterInterface_JCalls_cloned(&val_conv);
27938 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
27941 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_logger"))) TS_ChannelManagerReadArgs_get_logger(uint32_t this_ptr) {
27942 LDKChannelManagerReadArgs this_ptr_conv;
27943 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27944 this_ptr_conv.is_owned = false;
27945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27946 // WARNING: This object doesn't live past this scope, needs clone!
27947 uint32_t ret_ret = ((uintptr_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv)) | 1;
27951 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_logger"))) TS_ChannelManagerReadArgs_set_logger(uint32_t this_ptr, uint32_t val) {
27952 LDKChannelManagerReadArgs this_ptr_conv;
27953 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27954 this_ptr_conv.is_owned = false;
27955 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27956 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
27957 CHECK_ACCESS(val_ptr);
27958 LDKLogger val_conv = *(LDKLogger*)(val_ptr);
27959 if (val_conv.free == LDKLogger_JCalls_free) {
27960 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
27961 LDKLogger_JCalls_cloned(&val_conv);
27963 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
27966 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_get_default_config"))) TS_ChannelManagerReadArgs_get_default_config(uint32_t this_ptr) {
27967 LDKChannelManagerReadArgs this_ptr_conv;
27968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27969 this_ptr_conv.is_owned = false;
27970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27971 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
27972 uint32_t ret_ref = 0;
27973 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
27974 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
27975 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
27976 ret_ref = (uintptr_t)ret_var.inner;
27977 if (ret_var.is_owned) {
27983 void __attribute__((export_name("TS_ChannelManagerReadArgs_set_default_config"))) TS_ChannelManagerReadArgs_set_default_config(uint32_t this_ptr, uint32_t val) {
27984 LDKChannelManagerReadArgs this_ptr_conv;
27985 this_ptr_conv.inner = (void*)(this_ptr & (~1));
27986 this_ptr_conv.is_owned = false;
27987 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
27988 LDKUserConfig val_conv;
27989 val_conv.inner = (void*)(val & (~1));
27990 val_conv.is_owned = (val & 1) || (val == 0);
27991 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
27992 val_conv = UserConfig_clone(&val_conv);
27993 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
27996 uint32_t __attribute__((export_name("TS_ChannelManagerReadArgs_new"))) TS_ChannelManagerReadArgs_new(uint32_t keys_manager, uint32_t fee_estimator, uint32_t chain_monitor, uint32_t tx_broadcaster, uint32_t logger, uint32_t default_config, uint32_tArray channel_monitors) {
27997 void* keys_manager_ptr = (void*)(((uintptr_t)keys_manager) & ~1);
27998 CHECK_ACCESS(keys_manager_ptr);
27999 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
28000 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
28001 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28002 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
28004 void* fee_estimator_ptr = (void*)(((uintptr_t)fee_estimator) & ~1);
28005 CHECK_ACCESS(fee_estimator_ptr);
28006 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(fee_estimator_ptr);
28007 if (fee_estimator_conv.free == LDKFeeEstimator_JCalls_free) {
28008 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28009 LDKFeeEstimator_JCalls_cloned(&fee_estimator_conv);
28011 void* chain_monitor_ptr = (void*)(((uintptr_t)chain_monitor) & ~1);
28012 CHECK_ACCESS(chain_monitor_ptr);
28013 LDKWatch chain_monitor_conv = *(LDKWatch*)(chain_monitor_ptr);
28014 if (chain_monitor_conv.free == LDKWatch_JCalls_free) {
28015 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28016 LDKWatch_JCalls_cloned(&chain_monitor_conv);
28018 void* tx_broadcaster_ptr = (void*)(((uintptr_t)tx_broadcaster) & ~1);
28019 CHECK_ACCESS(tx_broadcaster_ptr);
28020 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(tx_broadcaster_ptr);
28021 if (tx_broadcaster_conv.free == LDKBroadcasterInterface_JCalls_free) {
28022 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28023 LDKBroadcasterInterface_JCalls_cloned(&tx_broadcaster_conv);
28025 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
28026 CHECK_ACCESS(logger_ptr);
28027 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
28028 if (logger_conv.free == LDKLogger_JCalls_free) {
28029 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
28030 LDKLogger_JCalls_cloned(&logger_conv);
28032 LDKUserConfig default_config_conv;
28033 default_config_conv.inner = (void*)(default_config & (~1));
28034 default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
28035 CHECK_INNER_FIELD_ACCESS_OR_NULL(default_config_conv);
28036 default_config_conv = UserConfig_clone(&default_config_conv);
28037 LDKCVec_ChannelMonitorZ channel_monitors_constr;
28038 channel_monitors_constr.datalen = channel_monitors->arr_len;
28039 if (channel_monitors_constr.datalen > 0)
28040 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
28042 channel_monitors_constr.data = NULL;
28043 uint32_t* channel_monitors_vals = channel_monitors->elems;
28044 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
28045 uint32_t channel_monitors_conv_16 = channel_monitors_vals[q];
28046 LDKChannelMonitor channel_monitors_conv_16_conv;
28047 channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
28048 channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
28049 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_monitors_conv_16_conv);
28050 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
28052 FREE(channel_monitors);
28053 LDKChannelManagerReadArgs ret_var = ChannelManagerReadArgs_new(keys_manager_conv, fee_estimator_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, default_config_conv, channel_monitors_constr);
28054 uint32_t ret_ref = 0;
28055 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28056 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28057 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28058 ret_ref = (uintptr_t)ret_var.inner;
28059 if (ret_var.is_owned) {
28065 uint32_t __attribute__((export_name("TS_C2Tuple_BlockHashChannelManagerZ_read"))) TS_C2Tuple_BlockHashChannelManagerZ_read(int8_tArray ser, uint32_t arg) {
28066 LDKu8slice ser_ref;
28067 ser_ref.datalen = ser->arr_len;
28068 ser_ref.data = ser->elems;
28069 LDKChannelManagerReadArgs arg_conv;
28070 arg_conv.inner = (void*)(arg & (~1));
28071 arg_conv.is_owned = (arg & 1) || (arg == 0);
28072 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28073 // WARNING: we need a move here but no clone is available for LDKChannelManagerReadArgs
28074 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
28075 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
28077 return (uint32_t)ret_conv;
28080 void __attribute__((export_name("TS_ExpandedKey_free"))) TS_ExpandedKey_free(uint32_t this_obj) {
28081 LDKExpandedKey this_obj_conv;
28082 this_obj_conv.inner = (void*)(this_obj & (~1));
28083 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28085 ExpandedKey_free(this_obj_conv);
28088 uint32_t __attribute__((export_name("TS_ExpandedKey_new"))) TS_ExpandedKey_new(int8_tArray key_material) {
28089 unsigned char key_material_arr[32];
28090 CHECK(key_material->arr_len == 32);
28091 memcpy(key_material_arr, key_material->elems, 32); FREE(key_material);
28092 unsigned char (*key_material_ref)[32] = &key_material_arr;
28093 LDKExpandedKey ret_var = ExpandedKey_new(key_material_ref);
28094 uint32_t ret_ref = 0;
28095 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28096 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28097 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28098 ret_ref = (uintptr_t)ret_var.inner;
28099 if (ret_var.is_owned) {
28105 uint32_t __attribute__((export_name("TS_create"))) TS_create(uint32_t keys, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs, uint32_t keys_manager, int64_t current_time) {
28106 LDKExpandedKey keys_conv;
28107 keys_conv.inner = (void*)(keys & (~1));
28108 keys_conv.is_owned = false;
28109 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
28110 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
28111 CHECK_ACCESS(min_value_msat_ptr);
28112 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28113 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
28114 void* keys_manager_ptr = (void*)(((uintptr_t)keys_manager) & ~1);
28115 if (!(keys_manager & 1)) { CHECK_ACCESS(keys_manager_ptr); }
28116 LDKKeysInterface* keys_manager_conv = (LDKKeysInterface*)keys_manager_ptr;
28117 LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ), "LDKCResult_C2Tuple_PaymentHashPaymentSecretZNoneZ");
28118 *ret_conv = create(&keys_conv, min_value_msat_conv, invoice_expiry_delta_secs, keys_manager_conv, current_time);
28119 return (uint32_t)ret_conv;
28122 uint32_t __attribute__((export_name("TS_create_from_hash"))) TS_create_from_hash(uint32_t keys, uint32_t min_value_msat, int8_tArray payment_hash, int32_t invoice_expiry_delta_secs, int64_t current_time) {
28123 LDKExpandedKey keys_conv;
28124 keys_conv.inner = (void*)(keys & (~1));
28125 keys_conv.is_owned = false;
28126 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
28127 void* min_value_msat_ptr = (void*)(((uintptr_t)min_value_msat) & ~1);
28128 CHECK_ACCESS(min_value_msat_ptr);
28129 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(min_value_msat_ptr);
28130 min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)min_value_msat) & ~1));
28131 LDKThirtyTwoBytes payment_hash_ref;
28132 CHECK(payment_hash->arr_len == 32);
28133 memcpy(payment_hash_ref.data, payment_hash->elems, 32); FREE(payment_hash);
28134 LDKCResult_PaymentSecretNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretNoneZ), "LDKCResult_PaymentSecretNoneZ");
28135 *ret_conv = create_from_hash(&keys_conv, min_value_msat_conv, payment_hash_ref, invoice_expiry_delta_secs, current_time);
28136 return (uint32_t)ret_conv;
28139 void __attribute__((export_name("TS_DecodeError_free"))) TS_DecodeError_free(uint32_t this_obj) {
28140 LDKDecodeError this_obj_conv;
28141 this_obj_conv.inner = (void*)(this_obj & (~1));
28142 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28143 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28144 DecodeError_free(this_obj_conv);
28147 static inline uintptr_t DecodeError_clone_ptr(LDKDecodeError *NONNULL_PTR arg) {
28148 LDKDecodeError ret_var = DecodeError_clone(arg);
28149 uint32_t ret_ref = 0;
28150 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28151 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28152 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28153 ret_ref = (uintptr_t)ret_var.inner;
28154 if (ret_var.is_owned) {
28159 uint32_t __attribute__((export_name("TS_DecodeError_clone_ptr"))) TS_DecodeError_clone_ptr(uint32_t arg) {
28160 LDKDecodeError arg_conv;
28161 arg_conv.inner = (void*)(arg & (~1));
28162 arg_conv.is_owned = false;
28163 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28164 uint32_t ret_conv = DecodeError_clone_ptr(&arg_conv);
28168 uint32_t __attribute__((export_name("TS_DecodeError_clone"))) TS_DecodeError_clone(uint32_t orig) {
28169 LDKDecodeError orig_conv;
28170 orig_conv.inner = (void*)(orig & (~1));
28171 orig_conv.is_owned = false;
28172 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28173 LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
28174 uint32_t ret_ref = 0;
28175 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28176 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28177 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28178 ret_ref = (uintptr_t)ret_var.inner;
28179 if (ret_var.is_owned) {
28185 void __attribute__((export_name("TS_Init_free"))) TS_Init_free(uint32_t this_obj) {
28186 LDKInit this_obj_conv;
28187 this_obj_conv.inner = (void*)(this_obj & (~1));
28188 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28189 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28190 Init_free(this_obj_conv);
28193 uint32_t __attribute__((export_name("TS_Init_get_features"))) TS_Init_get_features(uint32_t this_ptr) {
28194 LDKInit this_ptr_conv;
28195 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28196 this_ptr_conv.is_owned = false;
28197 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28198 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
28199 uint32_t ret_ref = 0;
28200 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28201 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28202 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28203 ret_ref = (uintptr_t)ret_var.inner;
28204 if (ret_var.is_owned) {
28210 void __attribute__((export_name("TS_Init_set_features"))) TS_Init_set_features(uint32_t this_ptr, uint32_t val) {
28211 LDKInit this_ptr_conv;
28212 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28213 this_ptr_conv.is_owned = false;
28214 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28215 LDKInitFeatures val_conv;
28216 val_conv.inner = (void*)(val & (~1));
28217 val_conv.is_owned = (val & 1) || (val == 0);
28218 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
28219 val_conv = InitFeatures_clone(&val_conv);
28220 Init_set_features(&this_ptr_conv, val_conv);
28223 uint32_t __attribute__((export_name("TS_Init_get_remote_network_address"))) TS_Init_get_remote_network_address(uint32_t this_ptr) {
28224 LDKInit this_ptr_conv;
28225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28226 this_ptr_conv.is_owned = false;
28227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28228 LDKCOption_NetAddressZ *ret_copy = MALLOC(sizeof(LDKCOption_NetAddressZ), "LDKCOption_NetAddressZ");
28229 *ret_copy = Init_get_remote_network_address(&this_ptr_conv);
28230 uint32_t ret_ref = (uintptr_t)ret_copy;
28234 void __attribute__((export_name("TS_Init_set_remote_network_address"))) TS_Init_set_remote_network_address(uint32_t this_ptr, uint32_t val) {
28235 LDKInit this_ptr_conv;
28236 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28237 this_ptr_conv.is_owned = false;
28238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28239 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
28240 CHECK_ACCESS(val_ptr);
28241 LDKCOption_NetAddressZ val_conv = *(LDKCOption_NetAddressZ*)(val_ptr);
28242 val_conv = COption_NetAddressZ_clone((LDKCOption_NetAddressZ*)(((uintptr_t)val) & ~1));
28243 Init_set_remote_network_address(&this_ptr_conv, val_conv);
28246 uint32_t __attribute__((export_name("TS_Init_new"))) TS_Init_new(uint32_t features_arg, uint32_t remote_network_address_arg) {
28247 LDKInitFeatures features_arg_conv;
28248 features_arg_conv.inner = (void*)(features_arg & (~1));
28249 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
28250 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
28251 features_arg_conv = InitFeatures_clone(&features_arg_conv);
28252 void* remote_network_address_arg_ptr = (void*)(((uintptr_t)remote_network_address_arg) & ~1);
28253 CHECK_ACCESS(remote_network_address_arg_ptr);
28254 LDKCOption_NetAddressZ remote_network_address_arg_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_arg_ptr);
28255 LDKInit ret_var = Init_new(features_arg_conv, remote_network_address_arg_conv);
28256 uint32_t ret_ref = 0;
28257 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28258 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28259 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28260 ret_ref = (uintptr_t)ret_var.inner;
28261 if (ret_var.is_owned) {
28267 static inline uintptr_t Init_clone_ptr(LDKInit *NONNULL_PTR arg) {
28268 LDKInit ret_var = Init_clone(arg);
28269 uint32_t ret_ref = 0;
28270 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28271 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28272 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28273 ret_ref = (uintptr_t)ret_var.inner;
28274 if (ret_var.is_owned) {
28279 uint32_t __attribute__((export_name("TS_Init_clone_ptr"))) TS_Init_clone_ptr(uint32_t arg) {
28281 arg_conv.inner = (void*)(arg & (~1));
28282 arg_conv.is_owned = false;
28283 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28284 uint32_t ret_conv = Init_clone_ptr(&arg_conv);
28288 uint32_t __attribute__((export_name("TS_Init_clone"))) TS_Init_clone(uint32_t orig) {
28290 orig_conv.inner = (void*)(orig & (~1));
28291 orig_conv.is_owned = false;
28292 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28293 LDKInit ret_var = Init_clone(&orig_conv);
28294 uint32_t ret_ref = 0;
28295 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28296 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28297 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28298 ret_ref = (uintptr_t)ret_var.inner;
28299 if (ret_var.is_owned) {
28305 void __attribute__((export_name("TS_ErrorMessage_free"))) TS_ErrorMessage_free(uint32_t this_obj) {
28306 LDKErrorMessage this_obj_conv;
28307 this_obj_conv.inner = (void*)(this_obj & (~1));
28308 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28310 ErrorMessage_free(this_obj_conv);
28313 int8_tArray __attribute__((export_name("TS_ErrorMessage_get_channel_id"))) TS_ErrorMessage_get_channel_id(uint32_t this_ptr) {
28314 LDKErrorMessage this_ptr_conv;
28315 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28316 this_ptr_conv.is_owned = false;
28317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28318 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
28319 memcpy(ret_arr->elems, *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
28323 void __attribute__((export_name("TS_ErrorMessage_set_channel_id"))) TS_ErrorMessage_set_channel_id(uint32_t this_ptr, int8_tArray val) {
28324 LDKErrorMessage this_ptr_conv;
28325 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28326 this_ptr_conv.is_owned = false;
28327 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28328 LDKThirtyTwoBytes val_ref;
28329 CHECK(val->arr_len == 32);
28330 memcpy(val_ref.data, val->elems, 32); FREE(val);
28331 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
28334 jstring __attribute__((export_name("TS_ErrorMessage_get_data"))) TS_ErrorMessage_get_data(uint32_t this_ptr) {
28335 LDKErrorMessage this_ptr_conv;
28336 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28337 this_ptr_conv.is_owned = false;
28338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28339 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
28340 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
28345 void __attribute__((export_name("TS_ErrorMessage_set_data"))) TS_ErrorMessage_set_data(uint32_t this_ptr, jstring val) {
28346 LDKErrorMessage this_ptr_conv;
28347 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28348 this_ptr_conv.is_owned = false;
28349 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28350 LDKStr val_conv = str_ref_to_owned_c(val);
28351 ErrorMessage_set_data(&this_ptr_conv, val_conv);
28354 uint32_t __attribute__((export_name("TS_ErrorMessage_new"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
28355 LDKThirtyTwoBytes channel_id_arg_ref;
28356 CHECK(channel_id_arg->arr_len == 32);
28357 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
28358 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
28359 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
28360 uint32_t ret_ref = 0;
28361 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28362 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28364 ret_ref = (uintptr_t)ret_var.inner;
28365 if (ret_var.is_owned) {
28371 static inline uintptr_t ErrorMessage_clone_ptr(LDKErrorMessage *NONNULL_PTR arg) {
28372 LDKErrorMessage ret_var = ErrorMessage_clone(arg);
28373 uint32_t ret_ref = 0;
28374 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28375 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28376 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28377 ret_ref = (uintptr_t)ret_var.inner;
28378 if (ret_var.is_owned) {
28383 uint32_t __attribute__((export_name("TS_ErrorMessage_clone_ptr"))) TS_ErrorMessage_clone_ptr(uint32_t arg) {
28384 LDKErrorMessage arg_conv;
28385 arg_conv.inner = (void*)(arg & (~1));
28386 arg_conv.is_owned = false;
28387 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28388 uint32_t ret_conv = ErrorMessage_clone_ptr(&arg_conv);
28392 uint32_t __attribute__((export_name("TS_ErrorMessage_clone"))) TS_ErrorMessage_clone(uint32_t orig) {
28393 LDKErrorMessage orig_conv;
28394 orig_conv.inner = (void*)(orig & (~1));
28395 orig_conv.is_owned = false;
28396 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28397 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
28398 uint32_t ret_ref = 0;
28399 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28400 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28401 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28402 ret_ref = (uintptr_t)ret_var.inner;
28403 if (ret_var.is_owned) {
28409 void __attribute__((export_name("TS_WarningMessage_free"))) TS_WarningMessage_free(uint32_t this_obj) {
28410 LDKWarningMessage this_obj_conv;
28411 this_obj_conv.inner = (void*)(this_obj & (~1));
28412 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28414 WarningMessage_free(this_obj_conv);
28417 int8_tArray __attribute__((export_name("TS_WarningMessage_get_channel_id"))) TS_WarningMessage_get_channel_id(uint32_t this_ptr) {
28418 LDKWarningMessage this_ptr_conv;
28419 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28420 this_ptr_conv.is_owned = false;
28421 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28422 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
28423 memcpy(ret_arr->elems, *WarningMessage_get_channel_id(&this_ptr_conv), 32);
28427 void __attribute__((export_name("TS_WarningMessage_set_channel_id"))) TS_WarningMessage_set_channel_id(uint32_t this_ptr, int8_tArray val) {
28428 LDKWarningMessage this_ptr_conv;
28429 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28430 this_ptr_conv.is_owned = false;
28431 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28432 LDKThirtyTwoBytes val_ref;
28433 CHECK(val->arr_len == 32);
28434 memcpy(val_ref.data, val->elems, 32); FREE(val);
28435 WarningMessage_set_channel_id(&this_ptr_conv, val_ref);
28438 jstring __attribute__((export_name("TS_WarningMessage_get_data"))) TS_WarningMessage_get_data(uint32_t this_ptr) {
28439 LDKWarningMessage this_ptr_conv;
28440 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28441 this_ptr_conv.is_owned = false;
28442 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28443 LDKStr ret_str = WarningMessage_get_data(&this_ptr_conv);
28444 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
28449 void __attribute__((export_name("TS_WarningMessage_set_data"))) TS_WarningMessage_set_data(uint32_t this_ptr, jstring val) {
28450 LDKWarningMessage this_ptr_conv;
28451 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28452 this_ptr_conv.is_owned = false;
28453 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28454 LDKStr val_conv = str_ref_to_owned_c(val);
28455 WarningMessage_set_data(&this_ptr_conv, val_conv);
28458 uint32_t __attribute__((export_name("TS_WarningMessage_new"))) TS_WarningMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
28459 LDKThirtyTwoBytes channel_id_arg_ref;
28460 CHECK(channel_id_arg->arr_len == 32);
28461 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
28462 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
28463 LDKWarningMessage ret_var = WarningMessage_new(channel_id_arg_ref, data_arg_conv);
28464 uint32_t ret_ref = 0;
28465 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28466 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28467 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28468 ret_ref = (uintptr_t)ret_var.inner;
28469 if (ret_var.is_owned) {
28475 static inline uintptr_t WarningMessage_clone_ptr(LDKWarningMessage *NONNULL_PTR arg) {
28476 LDKWarningMessage ret_var = WarningMessage_clone(arg);
28477 uint32_t ret_ref = 0;
28478 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28479 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28480 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28481 ret_ref = (uintptr_t)ret_var.inner;
28482 if (ret_var.is_owned) {
28487 uint32_t __attribute__((export_name("TS_WarningMessage_clone_ptr"))) TS_WarningMessage_clone_ptr(uint32_t arg) {
28488 LDKWarningMessage arg_conv;
28489 arg_conv.inner = (void*)(arg & (~1));
28490 arg_conv.is_owned = false;
28491 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28492 uint32_t ret_conv = WarningMessage_clone_ptr(&arg_conv);
28496 uint32_t __attribute__((export_name("TS_WarningMessage_clone"))) TS_WarningMessage_clone(uint32_t orig) {
28497 LDKWarningMessage orig_conv;
28498 orig_conv.inner = (void*)(orig & (~1));
28499 orig_conv.is_owned = false;
28500 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28501 LDKWarningMessage ret_var = WarningMessage_clone(&orig_conv);
28502 uint32_t ret_ref = 0;
28503 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28504 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28505 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28506 ret_ref = (uintptr_t)ret_var.inner;
28507 if (ret_var.is_owned) {
28513 void __attribute__((export_name("TS_Ping_free"))) TS_Ping_free(uint32_t this_obj) {
28514 LDKPing this_obj_conv;
28515 this_obj_conv.inner = (void*)(this_obj & (~1));
28516 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28518 Ping_free(this_obj_conv);
28521 int16_t __attribute__((export_name("TS_Ping_get_ponglen"))) TS_Ping_get_ponglen(uint32_t this_ptr) {
28522 LDKPing this_ptr_conv;
28523 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28524 this_ptr_conv.is_owned = false;
28525 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28526 int16_t ret_conv = Ping_get_ponglen(&this_ptr_conv);
28530 void __attribute__((export_name("TS_Ping_set_ponglen"))) TS_Ping_set_ponglen(uint32_t this_ptr, int16_t val) {
28531 LDKPing this_ptr_conv;
28532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28533 this_ptr_conv.is_owned = false;
28534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28535 Ping_set_ponglen(&this_ptr_conv, val);
28538 int16_t __attribute__((export_name("TS_Ping_get_byteslen"))) TS_Ping_get_byteslen(uint32_t this_ptr) {
28539 LDKPing this_ptr_conv;
28540 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28541 this_ptr_conv.is_owned = false;
28542 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28543 int16_t ret_conv = Ping_get_byteslen(&this_ptr_conv);
28547 void __attribute__((export_name("TS_Ping_set_byteslen"))) TS_Ping_set_byteslen(uint32_t this_ptr, int16_t val) {
28548 LDKPing this_ptr_conv;
28549 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28550 this_ptr_conv.is_owned = false;
28551 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28552 Ping_set_byteslen(&this_ptr_conv, val);
28555 uint32_t __attribute__((export_name("TS_Ping_new"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
28556 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
28557 uint32_t ret_ref = 0;
28558 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28559 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28560 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28561 ret_ref = (uintptr_t)ret_var.inner;
28562 if (ret_var.is_owned) {
28568 static inline uintptr_t Ping_clone_ptr(LDKPing *NONNULL_PTR arg) {
28569 LDKPing ret_var = Ping_clone(arg);
28570 uint32_t ret_ref = 0;
28571 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28572 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28573 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28574 ret_ref = (uintptr_t)ret_var.inner;
28575 if (ret_var.is_owned) {
28580 uint32_t __attribute__((export_name("TS_Ping_clone_ptr"))) TS_Ping_clone_ptr(uint32_t arg) {
28582 arg_conv.inner = (void*)(arg & (~1));
28583 arg_conv.is_owned = false;
28584 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28585 uint32_t ret_conv = Ping_clone_ptr(&arg_conv);
28589 uint32_t __attribute__((export_name("TS_Ping_clone"))) TS_Ping_clone(uint32_t orig) {
28591 orig_conv.inner = (void*)(orig & (~1));
28592 orig_conv.is_owned = false;
28593 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28594 LDKPing ret_var = Ping_clone(&orig_conv);
28595 uint32_t ret_ref = 0;
28596 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28597 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28599 ret_ref = (uintptr_t)ret_var.inner;
28600 if (ret_var.is_owned) {
28606 void __attribute__((export_name("TS_Pong_free"))) TS_Pong_free(uint32_t this_obj) {
28607 LDKPong this_obj_conv;
28608 this_obj_conv.inner = (void*)(this_obj & (~1));
28609 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28611 Pong_free(this_obj_conv);
28614 int16_t __attribute__((export_name("TS_Pong_get_byteslen"))) TS_Pong_get_byteslen(uint32_t this_ptr) {
28615 LDKPong this_ptr_conv;
28616 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28617 this_ptr_conv.is_owned = false;
28618 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28619 int16_t ret_conv = Pong_get_byteslen(&this_ptr_conv);
28623 void __attribute__((export_name("TS_Pong_set_byteslen"))) TS_Pong_set_byteslen(uint32_t this_ptr, int16_t val) {
28624 LDKPong this_ptr_conv;
28625 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28626 this_ptr_conv.is_owned = false;
28627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28628 Pong_set_byteslen(&this_ptr_conv, val);
28631 uint32_t __attribute__((export_name("TS_Pong_new"))) TS_Pong_new(int16_t byteslen_arg) {
28632 LDKPong ret_var = Pong_new(byteslen_arg);
28633 uint32_t ret_ref = 0;
28634 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28635 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28636 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28637 ret_ref = (uintptr_t)ret_var.inner;
28638 if (ret_var.is_owned) {
28644 static inline uintptr_t Pong_clone_ptr(LDKPong *NONNULL_PTR arg) {
28645 LDKPong ret_var = Pong_clone(arg);
28646 uint32_t ret_ref = 0;
28647 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28648 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28649 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28650 ret_ref = (uintptr_t)ret_var.inner;
28651 if (ret_var.is_owned) {
28656 uint32_t __attribute__((export_name("TS_Pong_clone_ptr"))) TS_Pong_clone_ptr(uint32_t arg) {
28658 arg_conv.inner = (void*)(arg & (~1));
28659 arg_conv.is_owned = false;
28660 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
28661 uint32_t ret_conv = Pong_clone_ptr(&arg_conv);
28665 uint32_t __attribute__((export_name("TS_Pong_clone"))) TS_Pong_clone(uint32_t orig) {
28667 orig_conv.inner = (void*)(orig & (~1));
28668 orig_conv.is_owned = false;
28669 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
28670 LDKPong ret_var = Pong_clone(&orig_conv);
28671 uint32_t ret_ref = 0;
28672 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
28673 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
28674 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
28675 ret_ref = (uintptr_t)ret_var.inner;
28676 if (ret_var.is_owned) {
28682 void __attribute__((export_name("TS_OpenChannel_free"))) TS_OpenChannel_free(uint32_t this_obj) {
28683 LDKOpenChannel this_obj_conv;
28684 this_obj_conv.inner = (void*)(this_obj & (~1));
28685 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
28686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
28687 OpenChannel_free(this_obj_conv);
28690 int8_tArray __attribute__((export_name("TS_OpenChannel_get_chain_hash"))) TS_OpenChannel_get_chain_hash(uint32_t this_ptr) {
28691 LDKOpenChannel this_ptr_conv;
28692 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28693 this_ptr_conv.is_owned = false;
28694 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28695 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
28696 memcpy(ret_arr->elems, *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
28700 void __attribute__((export_name("TS_OpenChannel_set_chain_hash"))) TS_OpenChannel_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
28701 LDKOpenChannel this_ptr_conv;
28702 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28703 this_ptr_conv.is_owned = false;
28704 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28705 LDKThirtyTwoBytes val_ref;
28706 CHECK(val->arr_len == 32);
28707 memcpy(val_ref.data, val->elems, 32); FREE(val);
28708 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
28711 int8_tArray __attribute__((export_name("TS_OpenChannel_get_temporary_channel_id"))) TS_OpenChannel_get_temporary_channel_id(uint32_t this_ptr) {
28712 LDKOpenChannel this_ptr_conv;
28713 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28714 this_ptr_conv.is_owned = false;
28715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28716 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
28717 memcpy(ret_arr->elems, *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
28721 void __attribute__((export_name("TS_OpenChannel_set_temporary_channel_id"))) TS_OpenChannel_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
28722 LDKOpenChannel this_ptr_conv;
28723 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28724 this_ptr_conv.is_owned = false;
28725 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28726 LDKThirtyTwoBytes val_ref;
28727 CHECK(val->arr_len == 32);
28728 memcpy(val_ref.data, val->elems, 32); FREE(val);
28729 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
28732 int64_t __attribute__((export_name("TS_OpenChannel_get_funding_satoshis"))) TS_OpenChannel_get_funding_satoshis(uint32_t this_ptr) {
28733 LDKOpenChannel this_ptr_conv;
28734 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28735 this_ptr_conv.is_owned = false;
28736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28737 int64_t ret_conv = OpenChannel_get_funding_satoshis(&this_ptr_conv);
28741 void __attribute__((export_name("TS_OpenChannel_set_funding_satoshis"))) TS_OpenChannel_set_funding_satoshis(uint32_t this_ptr, int64_t val) {
28742 LDKOpenChannel this_ptr_conv;
28743 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28744 this_ptr_conv.is_owned = false;
28745 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28746 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
28749 int64_t __attribute__((export_name("TS_OpenChannel_get_push_msat"))) TS_OpenChannel_get_push_msat(uint32_t this_ptr) {
28750 LDKOpenChannel this_ptr_conv;
28751 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28752 this_ptr_conv.is_owned = false;
28753 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28754 int64_t ret_conv = OpenChannel_get_push_msat(&this_ptr_conv);
28758 void __attribute__((export_name("TS_OpenChannel_set_push_msat"))) TS_OpenChannel_set_push_msat(uint32_t this_ptr, int64_t val) {
28759 LDKOpenChannel this_ptr_conv;
28760 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28761 this_ptr_conv.is_owned = false;
28762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28763 OpenChannel_set_push_msat(&this_ptr_conv, val);
28766 int64_t __attribute__((export_name("TS_OpenChannel_get_dust_limit_satoshis"))) TS_OpenChannel_get_dust_limit_satoshis(uint32_t this_ptr) {
28767 LDKOpenChannel this_ptr_conv;
28768 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28769 this_ptr_conv.is_owned = false;
28770 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28771 int64_t ret_conv = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
28775 void __attribute__((export_name("TS_OpenChannel_set_dust_limit_satoshis"))) TS_OpenChannel_set_dust_limit_satoshis(uint32_t this_ptr, int64_t val) {
28776 LDKOpenChannel this_ptr_conv;
28777 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28778 this_ptr_conv.is_owned = false;
28779 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28780 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
28783 int64_t __attribute__((export_name("TS_OpenChannel_get_max_htlc_value_in_flight_msat"))) TS_OpenChannel_get_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
28784 LDKOpenChannel this_ptr_conv;
28785 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28786 this_ptr_conv.is_owned = false;
28787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28788 int64_t ret_conv = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
28792 void __attribute__((export_name("TS_OpenChannel_set_max_htlc_value_in_flight_msat"))) TS_OpenChannel_set_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
28793 LDKOpenChannel this_ptr_conv;
28794 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28795 this_ptr_conv.is_owned = false;
28796 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28797 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
28800 int64_t __attribute__((export_name("TS_OpenChannel_get_channel_reserve_satoshis"))) TS_OpenChannel_get_channel_reserve_satoshis(uint32_t this_ptr) {
28801 LDKOpenChannel this_ptr_conv;
28802 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28803 this_ptr_conv.is_owned = false;
28804 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28805 int64_t ret_conv = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
28809 void __attribute__((export_name("TS_OpenChannel_set_channel_reserve_satoshis"))) TS_OpenChannel_set_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
28810 LDKOpenChannel this_ptr_conv;
28811 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28812 this_ptr_conv.is_owned = false;
28813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28814 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
28817 int64_t __attribute__((export_name("TS_OpenChannel_get_htlc_minimum_msat"))) TS_OpenChannel_get_htlc_minimum_msat(uint32_t this_ptr) {
28818 LDKOpenChannel this_ptr_conv;
28819 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28820 this_ptr_conv.is_owned = false;
28821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28822 int64_t ret_conv = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
28826 void __attribute__((export_name("TS_OpenChannel_set_htlc_minimum_msat"))) TS_OpenChannel_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
28827 LDKOpenChannel this_ptr_conv;
28828 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28829 this_ptr_conv.is_owned = false;
28830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28831 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
28834 int32_t __attribute__((export_name("TS_OpenChannel_get_feerate_per_kw"))) TS_OpenChannel_get_feerate_per_kw(uint32_t this_ptr) {
28835 LDKOpenChannel this_ptr_conv;
28836 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28837 this_ptr_conv.is_owned = false;
28838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28839 int32_t ret_conv = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
28843 void __attribute__((export_name("TS_OpenChannel_set_feerate_per_kw"))) TS_OpenChannel_set_feerate_per_kw(uint32_t this_ptr, int32_t val) {
28844 LDKOpenChannel this_ptr_conv;
28845 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28846 this_ptr_conv.is_owned = false;
28847 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28848 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
28851 int16_t __attribute__((export_name("TS_OpenChannel_get_to_self_delay"))) TS_OpenChannel_get_to_self_delay(uint32_t this_ptr) {
28852 LDKOpenChannel this_ptr_conv;
28853 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28854 this_ptr_conv.is_owned = false;
28855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28856 int16_t ret_conv = OpenChannel_get_to_self_delay(&this_ptr_conv);
28860 void __attribute__((export_name("TS_OpenChannel_set_to_self_delay"))) TS_OpenChannel_set_to_self_delay(uint32_t this_ptr, int16_t val) {
28861 LDKOpenChannel this_ptr_conv;
28862 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28863 this_ptr_conv.is_owned = false;
28864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28865 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
28868 int16_t __attribute__((export_name("TS_OpenChannel_get_max_accepted_htlcs"))) TS_OpenChannel_get_max_accepted_htlcs(uint32_t this_ptr) {
28869 LDKOpenChannel this_ptr_conv;
28870 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28871 this_ptr_conv.is_owned = false;
28872 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28873 int16_t ret_conv = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
28877 void __attribute__((export_name("TS_OpenChannel_set_max_accepted_htlcs"))) TS_OpenChannel_set_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
28878 LDKOpenChannel this_ptr_conv;
28879 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28880 this_ptr_conv.is_owned = false;
28881 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28882 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
28885 int8_tArray __attribute__((export_name("TS_OpenChannel_get_funding_pubkey"))) TS_OpenChannel_get_funding_pubkey(uint32_t this_ptr) {
28886 LDKOpenChannel this_ptr_conv;
28887 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28888 this_ptr_conv.is_owned = false;
28889 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28890 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28891 memcpy(ret_arr->elems, OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
28895 void __attribute__((export_name("TS_OpenChannel_set_funding_pubkey"))) TS_OpenChannel_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
28896 LDKOpenChannel this_ptr_conv;
28897 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28898 this_ptr_conv.is_owned = false;
28899 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28900 LDKPublicKey val_ref;
28901 CHECK(val->arr_len == 33);
28902 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28903 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
28906 int8_tArray __attribute__((export_name("TS_OpenChannel_get_revocation_basepoint"))) TS_OpenChannel_get_revocation_basepoint(uint32_t this_ptr) {
28907 LDKOpenChannel this_ptr_conv;
28908 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28909 this_ptr_conv.is_owned = false;
28910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28911 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28912 memcpy(ret_arr->elems, OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
28916 void __attribute__((export_name("TS_OpenChannel_set_revocation_basepoint"))) TS_OpenChannel_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
28917 LDKOpenChannel this_ptr_conv;
28918 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28919 this_ptr_conv.is_owned = false;
28920 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28921 LDKPublicKey val_ref;
28922 CHECK(val->arr_len == 33);
28923 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28924 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
28927 int8_tArray __attribute__((export_name("TS_OpenChannel_get_payment_point"))) TS_OpenChannel_get_payment_point(uint32_t this_ptr) {
28928 LDKOpenChannel this_ptr_conv;
28929 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28930 this_ptr_conv.is_owned = false;
28931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28932 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28933 memcpy(ret_arr->elems, OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
28937 void __attribute__((export_name("TS_OpenChannel_set_payment_point"))) TS_OpenChannel_set_payment_point(uint32_t this_ptr, int8_tArray val) {
28938 LDKOpenChannel this_ptr_conv;
28939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28940 this_ptr_conv.is_owned = false;
28941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28942 LDKPublicKey val_ref;
28943 CHECK(val->arr_len == 33);
28944 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28945 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
28948 int8_tArray __attribute__((export_name("TS_OpenChannel_get_delayed_payment_basepoint"))) TS_OpenChannel_get_delayed_payment_basepoint(uint32_t this_ptr) {
28949 LDKOpenChannel this_ptr_conv;
28950 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28951 this_ptr_conv.is_owned = false;
28952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28953 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28954 memcpy(ret_arr->elems, OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
28958 void __attribute__((export_name("TS_OpenChannel_set_delayed_payment_basepoint"))) TS_OpenChannel_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
28959 LDKOpenChannel this_ptr_conv;
28960 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28961 this_ptr_conv.is_owned = false;
28962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28963 LDKPublicKey val_ref;
28964 CHECK(val->arr_len == 33);
28965 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28966 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
28969 int8_tArray __attribute__((export_name("TS_OpenChannel_get_htlc_basepoint"))) TS_OpenChannel_get_htlc_basepoint(uint32_t this_ptr) {
28970 LDKOpenChannel this_ptr_conv;
28971 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28972 this_ptr_conv.is_owned = false;
28973 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28974 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28975 memcpy(ret_arr->elems, OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
28979 void __attribute__((export_name("TS_OpenChannel_set_htlc_basepoint"))) TS_OpenChannel_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
28980 LDKOpenChannel this_ptr_conv;
28981 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28982 this_ptr_conv.is_owned = false;
28983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28984 LDKPublicKey val_ref;
28985 CHECK(val->arr_len == 33);
28986 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
28987 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
28990 int8_tArray __attribute__((export_name("TS_OpenChannel_get_first_per_commitment_point"))) TS_OpenChannel_get_first_per_commitment_point(uint32_t this_ptr) {
28991 LDKOpenChannel this_ptr_conv;
28992 this_ptr_conv.inner = (void*)(this_ptr & (~1));
28993 this_ptr_conv.is_owned = false;
28994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
28995 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
28996 memcpy(ret_arr->elems, OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
29000 void __attribute__((export_name("TS_OpenChannel_set_first_per_commitment_point"))) TS_OpenChannel_set_first_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
29001 LDKOpenChannel this_ptr_conv;
29002 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29003 this_ptr_conv.is_owned = false;
29004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29005 LDKPublicKey val_ref;
29006 CHECK(val->arr_len == 33);
29007 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29008 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
29011 int8_t __attribute__((export_name("TS_OpenChannel_get_channel_flags"))) TS_OpenChannel_get_channel_flags(uint32_t this_ptr) {
29012 LDKOpenChannel this_ptr_conv;
29013 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29014 this_ptr_conv.is_owned = false;
29015 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29016 int8_t ret_conv = OpenChannel_get_channel_flags(&this_ptr_conv);
29020 void __attribute__((export_name("TS_OpenChannel_set_channel_flags"))) TS_OpenChannel_set_channel_flags(uint32_t this_ptr, int8_t val) {
29021 LDKOpenChannel this_ptr_conv;
29022 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29023 this_ptr_conv.is_owned = false;
29024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29025 OpenChannel_set_channel_flags(&this_ptr_conv, val);
29028 uint32_t __attribute__((export_name("TS_OpenChannel_get_channel_type"))) TS_OpenChannel_get_channel_type(uint32_t this_ptr) {
29029 LDKOpenChannel this_ptr_conv;
29030 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29031 this_ptr_conv.is_owned = false;
29032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29033 LDKChannelTypeFeatures ret_var = OpenChannel_get_channel_type(&this_ptr_conv);
29034 uint32_t ret_ref = 0;
29035 if ((uintptr_t)ret_var.inner > 4096) {
29036 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29037 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29039 ret_ref = (uintptr_t)ret_var.inner;
29040 if (ret_var.is_owned) {
29047 void __attribute__((export_name("TS_OpenChannel_set_channel_type"))) TS_OpenChannel_set_channel_type(uint32_t this_ptr, uint32_t val) {
29048 LDKOpenChannel this_ptr_conv;
29049 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29050 this_ptr_conv.is_owned = false;
29051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29052 LDKChannelTypeFeatures val_conv;
29053 val_conv.inner = (void*)(val & (~1));
29054 val_conv.is_owned = (val & 1) || (val == 0);
29055 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29056 val_conv = ChannelTypeFeatures_clone(&val_conv);
29057 OpenChannel_set_channel_type(&this_ptr_conv, val_conv);
29060 static inline uintptr_t OpenChannel_clone_ptr(LDKOpenChannel *NONNULL_PTR arg) {
29061 LDKOpenChannel ret_var = OpenChannel_clone(arg);
29062 uint32_t ret_ref = 0;
29063 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29064 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29065 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29066 ret_ref = (uintptr_t)ret_var.inner;
29067 if (ret_var.is_owned) {
29072 uint32_t __attribute__((export_name("TS_OpenChannel_clone_ptr"))) TS_OpenChannel_clone_ptr(uint32_t arg) {
29073 LDKOpenChannel arg_conv;
29074 arg_conv.inner = (void*)(arg & (~1));
29075 arg_conv.is_owned = false;
29076 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29077 uint32_t ret_conv = OpenChannel_clone_ptr(&arg_conv);
29081 uint32_t __attribute__((export_name("TS_OpenChannel_clone"))) TS_OpenChannel_clone(uint32_t orig) {
29082 LDKOpenChannel orig_conv;
29083 orig_conv.inner = (void*)(orig & (~1));
29084 orig_conv.is_owned = false;
29085 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29086 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
29087 uint32_t ret_ref = 0;
29088 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29089 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29090 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29091 ret_ref = (uintptr_t)ret_var.inner;
29092 if (ret_var.is_owned) {
29098 void __attribute__((export_name("TS_AcceptChannel_free"))) TS_AcceptChannel_free(uint32_t this_obj) {
29099 LDKAcceptChannel this_obj_conv;
29100 this_obj_conv.inner = (void*)(this_obj & (~1));
29101 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29103 AcceptChannel_free(this_obj_conv);
29106 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_temporary_channel_id"))) TS_AcceptChannel_get_temporary_channel_id(uint32_t this_ptr) {
29107 LDKAcceptChannel this_ptr_conv;
29108 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29109 this_ptr_conv.is_owned = false;
29110 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29111 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29112 memcpy(ret_arr->elems, *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
29116 void __attribute__((export_name("TS_AcceptChannel_set_temporary_channel_id"))) TS_AcceptChannel_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
29117 LDKAcceptChannel this_ptr_conv;
29118 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29119 this_ptr_conv.is_owned = false;
29120 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29121 LDKThirtyTwoBytes val_ref;
29122 CHECK(val->arr_len == 32);
29123 memcpy(val_ref.data, val->elems, 32); FREE(val);
29124 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
29127 int64_t __attribute__((export_name("TS_AcceptChannel_get_dust_limit_satoshis"))) TS_AcceptChannel_get_dust_limit_satoshis(uint32_t this_ptr) {
29128 LDKAcceptChannel this_ptr_conv;
29129 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29130 this_ptr_conv.is_owned = false;
29131 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29132 int64_t ret_conv = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
29136 void __attribute__((export_name("TS_AcceptChannel_set_dust_limit_satoshis"))) TS_AcceptChannel_set_dust_limit_satoshis(uint32_t this_ptr, int64_t val) {
29137 LDKAcceptChannel this_ptr_conv;
29138 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29139 this_ptr_conv.is_owned = false;
29140 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29141 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
29144 int64_t __attribute__((export_name("TS_AcceptChannel_get_max_htlc_value_in_flight_msat"))) TS_AcceptChannel_get_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
29145 LDKAcceptChannel this_ptr_conv;
29146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29147 this_ptr_conv.is_owned = false;
29148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29149 int64_t ret_conv = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
29153 void __attribute__((export_name("TS_AcceptChannel_set_max_htlc_value_in_flight_msat"))) TS_AcceptChannel_set_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
29154 LDKAcceptChannel this_ptr_conv;
29155 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29156 this_ptr_conv.is_owned = false;
29157 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29158 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
29161 int64_t __attribute__((export_name("TS_AcceptChannel_get_channel_reserve_satoshis"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint32_t this_ptr) {
29162 LDKAcceptChannel this_ptr_conv;
29163 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29164 this_ptr_conv.is_owned = false;
29165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29166 int64_t ret_conv = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
29170 void __attribute__((export_name("TS_AcceptChannel_set_channel_reserve_satoshis"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
29171 LDKAcceptChannel this_ptr_conv;
29172 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29173 this_ptr_conv.is_owned = false;
29174 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29175 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
29178 int64_t __attribute__((export_name("TS_AcceptChannel_get_htlc_minimum_msat"))) TS_AcceptChannel_get_htlc_minimum_msat(uint32_t this_ptr) {
29179 LDKAcceptChannel this_ptr_conv;
29180 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29181 this_ptr_conv.is_owned = false;
29182 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29183 int64_t ret_conv = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
29187 void __attribute__((export_name("TS_AcceptChannel_set_htlc_minimum_msat"))) TS_AcceptChannel_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
29188 LDKAcceptChannel this_ptr_conv;
29189 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29190 this_ptr_conv.is_owned = false;
29191 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29192 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
29195 int32_t __attribute__((export_name("TS_AcceptChannel_get_minimum_depth"))) TS_AcceptChannel_get_minimum_depth(uint32_t this_ptr) {
29196 LDKAcceptChannel this_ptr_conv;
29197 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29198 this_ptr_conv.is_owned = false;
29199 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29200 int32_t ret_conv = AcceptChannel_get_minimum_depth(&this_ptr_conv);
29204 void __attribute__((export_name("TS_AcceptChannel_set_minimum_depth"))) TS_AcceptChannel_set_minimum_depth(uint32_t this_ptr, int32_t val) {
29205 LDKAcceptChannel this_ptr_conv;
29206 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29207 this_ptr_conv.is_owned = false;
29208 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29209 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
29212 int16_t __attribute__((export_name("TS_AcceptChannel_get_to_self_delay"))) TS_AcceptChannel_get_to_self_delay(uint32_t this_ptr) {
29213 LDKAcceptChannel this_ptr_conv;
29214 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29215 this_ptr_conv.is_owned = false;
29216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29217 int16_t ret_conv = AcceptChannel_get_to_self_delay(&this_ptr_conv);
29221 void __attribute__((export_name("TS_AcceptChannel_set_to_self_delay"))) TS_AcceptChannel_set_to_self_delay(uint32_t this_ptr, int16_t val) {
29222 LDKAcceptChannel this_ptr_conv;
29223 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29224 this_ptr_conv.is_owned = false;
29225 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29226 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
29229 int16_t __attribute__((export_name("TS_AcceptChannel_get_max_accepted_htlcs"))) TS_AcceptChannel_get_max_accepted_htlcs(uint32_t this_ptr) {
29230 LDKAcceptChannel this_ptr_conv;
29231 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29232 this_ptr_conv.is_owned = false;
29233 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29234 int16_t ret_conv = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
29238 void __attribute__((export_name("TS_AcceptChannel_set_max_accepted_htlcs"))) TS_AcceptChannel_set_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
29239 LDKAcceptChannel this_ptr_conv;
29240 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29241 this_ptr_conv.is_owned = false;
29242 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29243 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
29246 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_funding_pubkey"))) TS_AcceptChannel_get_funding_pubkey(uint32_t this_ptr) {
29247 LDKAcceptChannel this_ptr_conv;
29248 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29249 this_ptr_conv.is_owned = false;
29250 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29251 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29252 memcpy(ret_arr->elems, AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
29256 void __attribute__((export_name("TS_AcceptChannel_set_funding_pubkey"))) TS_AcceptChannel_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
29257 LDKAcceptChannel this_ptr_conv;
29258 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29259 this_ptr_conv.is_owned = false;
29260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29261 LDKPublicKey val_ref;
29262 CHECK(val->arr_len == 33);
29263 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29264 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
29267 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_revocation_basepoint"))) TS_AcceptChannel_get_revocation_basepoint(uint32_t this_ptr) {
29268 LDKAcceptChannel this_ptr_conv;
29269 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29270 this_ptr_conv.is_owned = false;
29271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29272 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29273 memcpy(ret_arr->elems, AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
29277 void __attribute__((export_name("TS_AcceptChannel_set_revocation_basepoint"))) TS_AcceptChannel_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
29278 LDKAcceptChannel this_ptr_conv;
29279 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29280 this_ptr_conv.is_owned = false;
29281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29282 LDKPublicKey val_ref;
29283 CHECK(val->arr_len == 33);
29284 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29285 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
29288 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_payment_point"))) TS_AcceptChannel_get_payment_point(uint32_t this_ptr) {
29289 LDKAcceptChannel this_ptr_conv;
29290 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29291 this_ptr_conv.is_owned = false;
29292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29293 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29294 memcpy(ret_arr->elems, AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
29298 void __attribute__((export_name("TS_AcceptChannel_set_payment_point"))) TS_AcceptChannel_set_payment_point(uint32_t this_ptr, int8_tArray val) {
29299 LDKAcceptChannel this_ptr_conv;
29300 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29301 this_ptr_conv.is_owned = false;
29302 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29303 LDKPublicKey val_ref;
29304 CHECK(val->arr_len == 33);
29305 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29306 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
29309 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_delayed_payment_basepoint"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint32_t this_ptr) {
29310 LDKAcceptChannel this_ptr_conv;
29311 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29312 this_ptr_conv.is_owned = false;
29313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29314 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29315 memcpy(ret_arr->elems, AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
29319 void __attribute__((export_name("TS_AcceptChannel_set_delayed_payment_basepoint"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
29320 LDKAcceptChannel this_ptr_conv;
29321 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29322 this_ptr_conv.is_owned = false;
29323 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29324 LDKPublicKey val_ref;
29325 CHECK(val->arr_len == 33);
29326 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29327 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
29330 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_htlc_basepoint"))) TS_AcceptChannel_get_htlc_basepoint(uint32_t this_ptr) {
29331 LDKAcceptChannel this_ptr_conv;
29332 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29333 this_ptr_conv.is_owned = false;
29334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29335 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29336 memcpy(ret_arr->elems, AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
29340 void __attribute__((export_name("TS_AcceptChannel_set_htlc_basepoint"))) TS_AcceptChannel_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
29341 LDKAcceptChannel this_ptr_conv;
29342 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29343 this_ptr_conv.is_owned = false;
29344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29345 LDKPublicKey val_ref;
29346 CHECK(val->arr_len == 33);
29347 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29348 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
29351 int8_tArray __attribute__((export_name("TS_AcceptChannel_get_first_per_commitment_point"))) TS_AcceptChannel_get_first_per_commitment_point(uint32_t this_ptr) {
29352 LDKAcceptChannel this_ptr_conv;
29353 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29354 this_ptr_conv.is_owned = false;
29355 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29356 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29357 memcpy(ret_arr->elems, AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
29361 void __attribute__((export_name("TS_AcceptChannel_set_first_per_commitment_point"))) TS_AcceptChannel_set_first_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
29362 LDKAcceptChannel this_ptr_conv;
29363 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29364 this_ptr_conv.is_owned = false;
29365 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29366 LDKPublicKey val_ref;
29367 CHECK(val->arr_len == 33);
29368 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29369 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
29372 uint32_t __attribute__((export_name("TS_AcceptChannel_get_channel_type"))) TS_AcceptChannel_get_channel_type(uint32_t this_ptr) {
29373 LDKAcceptChannel this_ptr_conv;
29374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29375 this_ptr_conv.is_owned = false;
29376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29377 LDKChannelTypeFeatures ret_var = AcceptChannel_get_channel_type(&this_ptr_conv);
29378 uint32_t ret_ref = 0;
29379 if ((uintptr_t)ret_var.inner > 4096) {
29380 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29381 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29382 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29383 ret_ref = (uintptr_t)ret_var.inner;
29384 if (ret_var.is_owned) {
29391 void __attribute__((export_name("TS_AcceptChannel_set_channel_type"))) TS_AcceptChannel_set_channel_type(uint32_t this_ptr, uint32_t val) {
29392 LDKAcceptChannel this_ptr_conv;
29393 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29394 this_ptr_conv.is_owned = false;
29395 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29396 LDKChannelTypeFeatures val_conv;
29397 val_conv.inner = (void*)(val & (~1));
29398 val_conv.is_owned = (val & 1) || (val == 0);
29399 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
29400 val_conv = ChannelTypeFeatures_clone(&val_conv);
29401 AcceptChannel_set_channel_type(&this_ptr_conv, val_conv);
29404 static inline uintptr_t AcceptChannel_clone_ptr(LDKAcceptChannel *NONNULL_PTR arg) {
29405 LDKAcceptChannel ret_var = AcceptChannel_clone(arg);
29406 uint32_t ret_ref = 0;
29407 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29408 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29409 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29410 ret_ref = (uintptr_t)ret_var.inner;
29411 if (ret_var.is_owned) {
29416 uint32_t __attribute__((export_name("TS_AcceptChannel_clone_ptr"))) TS_AcceptChannel_clone_ptr(uint32_t arg) {
29417 LDKAcceptChannel arg_conv;
29418 arg_conv.inner = (void*)(arg & (~1));
29419 arg_conv.is_owned = false;
29420 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29421 uint32_t ret_conv = AcceptChannel_clone_ptr(&arg_conv);
29425 uint32_t __attribute__((export_name("TS_AcceptChannel_clone"))) TS_AcceptChannel_clone(uint32_t orig) {
29426 LDKAcceptChannel orig_conv;
29427 orig_conv.inner = (void*)(orig & (~1));
29428 orig_conv.is_owned = false;
29429 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29430 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
29431 uint32_t ret_ref = 0;
29432 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29433 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29435 ret_ref = (uintptr_t)ret_var.inner;
29436 if (ret_var.is_owned) {
29442 void __attribute__((export_name("TS_FundingCreated_free"))) TS_FundingCreated_free(uint32_t this_obj) {
29443 LDKFundingCreated this_obj_conv;
29444 this_obj_conv.inner = (void*)(this_obj & (~1));
29445 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29447 FundingCreated_free(this_obj_conv);
29450 int8_tArray __attribute__((export_name("TS_FundingCreated_get_temporary_channel_id"))) TS_FundingCreated_get_temporary_channel_id(uint32_t this_ptr) {
29451 LDKFundingCreated this_ptr_conv;
29452 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29453 this_ptr_conv.is_owned = false;
29454 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29455 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29456 memcpy(ret_arr->elems, *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
29460 void __attribute__((export_name("TS_FundingCreated_set_temporary_channel_id"))) TS_FundingCreated_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
29461 LDKFundingCreated this_ptr_conv;
29462 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29463 this_ptr_conv.is_owned = false;
29464 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29465 LDKThirtyTwoBytes val_ref;
29466 CHECK(val->arr_len == 32);
29467 memcpy(val_ref.data, val->elems, 32); FREE(val);
29468 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
29471 int8_tArray __attribute__((export_name("TS_FundingCreated_get_funding_txid"))) TS_FundingCreated_get_funding_txid(uint32_t this_ptr) {
29472 LDKFundingCreated this_ptr_conv;
29473 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29474 this_ptr_conv.is_owned = false;
29475 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29476 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29477 memcpy(ret_arr->elems, *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
29481 void __attribute__((export_name("TS_FundingCreated_set_funding_txid"))) TS_FundingCreated_set_funding_txid(uint32_t this_ptr, int8_tArray val) {
29482 LDKFundingCreated this_ptr_conv;
29483 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29484 this_ptr_conv.is_owned = false;
29485 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29486 LDKThirtyTwoBytes val_ref;
29487 CHECK(val->arr_len == 32);
29488 memcpy(val_ref.data, val->elems, 32); FREE(val);
29489 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
29492 int16_t __attribute__((export_name("TS_FundingCreated_get_funding_output_index"))) TS_FundingCreated_get_funding_output_index(uint32_t this_ptr) {
29493 LDKFundingCreated this_ptr_conv;
29494 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29495 this_ptr_conv.is_owned = false;
29496 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29497 int16_t ret_conv = FundingCreated_get_funding_output_index(&this_ptr_conv);
29501 void __attribute__((export_name("TS_FundingCreated_set_funding_output_index"))) TS_FundingCreated_set_funding_output_index(uint32_t this_ptr, int16_t val) {
29502 LDKFundingCreated this_ptr_conv;
29503 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29504 this_ptr_conv.is_owned = false;
29505 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29506 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
29509 int8_tArray __attribute__((export_name("TS_FundingCreated_get_signature"))) TS_FundingCreated_get_signature(uint32_t this_ptr) {
29510 LDKFundingCreated this_ptr_conv;
29511 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29512 this_ptr_conv.is_owned = false;
29513 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29514 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
29515 memcpy(ret_arr->elems, FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
29519 void __attribute__((export_name("TS_FundingCreated_set_signature"))) TS_FundingCreated_set_signature(uint32_t this_ptr, int8_tArray val) {
29520 LDKFundingCreated this_ptr_conv;
29521 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29522 this_ptr_conv.is_owned = false;
29523 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29524 LDKSignature val_ref;
29525 CHECK(val->arr_len == 64);
29526 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
29527 FundingCreated_set_signature(&this_ptr_conv, val_ref);
29530 uint32_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) {
29531 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
29532 CHECK(temporary_channel_id_arg->arr_len == 32);
29533 memcpy(temporary_channel_id_arg_ref.data, temporary_channel_id_arg->elems, 32); FREE(temporary_channel_id_arg);
29534 LDKThirtyTwoBytes funding_txid_arg_ref;
29535 CHECK(funding_txid_arg->arr_len == 32);
29536 memcpy(funding_txid_arg_ref.data, funding_txid_arg->elems, 32); FREE(funding_txid_arg);
29537 LDKSignature signature_arg_ref;
29538 CHECK(signature_arg->arr_len == 64);
29539 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
29540 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
29541 uint32_t ret_ref = 0;
29542 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29543 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29544 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29545 ret_ref = (uintptr_t)ret_var.inner;
29546 if (ret_var.is_owned) {
29552 static inline uintptr_t FundingCreated_clone_ptr(LDKFundingCreated *NONNULL_PTR arg) {
29553 LDKFundingCreated ret_var = FundingCreated_clone(arg);
29554 uint32_t ret_ref = 0;
29555 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29556 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29557 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29558 ret_ref = (uintptr_t)ret_var.inner;
29559 if (ret_var.is_owned) {
29564 uint32_t __attribute__((export_name("TS_FundingCreated_clone_ptr"))) TS_FundingCreated_clone_ptr(uint32_t arg) {
29565 LDKFundingCreated arg_conv;
29566 arg_conv.inner = (void*)(arg & (~1));
29567 arg_conv.is_owned = false;
29568 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29569 uint32_t ret_conv = FundingCreated_clone_ptr(&arg_conv);
29573 uint32_t __attribute__((export_name("TS_FundingCreated_clone"))) TS_FundingCreated_clone(uint32_t orig) {
29574 LDKFundingCreated orig_conv;
29575 orig_conv.inner = (void*)(orig & (~1));
29576 orig_conv.is_owned = false;
29577 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29578 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
29579 uint32_t ret_ref = 0;
29580 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29581 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29582 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29583 ret_ref = (uintptr_t)ret_var.inner;
29584 if (ret_var.is_owned) {
29590 void __attribute__((export_name("TS_FundingSigned_free"))) TS_FundingSigned_free(uint32_t this_obj) {
29591 LDKFundingSigned this_obj_conv;
29592 this_obj_conv.inner = (void*)(this_obj & (~1));
29593 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29594 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29595 FundingSigned_free(this_obj_conv);
29598 int8_tArray __attribute__((export_name("TS_FundingSigned_get_channel_id"))) TS_FundingSigned_get_channel_id(uint32_t this_ptr) {
29599 LDKFundingSigned this_ptr_conv;
29600 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29601 this_ptr_conv.is_owned = false;
29602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29603 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29604 memcpy(ret_arr->elems, *FundingSigned_get_channel_id(&this_ptr_conv), 32);
29608 void __attribute__((export_name("TS_FundingSigned_set_channel_id"))) TS_FundingSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
29609 LDKFundingSigned this_ptr_conv;
29610 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29611 this_ptr_conv.is_owned = false;
29612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29613 LDKThirtyTwoBytes val_ref;
29614 CHECK(val->arr_len == 32);
29615 memcpy(val_ref.data, val->elems, 32); FREE(val);
29616 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
29619 int8_tArray __attribute__((export_name("TS_FundingSigned_get_signature"))) TS_FundingSigned_get_signature(uint32_t this_ptr) {
29620 LDKFundingSigned this_ptr_conv;
29621 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29622 this_ptr_conv.is_owned = false;
29623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29624 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
29625 memcpy(ret_arr->elems, FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
29629 void __attribute__((export_name("TS_FundingSigned_set_signature"))) TS_FundingSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
29630 LDKFundingSigned this_ptr_conv;
29631 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29632 this_ptr_conv.is_owned = false;
29633 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29634 LDKSignature val_ref;
29635 CHECK(val->arr_len == 64);
29636 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
29637 FundingSigned_set_signature(&this_ptr_conv, val_ref);
29640 uint32_t __attribute__((export_name("TS_FundingSigned_new"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
29641 LDKThirtyTwoBytes channel_id_arg_ref;
29642 CHECK(channel_id_arg->arr_len == 32);
29643 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
29644 LDKSignature signature_arg_ref;
29645 CHECK(signature_arg->arr_len == 64);
29646 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
29647 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
29648 uint32_t ret_ref = 0;
29649 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29650 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29651 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29652 ret_ref = (uintptr_t)ret_var.inner;
29653 if (ret_var.is_owned) {
29659 static inline uintptr_t FundingSigned_clone_ptr(LDKFundingSigned *NONNULL_PTR arg) {
29660 LDKFundingSigned ret_var = FundingSigned_clone(arg);
29661 uint32_t ret_ref = 0;
29662 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29663 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29664 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29665 ret_ref = (uintptr_t)ret_var.inner;
29666 if (ret_var.is_owned) {
29671 uint32_t __attribute__((export_name("TS_FundingSigned_clone_ptr"))) TS_FundingSigned_clone_ptr(uint32_t arg) {
29672 LDKFundingSigned arg_conv;
29673 arg_conv.inner = (void*)(arg & (~1));
29674 arg_conv.is_owned = false;
29675 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29676 uint32_t ret_conv = FundingSigned_clone_ptr(&arg_conv);
29680 uint32_t __attribute__((export_name("TS_FundingSigned_clone"))) TS_FundingSigned_clone(uint32_t orig) {
29681 LDKFundingSigned orig_conv;
29682 orig_conv.inner = (void*)(orig & (~1));
29683 orig_conv.is_owned = false;
29684 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29685 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
29686 uint32_t ret_ref = 0;
29687 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29688 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29689 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29690 ret_ref = (uintptr_t)ret_var.inner;
29691 if (ret_var.is_owned) {
29697 void __attribute__((export_name("TS_ChannelReady_free"))) TS_ChannelReady_free(uint32_t this_obj) {
29698 LDKChannelReady this_obj_conv;
29699 this_obj_conv.inner = (void*)(this_obj & (~1));
29700 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29701 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29702 ChannelReady_free(this_obj_conv);
29705 int8_tArray __attribute__((export_name("TS_ChannelReady_get_channel_id"))) TS_ChannelReady_get_channel_id(uint32_t this_ptr) {
29706 LDKChannelReady this_ptr_conv;
29707 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29708 this_ptr_conv.is_owned = false;
29709 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29710 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29711 memcpy(ret_arr->elems, *ChannelReady_get_channel_id(&this_ptr_conv), 32);
29715 void __attribute__((export_name("TS_ChannelReady_set_channel_id"))) TS_ChannelReady_set_channel_id(uint32_t this_ptr, int8_tArray val) {
29716 LDKChannelReady this_ptr_conv;
29717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29718 this_ptr_conv.is_owned = false;
29719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29720 LDKThirtyTwoBytes val_ref;
29721 CHECK(val->arr_len == 32);
29722 memcpy(val_ref.data, val->elems, 32); FREE(val);
29723 ChannelReady_set_channel_id(&this_ptr_conv, val_ref);
29726 int8_tArray __attribute__((export_name("TS_ChannelReady_get_next_per_commitment_point"))) TS_ChannelReady_get_next_per_commitment_point(uint32_t this_ptr) {
29727 LDKChannelReady this_ptr_conv;
29728 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29729 this_ptr_conv.is_owned = false;
29730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29731 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
29732 memcpy(ret_arr->elems, ChannelReady_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
29736 void __attribute__((export_name("TS_ChannelReady_set_next_per_commitment_point"))) TS_ChannelReady_set_next_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
29737 LDKChannelReady this_ptr_conv;
29738 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29739 this_ptr_conv.is_owned = false;
29740 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29741 LDKPublicKey val_ref;
29742 CHECK(val->arr_len == 33);
29743 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
29744 ChannelReady_set_next_per_commitment_point(&this_ptr_conv, val_ref);
29747 uint32_t __attribute__((export_name("TS_ChannelReady_get_short_channel_id_alias"))) TS_ChannelReady_get_short_channel_id_alias(uint32_t this_ptr) {
29748 LDKChannelReady this_ptr_conv;
29749 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29750 this_ptr_conv.is_owned = false;
29751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29752 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
29753 *ret_copy = ChannelReady_get_short_channel_id_alias(&this_ptr_conv);
29754 uint32_t ret_ref = (uintptr_t)ret_copy;
29758 void __attribute__((export_name("TS_ChannelReady_set_short_channel_id_alias"))) TS_ChannelReady_set_short_channel_id_alias(uint32_t this_ptr, uint32_t val) {
29759 LDKChannelReady this_ptr_conv;
29760 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29761 this_ptr_conv.is_owned = false;
29762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29763 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
29764 CHECK_ACCESS(val_ptr);
29765 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
29766 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
29767 ChannelReady_set_short_channel_id_alias(&this_ptr_conv, val_conv);
29770 uint32_t __attribute__((export_name("TS_ChannelReady_new"))) TS_ChannelReady_new(int8_tArray channel_id_arg, int8_tArray next_per_commitment_point_arg, uint32_t short_channel_id_alias_arg) {
29771 LDKThirtyTwoBytes channel_id_arg_ref;
29772 CHECK(channel_id_arg->arr_len == 32);
29773 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
29774 LDKPublicKey next_per_commitment_point_arg_ref;
29775 CHECK(next_per_commitment_point_arg->arr_len == 33);
29776 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
29777 void* short_channel_id_alias_arg_ptr = (void*)(((uintptr_t)short_channel_id_alias_arg) & ~1);
29778 CHECK_ACCESS(short_channel_id_alias_arg_ptr);
29779 LDKCOption_u64Z short_channel_id_alias_arg_conv = *(LDKCOption_u64Z*)(short_channel_id_alias_arg_ptr);
29780 short_channel_id_alias_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)short_channel_id_alias_arg) & ~1));
29781 LDKChannelReady ret_var = ChannelReady_new(channel_id_arg_ref, next_per_commitment_point_arg_ref, short_channel_id_alias_arg_conv);
29782 uint32_t ret_ref = 0;
29783 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29784 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29785 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29786 ret_ref = (uintptr_t)ret_var.inner;
29787 if (ret_var.is_owned) {
29793 static inline uintptr_t ChannelReady_clone_ptr(LDKChannelReady *NONNULL_PTR arg) {
29794 LDKChannelReady ret_var = ChannelReady_clone(arg);
29795 uint32_t ret_ref = 0;
29796 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29797 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29798 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29799 ret_ref = (uintptr_t)ret_var.inner;
29800 if (ret_var.is_owned) {
29805 uint32_t __attribute__((export_name("TS_ChannelReady_clone_ptr"))) TS_ChannelReady_clone_ptr(uint32_t arg) {
29806 LDKChannelReady arg_conv;
29807 arg_conv.inner = (void*)(arg & (~1));
29808 arg_conv.is_owned = false;
29809 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29810 uint32_t ret_conv = ChannelReady_clone_ptr(&arg_conv);
29814 uint32_t __attribute__((export_name("TS_ChannelReady_clone"))) TS_ChannelReady_clone(uint32_t orig) {
29815 LDKChannelReady orig_conv;
29816 orig_conv.inner = (void*)(orig & (~1));
29817 orig_conv.is_owned = false;
29818 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29819 LDKChannelReady ret_var = ChannelReady_clone(&orig_conv);
29820 uint32_t ret_ref = 0;
29821 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29822 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29823 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29824 ret_ref = (uintptr_t)ret_var.inner;
29825 if (ret_var.is_owned) {
29831 void __attribute__((export_name("TS_Shutdown_free"))) TS_Shutdown_free(uint32_t this_obj) {
29832 LDKShutdown this_obj_conv;
29833 this_obj_conv.inner = (void*)(this_obj & (~1));
29834 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29835 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29836 Shutdown_free(this_obj_conv);
29839 int8_tArray __attribute__((export_name("TS_Shutdown_get_channel_id"))) TS_Shutdown_get_channel_id(uint32_t this_ptr) {
29840 LDKShutdown this_ptr_conv;
29841 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29842 this_ptr_conv.is_owned = false;
29843 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29844 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
29845 memcpy(ret_arr->elems, *Shutdown_get_channel_id(&this_ptr_conv), 32);
29849 void __attribute__((export_name("TS_Shutdown_set_channel_id"))) TS_Shutdown_set_channel_id(uint32_t this_ptr, int8_tArray val) {
29850 LDKShutdown this_ptr_conv;
29851 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29852 this_ptr_conv.is_owned = false;
29853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29854 LDKThirtyTwoBytes val_ref;
29855 CHECK(val->arr_len == 32);
29856 memcpy(val_ref.data, val->elems, 32); FREE(val);
29857 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
29860 int8_tArray __attribute__((export_name("TS_Shutdown_get_scriptpubkey"))) TS_Shutdown_get_scriptpubkey(uint32_t this_ptr) {
29861 LDKShutdown this_ptr_conv;
29862 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29863 this_ptr_conv.is_owned = false;
29864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29865 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
29866 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
29867 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
29871 void __attribute__((export_name("TS_Shutdown_set_scriptpubkey"))) TS_Shutdown_set_scriptpubkey(uint32_t this_ptr, int8_tArray val) {
29872 LDKShutdown this_ptr_conv;
29873 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29874 this_ptr_conv.is_owned = false;
29875 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29876 LDKCVec_u8Z val_ref;
29877 val_ref.datalen = val->arr_len;
29878 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
29879 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
29880 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
29883 uint32_t __attribute__((export_name("TS_Shutdown_new"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
29884 LDKThirtyTwoBytes channel_id_arg_ref;
29885 CHECK(channel_id_arg->arr_len == 32);
29886 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
29887 LDKCVec_u8Z scriptpubkey_arg_ref;
29888 scriptpubkey_arg_ref.datalen = scriptpubkey_arg->arr_len;
29889 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
29890 memcpy(scriptpubkey_arg_ref.data, scriptpubkey_arg->elems, scriptpubkey_arg_ref.datalen); FREE(scriptpubkey_arg);
29891 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
29892 uint32_t ret_ref = 0;
29893 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29894 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29895 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29896 ret_ref = (uintptr_t)ret_var.inner;
29897 if (ret_var.is_owned) {
29903 static inline uintptr_t Shutdown_clone_ptr(LDKShutdown *NONNULL_PTR arg) {
29904 LDKShutdown ret_var = Shutdown_clone(arg);
29905 uint32_t ret_ref = 0;
29906 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29907 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29908 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29909 ret_ref = (uintptr_t)ret_var.inner;
29910 if (ret_var.is_owned) {
29915 uint32_t __attribute__((export_name("TS_Shutdown_clone_ptr"))) TS_Shutdown_clone_ptr(uint32_t arg) {
29916 LDKShutdown arg_conv;
29917 arg_conv.inner = (void*)(arg & (~1));
29918 arg_conv.is_owned = false;
29919 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
29920 uint32_t ret_conv = Shutdown_clone_ptr(&arg_conv);
29924 uint32_t __attribute__((export_name("TS_Shutdown_clone"))) TS_Shutdown_clone(uint32_t orig) {
29925 LDKShutdown orig_conv;
29926 orig_conv.inner = (void*)(orig & (~1));
29927 orig_conv.is_owned = false;
29928 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
29929 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
29930 uint32_t ret_ref = 0;
29931 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29932 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29933 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29934 ret_ref = (uintptr_t)ret_var.inner;
29935 if (ret_var.is_owned) {
29941 void __attribute__((export_name("TS_ClosingSignedFeeRange_free"))) TS_ClosingSignedFeeRange_free(uint32_t this_obj) {
29942 LDKClosingSignedFeeRange this_obj_conv;
29943 this_obj_conv.inner = (void*)(this_obj & (~1));
29944 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
29945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
29946 ClosingSignedFeeRange_free(this_obj_conv);
29949 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_min_fee_satoshis"))) TS_ClosingSignedFeeRange_get_min_fee_satoshis(uint32_t this_ptr) {
29950 LDKClosingSignedFeeRange this_ptr_conv;
29951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29952 this_ptr_conv.is_owned = false;
29953 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29954 int64_t ret_conv = ClosingSignedFeeRange_get_min_fee_satoshis(&this_ptr_conv);
29958 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_min_fee_satoshis"))) TS_ClosingSignedFeeRange_set_min_fee_satoshis(uint32_t this_ptr, int64_t val) {
29959 LDKClosingSignedFeeRange this_ptr_conv;
29960 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29961 this_ptr_conv.is_owned = false;
29962 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29963 ClosingSignedFeeRange_set_min_fee_satoshis(&this_ptr_conv, val);
29966 int64_t __attribute__((export_name("TS_ClosingSignedFeeRange_get_max_fee_satoshis"))) TS_ClosingSignedFeeRange_get_max_fee_satoshis(uint32_t this_ptr) {
29967 LDKClosingSignedFeeRange this_ptr_conv;
29968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29969 this_ptr_conv.is_owned = false;
29970 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29971 int64_t ret_conv = ClosingSignedFeeRange_get_max_fee_satoshis(&this_ptr_conv);
29975 void __attribute__((export_name("TS_ClosingSignedFeeRange_set_max_fee_satoshis"))) TS_ClosingSignedFeeRange_set_max_fee_satoshis(uint32_t this_ptr, int64_t val) {
29976 LDKClosingSignedFeeRange this_ptr_conv;
29977 this_ptr_conv.inner = (void*)(this_ptr & (~1));
29978 this_ptr_conv.is_owned = false;
29979 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
29980 ClosingSignedFeeRange_set_max_fee_satoshis(&this_ptr_conv, val);
29983 uint32_t __attribute__((export_name("TS_ClosingSignedFeeRange_new"))) TS_ClosingSignedFeeRange_new(int64_t min_fee_satoshis_arg, int64_t max_fee_satoshis_arg) {
29984 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_new(min_fee_satoshis_arg, max_fee_satoshis_arg);
29985 uint32_t ret_ref = 0;
29986 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
29987 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
29988 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
29989 ret_ref = (uintptr_t)ret_var.inner;
29990 if (ret_var.is_owned) {
29996 static inline uintptr_t ClosingSignedFeeRange_clone_ptr(LDKClosingSignedFeeRange *NONNULL_PTR arg) {
29997 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(arg);
29998 uint32_t ret_ref = 0;
29999 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30000 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30001 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30002 ret_ref = (uintptr_t)ret_var.inner;
30003 if (ret_var.is_owned) {
30008 uint32_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone_ptr"))) TS_ClosingSignedFeeRange_clone_ptr(uint32_t arg) {
30009 LDKClosingSignedFeeRange arg_conv;
30010 arg_conv.inner = (void*)(arg & (~1));
30011 arg_conv.is_owned = false;
30012 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30013 uint32_t ret_conv = ClosingSignedFeeRange_clone_ptr(&arg_conv);
30017 uint32_t __attribute__((export_name("TS_ClosingSignedFeeRange_clone"))) TS_ClosingSignedFeeRange_clone(uint32_t orig) {
30018 LDKClosingSignedFeeRange orig_conv;
30019 orig_conv.inner = (void*)(orig & (~1));
30020 orig_conv.is_owned = false;
30021 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30022 LDKClosingSignedFeeRange ret_var = ClosingSignedFeeRange_clone(&orig_conv);
30023 uint32_t ret_ref = 0;
30024 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30025 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30026 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30027 ret_ref = (uintptr_t)ret_var.inner;
30028 if (ret_var.is_owned) {
30034 void __attribute__((export_name("TS_ClosingSigned_free"))) TS_ClosingSigned_free(uint32_t this_obj) {
30035 LDKClosingSigned this_obj_conv;
30036 this_obj_conv.inner = (void*)(this_obj & (~1));
30037 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30038 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30039 ClosingSigned_free(this_obj_conv);
30042 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_channel_id"))) TS_ClosingSigned_get_channel_id(uint32_t this_ptr) {
30043 LDKClosingSigned this_ptr_conv;
30044 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30045 this_ptr_conv.is_owned = false;
30046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30047 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30048 memcpy(ret_arr->elems, *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
30052 void __attribute__((export_name("TS_ClosingSigned_set_channel_id"))) TS_ClosingSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30053 LDKClosingSigned this_ptr_conv;
30054 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30055 this_ptr_conv.is_owned = false;
30056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30057 LDKThirtyTwoBytes val_ref;
30058 CHECK(val->arr_len == 32);
30059 memcpy(val_ref.data, val->elems, 32); FREE(val);
30060 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
30063 int64_t __attribute__((export_name("TS_ClosingSigned_get_fee_satoshis"))) TS_ClosingSigned_get_fee_satoshis(uint32_t this_ptr) {
30064 LDKClosingSigned this_ptr_conv;
30065 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30066 this_ptr_conv.is_owned = false;
30067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30068 int64_t ret_conv = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
30072 void __attribute__((export_name("TS_ClosingSigned_set_fee_satoshis"))) TS_ClosingSigned_set_fee_satoshis(uint32_t this_ptr, int64_t val) {
30073 LDKClosingSigned this_ptr_conv;
30074 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30075 this_ptr_conv.is_owned = false;
30076 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30077 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
30080 int8_tArray __attribute__((export_name("TS_ClosingSigned_get_signature"))) TS_ClosingSigned_get_signature(uint32_t this_ptr) {
30081 LDKClosingSigned this_ptr_conv;
30082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30083 this_ptr_conv.is_owned = false;
30084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30085 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
30086 memcpy(ret_arr->elems, ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
30090 void __attribute__((export_name("TS_ClosingSigned_set_signature"))) TS_ClosingSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
30091 LDKClosingSigned this_ptr_conv;
30092 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30093 this_ptr_conv.is_owned = false;
30094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30095 LDKSignature val_ref;
30096 CHECK(val->arr_len == 64);
30097 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
30098 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
30101 uint32_t __attribute__((export_name("TS_ClosingSigned_get_fee_range"))) TS_ClosingSigned_get_fee_range(uint32_t this_ptr) {
30102 LDKClosingSigned this_ptr_conv;
30103 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30104 this_ptr_conv.is_owned = false;
30105 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30106 LDKClosingSignedFeeRange ret_var = ClosingSigned_get_fee_range(&this_ptr_conv);
30107 uint32_t ret_ref = 0;
30108 if ((uintptr_t)ret_var.inner > 4096) {
30109 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30110 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30112 ret_ref = (uintptr_t)ret_var.inner;
30113 if (ret_var.is_owned) {
30120 void __attribute__((export_name("TS_ClosingSigned_set_fee_range"))) TS_ClosingSigned_set_fee_range(uint32_t this_ptr, uint32_t val) {
30121 LDKClosingSigned this_ptr_conv;
30122 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30123 this_ptr_conv.is_owned = false;
30124 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30125 LDKClosingSignedFeeRange val_conv;
30126 val_conv.inner = (void*)(val & (~1));
30127 val_conv.is_owned = (val & 1) || (val == 0);
30128 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
30129 val_conv = ClosingSignedFeeRange_clone(&val_conv);
30130 ClosingSigned_set_fee_range(&this_ptr_conv, val_conv);
30133 uint32_t __attribute__((export_name("TS_ClosingSigned_new"))) TS_ClosingSigned_new(int8_tArray channel_id_arg, int64_t fee_satoshis_arg, int8_tArray signature_arg, uint32_t fee_range_arg) {
30134 LDKThirtyTwoBytes channel_id_arg_ref;
30135 CHECK(channel_id_arg->arr_len == 32);
30136 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30137 LDKSignature signature_arg_ref;
30138 CHECK(signature_arg->arr_len == 64);
30139 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
30140 LDKClosingSignedFeeRange fee_range_arg_conv;
30141 fee_range_arg_conv.inner = (void*)(fee_range_arg & (~1));
30142 fee_range_arg_conv.is_owned = (fee_range_arg & 1) || (fee_range_arg == 0);
30143 CHECK_INNER_FIELD_ACCESS_OR_NULL(fee_range_arg_conv);
30144 fee_range_arg_conv = ClosingSignedFeeRange_clone(&fee_range_arg_conv);
30145 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref, fee_range_arg_conv);
30146 uint32_t ret_ref = 0;
30147 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30148 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30149 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30150 ret_ref = (uintptr_t)ret_var.inner;
30151 if (ret_var.is_owned) {
30157 static inline uintptr_t ClosingSigned_clone_ptr(LDKClosingSigned *NONNULL_PTR arg) {
30158 LDKClosingSigned ret_var = ClosingSigned_clone(arg);
30159 uint32_t ret_ref = 0;
30160 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30161 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30162 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30163 ret_ref = (uintptr_t)ret_var.inner;
30164 if (ret_var.is_owned) {
30169 uint32_t __attribute__((export_name("TS_ClosingSigned_clone_ptr"))) TS_ClosingSigned_clone_ptr(uint32_t arg) {
30170 LDKClosingSigned arg_conv;
30171 arg_conv.inner = (void*)(arg & (~1));
30172 arg_conv.is_owned = false;
30173 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30174 uint32_t ret_conv = ClosingSigned_clone_ptr(&arg_conv);
30178 uint32_t __attribute__((export_name("TS_ClosingSigned_clone"))) TS_ClosingSigned_clone(uint32_t orig) {
30179 LDKClosingSigned orig_conv;
30180 orig_conv.inner = (void*)(orig & (~1));
30181 orig_conv.is_owned = false;
30182 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30183 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
30184 uint32_t ret_ref = 0;
30185 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30186 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30187 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30188 ret_ref = (uintptr_t)ret_var.inner;
30189 if (ret_var.is_owned) {
30195 void __attribute__((export_name("TS_UpdateAddHTLC_free"))) TS_UpdateAddHTLC_free(uint32_t this_obj) {
30196 LDKUpdateAddHTLC this_obj_conv;
30197 this_obj_conv.inner = (void*)(this_obj & (~1));
30198 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30199 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30200 UpdateAddHTLC_free(this_obj_conv);
30203 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_channel_id"))) TS_UpdateAddHTLC_get_channel_id(uint32_t this_ptr) {
30204 LDKUpdateAddHTLC this_ptr_conv;
30205 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30206 this_ptr_conv.is_owned = false;
30207 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30208 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30209 memcpy(ret_arr->elems, *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
30213 void __attribute__((export_name("TS_UpdateAddHTLC_set_channel_id"))) TS_UpdateAddHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30214 LDKUpdateAddHTLC this_ptr_conv;
30215 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30216 this_ptr_conv.is_owned = false;
30217 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30218 LDKThirtyTwoBytes val_ref;
30219 CHECK(val->arr_len == 32);
30220 memcpy(val_ref.data, val->elems, 32); FREE(val);
30221 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
30224 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_htlc_id"))) TS_UpdateAddHTLC_get_htlc_id(uint32_t this_ptr) {
30225 LDKUpdateAddHTLC this_ptr_conv;
30226 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30227 this_ptr_conv.is_owned = false;
30228 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30229 int64_t ret_conv = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
30233 void __attribute__((export_name("TS_UpdateAddHTLC_set_htlc_id"))) TS_UpdateAddHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
30234 LDKUpdateAddHTLC this_ptr_conv;
30235 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30236 this_ptr_conv.is_owned = false;
30237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30238 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
30241 int64_t __attribute__((export_name("TS_UpdateAddHTLC_get_amount_msat"))) TS_UpdateAddHTLC_get_amount_msat(uint32_t this_ptr) {
30242 LDKUpdateAddHTLC this_ptr_conv;
30243 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30244 this_ptr_conv.is_owned = false;
30245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30246 int64_t ret_conv = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
30250 void __attribute__((export_name("TS_UpdateAddHTLC_set_amount_msat"))) TS_UpdateAddHTLC_set_amount_msat(uint32_t this_ptr, int64_t val) {
30251 LDKUpdateAddHTLC this_ptr_conv;
30252 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30253 this_ptr_conv.is_owned = false;
30254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30255 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
30258 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_get_payment_hash"))) TS_UpdateAddHTLC_get_payment_hash(uint32_t this_ptr) {
30259 LDKUpdateAddHTLC this_ptr_conv;
30260 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30261 this_ptr_conv.is_owned = false;
30262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30263 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30264 memcpy(ret_arr->elems, *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
30268 void __attribute__((export_name("TS_UpdateAddHTLC_set_payment_hash"))) TS_UpdateAddHTLC_set_payment_hash(uint32_t this_ptr, int8_tArray val) {
30269 LDKUpdateAddHTLC this_ptr_conv;
30270 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30271 this_ptr_conv.is_owned = false;
30272 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30273 LDKThirtyTwoBytes val_ref;
30274 CHECK(val->arr_len == 32);
30275 memcpy(val_ref.data, val->elems, 32); FREE(val);
30276 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
30279 int32_t __attribute__((export_name("TS_UpdateAddHTLC_get_cltv_expiry"))) TS_UpdateAddHTLC_get_cltv_expiry(uint32_t this_ptr) {
30280 LDKUpdateAddHTLC this_ptr_conv;
30281 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30282 this_ptr_conv.is_owned = false;
30283 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30284 int32_t ret_conv = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
30288 void __attribute__((export_name("TS_UpdateAddHTLC_set_cltv_expiry"))) TS_UpdateAddHTLC_set_cltv_expiry(uint32_t this_ptr, int32_t val) {
30289 LDKUpdateAddHTLC this_ptr_conv;
30290 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30291 this_ptr_conv.is_owned = false;
30292 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30293 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
30296 static inline uintptr_t UpdateAddHTLC_clone_ptr(LDKUpdateAddHTLC *NONNULL_PTR arg) {
30297 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(arg);
30298 uint32_t ret_ref = 0;
30299 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30300 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30301 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30302 ret_ref = (uintptr_t)ret_var.inner;
30303 if (ret_var.is_owned) {
30308 uint32_t __attribute__((export_name("TS_UpdateAddHTLC_clone_ptr"))) TS_UpdateAddHTLC_clone_ptr(uint32_t arg) {
30309 LDKUpdateAddHTLC arg_conv;
30310 arg_conv.inner = (void*)(arg & (~1));
30311 arg_conv.is_owned = false;
30312 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30313 uint32_t ret_conv = UpdateAddHTLC_clone_ptr(&arg_conv);
30317 uint32_t __attribute__((export_name("TS_UpdateAddHTLC_clone"))) TS_UpdateAddHTLC_clone(uint32_t orig) {
30318 LDKUpdateAddHTLC orig_conv;
30319 orig_conv.inner = (void*)(orig & (~1));
30320 orig_conv.is_owned = false;
30321 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30322 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
30323 uint32_t ret_ref = 0;
30324 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30325 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30326 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30327 ret_ref = (uintptr_t)ret_var.inner;
30328 if (ret_var.is_owned) {
30334 void __attribute__((export_name("TS_UpdateFulfillHTLC_free"))) TS_UpdateFulfillHTLC_free(uint32_t this_obj) {
30335 LDKUpdateFulfillHTLC this_obj_conv;
30336 this_obj_conv.inner = (void*)(this_obj & (~1));
30337 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30339 UpdateFulfillHTLC_free(this_obj_conv);
30342 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_channel_id"))) TS_UpdateFulfillHTLC_get_channel_id(uint32_t this_ptr) {
30343 LDKUpdateFulfillHTLC this_ptr_conv;
30344 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30345 this_ptr_conv.is_owned = false;
30346 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30347 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30348 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
30352 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_channel_id"))) TS_UpdateFulfillHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30353 LDKUpdateFulfillHTLC this_ptr_conv;
30354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30355 this_ptr_conv.is_owned = false;
30356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30357 LDKThirtyTwoBytes val_ref;
30358 CHECK(val->arr_len == 32);
30359 memcpy(val_ref.data, val->elems, 32); FREE(val);
30360 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
30363 int64_t __attribute__((export_name("TS_UpdateFulfillHTLC_get_htlc_id"))) TS_UpdateFulfillHTLC_get_htlc_id(uint32_t this_ptr) {
30364 LDKUpdateFulfillHTLC this_ptr_conv;
30365 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30366 this_ptr_conv.is_owned = false;
30367 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30368 int64_t ret_conv = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
30372 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_htlc_id"))) TS_UpdateFulfillHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
30373 LDKUpdateFulfillHTLC this_ptr_conv;
30374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30375 this_ptr_conv.is_owned = false;
30376 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30377 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
30380 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_get_payment_preimage"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint32_t this_ptr) {
30381 LDKUpdateFulfillHTLC this_ptr_conv;
30382 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30383 this_ptr_conv.is_owned = false;
30384 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30385 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30386 memcpy(ret_arr->elems, *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
30390 void __attribute__((export_name("TS_UpdateFulfillHTLC_set_payment_preimage"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint32_t this_ptr, int8_tArray val) {
30391 LDKUpdateFulfillHTLC this_ptr_conv;
30392 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30393 this_ptr_conv.is_owned = false;
30394 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30395 LDKThirtyTwoBytes val_ref;
30396 CHECK(val->arr_len == 32);
30397 memcpy(val_ref.data, val->elems, 32); FREE(val);
30398 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
30401 uint32_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) {
30402 LDKThirtyTwoBytes channel_id_arg_ref;
30403 CHECK(channel_id_arg->arr_len == 32);
30404 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30405 LDKThirtyTwoBytes payment_preimage_arg_ref;
30406 CHECK(payment_preimage_arg->arr_len == 32);
30407 memcpy(payment_preimage_arg_ref.data, payment_preimage_arg->elems, 32); FREE(payment_preimage_arg);
30408 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
30409 uint32_t ret_ref = 0;
30410 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30411 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30412 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30413 ret_ref = (uintptr_t)ret_var.inner;
30414 if (ret_var.is_owned) {
30420 static inline uintptr_t UpdateFulfillHTLC_clone_ptr(LDKUpdateFulfillHTLC *NONNULL_PTR arg) {
30421 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(arg);
30422 uint32_t ret_ref = 0;
30423 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30424 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30425 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30426 ret_ref = (uintptr_t)ret_var.inner;
30427 if (ret_var.is_owned) {
30432 uint32_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone_ptr"))) TS_UpdateFulfillHTLC_clone_ptr(uint32_t arg) {
30433 LDKUpdateFulfillHTLC arg_conv;
30434 arg_conv.inner = (void*)(arg & (~1));
30435 arg_conv.is_owned = false;
30436 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30437 uint32_t ret_conv = UpdateFulfillHTLC_clone_ptr(&arg_conv);
30441 uint32_t __attribute__((export_name("TS_UpdateFulfillHTLC_clone"))) TS_UpdateFulfillHTLC_clone(uint32_t orig) {
30442 LDKUpdateFulfillHTLC orig_conv;
30443 orig_conv.inner = (void*)(orig & (~1));
30444 orig_conv.is_owned = false;
30445 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30446 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
30447 uint32_t ret_ref = 0;
30448 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30449 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30451 ret_ref = (uintptr_t)ret_var.inner;
30452 if (ret_var.is_owned) {
30458 void __attribute__((export_name("TS_UpdateFailHTLC_free"))) TS_UpdateFailHTLC_free(uint32_t this_obj) {
30459 LDKUpdateFailHTLC this_obj_conv;
30460 this_obj_conv.inner = (void*)(this_obj & (~1));
30461 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30463 UpdateFailHTLC_free(this_obj_conv);
30466 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_get_channel_id"))) TS_UpdateFailHTLC_get_channel_id(uint32_t this_ptr) {
30467 LDKUpdateFailHTLC this_ptr_conv;
30468 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30469 this_ptr_conv.is_owned = false;
30470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30471 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30472 memcpy(ret_arr->elems, *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
30476 void __attribute__((export_name("TS_UpdateFailHTLC_set_channel_id"))) TS_UpdateFailHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30477 LDKUpdateFailHTLC this_ptr_conv;
30478 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30479 this_ptr_conv.is_owned = false;
30480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30481 LDKThirtyTwoBytes val_ref;
30482 CHECK(val->arr_len == 32);
30483 memcpy(val_ref.data, val->elems, 32); FREE(val);
30484 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
30487 int64_t __attribute__((export_name("TS_UpdateFailHTLC_get_htlc_id"))) TS_UpdateFailHTLC_get_htlc_id(uint32_t this_ptr) {
30488 LDKUpdateFailHTLC this_ptr_conv;
30489 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30490 this_ptr_conv.is_owned = false;
30491 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30492 int64_t ret_conv = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
30496 void __attribute__((export_name("TS_UpdateFailHTLC_set_htlc_id"))) TS_UpdateFailHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
30497 LDKUpdateFailHTLC this_ptr_conv;
30498 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30499 this_ptr_conv.is_owned = false;
30500 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30501 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
30504 static inline uintptr_t UpdateFailHTLC_clone_ptr(LDKUpdateFailHTLC *NONNULL_PTR arg) {
30505 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(arg);
30506 uint32_t ret_ref = 0;
30507 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30508 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30509 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30510 ret_ref = (uintptr_t)ret_var.inner;
30511 if (ret_var.is_owned) {
30516 uint32_t __attribute__((export_name("TS_UpdateFailHTLC_clone_ptr"))) TS_UpdateFailHTLC_clone_ptr(uint32_t arg) {
30517 LDKUpdateFailHTLC arg_conv;
30518 arg_conv.inner = (void*)(arg & (~1));
30519 arg_conv.is_owned = false;
30520 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30521 uint32_t ret_conv = UpdateFailHTLC_clone_ptr(&arg_conv);
30525 uint32_t __attribute__((export_name("TS_UpdateFailHTLC_clone"))) TS_UpdateFailHTLC_clone(uint32_t orig) {
30526 LDKUpdateFailHTLC orig_conv;
30527 orig_conv.inner = (void*)(orig & (~1));
30528 orig_conv.is_owned = false;
30529 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30530 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
30531 uint32_t ret_ref = 0;
30532 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30533 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30534 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30535 ret_ref = (uintptr_t)ret_var.inner;
30536 if (ret_var.is_owned) {
30542 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_free"))) TS_UpdateFailMalformedHTLC_free(uint32_t this_obj) {
30543 LDKUpdateFailMalformedHTLC this_obj_conv;
30544 this_obj_conv.inner = (void*)(this_obj & (~1));
30545 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30546 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30547 UpdateFailMalformedHTLC_free(this_obj_conv);
30550 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_channel_id"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint32_t this_ptr) {
30551 LDKUpdateFailMalformedHTLC this_ptr_conv;
30552 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30553 this_ptr_conv.is_owned = false;
30554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30555 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30556 memcpy(ret_arr->elems, *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
30560 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_channel_id"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30561 LDKUpdateFailMalformedHTLC this_ptr_conv;
30562 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30563 this_ptr_conv.is_owned = false;
30564 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30565 LDKThirtyTwoBytes val_ref;
30566 CHECK(val->arr_len == 32);
30567 memcpy(val_ref.data, val->elems, 32); FREE(val);
30568 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
30571 int64_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_htlc_id"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint32_t this_ptr) {
30572 LDKUpdateFailMalformedHTLC this_ptr_conv;
30573 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30574 this_ptr_conv.is_owned = false;
30575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30576 int64_t ret_conv = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
30580 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_htlc_id"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
30581 LDKUpdateFailMalformedHTLC this_ptr_conv;
30582 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30583 this_ptr_conv.is_owned = false;
30584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30585 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
30588 int16_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_get_failure_code"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint32_t this_ptr) {
30589 LDKUpdateFailMalformedHTLC this_ptr_conv;
30590 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30591 this_ptr_conv.is_owned = false;
30592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30593 int16_t ret_conv = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
30597 void __attribute__((export_name("TS_UpdateFailMalformedHTLC_set_failure_code"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint32_t this_ptr, int16_t val) {
30598 LDKUpdateFailMalformedHTLC this_ptr_conv;
30599 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30600 this_ptr_conv.is_owned = false;
30601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30602 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
30605 static inline uintptr_t UpdateFailMalformedHTLC_clone_ptr(LDKUpdateFailMalformedHTLC *NONNULL_PTR arg) {
30606 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(arg);
30607 uint32_t ret_ref = 0;
30608 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30609 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30610 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30611 ret_ref = (uintptr_t)ret_var.inner;
30612 if (ret_var.is_owned) {
30617 uint32_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone_ptr"))) TS_UpdateFailMalformedHTLC_clone_ptr(uint32_t arg) {
30618 LDKUpdateFailMalformedHTLC arg_conv;
30619 arg_conv.inner = (void*)(arg & (~1));
30620 arg_conv.is_owned = false;
30621 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30622 uint32_t ret_conv = UpdateFailMalformedHTLC_clone_ptr(&arg_conv);
30626 uint32_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_clone"))) TS_UpdateFailMalformedHTLC_clone(uint32_t orig) {
30627 LDKUpdateFailMalformedHTLC orig_conv;
30628 orig_conv.inner = (void*)(orig & (~1));
30629 orig_conv.is_owned = false;
30630 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30631 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
30632 uint32_t ret_ref = 0;
30633 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30634 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30635 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30636 ret_ref = (uintptr_t)ret_var.inner;
30637 if (ret_var.is_owned) {
30643 void __attribute__((export_name("TS_CommitmentSigned_free"))) TS_CommitmentSigned_free(uint32_t this_obj) {
30644 LDKCommitmentSigned this_obj_conv;
30645 this_obj_conv.inner = (void*)(this_obj & (~1));
30646 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30647 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30648 CommitmentSigned_free(this_obj_conv);
30651 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_channel_id"))) TS_CommitmentSigned_get_channel_id(uint32_t this_ptr) {
30652 LDKCommitmentSigned this_ptr_conv;
30653 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30654 this_ptr_conv.is_owned = false;
30655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30656 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30657 memcpy(ret_arr->elems, *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
30661 void __attribute__((export_name("TS_CommitmentSigned_set_channel_id"))) TS_CommitmentSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30662 LDKCommitmentSigned this_ptr_conv;
30663 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30664 this_ptr_conv.is_owned = false;
30665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30666 LDKThirtyTwoBytes val_ref;
30667 CHECK(val->arr_len == 32);
30668 memcpy(val_ref.data, val->elems, 32); FREE(val);
30669 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
30672 int8_tArray __attribute__((export_name("TS_CommitmentSigned_get_signature"))) TS_CommitmentSigned_get_signature(uint32_t this_ptr) {
30673 LDKCommitmentSigned this_ptr_conv;
30674 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30675 this_ptr_conv.is_owned = false;
30676 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30677 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
30678 memcpy(ret_arr->elems, CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
30682 void __attribute__((export_name("TS_CommitmentSigned_set_signature"))) TS_CommitmentSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
30683 LDKCommitmentSigned this_ptr_conv;
30684 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30685 this_ptr_conv.is_owned = false;
30686 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30687 LDKSignature val_ref;
30688 CHECK(val->arr_len == 64);
30689 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
30690 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
30693 void __attribute__((export_name("TS_CommitmentSigned_set_htlc_signatures"))) TS_CommitmentSigned_set_htlc_signatures(uint32_t this_ptr, ptrArray val) {
30694 LDKCommitmentSigned this_ptr_conv;
30695 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30696 this_ptr_conv.is_owned = false;
30697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30698 LDKCVec_SignatureZ val_constr;
30699 val_constr.datalen = val->arr_len;
30700 if (val_constr.datalen > 0)
30701 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
30703 val_constr.data = NULL;
30704 int8_tArray* val_vals = (void*) val->elems;
30705 for (size_t m = 0; m < val_constr.datalen; m++) {
30706 int8_tArray val_conv_12 = val_vals[m];
30707 LDKSignature val_conv_12_ref;
30708 CHECK(val_conv_12->arr_len == 64);
30709 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
30710 val_constr.data[m] = val_conv_12_ref;
30713 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
30716 uint32_t __attribute__((export_name("TS_CommitmentSigned_new"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
30717 LDKThirtyTwoBytes channel_id_arg_ref;
30718 CHECK(channel_id_arg->arr_len == 32);
30719 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30720 LDKSignature signature_arg_ref;
30721 CHECK(signature_arg->arr_len == 64);
30722 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
30723 LDKCVec_SignatureZ htlc_signatures_arg_constr;
30724 htlc_signatures_arg_constr.datalen = htlc_signatures_arg->arr_len;
30725 if (htlc_signatures_arg_constr.datalen > 0)
30726 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
30728 htlc_signatures_arg_constr.data = NULL;
30729 int8_tArray* htlc_signatures_arg_vals = (void*) htlc_signatures_arg->elems;
30730 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
30731 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
30732 LDKSignature htlc_signatures_arg_conv_12_ref;
30733 CHECK(htlc_signatures_arg_conv_12->arr_len == 64);
30734 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, htlc_signatures_arg_conv_12->elems, 64); FREE(htlc_signatures_arg_conv_12);
30735 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
30737 FREE(htlc_signatures_arg);
30738 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
30739 uint32_t ret_ref = 0;
30740 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30741 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30743 ret_ref = (uintptr_t)ret_var.inner;
30744 if (ret_var.is_owned) {
30750 static inline uintptr_t CommitmentSigned_clone_ptr(LDKCommitmentSigned *NONNULL_PTR arg) {
30751 LDKCommitmentSigned ret_var = CommitmentSigned_clone(arg);
30752 uint32_t ret_ref = 0;
30753 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30754 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30755 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30756 ret_ref = (uintptr_t)ret_var.inner;
30757 if (ret_var.is_owned) {
30762 uint32_t __attribute__((export_name("TS_CommitmentSigned_clone_ptr"))) TS_CommitmentSigned_clone_ptr(uint32_t arg) {
30763 LDKCommitmentSigned arg_conv;
30764 arg_conv.inner = (void*)(arg & (~1));
30765 arg_conv.is_owned = false;
30766 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30767 uint32_t ret_conv = CommitmentSigned_clone_ptr(&arg_conv);
30771 uint32_t __attribute__((export_name("TS_CommitmentSigned_clone"))) TS_CommitmentSigned_clone(uint32_t orig) {
30772 LDKCommitmentSigned orig_conv;
30773 orig_conv.inner = (void*)(orig & (~1));
30774 orig_conv.is_owned = false;
30775 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30776 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
30777 uint32_t ret_ref = 0;
30778 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30779 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30780 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30781 ret_ref = (uintptr_t)ret_var.inner;
30782 if (ret_var.is_owned) {
30788 void __attribute__((export_name("TS_RevokeAndACK_free"))) TS_RevokeAndACK_free(uint32_t this_obj) {
30789 LDKRevokeAndACK this_obj_conv;
30790 this_obj_conv.inner = (void*)(this_obj & (~1));
30791 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30792 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30793 RevokeAndACK_free(this_obj_conv);
30796 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_channel_id"))) TS_RevokeAndACK_get_channel_id(uint32_t this_ptr) {
30797 LDKRevokeAndACK this_ptr_conv;
30798 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30799 this_ptr_conv.is_owned = false;
30800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30801 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30802 memcpy(ret_arr->elems, *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
30806 void __attribute__((export_name("TS_RevokeAndACK_set_channel_id"))) TS_RevokeAndACK_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30807 LDKRevokeAndACK this_ptr_conv;
30808 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30809 this_ptr_conv.is_owned = false;
30810 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30811 LDKThirtyTwoBytes val_ref;
30812 CHECK(val->arr_len == 32);
30813 memcpy(val_ref.data, val->elems, 32); FREE(val);
30814 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
30817 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_per_commitment_secret"))) TS_RevokeAndACK_get_per_commitment_secret(uint32_t this_ptr) {
30818 LDKRevokeAndACK this_ptr_conv;
30819 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30820 this_ptr_conv.is_owned = false;
30821 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30822 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30823 memcpy(ret_arr->elems, *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
30827 void __attribute__((export_name("TS_RevokeAndACK_set_per_commitment_secret"))) TS_RevokeAndACK_set_per_commitment_secret(uint32_t this_ptr, int8_tArray val) {
30828 LDKRevokeAndACK this_ptr_conv;
30829 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30830 this_ptr_conv.is_owned = false;
30831 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30832 LDKThirtyTwoBytes val_ref;
30833 CHECK(val->arr_len == 32);
30834 memcpy(val_ref.data, val->elems, 32); FREE(val);
30835 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
30838 int8_tArray __attribute__((export_name("TS_RevokeAndACK_get_next_per_commitment_point"))) TS_RevokeAndACK_get_next_per_commitment_point(uint32_t this_ptr) {
30839 LDKRevokeAndACK this_ptr_conv;
30840 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30841 this_ptr_conv.is_owned = false;
30842 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30843 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
30844 memcpy(ret_arr->elems, RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
30848 void __attribute__((export_name("TS_RevokeAndACK_set_next_per_commitment_point"))) TS_RevokeAndACK_set_next_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
30849 LDKRevokeAndACK this_ptr_conv;
30850 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30851 this_ptr_conv.is_owned = false;
30852 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30853 LDKPublicKey val_ref;
30854 CHECK(val->arr_len == 33);
30855 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
30856 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
30859 uint32_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) {
30860 LDKThirtyTwoBytes channel_id_arg_ref;
30861 CHECK(channel_id_arg->arr_len == 32);
30862 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30863 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
30864 CHECK(per_commitment_secret_arg->arr_len == 32);
30865 memcpy(per_commitment_secret_arg_ref.data, per_commitment_secret_arg->elems, 32); FREE(per_commitment_secret_arg);
30866 LDKPublicKey next_per_commitment_point_arg_ref;
30867 CHECK(next_per_commitment_point_arg->arr_len == 33);
30868 memcpy(next_per_commitment_point_arg_ref.compressed_form, next_per_commitment_point_arg->elems, 33); FREE(next_per_commitment_point_arg);
30869 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
30870 uint32_t ret_ref = 0;
30871 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30872 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30873 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30874 ret_ref = (uintptr_t)ret_var.inner;
30875 if (ret_var.is_owned) {
30881 static inline uintptr_t RevokeAndACK_clone_ptr(LDKRevokeAndACK *NONNULL_PTR arg) {
30882 LDKRevokeAndACK ret_var = RevokeAndACK_clone(arg);
30883 uint32_t ret_ref = 0;
30884 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30885 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30886 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30887 ret_ref = (uintptr_t)ret_var.inner;
30888 if (ret_var.is_owned) {
30893 uint32_t __attribute__((export_name("TS_RevokeAndACK_clone_ptr"))) TS_RevokeAndACK_clone_ptr(uint32_t arg) {
30894 LDKRevokeAndACK arg_conv;
30895 arg_conv.inner = (void*)(arg & (~1));
30896 arg_conv.is_owned = false;
30897 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30898 uint32_t ret_conv = RevokeAndACK_clone_ptr(&arg_conv);
30902 uint32_t __attribute__((export_name("TS_RevokeAndACK_clone"))) TS_RevokeAndACK_clone(uint32_t orig) {
30903 LDKRevokeAndACK orig_conv;
30904 orig_conv.inner = (void*)(orig & (~1));
30905 orig_conv.is_owned = false;
30906 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
30907 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
30908 uint32_t ret_ref = 0;
30909 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30910 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30911 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30912 ret_ref = (uintptr_t)ret_var.inner;
30913 if (ret_var.is_owned) {
30919 void __attribute__((export_name("TS_UpdateFee_free"))) TS_UpdateFee_free(uint32_t this_obj) {
30920 LDKUpdateFee this_obj_conv;
30921 this_obj_conv.inner = (void*)(this_obj & (~1));
30922 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
30923 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
30924 UpdateFee_free(this_obj_conv);
30927 int8_tArray __attribute__((export_name("TS_UpdateFee_get_channel_id"))) TS_UpdateFee_get_channel_id(uint32_t this_ptr) {
30928 LDKUpdateFee this_ptr_conv;
30929 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30930 this_ptr_conv.is_owned = false;
30931 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30932 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
30933 memcpy(ret_arr->elems, *UpdateFee_get_channel_id(&this_ptr_conv), 32);
30937 void __attribute__((export_name("TS_UpdateFee_set_channel_id"))) TS_UpdateFee_set_channel_id(uint32_t this_ptr, int8_tArray val) {
30938 LDKUpdateFee this_ptr_conv;
30939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30940 this_ptr_conv.is_owned = false;
30941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30942 LDKThirtyTwoBytes val_ref;
30943 CHECK(val->arr_len == 32);
30944 memcpy(val_ref.data, val->elems, 32); FREE(val);
30945 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
30948 int32_t __attribute__((export_name("TS_UpdateFee_get_feerate_per_kw"))) TS_UpdateFee_get_feerate_per_kw(uint32_t this_ptr) {
30949 LDKUpdateFee this_ptr_conv;
30950 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30951 this_ptr_conv.is_owned = false;
30952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30953 int32_t ret_conv = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
30957 void __attribute__((export_name("TS_UpdateFee_set_feerate_per_kw"))) TS_UpdateFee_set_feerate_per_kw(uint32_t this_ptr, int32_t val) {
30958 LDKUpdateFee this_ptr_conv;
30959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
30960 this_ptr_conv.is_owned = false;
30961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
30962 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
30965 uint32_t __attribute__((export_name("TS_UpdateFee_new"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
30966 LDKThirtyTwoBytes channel_id_arg_ref;
30967 CHECK(channel_id_arg->arr_len == 32);
30968 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
30969 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
30970 uint32_t ret_ref = 0;
30971 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30972 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30973 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30974 ret_ref = (uintptr_t)ret_var.inner;
30975 if (ret_var.is_owned) {
30981 static inline uintptr_t UpdateFee_clone_ptr(LDKUpdateFee *NONNULL_PTR arg) {
30982 LDKUpdateFee ret_var = UpdateFee_clone(arg);
30983 uint32_t ret_ref = 0;
30984 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
30985 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
30986 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
30987 ret_ref = (uintptr_t)ret_var.inner;
30988 if (ret_var.is_owned) {
30993 uint32_t __attribute__((export_name("TS_UpdateFee_clone_ptr"))) TS_UpdateFee_clone_ptr(uint32_t arg) {
30994 LDKUpdateFee arg_conv;
30995 arg_conv.inner = (void*)(arg & (~1));
30996 arg_conv.is_owned = false;
30997 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
30998 uint32_t ret_conv = UpdateFee_clone_ptr(&arg_conv);
31002 uint32_t __attribute__((export_name("TS_UpdateFee_clone"))) TS_UpdateFee_clone(uint32_t orig) {
31003 LDKUpdateFee orig_conv;
31004 orig_conv.inner = (void*)(orig & (~1));
31005 orig_conv.is_owned = false;
31006 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31007 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
31008 uint32_t ret_ref = 0;
31009 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31010 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31011 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31012 ret_ref = (uintptr_t)ret_var.inner;
31013 if (ret_var.is_owned) {
31019 void __attribute__((export_name("TS_DataLossProtect_free"))) TS_DataLossProtect_free(uint32_t this_obj) {
31020 LDKDataLossProtect this_obj_conv;
31021 this_obj_conv.inner = (void*)(this_obj & (~1));
31022 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31023 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31024 DataLossProtect_free(this_obj_conv);
31027 int8_tArray __attribute__((export_name("TS_DataLossProtect_get_your_last_per_commitment_secret"))) TS_DataLossProtect_get_your_last_per_commitment_secret(uint32_t this_ptr) {
31028 LDKDataLossProtect this_ptr_conv;
31029 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31030 this_ptr_conv.is_owned = false;
31031 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31032 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31033 memcpy(ret_arr->elems, *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
31037 void __attribute__((export_name("TS_DataLossProtect_set_your_last_per_commitment_secret"))) TS_DataLossProtect_set_your_last_per_commitment_secret(uint32_t this_ptr, int8_tArray val) {
31038 LDKDataLossProtect this_ptr_conv;
31039 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31040 this_ptr_conv.is_owned = false;
31041 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31042 LDKThirtyTwoBytes val_ref;
31043 CHECK(val->arr_len == 32);
31044 memcpy(val_ref.data, val->elems, 32); FREE(val);
31045 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
31048 int8_tArray __attribute__((export_name("TS_DataLossProtect_get_my_current_per_commitment_point"))) TS_DataLossProtect_get_my_current_per_commitment_point(uint32_t this_ptr) {
31049 LDKDataLossProtect this_ptr_conv;
31050 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31051 this_ptr_conv.is_owned = false;
31052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31053 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31054 memcpy(ret_arr->elems, DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
31058 void __attribute__((export_name("TS_DataLossProtect_set_my_current_per_commitment_point"))) TS_DataLossProtect_set_my_current_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
31059 LDKDataLossProtect this_ptr_conv;
31060 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31061 this_ptr_conv.is_owned = false;
31062 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31063 LDKPublicKey val_ref;
31064 CHECK(val->arr_len == 33);
31065 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31066 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
31069 uint32_t __attribute__((export_name("TS_DataLossProtect_new"))) TS_DataLossProtect_new(int8_tArray your_last_per_commitment_secret_arg, int8_tArray my_current_per_commitment_point_arg) {
31070 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
31071 CHECK(your_last_per_commitment_secret_arg->arr_len == 32);
31072 memcpy(your_last_per_commitment_secret_arg_ref.data, your_last_per_commitment_secret_arg->elems, 32); FREE(your_last_per_commitment_secret_arg);
31073 LDKPublicKey my_current_per_commitment_point_arg_ref;
31074 CHECK(my_current_per_commitment_point_arg->arr_len == 33);
31075 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);
31076 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
31077 uint32_t ret_ref = 0;
31078 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31079 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31080 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31081 ret_ref = (uintptr_t)ret_var.inner;
31082 if (ret_var.is_owned) {
31088 static inline uintptr_t DataLossProtect_clone_ptr(LDKDataLossProtect *NONNULL_PTR arg) {
31089 LDKDataLossProtect ret_var = DataLossProtect_clone(arg);
31090 uint32_t ret_ref = 0;
31091 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31092 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31093 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31094 ret_ref = (uintptr_t)ret_var.inner;
31095 if (ret_var.is_owned) {
31100 uint32_t __attribute__((export_name("TS_DataLossProtect_clone_ptr"))) TS_DataLossProtect_clone_ptr(uint32_t arg) {
31101 LDKDataLossProtect arg_conv;
31102 arg_conv.inner = (void*)(arg & (~1));
31103 arg_conv.is_owned = false;
31104 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31105 uint32_t ret_conv = DataLossProtect_clone_ptr(&arg_conv);
31109 uint32_t __attribute__((export_name("TS_DataLossProtect_clone"))) TS_DataLossProtect_clone(uint32_t orig) {
31110 LDKDataLossProtect orig_conv;
31111 orig_conv.inner = (void*)(orig & (~1));
31112 orig_conv.is_owned = false;
31113 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31114 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
31115 uint32_t ret_ref = 0;
31116 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31117 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31119 ret_ref = (uintptr_t)ret_var.inner;
31120 if (ret_var.is_owned) {
31126 void __attribute__((export_name("TS_ChannelReestablish_free"))) TS_ChannelReestablish_free(uint32_t this_obj) {
31127 LDKChannelReestablish this_obj_conv;
31128 this_obj_conv.inner = (void*)(this_obj & (~1));
31129 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31130 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31131 ChannelReestablish_free(this_obj_conv);
31134 int8_tArray __attribute__((export_name("TS_ChannelReestablish_get_channel_id"))) TS_ChannelReestablish_get_channel_id(uint32_t this_ptr) {
31135 LDKChannelReestablish this_ptr_conv;
31136 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31137 this_ptr_conv.is_owned = false;
31138 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31139 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31140 memcpy(ret_arr->elems, *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
31144 void __attribute__((export_name("TS_ChannelReestablish_set_channel_id"))) TS_ChannelReestablish_set_channel_id(uint32_t this_ptr, int8_tArray val) {
31145 LDKChannelReestablish this_ptr_conv;
31146 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31147 this_ptr_conv.is_owned = false;
31148 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31149 LDKThirtyTwoBytes val_ref;
31150 CHECK(val->arr_len == 32);
31151 memcpy(val_ref.data, val->elems, 32); FREE(val);
31152 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
31155 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_local_commitment_number"))) TS_ChannelReestablish_get_next_local_commitment_number(uint32_t this_ptr) {
31156 LDKChannelReestablish this_ptr_conv;
31157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31158 this_ptr_conv.is_owned = false;
31159 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31160 int64_t ret_conv = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
31164 void __attribute__((export_name("TS_ChannelReestablish_set_next_local_commitment_number"))) TS_ChannelReestablish_set_next_local_commitment_number(uint32_t this_ptr, int64_t val) {
31165 LDKChannelReestablish this_ptr_conv;
31166 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31167 this_ptr_conv.is_owned = false;
31168 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31169 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
31172 int64_t __attribute__((export_name("TS_ChannelReestablish_get_next_remote_commitment_number"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint32_t this_ptr) {
31173 LDKChannelReestablish this_ptr_conv;
31174 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31175 this_ptr_conv.is_owned = false;
31176 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31177 int64_t ret_conv = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
31181 void __attribute__((export_name("TS_ChannelReestablish_set_next_remote_commitment_number"))) TS_ChannelReestablish_set_next_remote_commitment_number(uint32_t this_ptr, int64_t val) {
31182 LDKChannelReestablish this_ptr_conv;
31183 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31184 this_ptr_conv.is_owned = false;
31185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31186 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
31189 static inline uintptr_t ChannelReestablish_clone_ptr(LDKChannelReestablish *NONNULL_PTR arg) {
31190 LDKChannelReestablish ret_var = ChannelReestablish_clone(arg);
31191 uint32_t ret_ref = 0;
31192 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31193 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31194 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31195 ret_ref = (uintptr_t)ret_var.inner;
31196 if (ret_var.is_owned) {
31201 uint32_t __attribute__((export_name("TS_ChannelReestablish_clone_ptr"))) TS_ChannelReestablish_clone_ptr(uint32_t arg) {
31202 LDKChannelReestablish arg_conv;
31203 arg_conv.inner = (void*)(arg & (~1));
31204 arg_conv.is_owned = false;
31205 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31206 uint32_t ret_conv = ChannelReestablish_clone_ptr(&arg_conv);
31210 uint32_t __attribute__((export_name("TS_ChannelReestablish_clone"))) TS_ChannelReestablish_clone(uint32_t orig) {
31211 LDKChannelReestablish orig_conv;
31212 orig_conv.inner = (void*)(orig & (~1));
31213 orig_conv.is_owned = false;
31214 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31215 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
31216 uint32_t ret_ref = 0;
31217 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31218 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31219 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31220 ret_ref = (uintptr_t)ret_var.inner;
31221 if (ret_var.is_owned) {
31227 void __attribute__((export_name("TS_AnnouncementSignatures_free"))) TS_AnnouncementSignatures_free(uint32_t this_obj) {
31228 LDKAnnouncementSignatures this_obj_conv;
31229 this_obj_conv.inner = (void*)(this_obj & (~1));
31230 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31231 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31232 AnnouncementSignatures_free(this_obj_conv);
31235 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_channel_id"))) TS_AnnouncementSignatures_get_channel_id(uint32_t this_ptr) {
31236 LDKAnnouncementSignatures this_ptr_conv;
31237 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31238 this_ptr_conv.is_owned = false;
31239 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31240 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31241 memcpy(ret_arr->elems, *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
31245 void __attribute__((export_name("TS_AnnouncementSignatures_set_channel_id"))) TS_AnnouncementSignatures_set_channel_id(uint32_t this_ptr, int8_tArray val) {
31246 LDKAnnouncementSignatures this_ptr_conv;
31247 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31248 this_ptr_conv.is_owned = false;
31249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31250 LDKThirtyTwoBytes val_ref;
31251 CHECK(val->arr_len == 32);
31252 memcpy(val_ref.data, val->elems, 32); FREE(val);
31253 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
31256 int64_t __attribute__((export_name("TS_AnnouncementSignatures_get_short_channel_id"))) TS_AnnouncementSignatures_get_short_channel_id(uint32_t this_ptr) {
31257 LDKAnnouncementSignatures this_ptr_conv;
31258 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31259 this_ptr_conv.is_owned = false;
31260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31261 int64_t ret_conv = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
31265 void __attribute__((export_name("TS_AnnouncementSignatures_set_short_channel_id"))) TS_AnnouncementSignatures_set_short_channel_id(uint32_t this_ptr, int64_t val) {
31266 LDKAnnouncementSignatures this_ptr_conv;
31267 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31268 this_ptr_conv.is_owned = false;
31269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31270 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
31273 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_node_signature"))) TS_AnnouncementSignatures_get_node_signature(uint32_t this_ptr) {
31274 LDKAnnouncementSignatures this_ptr_conv;
31275 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31276 this_ptr_conv.is_owned = false;
31277 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31278 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31279 memcpy(ret_arr->elems, AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
31283 void __attribute__((export_name("TS_AnnouncementSignatures_set_node_signature"))) TS_AnnouncementSignatures_set_node_signature(uint32_t this_ptr, int8_tArray val) {
31284 LDKAnnouncementSignatures this_ptr_conv;
31285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31286 this_ptr_conv.is_owned = false;
31287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31288 LDKSignature val_ref;
31289 CHECK(val->arr_len == 64);
31290 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31291 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
31294 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_get_bitcoin_signature"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint32_t this_ptr) {
31295 LDKAnnouncementSignatures this_ptr_conv;
31296 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31297 this_ptr_conv.is_owned = false;
31298 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31299 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31300 memcpy(ret_arr->elems, AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
31304 void __attribute__((export_name("TS_AnnouncementSignatures_set_bitcoin_signature"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint32_t this_ptr, int8_tArray val) {
31305 LDKAnnouncementSignatures this_ptr_conv;
31306 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31307 this_ptr_conv.is_owned = false;
31308 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31309 LDKSignature val_ref;
31310 CHECK(val->arr_len == 64);
31311 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31312 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
31315 uint32_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) {
31316 LDKThirtyTwoBytes channel_id_arg_ref;
31317 CHECK(channel_id_arg->arr_len == 32);
31318 memcpy(channel_id_arg_ref.data, channel_id_arg->elems, 32); FREE(channel_id_arg);
31319 LDKSignature node_signature_arg_ref;
31320 CHECK(node_signature_arg->arr_len == 64);
31321 memcpy(node_signature_arg_ref.compact_form, node_signature_arg->elems, 64); FREE(node_signature_arg);
31322 LDKSignature bitcoin_signature_arg_ref;
31323 CHECK(bitcoin_signature_arg->arr_len == 64);
31324 memcpy(bitcoin_signature_arg_ref.compact_form, bitcoin_signature_arg->elems, 64); FREE(bitcoin_signature_arg);
31325 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
31326 uint32_t ret_ref = 0;
31327 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31328 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31329 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31330 ret_ref = (uintptr_t)ret_var.inner;
31331 if (ret_var.is_owned) {
31337 static inline uintptr_t AnnouncementSignatures_clone_ptr(LDKAnnouncementSignatures *NONNULL_PTR arg) {
31338 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(arg);
31339 uint32_t ret_ref = 0;
31340 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31341 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31342 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31343 ret_ref = (uintptr_t)ret_var.inner;
31344 if (ret_var.is_owned) {
31349 uint32_t __attribute__((export_name("TS_AnnouncementSignatures_clone_ptr"))) TS_AnnouncementSignatures_clone_ptr(uint32_t arg) {
31350 LDKAnnouncementSignatures arg_conv;
31351 arg_conv.inner = (void*)(arg & (~1));
31352 arg_conv.is_owned = false;
31353 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31354 uint32_t ret_conv = AnnouncementSignatures_clone_ptr(&arg_conv);
31358 uint32_t __attribute__((export_name("TS_AnnouncementSignatures_clone"))) TS_AnnouncementSignatures_clone(uint32_t orig) {
31359 LDKAnnouncementSignatures orig_conv;
31360 orig_conv.inner = (void*)(orig & (~1));
31361 orig_conv.is_owned = false;
31362 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31363 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
31364 uint32_t ret_ref = 0;
31365 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31366 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31367 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31368 ret_ref = (uintptr_t)ret_var.inner;
31369 if (ret_var.is_owned) {
31375 void __attribute__((export_name("TS_NetAddress_free"))) TS_NetAddress_free(uint32_t this_ptr) {
31376 if ((this_ptr & 1) != 0) return;
31377 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
31378 CHECK_ACCESS(this_ptr_ptr);
31379 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(this_ptr_ptr);
31380 FREE((void*)this_ptr);
31381 NetAddress_free(this_ptr_conv);
31384 static inline uintptr_t NetAddress_clone_ptr(LDKNetAddress *NONNULL_PTR arg) {
31385 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31386 *ret_copy = NetAddress_clone(arg);
31387 uint32_t ret_ref = (uintptr_t)ret_copy;
31390 uint32_t __attribute__((export_name("TS_NetAddress_clone_ptr"))) TS_NetAddress_clone_ptr(uint32_t arg) {
31391 LDKNetAddress* arg_conv = (LDKNetAddress*)arg;
31392 uint32_t ret_conv = NetAddress_clone_ptr(arg_conv);
31396 uint32_t __attribute__((export_name("TS_NetAddress_clone"))) TS_NetAddress_clone(uint32_t orig) {
31397 LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
31398 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31399 *ret_copy = NetAddress_clone(orig_conv);
31400 uint32_t ret_ref = (uintptr_t)ret_copy;
31404 uint32_t __attribute__((export_name("TS_NetAddress_ipv4"))) TS_NetAddress_ipv4(int8_tArray addr, int16_t port) {
31405 LDKFourBytes addr_ref;
31406 CHECK(addr->arr_len == 4);
31407 memcpy(addr_ref.data, addr->elems, 4); FREE(addr);
31408 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31409 *ret_copy = NetAddress_ipv4(addr_ref, port);
31410 uint32_t ret_ref = (uintptr_t)ret_copy;
31414 uint32_t __attribute__((export_name("TS_NetAddress_ipv6"))) TS_NetAddress_ipv6(int8_tArray addr, int16_t port) {
31415 LDKSixteenBytes addr_ref;
31416 CHECK(addr->arr_len == 16);
31417 memcpy(addr_ref.data, addr->elems, 16); FREE(addr);
31418 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31419 *ret_copy = NetAddress_ipv6(addr_ref, port);
31420 uint32_t ret_ref = (uintptr_t)ret_copy;
31424 uint32_t __attribute__((export_name("TS_NetAddress_onion_v2"))) TS_NetAddress_onion_v2(int8_tArray a) {
31425 LDKTwelveBytes a_ref;
31426 CHECK(a->arr_len == 12);
31427 memcpy(a_ref.data, a->elems, 12); FREE(a);
31428 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31429 *ret_copy = NetAddress_onion_v2(a_ref);
31430 uint32_t ret_ref = (uintptr_t)ret_copy;
31434 uint32_t __attribute__((export_name("TS_NetAddress_onion_v3"))) TS_NetAddress_onion_v3(int8_tArray ed25519_pubkey, int16_t checksum, int8_t version, int16_t port) {
31435 LDKThirtyTwoBytes ed25519_pubkey_ref;
31436 CHECK(ed25519_pubkey->arr_len == 32);
31437 memcpy(ed25519_pubkey_ref.data, ed25519_pubkey->elems, 32); FREE(ed25519_pubkey);
31438 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31439 *ret_copy = NetAddress_onion_v3(ed25519_pubkey_ref, checksum, version, port);
31440 uint32_t ret_ref = (uintptr_t)ret_copy;
31444 uint32_t __attribute__((export_name("TS_NetAddress_hostname"))) TS_NetAddress_hostname(uint32_t hostname, int16_t port) {
31445 LDKHostname hostname_conv;
31446 hostname_conv.inner = (void*)(hostname & (~1));
31447 hostname_conv.is_owned = (hostname & 1) || (hostname == 0);
31448 CHECK_INNER_FIELD_ACCESS_OR_NULL(hostname_conv);
31449 hostname_conv = Hostname_clone(&hostname_conv);
31450 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
31451 *ret_copy = NetAddress_hostname(hostname_conv, port);
31452 uint32_t ret_ref = (uintptr_t)ret_copy;
31456 int8_tArray __attribute__((export_name("TS_NetAddress_write"))) TS_NetAddress_write(uint32_t obj) {
31457 LDKNetAddress* obj_conv = (LDKNetAddress*)obj;
31458 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
31459 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
31460 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
31461 CVec_u8Z_free(ret_var);
31465 uint32_t __attribute__((export_name("TS_NetAddress_read"))) TS_NetAddress_read(int8_tArray ser) {
31466 LDKu8slice ser_ref;
31467 ser_ref.datalen = ser->arr_len;
31468 ser_ref.data = ser->elems;
31469 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
31470 *ret_conv = NetAddress_read(ser_ref);
31472 return (uint32_t)ret_conv;
31475 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_free"))) TS_UnsignedNodeAnnouncement_free(uint32_t this_obj) {
31476 LDKUnsignedNodeAnnouncement this_obj_conv;
31477 this_obj_conv.inner = (void*)(this_obj & (~1));
31478 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31480 UnsignedNodeAnnouncement_free(this_obj_conv);
31483 uint32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_features"))) TS_UnsignedNodeAnnouncement_get_features(uint32_t this_ptr) {
31484 LDKUnsignedNodeAnnouncement this_ptr_conv;
31485 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31486 this_ptr_conv.is_owned = false;
31487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31488 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
31489 uint32_t ret_ref = 0;
31490 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31491 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31492 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31493 ret_ref = (uintptr_t)ret_var.inner;
31494 if (ret_var.is_owned) {
31500 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_features"))) TS_UnsignedNodeAnnouncement_set_features(uint32_t this_ptr, uint32_t val) {
31501 LDKUnsignedNodeAnnouncement this_ptr_conv;
31502 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31503 this_ptr_conv.is_owned = false;
31504 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31505 LDKNodeFeatures val_conv;
31506 val_conv.inner = (void*)(val & (~1));
31507 val_conv.is_owned = (val & 1) || (val == 0);
31508 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31509 val_conv = NodeFeatures_clone(&val_conv);
31510 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
31513 int32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_timestamp"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint32_t this_ptr) {
31514 LDKUnsignedNodeAnnouncement this_ptr_conv;
31515 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31516 this_ptr_conv.is_owned = false;
31517 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31518 int32_t ret_conv = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
31522 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_timestamp"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint32_t this_ptr, int32_t val) {
31523 LDKUnsignedNodeAnnouncement this_ptr_conv;
31524 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31525 this_ptr_conv.is_owned = false;
31526 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31527 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
31530 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_node_id"))) TS_UnsignedNodeAnnouncement_get_node_id(uint32_t this_ptr) {
31531 LDKUnsignedNodeAnnouncement this_ptr_conv;
31532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31533 this_ptr_conv.is_owned = false;
31534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31535 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31536 memcpy(ret_arr->elems, UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form, 33);
31540 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_node_id"))) TS_UnsignedNodeAnnouncement_set_node_id(uint32_t this_ptr, int8_tArray val) {
31541 LDKUnsignedNodeAnnouncement this_ptr_conv;
31542 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31543 this_ptr_conv.is_owned = false;
31544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31545 LDKPublicKey val_ref;
31546 CHECK(val->arr_len == 33);
31547 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31548 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_ref);
31551 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_rgb"))) TS_UnsignedNodeAnnouncement_get_rgb(uint32_t this_ptr) {
31552 LDKUnsignedNodeAnnouncement this_ptr_conv;
31553 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31554 this_ptr_conv.is_owned = false;
31555 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31556 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
31557 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
31561 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_rgb"))) TS_UnsignedNodeAnnouncement_set_rgb(uint32_t this_ptr, int8_tArray val) {
31562 LDKUnsignedNodeAnnouncement this_ptr_conv;
31563 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31564 this_ptr_conv.is_owned = false;
31565 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31566 LDKThreeBytes val_ref;
31567 CHECK(val->arr_len == 3);
31568 memcpy(val_ref.data, val->elems, 3); FREE(val);
31569 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
31572 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_get_alias"))) TS_UnsignedNodeAnnouncement_get_alias(uint32_t this_ptr) {
31573 LDKUnsignedNodeAnnouncement this_ptr_conv;
31574 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31575 this_ptr_conv.is_owned = false;
31576 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31577 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31578 memcpy(ret_arr->elems, *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv), 32);
31582 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_alias"))) TS_UnsignedNodeAnnouncement_set_alias(uint32_t this_ptr, int8_tArray val) {
31583 LDKUnsignedNodeAnnouncement this_ptr_conv;
31584 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31585 this_ptr_conv.is_owned = false;
31586 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31587 LDKThirtyTwoBytes val_ref;
31588 CHECK(val->arr_len == 32);
31589 memcpy(val_ref.data, val->elems, 32); FREE(val);
31590 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_ref);
31593 void __attribute__((export_name("TS_UnsignedNodeAnnouncement_set_addresses"))) TS_UnsignedNodeAnnouncement_set_addresses(uint32_t this_ptr, uint32_tArray val) {
31594 LDKUnsignedNodeAnnouncement this_ptr_conv;
31595 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31596 this_ptr_conv.is_owned = false;
31597 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31598 LDKCVec_NetAddressZ val_constr;
31599 val_constr.datalen = val->arr_len;
31600 if (val_constr.datalen > 0)
31601 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
31603 val_constr.data = NULL;
31604 uint32_t* val_vals = val->elems;
31605 for (size_t m = 0; m < val_constr.datalen; m++) {
31606 uint32_t val_conv_12 = val_vals[m];
31607 void* val_conv_12_ptr = (void*)(((uintptr_t)val_conv_12) & ~1);
31608 CHECK_ACCESS(val_conv_12_ptr);
31609 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
31610 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uintptr_t)val_conv_12) & ~1));
31611 val_constr.data[m] = val_conv_12_conv;
31614 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
31617 static inline uintptr_t UnsignedNodeAnnouncement_clone_ptr(LDKUnsignedNodeAnnouncement *NONNULL_PTR arg) {
31618 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(arg);
31619 uint32_t ret_ref = 0;
31620 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31621 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31622 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31623 ret_ref = (uintptr_t)ret_var.inner;
31624 if (ret_var.is_owned) {
31629 uint32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone_ptr"))) TS_UnsignedNodeAnnouncement_clone_ptr(uint32_t arg) {
31630 LDKUnsignedNodeAnnouncement arg_conv;
31631 arg_conv.inner = (void*)(arg & (~1));
31632 arg_conv.is_owned = false;
31633 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31634 uint32_t ret_conv = UnsignedNodeAnnouncement_clone_ptr(&arg_conv);
31638 uint32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_clone"))) TS_UnsignedNodeAnnouncement_clone(uint32_t orig) {
31639 LDKUnsignedNodeAnnouncement orig_conv;
31640 orig_conv.inner = (void*)(orig & (~1));
31641 orig_conv.is_owned = false;
31642 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31643 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
31644 uint32_t ret_ref = 0;
31645 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31646 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31647 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31648 ret_ref = (uintptr_t)ret_var.inner;
31649 if (ret_var.is_owned) {
31655 void __attribute__((export_name("TS_NodeAnnouncement_free"))) TS_NodeAnnouncement_free(uint32_t this_obj) {
31656 LDKNodeAnnouncement this_obj_conv;
31657 this_obj_conv.inner = (void*)(this_obj & (~1));
31658 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31659 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31660 NodeAnnouncement_free(this_obj_conv);
31663 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_get_signature"))) TS_NodeAnnouncement_get_signature(uint32_t this_ptr) {
31664 LDKNodeAnnouncement this_ptr_conv;
31665 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31666 this_ptr_conv.is_owned = false;
31667 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31668 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31669 memcpy(ret_arr->elems, NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
31673 void __attribute__((export_name("TS_NodeAnnouncement_set_signature"))) TS_NodeAnnouncement_set_signature(uint32_t this_ptr, int8_tArray val) {
31674 LDKNodeAnnouncement this_ptr_conv;
31675 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31676 this_ptr_conv.is_owned = false;
31677 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31678 LDKSignature val_ref;
31679 CHECK(val->arr_len == 64);
31680 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31681 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
31684 uint32_t __attribute__((export_name("TS_NodeAnnouncement_get_contents"))) TS_NodeAnnouncement_get_contents(uint32_t this_ptr) {
31685 LDKNodeAnnouncement this_ptr_conv;
31686 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31687 this_ptr_conv.is_owned = false;
31688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31689 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
31690 uint32_t ret_ref = 0;
31691 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31692 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31693 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31694 ret_ref = (uintptr_t)ret_var.inner;
31695 if (ret_var.is_owned) {
31701 void __attribute__((export_name("TS_NodeAnnouncement_set_contents"))) TS_NodeAnnouncement_set_contents(uint32_t this_ptr, uint32_t val) {
31702 LDKNodeAnnouncement this_ptr_conv;
31703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31704 this_ptr_conv.is_owned = false;
31705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31706 LDKUnsignedNodeAnnouncement val_conv;
31707 val_conv.inner = (void*)(val & (~1));
31708 val_conv.is_owned = (val & 1) || (val == 0);
31709 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31710 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
31711 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
31714 uint32_t __attribute__((export_name("TS_NodeAnnouncement_new"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint32_t contents_arg) {
31715 LDKSignature signature_arg_ref;
31716 CHECK(signature_arg->arr_len == 64);
31717 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
31718 LDKUnsignedNodeAnnouncement contents_arg_conv;
31719 contents_arg_conv.inner = (void*)(contents_arg & (~1));
31720 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
31721 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
31722 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
31723 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
31724 uint32_t ret_ref = 0;
31725 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31726 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31727 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31728 ret_ref = (uintptr_t)ret_var.inner;
31729 if (ret_var.is_owned) {
31735 static inline uintptr_t NodeAnnouncement_clone_ptr(LDKNodeAnnouncement *NONNULL_PTR arg) {
31736 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(arg);
31737 uint32_t ret_ref = 0;
31738 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31739 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31740 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31741 ret_ref = (uintptr_t)ret_var.inner;
31742 if (ret_var.is_owned) {
31747 uint32_t __attribute__((export_name("TS_NodeAnnouncement_clone_ptr"))) TS_NodeAnnouncement_clone_ptr(uint32_t arg) {
31748 LDKNodeAnnouncement arg_conv;
31749 arg_conv.inner = (void*)(arg & (~1));
31750 arg_conv.is_owned = false;
31751 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31752 uint32_t ret_conv = NodeAnnouncement_clone_ptr(&arg_conv);
31756 uint32_t __attribute__((export_name("TS_NodeAnnouncement_clone"))) TS_NodeAnnouncement_clone(uint32_t orig) {
31757 LDKNodeAnnouncement orig_conv;
31758 orig_conv.inner = (void*)(orig & (~1));
31759 orig_conv.is_owned = false;
31760 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31761 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
31762 uint32_t ret_ref = 0;
31763 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31764 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31765 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31766 ret_ref = (uintptr_t)ret_var.inner;
31767 if (ret_var.is_owned) {
31773 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_free"))) TS_UnsignedChannelAnnouncement_free(uint32_t this_obj) {
31774 LDKUnsignedChannelAnnouncement this_obj_conv;
31775 this_obj_conv.inner = (void*)(this_obj & (~1));
31776 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31777 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31778 UnsignedChannelAnnouncement_free(this_obj_conv);
31781 uint32_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_features"))) TS_UnsignedChannelAnnouncement_get_features(uint32_t this_ptr) {
31782 LDKUnsignedChannelAnnouncement this_ptr_conv;
31783 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31784 this_ptr_conv.is_owned = false;
31785 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31786 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
31787 uint32_t ret_ref = 0;
31788 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31789 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31790 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31791 ret_ref = (uintptr_t)ret_var.inner;
31792 if (ret_var.is_owned) {
31798 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_features"))) TS_UnsignedChannelAnnouncement_set_features(uint32_t this_ptr, uint32_t val) {
31799 LDKUnsignedChannelAnnouncement this_ptr_conv;
31800 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31801 this_ptr_conv.is_owned = false;
31802 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31803 LDKChannelFeatures val_conv;
31804 val_conv.inner = (void*)(val & (~1));
31805 val_conv.is_owned = (val & 1) || (val == 0);
31806 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
31807 val_conv = ChannelFeatures_clone(&val_conv);
31808 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
31811 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_chain_hash"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint32_t this_ptr) {
31812 LDKUnsignedChannelAnnouncement this_ptr_conv;
31813 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31814 this_ptr_conv.is_owned = false;
31815 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31816 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
31817 memcpy(ret_arr->elems, *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
31821 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_chain_hash"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
31822 LDKUnsignedChannelAnnouncement this_ptr_conv;
31823 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31824 this_ptr_conv.is_owned = false;
31825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31826 LDKThirtyTwoBytes val_ref;
31827 CHECK(val->arr_len == 32);
31828 memcpy(val_ref.data, val->elems, 32); FREE(val);
31829 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
31832 int64_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_short_channel_id"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint32_t this_ptr) {
31833 LDKUnsignedChannelAnnouncement this_ptr_conv;
31834 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31835 this_ptr_conv.is_owned = false;
31836 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31837 int64_t ret_conv = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
31841 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_short_channel_id"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint32_t this_ptr, int64_t val) {
31842 LDKUnsignedChannelAnnouncement this_ptr_conv;
31843 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31844 this_ptr_conv.is_owned = false;
31845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31846 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
31849 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_1"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint32_t this_ptr) {
31850 LDKUnsignedChannelAnnouncement this_ptr_conv;
31851 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31852 this_ptr_conv.is_owned = false;
31853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31854 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31855 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form, 33);
31859 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_1"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint32_t this_ptr, int8_tArray val) {
31860 LDKUnsignedChannelAnnouncement this_ptr_conv;
31861 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31862 this_ptr_conv.is_owned = false;
31863 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31864 LDKPublicKey val_ref;
31865 CHECK(val->arr_len == 33);
31866 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31867 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_ref);
31870 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_node_id_2"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint32_t this_ptr) {
31871 LDKUnsignedChannelAnnouncement this_ptr_conv;
31872 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31873 this_ptr_conv.is_owned = false;
31874 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31875 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31876 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form, 33);
31880 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_node_id_2"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint32_t this_ptr, int8_tArray val) {
31881 LDKUnsignedChannelAnnouncement this_ptr_conv;
31882 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31883 this_ptr_conv.is_owned = false;
31884 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31885 LDKPublicKey val_ref;
31886 CHECK(val->arr_len == 33);
31887 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31888 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_ref);
31891 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint32_t this_ptr) {
31892 LDKUnsignedChannelAnnouncement this_ptr_conv;
31893 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31894 this_ptr_conv.is_owned = false;
31895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31896 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31897 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form, 33);
31901 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_1"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint32_t this_ptr, int8_tArray val) {
31902 LDKUnsignedChannelAnnouncement this_ptr_conv;
31903 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31904 this_ptr_conv.is_owned = false;
31905 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31906 LDKPublicKey val_ref;
31907 CHECK(val->arr_len == 33);
31908 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31909 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_ref);
31912 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_get_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint32_t this_ptr) {
31913 LDKUnsignedChannelAnnouncement this_ptr_conv;
31914 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31915 this_ptr_conv.is_owned = false;
31916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31917 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
31918 memcpy(ret_arr->elems, UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form, 33);
31922 void __attribute__((export_name("TS_UnsignedChannelAnnouncement_set_bitcoin_key_2"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint32_t this_ptr, int8_tArray val) {
31923 LDKUnsignedChannelAnnouncement this_ptr_conv;
31924 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31925 this_ptr_conv.is_owned = false;
31926 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31927 LDKPublicKey val_ref;
31928 CHECK(val->arr_len == 33);
31929 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
31930 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
31933 static inline uintptr_t UnsignedChannelAnnouncement_clone_ptr(LDKUnsignedChannelAnnouncement *NONNULL_PTR arg) {
31934 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(arg);
31935 uint32_t ret_ref = 0;
31936 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31937 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31938 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31939 ret_ref = (uintptr_t)ret_var.inner;
31940 if (ret_var.is_owned) {
31945 uint32_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone_ptr"))) TS_UnsignedChannelAnnouncement_clone_ptr(uint32_t arg) {
31946 LDKUnsignedChannelAnnouncement arg_conv;
31947 arg_conv.inner = (void*)(arg & (~1));
31948 arg_conv.is_owned = false;
31949 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
31950 uint32_t ret_conv = UnsignedChannelAnnouncement_clone_ptr(&arg_conv);
31954 uint32_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_clone"))) TS_UnsignedChannelAnnouncement_clone(uint32_t orig) {
31955 LDKUnsignedChannelAnnouncement orig_conv;
31956 orig_conv.inner = (void*)(orig & (~1));
31957 orig_conv.is_owned = false;
31958 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
31959 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
31960 uint32_t ret_ref = 0;
31961 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
31962 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
31963 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
31964 ret_ref = (uintptr_t)ret_var.inner;
31965 if (ret_var.is_owned) {
31971 void __attribute__((export_name("TS_ChannelAnnouncement_free"))) TS_ChannelAnnouncement_free(uint32_t this_obj) {
31972 LDKChannelAnnouncement this_obj_conv;
31973 this_obj_conv.inner = (void*)(this_obj & (~1));
31974 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
31975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
31976 ChannelAnnouncement_free(this_obj_conv);
31979 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_1"))) TS_ChannelAnnouncement_get_node_signature_1(uint32_t this_ptr) {
31980 LDKChannelAnnouncement this_ptr_conv;
31981 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31982 this_ptr_conv.is_owned = false;
31983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31984 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
31985 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
31989 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_1"))) TS_ChannelAnnouncement_set_node_signature_1(uint32_t this_ptr, int8_tArray val) {
31990 LDKChannelAnnouncement this_ptr_conv;
31991 this_ptr_conv.inner = (void*)(this_ptr & (~1));
31992 this_ptr_conv.is_owned = false;
31993 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
31994 LDKSignature val_ref;
31995 CHECK(val->arr_len == 64);
31996 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
31997 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
32000 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_node_signature_2"))) TS_ChannelAnnouncement_get_node_signature_2(uint32_t this_ptr) {
32001 LDKChannelAnnouncement this_ptr_conv;
32002 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32003 this_ptr_conv.is_owned = false;
32004 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32005 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32006 memcpy(ret_arr->elems, ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
32010 void __attribute__((export_name("TS_ChannelAnnouncement_set_node_signature_2"))) TS_ChannelAnnouncement_set_node_signature_2(uint32_t this_ptr, int8_tArray val) {
32011 LDKChannelAnnouncement this_ptr_conv;
32012 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32013 this_ptr_conv.is_owned = false;
32014 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32015 LDKSignature val_ref;
32016 CHECK(val->arr_len == 64);
32017 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32018 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
32021 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_1"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint32_t this_ptr) {
32022 LDKChannelAnnouncement this_ptr_conv;
32023 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32024 this_ptr_conv.is_owned = false;
32025 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32026 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32027 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
32031 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_1"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint32_t this_ptr, int8_tArray val) {
32032 LDKChannelAnnouncement this_ptr_conv;
32033 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32034 this_ptr_conv.is_owned = false;
32035 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32036 LDKSignature val_ref;
32037 CHECK(val->arr_len == 64);
32038 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32039 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
32042 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_get_bitcoin_signature_2"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint32_t this_ptr) {
32043 LDKChannelAnnouncement this_ptr_conv;
32044 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32045 this_ptr_conv.is_owned = false;
32046 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32047 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32048 memcpy(ret_arr->elems, ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
32052 void __attribute__((export_name("TS_ChannelAnnouncement_set_bitcoin_signature_2"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint32_t this_ptr, int8_tArray val) {
32053 LDKChannelAnnouncement this_ptr_conv;
32054 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32055 this_ptr_conv.is_owned = false;
32056 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32057 LDKSignature val_ref;
32058 CHECK(val->arr_len == 64);
32059 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32060 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
32063 uint32_t __attribute__((export_name("TS_ChannelAnnouncement_get_contents"))) TS_ChannelAnnouncement_get_contents(uint32_t this_ptr) {
32064 LDKChannelAnnouncement this_ptr_conv;
32065 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32066 this_ptr_conv.is_owned = false;
32067 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32068 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
32069 uint32_t ret_ref = 0;
32070 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32071 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32072 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32073 ret_ref = (uintptr_t)ret_var.inner;
32074 if (ret_var.is_owned) {
32080 void __attribute__((export_name("TS_ChannelAnnouncement_set_contents"))) TS_ChannelAnnouncement_set_contents(uint32_t this_ptr, uint32_t val) {
32081 LDKChannelAnnouncement this_ptr_conv;
32082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32083 this_ptr_conv.is_owned = false;
32084 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32085 LDKUnsignedChannelAnnouncement val_conv;
32086 val_conv.inner = (void*)(val & (~1));
32087 val_conv.is_owned = (val & 1) || (val == 0);
32088 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
32089 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
32090 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
32093 uint32_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, uint32_t contents_arg) {
32094 LDKSignature node_signature_1_arg_ref;
32095 CHECK(node_signature_1_arg->arr_len == 64);
32096 memcpy(node_signature_1_arg_ref.compact_form, node_signature_1_arg->elems, 64); FREE(node_signature_1_arg);
32097 LDKSignature node_signature_2_arg_ref;
32098 CHECK(node_signature_2_arg->arr_len == 64);
32099 memcpy(node_signature_2_arg_ref.compact_form, node_signature_2_arg->elems, 64); FREE(node_signature_2_arg);
32100 LDKSignature bitcoin_signature_1_arg_ref;
32101 CHECK(bitcoin_signature_1_arg->arr_len == 64);
32102 memcpy(bitcoin_signature_1_arg_ref.compact_form, bitcoin_signature_1_arg->elems, 64); FREE(bitcoin_signature_1_arg);
32103 LDKSignature bitcoin_signature_2_arg_ref;
32104 CHECK(bitcoin_signature_2_arg->arr_len == 64);
32105 memcpy(bitcoin_signature_2_arg_ref.compact_form, bitcoin_signature_2_arg->elems, 64); FREE(bitcoin_signature_2_arg);
32106 LDKUnsignedChannelAnnouncement contents_arg_conv;
32107 contents_arg_conv.inner = (void*)(contents_arg & (~1));
32108 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
32109 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
32110 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
32111 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);
32112 uint32_t ret_ref = 0;
32113 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32114 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32115 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32116 ret_ref = (uintptr_t)ret_var.inner;
32117 if (ret_var.is_owned) {
32123 static inline uintptr_t ChannelAnnouncement_clone_ptr(LDKChannelAnnouncement *NONNULL_PTR arg) {
32124 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(arg);
32125 uint32_t ret_ref = 0;
32126 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32127 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32128 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32129 ret_ref = (uintptr_t)ret_var.inner;
32130 if (ret_var.is_owned) {
32135 uint32_t __attribute__((export_name("TS_ChannelAnnouncement_clone_ptr"))) TS_ChannelAnnouncement_clone_ptr(uint32_t arg) {
32136 LDKChannelAnnouncement arg_conv;
32137 arg_conv.inner = (void*)(arg & (~1));
32138 arg_conv.is_owned = false;
32139 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32140 uint32_t ret_conv = ChannelAnnouncement_clone_ptr(&arg_conv);
32144 uint32_t __attribute__((export_name("TS_ChannelAnnouncement_clone"))) TS_ChannelAnnouncement_clone(uint32_t orig) {
32145 LDKChannelAnnouncement orig_conv;
32146 orig_conv.inner = (void*)(orig & (~1));
32147 orig_conv.is_owned = false;
32148 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32149 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
32150 uint32_t ret_ref = 0;
32151 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32152 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32153 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32154 ret_ref = (uintptr_t)ret_var.inner;
32155 if (ret_var.is_owned) {
32161 void __attribute__((export_name("TS_UnsignedChannelUpdate_free"))) TS_UnsignedChannelUpdate_free(uint32_t this_obj) {
32162 LDKUnsignedChannelUpdate this_obj_conv;
32163 this_obj_conv.inner = (void*)(this_obj & (~1));
32164 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32165 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32166 UnsignedChannelUpdate_free(this_obj_conv);
32169 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_get_chain_hash"))) TS_UnsignedChannelUpdate_get_chain_hash(uint32_t this_ptr) {
32170 LDKUnsignedChannelUpdate this_ptr_conv;
32171 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32172 this_ptr_conv.is_owned = false;
32173 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32174 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32175 memcpy(ret_arr->elems, *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
32179 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_chain_hash"))) TS_UnsignedChannelUpdate_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
32180 LDKUnsignedChannelUpdate this_ptr_conv;
32181 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32182 this_ptr_conv.is_owned = false;
32183 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32184 LDKThirtyTwoBytes val_ref;
32185 CHECK(val->arr_len == 32);
32186 memcpy(val_ref.data, val->elems, 32); FREE(val);
32187 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
32190 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_short_channel_id"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint32_t this_ptr) {
32191 LDKUnsignedChannelUpdate this_ptr_conv;
32192 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32193 this_ptr_conv.is_owned = false;
32194 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32195 int64_t ret_conv = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
32199 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_short_channel_id"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint32_t this_ptr, int64_t val) {
32200 LDKUnsignedChannelUpdate this_ptr_conv;
32201 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32202 this_ptr_conv.is_owned = false;
32203 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32204 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
32207 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_timestamp"))) TS_UnsignedChannelUpdate_get_timestamp(uint32_t this_ptr) {
32208 LDKUnsignedChannelUpdate this_ptr_conv;
32209 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32210 this_ptr_conv.is_owned = false;
32211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32212 int32_t ret_conv = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
32216 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_timestamp"))) TS_UnsignedChannelUpdate_set_timestamp(uint32_t this_ptr, int32_t val) {
32217 LDKUnsignedChannelUpdate this_ptr_conv;
32218 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32219 this_ptr_conv.is_owned = false;
32220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32221 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
32224 int8_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_flags"))) TS_UnsignedChannelUpdate_get_flags(uint32_t this_ptr) {
32225 LDKUnsignedChannelUpdate this_ptr_conv;
32226 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32227 this_ptr_conv.is_owned = false;
32228 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32229 int8_t ret_conv = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
32233 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_flags"))) TS_UnsignedChannelUpdate_set_flags(uint32_t this_ptr, int8_t val) {
32234 LDKUnsignedChannelUpdate this_ptr_conv;
32235 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32236 this_ptr_conv.is_owned = false;
32237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32238 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
32241 int16_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint32_t this_ptr) {
32242 LDKUnsignedChannelUpdate this_ptr_conv;
32243 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32244 this_ptr_conv.is_owned = false;
32245 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32246 int16_t ret_conv = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
32250 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_cltv_expiry_delta"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
32251 LDKUnsignedChannelUpdate this_ptr_conv;
32252 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32253 this_ptr_conv.is_owned = false;
32254 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32255 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
32258 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint32_t this_ptr) {
32259 LDKUnsignedChannelUpdate this_ptr_conv;
32260 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32261 this_ptr_conv.is_owned = false;
32262 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32263 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
32267 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_minimum_msat"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
32268 LDKUnsignedChannelUpdate this_ptr_conv;
32269 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32270 this_ptr_conv.is_owned = false;
32271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32272 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
32275 int64_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_get_htlc_maximum_msat(uint32_t this_ptr) {
32276 LDKUnsignedChannelUpdate this_ptr_conv;
32277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32278 this_ptr_conv.is_owned = false;
32279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32280 int64_t ret_conv = UnsignedChannelUpdate_get_htlc_maximum_msat(&this_ptr_conv);
32284 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_htlc_maximum_msat"))) TS_UnsignedChannelUpdate_set_htlc_maximum_msat(uint32_t this_ptr, int64_t val) {
32285 LDKUnsignedChannelUpdate this_ptr_conv;
32286 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32287 this_ptr_conv.is_owned = false;
32288 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32289 UnsignedChannelUpdate_set_htlc_maximum_msat(&this_ptr_conv, val);
32292 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_base_msat"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint32_t this_ptr) {
32293 LDKUnsignedChannelUpdate this_ptr_conv;
32294 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32295 this_ptr_conv.is_owned = false;
32296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32297 int32_t ret_conv = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
32301 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_base_msat"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint32_t this_ptr, int32_t val) {
32302 LDKUnsignedChannelUpdate this_ptr_conv;
32303 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32304 this_ptr_conv.is_owned = false;
32305 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32306 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
32309 int32_t __attribute__((export_name("TS_UnsignedChannelUpdate_get_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint32_t this_ptr) {
32310 LDKUnsignedChannelUpdate this_ptr_conv;
32311 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32312 this_ptr_conv.is_owned = false;
32313 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32314 int32_t ret_conv = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
32318 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_fee_proportional_millionths"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint32_t this_ptr, int32_t val) {
32319 LDKUnsignedChannelUpdate this_ptr_conv;
32320 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32321 this_ptr_conv.is_owned = false;
32322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32323 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
32326 void __attribute__((export_name("TS_UnsignedChannelUpdate_set_excess_data"))) TS_UnsignedChannelUpdate_set_excess_data(uint32_t this_ptr, int8_tArray val) {
32327 LDKUnsignedChannelUpdate this_ptr_conv;
32328 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32329 this_ptr_conv.is_owned = false;
32330 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32331 LDKCVec_u8Z val_ref;
32332 val_ref.datalen = val->arr_len;
32333 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
32334 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
32335 UnsignedChannelUpdate_set_excess_data(&this_ptr_conv, val_ref);
32338 uint32_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) {
32339 LDKThirtyTwoBytes chain_hash_arg_ref;
32340 CHECK(chain_hash_arg->arr_len == 32);
32341 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
32342 LDKCVec_u8Z excess_data_arg_ref;
32343 excess_data_arg_ref.datalen = excess_data_arg->arr_len;
32344 excess_data_arg_ref.data = MALLOC(excess_data_arg_ref.datalen, "LDKCVec_u8Z Bytes");
32345 memcpy(excess_data_arg_ref.data, excess_data_arg->elems, excess_data_arg_ref.datalen); FREE(excess_data_arg);
32346 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);
32347 uint32_t ret_ref = 0;
32348 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32349 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32350 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32351 ret_ref = (uintptr_t)ret_var.inner;
32352 if (ret_var.is_owned) {
32358 static inline uintptr_t UnsignedChannelUpdate_clone_ptr(LDKUnsignedChannelUpdate *NONNULL_PTR arg) {
32359 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(arg);
32360 uint32_t ret_ref = 0;
32361 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32362 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32363 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32364 ret_ref = (uintptr_t)ret_var.inner;
32365 if (ret_var.is_owned) {
32370 uint32_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone_ptr"))) TS_UnsignedChannelUpdate_clone_ptr(uint32_t arg) {
32371 LDKUnsignedChannelUpdate arg_conv;
32372 arg_conv.inner = (void*)(arg & (~1));
32373 arg_conv.is_owned = false;
32374 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32375 uint32_t ret_conv = UnsignedChannelUpdate_clone_ptr(&arg_conv);
32379 uint32_t __attribute__((export_name("TS_UnsignedChannelUpdate_clone"))) TS_UnsignedChannelUpdate_clone(uint32_t orig) {
32380 LDKUnsignedChannelUpdate orig_conv;
32381 orig_conv.inner = (void*)(orig & (~1));
32382 orig_conv.is_owned = false;
32383 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32384 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
32385 uint32_t ret_ref = 0;
32386 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32387 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32388 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32389 ret_ref = (uintptr_t)ret_var.inner;
32390 if (ret_var.is_owned) {
32396 void __attribute__((export_name("TS_ChannelUpdate_free"))) TS_ChannelUpdate_free(uint32_t this_obj) {
32397 LDKChannelUpdate this_obj_conv;
32398 this_obj_conv.inner = (void*)(this_obj & (~1));
32399 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32401 ChannelUpdate_free(this_obj_conv);
32404 int8_tArray __attribute__((export_name("TS_ChannelUpdate_get_signature"))) TS_ChannelUpdate_get_signature(uint32_t this_ptr) {
32405 LDKChannelUpdate this_ptr_conv;
32406 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32407 this_ptr_conv.is_owned = false;
32408 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32409 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
32410 memcpy(ret_arr->elems, ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
32414 void __attribute__((export_name("TS_ChannelUpdate_set_signature"))) TS_ChannelUpdate_set_signature(uint32_t this_ptr, int8_tArray val) {
32415 LDKChannelUpdate this_ptr_conv;
32416 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32417 this_ptr_conv.is_owned = false;
32418 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32419 LDKSignature val_ref;
32420 CHECK(val->arr_len == 64);
32421 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
32422 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
32425 uint32_t __attribute__((export_name("TS_ChannelUpdate_get_contents"))) TS_ChannelUpdate_get_contents(uint32_t this_ptr) {
32426 LDKChannelUpdate this_ptr_conv;
32427 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32428 this_ptr_conv.is_owned = false;
32429 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32430 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
32431 uint32_t ret_ref = 0;
32432 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32433 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32434 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32435 ret_ref = (uintptr_t)ret_var.inner;
32436 if (ret_var.is_owned) {
32442 void __attribute__((export_name("TS_ChannelUpdate_set_contents"))) TS_ChannelUpdate_set_contents(uint32_t this_ptr, uint32_t val) {
32443 LDKChannelUpdate this_ptr_conv;
32444 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32445 this_ptr_conv.is_owned = false;
32446 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32447 LDKUnsignedChannelUpdate val_conv;
32448 val_conv.inner = (void*)(val & (~1));
32449 val_conv.is_owned = (val & 1) || (val == 0);
32450 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
32451 val_conv = UnsignedChannelUpdate_clone(&val_conv);
32452 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
32455 uint32_t __attribute__((export_name("TS_ChannelUpdate_new"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint32_t contents_arg) {
32456 LDKSignature signature_arg_ref;
32457 CHECK(signature_arg->arr_len == 64);
32458 memcpy(signature_arg_ref.compact_form, signature_arg->elems, 64); FREE(signature_arg);
32459 LDKUnsignedChannelUpdate contents_arg_conv;
32460 contents_arg_conv.inner = (void*)(contents_arg & (~1));
32461 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
32462 CHECK_INNER_FIELD_ACCESS_OR_NULL(contents_arg_conv);
32463 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
32464 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
32465 uint32_t ret_ref = 0;
32466 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32467 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32468 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32469 ret_ref = (uintptr_t)ret_var.inner;
32470 if (ret_var.is_owned) {
32476 static inline uintptr_t ChannelUpdate_clone_ptr(LDKChannelUpdate *NONNULL_PTR arg) {
32477 LDKChannelUpdate ret_var = ChannelUpdate_clone(arg);
32478 uint32_t ret_ref = 0;
32479 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32480 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32481 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32482 ret_ref = (uintptr_t)ret_var.inner;
32483 if (ret_var.is_owned) {
32488 uint32_t __attribute__((export_name("TS_ChannelUpdate_clone_ptr"))) TS_ChannelUpdate_clone_ptr(uint32_t arg) {
32489 LDKChannelUpdate arg_conv;
32490 arg_conv.inner = (void*)(arg & (~1));
32491 arg_conv.is_owned = false;
32492 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32493 uint32_t ret_conv = ChannelUpdate_clone_ptr(&arg_conv);
32497 uint32_t __attribute__((export_name("TS_ChannelUpdate_clone"))) TS_ChannelUpdate_clone(uint32_t orig) {
32498 LDKChannelUpdate orig_conv;
32499 orig_conv.inner = (void*)(orig & (~1));
32500 orig_conv.is_owned = false;
32501 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32502 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
32503 uint32_t ret_ref = 0;
32504 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32505 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32506 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32507 ret_ref = (uintptr_t)ret_var.inner;
32508 if (ret_var.is_owned) {
32514 void __attribute__((export_name("TS_QueryChannelRange_free"))) TS_QueryChannelRange_free(uint32_t this_obj) {
32515 LDKQueryChannelRange this_obj_conv;
32516 this_obj_conv.inner = (void*)(this_obj & (~1));
32517 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32518 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32519 QueryChannelRange_free(this_obj_conv);
32522 int8_tArray __attribute__((export_name("TS_QueryChannelRange_get_chain_hash"))) TS_QueryChannelRange_get_chain_hash(uint32_t this_ptr) {
32523 LDKQueryChannelRange this_ptr_conv;
32524 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32525 this_ptr_conv.is_owned = false;
32526 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32527 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32528 memcpy(ret_arr->elems, *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
32532 void __attribute__((export_name("TS_QueryChannelRange_set_chain_hash"))) TS_QueryChannelRange_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
32533 LDKQueryChannelRange this_ptr_conv;
32534 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32535 this_ptr_conv.is_owned = false;
32536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32537 LDKThirtyTwoBytes val_ref;
32538 CHECK(val->arr_len == 32);
32539 memcpy(val_ref.data, val->elems, 32); FREE(val);
32540 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
32543 int32_t __attribute__((export_name("TS_QueryChannelRange_get_first_blocknum"))) TS_QueryChannelRange_get_first_blocknum(uint32_t this_ptr) {
32544 LDKQueryChannelRange this_ptr_conv;
32545 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32546 this_ptr_conv.is_owned = false;
32547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32548 int32_t ret_conv = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
32552 void __attribute__((export_name("TS_QueryChannelRange_set_first_blocknum"))) TS_QueryChannelRange_set_first_blocknum(uint32_t this_ptr, int32_t val) {
32553 LDKQueryChannelRange this_ptr_conv;
32554 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32555 this_ptr_conv.is_owned = false;
32556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32557 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
32560 int32_t __attribute__((export_name("TS_QueryChannelRange_get_number_of_blocks"))) TS_QueryChannelRange_get_number_of_blocks(uint32_t this_ptr) {
32561 LDKQueryChannelRange this_ptr_conv;
32562 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32563 this_ptr_conv.is_owned = false;
32564 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32565 int32_t ret_conv = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
32569 void __attribute__((export_name("TS_QueryChannelRange_set_number_of_blocks"))) TS_QueryChannelRange_set_number_of_blocks(uint32_t this_ptr, int32_t val) {
32570 LDKQueryChannelRange this_ptr_conv;
32571 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32572 this_ptr_conv.is_owned = false;
32573 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32574 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
32577 uint32_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) {
32578 LDKThirtyTwoBytes chain_hash_arg_ref;
32579 CHECK(chain_hash_arg->arr_len == 32);
32580 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
32581 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
32582 uint32_t ret_ref = 0;
32583 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32584 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32585 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32586 ret_ref = (uintptr_t)ret_var.inner;
32587 if (ret_var.is_owned) {
32593 static inline uintptr_t QueryChannelRange_clone_ptr(LDKQueryChannelRange *NONNULL_PTR arg) {
32594 LDKQueryChannelRange ret_var = QueryChannelRange_clone(arg);
32595 uint32_t ret_ref = 0;
32596 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32597 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32598 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32599 ret_ref = (uintptr_t)ret_var.inner;
32600 if (ret_var.is_owned) {
32605 uint32_t __attribute__((export_name("TS_QueryChannelRange_clone_ptr"))) TS_QueryChannelRange_clone_ptr(uint32_t arg) {
32606 LDKQueryChannelRange arg_conv;
32607 arg_conv.inner = (void*)(arg & (~1));
32608 arg_conv.is_owned = false;
32609 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32610 uint32_t ret_conv = QueryChannelRange_clone_ptr(&arg_conv);
32614 uint32_t __attribute__((export_name("TS_QueryChannelRange_clone"))) TS_QueryChannelRange_clone(uint32_t orig) {
32615 LDKQueryChannelRange orig_conv;
32616 orig_conv.inner = (void*)(orig & (~1));
32617 orig_conv.is_owned = false;
32618 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32619 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
32620 uint32_t ret_ref = 0;
32621 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32622 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32623 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32624 ret_ref = (uintptr_t)ret_var.inner;
32625 if (ret_var.is_owned) {
32631 void __attribute__((export_name("TS_ReplyChannelRange_free"))) TS_ReplyChannelRange_free(uint32_t this_obj) {
32632 LDKReplyChannelRange this_obj_conv;
32633 this_obj_conv.inner = (void*)(this_obj & (~1));
32634 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32635 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32636 ReplyChannelRange_free(this_obj_conv);
32639 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_get_chain_hash"))) TS_ReplyChannelRange_get_chain_hash(uint32_t this_ptr) {
32640 LDKReplyChannelRange this_ptr_conv;
32641 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32642 this_ptr_conv.is_owned = false;
32643 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32644 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32645 memcpy(ret_arr->elems, *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
32649 void __attribute__((export_name("TS_ReplyChannelRange_set_chain_hash"))) TS_ReplyChannelRange_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
32650 LDKReplyChannelRange this_ptr_conv;
32651 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32652 this_ptr_conv.is_owned = false;
32653 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32654 LDKThirtyTwoBytes val_ref;
32655 CHECK(val->arr_len == 32);
32656 memcpy(val_ref.data, val->elems, 32); FREE(val);
32657 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
32660 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_first_blocknum"))) TS_ReplyChannelRange_get_first_blocknum(uint32_t this_ptr) {
32661 LDKReplyChannelRange this_ptr_conv;
32662 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32663 this_ptr_conv.is_owned = false;
32664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32665 int32_t ret_conv = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
32669 void __attribute__((export_name("TS_ReplyChannelRange_set_first_blocknum"))) TS_ReplyChannelRange_set_first_blocknum(uint32_t this_ptr, int32_t val) {
32670 LDKReplyChannelRange this_ptr_conv;
32671 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32672 this_ptr_conv.is_owned = false;
32673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32674 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
32677 int32_t __attribute__((export_name("TS_ReplyChannelRange_get_number_of_blocks"))) TS_ReplyChannelRange_get_number_of_blocks(uint32_t this_ptr) {
32678 LDKReplyChannelRange this_ptr_conv;
32679 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32680 this_ptr_conv.is_owned = false;
32681 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32682 int32_t ret_conv = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
32686 void __attribute__((export_name("TS_ReplyChannelRange_set_number_of_blocks"))) TS_ReplyChannelRange_set_number_of_blocks(uint32_t this_ptr, int32_t val) {
32687 LDKReplyChannelRange this_ptr_conv;
32688 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32689 this_ptr_conv.is_owned = false;
32690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32691 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
32694 jboolean __attribute__((export_name("TS_ReplyChannelRange_get_sync_complete"))) TS_ReplyChannelRange_get_sync_complete(uint32_t this_ptr) {
32695 LDKReplyChannelRange this_ptr_conv;
32696 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32697 this_ptr_conv.is_owned = false;
32698 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32699 jboolean ret_conv = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
32703 void __attribute__((export_name("TS_ReplyChannelRange_set_sync_complete"))) TS_ReplyChannelRange_set_sync_complete(uint32_t this_ptr, jboolean val) {
32704 LDKReplyChannelRange this_ptr_conv;
32705 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32706 this_ptr_conv.is_owned = false;
32707 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32708 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
32711 void __attribute__((export_name("TS_ReplyChannelRange_set_short_channel_ids"))) TS_ReplyChannelRange_set_short_channel_ids(uint32_t this_ptr, int64_tArray val) {
32712 LDKReplyChannelRange this_ptr_conv;
32713 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32714 this_ptr_conv.is_owned = false;
32715 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32716 LDKCVec_u64Z val_constr;
32717 val_constr.datalen = val->arr_len;
32718 if (val_constr.datalen > 0)
32719 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
32721 val_constr.data = NULL;
32722 int64_t* val_vals = val->elems;
32723 for (size_t i = 0; i < val_constr.datalen; i++) {
32724 int64_t val_conv_8 = val_vals[i];
32725 val_constr.data[i] = val_conv_8;
32728 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
32731 uint32_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) {
32732 LDKThirtyTwoBytes chain_hash_arg_ref;
32733 CHECK(chain_hash_arg->arr_len == 32);
32734 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
32735 LDKCVec_u64Z short_channel_ids_arg_constr;
32736 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
32737 if (short_channel_ids_arg_constr.datalen > 0)
32738 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
32740 short_channel_ids_arg_constr.data = NULL;
32741 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
32742 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
32743 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
32744 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
32746 FREE(short_channel_ids_arg);
32747 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
32748 uint32_t ret_ref = 0;
32749 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32750 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32751 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32752 ret_ref = (uintptr_t)ret_var.inner;
32753 if (ret_var.is_owned) {
32759 static inline uintptr_t ReplyChannelRange_clone_ptr(LDKReplyChannelRange *NONNULL_PTR arg) {
32760 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(arg);
32761 uint32_t ret_ref = 0;
32762 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32763 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32764 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32765 ret_ref = (uintptr_t)ret_var.inner;
32766 if (ret_var.is_owned) {
32771 uint32_t __attribute__((export_name("TS_ReplyChannelRange_clone_ptr"))) TS_ReplyChannelRange_clone_ptr(uint32_t arg) {
32772 LDKReplyChannelRange arg_conv;
32773 arg_conv.inner = (void*)(arg & (~1));
32774 arg_conv.is_owned = false;
32775 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32776 uint32_t ret_conv = ReplyChannelRange_clone_ptr(&arg_conv);
32780 uint32_t __attribute__((export_name("TS_ReplyChannelRange_clone"))) TS_ReplyChannelRange_clone(uint32_t orig) {
32781 LDKReplyChannelRange orig_conv;
32782 orig_conv.inner = (void*)(orig & (~1));
32783 orig_conv.is_owned = false;
32784 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32785 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
32786 uint32_t ret_ref = 0;
32787 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32788 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32789 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32790 ret_ref = (uintptr_t)ret_var.inner;
32791 if (ret_var.is_owned) {
32797 void __attribute__((export_name("TS_QueryShortChannelIds_free"))) TS_QueryShortChannelIds_free(uint32_t this_obj) {
32798 LDKQueryShortChannelIds this_obj_conv;
32799 this_obj_conv.inner = (void*)(this_obj & (~1));
32800 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32802 QueryShortChannelIds_free(this_obj_conv);
32805 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_get_chain_hash"))) TS_QueryShortChannelIds_get_chain_hash(uint32_t this_ptr) {
32806 LDKQueryShortChannelIds this_ptr_conv;
32807 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32808 this_ptr_conv.is_owned = false;
32809 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32810 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32811 memcpy(ret_arr->elems, *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
32815 void __attribute__((export_name("TS_QueryShortChannelIds_set_chain_hash"))) TS_QueryShortChannelIds_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
32816 LDKQueryShortChannelIds this_ptr_conv;
32817 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32818 this_ptr_conv.is_owned = false;
32819 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32820 LDKThirtyTwoBytes val_ref;
32821 CHECK(val->arr_len == 32);
32822 memcpy(val_ref.data, val->elems, 32); FREE(val);
32823 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
32826 void __attribute__((export_name("TS_QueryShortChannelIds_set_short_channel_ids"))) TS_QueryShortChannelIds_set_short_channel_ids(uint32_t this_ptr, int64_tArray val) {
32827 LDKQueryShortChannelIds this_ptr_conv;
32828 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32829 this_ptr_conv.is_owned = false;
32830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32831 LDKCVec_u64Z val_constr;
32832 val_constr.datalen = val->arr_len;
32833 if (val_constr.datalen > 0)
32834 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
32836 val_constr.data = NULL;
32837 int64_t* val_vals = val->elems;
32838 for (size_t i = 0; i < val_constr.datalen; i++) {
32839 int64_t val_conv_8 = val_vals[i];
32840 val_constr.data[i] = val_conv_8;
32843 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
32846 uint32_t __attribute__((export_name("TS_QueryShortChannelIds_new"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
32847 LDKThirtyTwoBytes chain_hash_arg_ref;
32848 CHECK(chain_hash_arg->arr_len == 32);
32849 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
32850 LDKCVec_u64Z short_channel_ids_arg_constr;
32851 short_channel_ids_arg_constr.datalen = short_channel_ids_arg->arr_len;
32852 if (short_channel_ids_arg_constr.datalen > 0)
32853 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
32855 short_channel_ids_arg_constr.data = NULL;
32856 int64_t* short_channel_ids_arg_vals = short_channel_ids_arg->elems;
32857 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
32858 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
32859 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
32861 FREE(short_channel_ids_arg);
32862 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
32863 uint32_t ret_ref = 0;
32864 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32865 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32866 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32867 ret_ref = (uintptr_t)ret_var.inner;
32868 if (ret_var.is_owned) {
32874 static inline uintptr_t QueryShortChannelIds_clone_ptr(LDKQueryShortChannelIds *NONNULL_PTR arg) {
32875 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(arg);
32876 uint32_t ret_ref = 0;
32877 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32878 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32879 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32880 ret_ref = (uintptr_t)ret_var.inner;
32881 if (ret_var.is_owned) {
32886 uint32_t __attribute__((export_name("TS_QueryShortChannelIds_clone_ptr"))) TS_QueryShortChannelIds_clone_ptr(uint32_t arg) {
32887 LDKQueryShortChannelIds arg_conv;
32888 arg_conv.inner = (void*)(arg & (~1));
32889 arg_conv.is_owned = false;
32890 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32891 uint32_t ret_conv = QueryShortChannelIds_clone_ptr(&arg_conv);
32895 uint32_t __attribute__((export_name("TS_QueryShortChannelIds_clone"))) TS_QueryShortChannelIds_clone(uint32_t orig) {
32896 LDKQueryShortChannelIds orig_conv;
32897 orig_conv.inner = (void*)(orig & (~1));
32898 orig_conv.is_owned = false;
32899 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
32900 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
32901 uint32_t ret_ref = 0;
32902 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32903 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32904 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32905 ret_ref = (uintptr_t)ret_var.inner;
32906 if (ret_var.is_owned) {
32912 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_free"))) TS_ReplyShortChannelIdsEnd_free(uint32_t this_obj) {
32913 LDKReplyShortChannelIdsEnd this_obj_conv;
32914 this_obj_conv.inner = (void*)(this_obj & (~1));
32915 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
32916 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
32917 ReplyShortChannelIdsEnd_free(this_obj_conv);
32920 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_chain_hash"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint32_t this_ptr) {
32921 LDKReplyShortChannelIdsEnd this_ptr_conv;
32922 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32923 this_ptr_conv.is_owned = false;
32924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32925 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
32926 memcpy(ret_arr->elems, *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
32930 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_chain_hash"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
32931 LDKReplyShortChannelIdsEnd this_ptr_conv;
32932 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32933 this_ptr_conv.is_owned = false;
32934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32935 LDKThirtyTwoBytes val_ref;
32936 CHECK(val->arr_len == 32);
32937 memcpy(val_ref.data, val->elems, 32); FREE(val);
32938 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
32941 jboolean __attribute__((export_name("TS_ReplyShortChannelIdsEnd_get_full_information"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint32_t this_ptr) {
32942 LDKReplyShortChannelIdsEnd this_ptr_conv;
32943 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32944 this_ptr_conv.is_owned = false;
32945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32946 jboolean ret_conv = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
32950 void __attribute__((export_name("TS_ReplyShortChannelIdsEnd_set_full_information"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint32_t this_ptr, jboolean val) {
32951 LDKReplyShortChannelIdsEnd this_ptr_conv;
32952 this_ptr_conv.inner = (void*)(this_ptr & (~1));
32953 this_ptr_conv.is_owned = false;
32954 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
32955 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
32958 uint32_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_new"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
32959 LDKThirtyTwoBytes chain_hash_arg_ref;
32960 CHECK(chain_hash_arg->arr_len == 32);
32961 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
32962 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
32963 uint32_t ret_ref = 0;
32964 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32965 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32966 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32967 ret_ref = (uintptr_t)ret_var.inner;
32968 if (ret_var.is_owned) {
32974 static inline uintptr_t ReplyShortChannelIdsEnd_clone_ptr(LDKReplyShortChannelIdsEnd *NONNULL_PTR arg) {
32975 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(arg);
32976 uint32_t ret_ref = 0;
32977 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
32978 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
32979 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
32980 ret_ref = (uintptr_t)ret_var.inner;
32981 if (ret_var.is_owned) {
32986 uint32_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone_ptr"))) TS_ReplyShortChannelIdsEnd_clone_ptr(uint32_t arg) {
32987 LDKReplyShortChannelIdsEnd arg_conv;
32988 arg_conv.inner = (void*)(arg & (~1));
32989 arg_conv.is_owned = false;
32990 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
32991 uint32_t ret_conv = ReplyShortChannelIdsEnd_clone_ptr(&arg_conv);
32995 uint32_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_clone"))) TS_ReplyShortChannelIdsEnd_clone(uint32_t orig) {
32996 LDKReplyShortChannelIdsEnd orig_conv;
32997 orig_conv.inner = (void*)(orig & (~1));
32998 orig_conv.is_owned = false;
32999 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33000 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
33001 uint32_t ret_ref = 0;
33002 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33003 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33004 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33005 ret_ref = (uintptr_t)ret_var.inner;
33006 if (ret_var.is_owned) {
33012 void __attribute__((export_name("TS_GossipTimestampFilter_free"))) TS_GossipTimestampFilter_free(uint32_t this_obj) {
33013 LDKGossipTimestampFilter this_obj_conv;
33014 this_obj_conv.inner = (void*)(this_obj & (~1));
33015 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
33016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33017 GossipTimestampFilter_free(this_obj_conv);
33020 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_get_chain_hash"))) TS_GossipTimestampFilter_get_chain_hash(uint32_t this_ptr) {
33021 LDKGossipTimestampFilter this_ptr_conv;
33022 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33023 this_ptr_conv.is_owned = false;
33024 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33025 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
33026 memcpy(ret_arr->elems, *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
33030 void __attribute__((export_name("TS_GossipTimestampFilter_set_chain_hash"))) TS_GossipTimestampFilter_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
33031 LDKGossipTimestampFilter this_ptr_conv;
33032 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33033 this_ptr_conv.is_owned = false;
33034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33035 LDKThirtyTwoBytes val_ref;
33036 CHECK(val->arr_len == 32);
33037 memcpy(val_ref.data, val->elems, 32); FREE(val);
33038 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
33041 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_first_timestamp"))) TS_GossipTimestampFilter_get_first_timestamp(uint32_t this_ptr) {
33042 LDKGossipTimestampFilter this_ptr_conv;
33043 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33044 this_ptr_conv.is_owned = false;
33045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33046 int32_t ret_conv = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
33050 void __attribute__((export_name("TS_GossipTimestampFilter_set_first_timestamp"))) TS_GossipTimestampFilter_set_first_timestamp(uint32_t this_ptr, int32_t val) {
33051 LDKGossipTimestampFilter this_ptr_conv;
33052 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33053 this_ptr_conv.is_owned = false;
33054 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33055 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
33058 int32_t __attribute__((export_name("TS_GossipTimestampFilter_get_timestamp_range"))) TS_GossipTimestampFilter_get_timestamp_range(uint32_t this_ptr) {
33059 LDKGossipTimestampFilter this_ptr_conv;
33060 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33061 this_ptr_conv.is_owned = false;
33062 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33063 int32_t ret_conv = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
33067 void __attribute__((export_name("TS_GossipTimestampFilter_set_timestamp_range"))) TS_GossipTimestampFilter_set_timestamp_range(uint32_t this_ptr, int32_t val) {
33068 LDKGossipTimestampFilter this_ptr_conv;
33069 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33070 this_ptr_conv.is_owned = false;
33071 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33072 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
33075 uint32_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) {
33076 LDKThirtyTwoBytes chain_hash_arg_ref;
33077 CHECK(chain_hash_arg->arr_len == 32);
33078 memcpy(chain_hash_arg_ref.data, chain_hash_arg->elems, 32); FREE(chain_hash_arg);
33079 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
33080 uint32_t ret_ref = 0;
33081 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33082 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33083 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33084 ret_ref = (uintptr_t)ret_var.inner;
33085 if (ret_var.is_owned) {
33091 static inline uintptr_t GossipTimestampFilter_clone_ptr(LDKGossipTimestampFilter *NONNULL_PTR arg) {
33092 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(arg);
33093 uint32_t ret_ref = 0;
33094 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33095 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33096 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33097 ret_ref = (uintptr_t)ret_var.inner;
33098 if (ret_var.is_owned) {
33103 uint32_t __attribute__((export_name("TS_GossipTimestampFilter_clone_ptr"))) TS_GossipTimestampFilter_clone_ptr(uint32_t arg) {
33104 LDKGossipTimestampFilter arg_conv;
33105 arg_conv.inner = (void*)(arg & (~1));
33106 arg_conv.is_owned = false;
33107 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33108 uint32_t ret_conv = GossipTimestampFilter_clone_ptr(&arg_conv);
33112 uint32_t __attribute__((export_name("TS_GossipTimestampFilter_clone"))) TS_GossipTimestampFilter_clone(uint32_t orig) {
33113 LDKGossipTimestampFilter orig_conv;
33114 orig_conv.inner = (void*)(orig & (~1));
33115 orig_conv.is_owned = false;
33116 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33117 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
33118 uint32_t ret_ref = 0;
33119 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33120 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33121 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33122 ret_ref = (uintptr_t)ret_var.inner;
33123 if (ret_var.is_owned) {
33129 void __attribute__((export_name("TS_ErrorAction_free"))) TS_ErrorAction_free(uint32_t this_ptr) {
33130 if ((this_ptr & 1) != 0) return;
33131 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
33132 CHECK_ACCESS(this_ptr_ptr);
33133 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(this_ptr_ptr);
33134 FREE((void*)this_ptr);
33135 ErrorAction_free(this_ptr_conv);
33138 static inline uintptr_t ErrorAction_clone_ptr(LDKErrorAction *NONNULL_PTR arg) {
33139 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33140 *ret_copy = ErrorAction_clone(arg);
33141 uint32_t ret_ref = (uintptr_t)ret_copy;
33144 uint32_t __attribute__((export_name("TS_ErrorAction_clone_ptr"))) TS_ErrorAction_clone_ptr(uint32_t arg) {
33145 LDKErrorAction* arg_conv = (LDKErrorAction*)arg;
33146 uint32_t ret_conv = ErrorAction_clone_ptr(arg_conv);
33150 uint32_t __attribute__((export_name("TS_ErrorAction_clone"))) TS_ErrorAction_clone(uint32_t orig) {
33151 LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
33152 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33153 *ret_copy = ErrorAction_clone(orig_conv);
33154 uint32_t ret_ref = (uintptr_t)ret_copy;
33158 uint32_t __attribute__((export_name("TS_ErrorAction_disconnect_peer"))) TS_ErrorAction_disconnect_peer(uint32_t msg) {
33159 LDKErrorMessage msg_conv;
33160 msg_conv.inner = (void*)(msg & (~1));
33161 msg_conv.is_owned = (msg & 1) || (msg == 0);
33162 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
33163 msg_conv = ErrorMessage_clone(&msg_conv);
33164 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33165 *ret_copy = ErrorAction_disconnect_peer(msg_conv);
33166 uint32_t ret_ref = (uintptr_t)ret_copy;
33170 uint32_t __attribute__((export_name("TS_ErrorAction_ignore_error"))) TS_ErrorAction_ignore_error() {
33171 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33172 *ret_copy = ErrorAction_ignore_error();
33173 uint32_t ret_ref = (uintptr_t)ret_copy;
33177 uint32_t __attribute__((export_name("TS_ErrorAction_ignore_and_log"))) TS_ErrorAction_ignore_and_log(uint32_t a) {
33178 LDKLevel a_conv = LDKLevel_from_js(a);
33179 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33180 *ret_copy = ErrorAction_ignore_and_log(a_conv);
33181 uint32_t ret_ref = (uintptr_t)ret_copy;
33185 uint32_t __attribute__((export_name("TS_ErrorAction_ignore_duplicate_gossip"))) TS_ErrorAction_ignore_duplicate_gossip() {
33186 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33187 *ret_copy = ErrorAction_ignore_duplicate_gossip();
33188 uint32_t ret_ref = (uintptr_t)ret_copy;
33192 uint32_t __attribute__((export_name("TS_ErrorAction_send_error_message"))) TS_ErrorAction_send_error_message(uint32_t msg) {
33193 LDKErrorMessage msg_conv;
33194 msg_conv.inner = (void*)(msg & (~1));
33195 msg_conv.is_owned = (msg & 1) || (msg == 0);
33196 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
33197 msg_conv = ErrorMessage_clone(&msg_conv);
33198 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33199 *ret_copy = ErrorAction_send_error_message(msg_conv);
33200 uint32_t ret_ref = (uintptr_t)ret_copy;
33204 uint32_t __attribute__((export_name("TS_ErrorAction_send_warning_message"))) TS_ErrorAction_send_warning_message(uint32_t msg, uint32_t log_level) {
33205 LDKWarningMessage msg_conv;
33206 msg_conv.inner = (void*)(msg & (~1));
33207 msg_conv.is_owned = (msg & 1) || (msg == 0);
33208 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
33209 msg_conv = WarningMessage_clone(&msg_conv);
33210 LDKLevel log_level_conv = LDKLevel_from_js(log_level);
33211 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33212 *ret_copy = ErrorAction_send_warning_message(msg_conv, log_level_conv);
33213 uint32_t ret_ref = (uintptr_t)ret_copy;
33217 void __attribute__((export_name("TS_LightningError_free"))) TS_LightningError_free(uint32_t this_obj) {
33218 LDKLightningError this_obj_conv;
33219 this_obj_conv.inner = (void*)(this_obj & (~1));
33220 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
33221 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33222 LightningError_free(this_obj_conv);
33225 jstring __attribute__((export_name("TS_LightningError_get_err"))) TS_LightningError_get_err(uint32_t this_ptr) {
33226 LDKLightningError this_ptr_conv;
33227 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33228 this_ptr_conv.is_owned = false;
33229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33230 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
33231 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
33236 void __attribute__((export_name("TS_LightningError_set_err"))) TS_LightningError_set_err(uint32_t this_ptr, jstring val) {
33237 LDKLightningError this_ptr_conv;
33238 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33239 this_ptr_conv.is_owned = false;
33240 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33241 LDKStr val_conv = str_ref_to_owned_c(val);
33242 LightningError_set_err(&this_ptr_conv, val_conv);
33245 uint32_t __attribute__((export_name("TS_LightningError_get_action"))) TS_LightningError_get_action(uint32_t this_ptr) {
33246 LDKLightningError this_ptr_conv;
33247 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33248 this_ptr_conv.is_owned = false;
33249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33250 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
33251 *ret_copy = LightningError_get_action(&this_ptr_conv);
33252 uint32_t ret_ref = (uintptr_t)ret_copy;
33256 void __attribute__((export_name("TS_LightningError_set_action"))) TS_LightningError_set_action(uint32_t this_ptr, uint32_t val) {
33257 LDKLightningError this_ptr_conv;
33258 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33259 this_ptr_conv.is_owned = false;
33260 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33261 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
33262 CHECK_ACCESS(val_ptr);
33263 LDKErrorAction val_conv = *(LDKErrorAction*)(val_ptr);
33264 val_conv = ErrorAction_clone((LDKErrorAction*)(((uintptr_t)val) & ~1));
33265 LightningError_set_action(&this_ptr_conv, val_conv);
33268 uint32_t __attribute__((export_name("TS_LightningError_new"))) TS_LightningError_new(jstring err_arg, uint32_t action_arg) {
33269 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
33270 void* action_arg_ptr = (void*)(((uintptr_t)action_arg) & ~1);
33271 CHECK_ACCESS(action_arg_ptr);
33272 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(action_arg_ptr);
33273 action_arg_conv = ErrorAction_clone((LDKErrorAction*)(((uintptr_t)action_arg) & ~1));
33274 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
33275 uint32_t ret_ref = 0;
33276 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33277 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33278 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33279 ret_ref = (uintptr_t)ret_var.inner;
33280 if (ret_var.is_owned) {
33286 static inline uintptr_t LightningError_clone_ptr(LDKLightningError *NONNULL_PTR arg) {
33287 LDKLightningError ret_var = LightningError_clone(arg);
33288 uint32_t ret_ref = 0;
33289 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33290 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33291 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33292 ret_ref = (uintptr_t)ret_var.inner;
33293 if (ret_var.is_owned) {
33298 uint32_t __attribute__((export_name("TS_LightningError_clone_ptr"))) TS_LightningError_clone_ptr(uint32_t arg) {
33299 LDKLightningError arg_conv;
33300 arg_conv.inner = (void*)(arg & (~1));
33301 arg_conv.is_owned = false;
33302 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33303 uint32_t ret_conv = LightningError_clone_ptr(&arg_conv);
33307 uint32_t __attribute__((export_name("TS_LightningError_clone"))) TS_LightningError_clone(uint32_t orig) {
33308 LDKLightningError orig_conv;
33309 orig_conv.inner = (void*)(orig & (~1));
33310 orig_conv.is_owned = false;
33311 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33312 LDKLightningError ret_var = LightningError_clone(&orig_conv);
33313 uint32_t ret_ref = 0;
33314 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33315 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33316 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33317 ret_ref = (uintptr_t)ret_var.inner;
33318 if (ret_var.is_owned) {
33324 void __attribute__((export_name("TS_CommitmentUpdate_free"))) TS_CommitmentUpdate_free(uint32_t this_obj) {
33325 LDKCommitmentUpdate this_obj_conv;
33326 this_obj_conv.inner = (void*)(this_obj & (~1));
33327 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
33328 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
33329 CommitmentUpdate_free(this_obj_conv);
33332 uint32_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_add_htlcs"))) TS_CommitmentUpdate_get_update_add_htlcs(uint32_t this_ptr) {
33333 LDKCommitmentUpdate this_ptr_conv;
33334 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33335 this_ptr_conv.is_owned = false;
33336 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33337 LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_conv);
33338 uint32_tArray ret_arr = NULL;
33339 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
33340 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
33341 for (size_t p = 0; p < ret_var.datalen; p++) {
33342 LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p];
33343 uint32_t ret_conv_15_ref = 0;
33344 CHECK((((uintptr_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33345 CHECK((((uintptr_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33346 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_15_var);
33347 ret_conv_15_ref = (uintptr_t)ret_conv_15_var.inner;
33348 if (ret_conv_15_var.is_owned) {
33349 ret_conv_15_ref |= 1;
33351 ret_arr_ptr[p] = ret_conv_15_ref;
33354 FREE(ret_var.data);
33358 void __attribute__((export_name("TS_CommitmentUpdate_set_update_add_htlcs"))) TS_CommitmentUpdate_set_update_add_htlcs(uint32_t this_ptr, uint32_tArray val) {
33359 LDKCommitmentUpdate this_ptr_conv;
33360 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33361 this_ptr_conv.is_owned = false;
33362 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33363 LDKCVec_UpdateAddHTLCZ val_constr;
33364 val_constr.datalen = val->arr_len;
33365 if (val_constr.datalen > 0)
33366 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
33368 val_constr.data = NULL;
33369 uint32_t* val_vals = val->elems;
33370 for (size_t p = 0; p < val_constr.datalen; p++) {
33371 uint32_t val_conv_15 = val_vals[p];
33372 LDKUpdateAddHTLC val_conv_15_conv;
33373 val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
33374 val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
33375 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_15_conv);
33376 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
33377 val_constr.data[p] = val_conv_15_conv;
33380 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
33383 uint32_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fulfill_htlcs"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint32_t this_ptr) {
33384 LDKCommitmentUpdate this_ptr_conv;
33385 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33386 this_ptr_conv.is_owned = false;
33387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33388 LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_conv);
33389 uint32_tArray ret_arr = NULL;
33390 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
33391 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
33392 for (size_t t = 0; t < ret_var.datalen; t++) {
33393 LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t];
33394 uint32_t ret_conv_19_ref = 0;
33395 CHECK((((uintptr_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33396 CHECK((((uintptr_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33397 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_19_var);
33398 ret_conv_19_ref = (uintptr_t)ret_conv_19_var.inner;
33399 if (ret_conv_19_var.is_owned) {
33400 ret_conv_19_ref |= 1;
33402 ret_arr_ptr[t] = ret_conv_19_ref;
33405 FREE(ret_var.data);
33409 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fulfill_htlcs"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint32_t this_ptr, uint32_tArray val) {
33410 LDKCommitmentUpdate this_ptr_conv;
33411 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33412 this_ptr_conv.is_owned = false;
33413 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33414 LDKCVec_UpdateFulfillHTLCZ val_constr;
33415 val_constr.datalen = val->arr_len;
33416 if (val_constr.datalen > 0)
33417 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
33419 val_constr.data = NULL;
33420 uint32_t* val_vals = val->elems;
33421 for (size_t t = 0; t < val_constr.datalen; t++) {
33422 uint32_t val_conv_19 = val_vals[t];
33423 LDKUpdateFulfillHTLC val_conv_19_conv;
33424 val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
33425 val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
33426 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_19_conv);
33427 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
33428 val_constr.data[t] = val_conv_19_conv;
33431 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
33434 uint32_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_htlcs"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint32_t this_ptr) {
33435 LDKCommitmentUpdate this_ptr_conv;
33436 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33437 this_ptr_conv.is_owned = false;
33438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33439 LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_conv);
33440 uint32_tArray ret_arr = NULL;
33441 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
33442 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
33443 for (size_t q = 0; q < ret_var.datalen; q++) {
33444 LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q];
33445 uint32_t ret_conv_16_ref = 0;
33446 CHECK((((uintptr_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33447 CHECK((((uintptr_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33448 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_16_var);
33449 ret_conv_16_ref = (uintptr_t)ret_conv_16_var.inner;
33450 if (ret_conv_16_var.is_owned) {
33451 ret_conv_16_ref |= 1;
33453 ret_arr_ptr[q] = ret_conv_16_ref;
33456 FREE(ret_var.data);
33460 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_htlcs"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint32_t this_ptr, uint32_tArray val) {
33461 LDKCommitmentUpdate this_ptr_conv;
33462 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33463 this_ptr_conv.is_owned = false;
33464 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33465 LDKCVec_UpdateFailHTLCZ val_constr;
33466 val_constr.datalen = val->arr_len;
33467 if (val_constr.datalen > 0)
33468 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
33470 val_constr.data = NULL;
33471 uint32_t* val_vals = val->elems;
33472 for (size_t q = 0; q < val_constr.datalen; q++) {
33473 uint32_t val_conv_16 = val_vals[q];
33474 LDKUpdateFailHTLC val_conv_16_conv;
33475 val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
33476 val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
33477 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_16_conv);
33478 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
33479 val_constr.data[q] = val_conv_16_conv;
33482 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
33485 uint32_tArray __attribute__((export_name("TS_CommitmentUpdate_get_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint32_t this_ptr) {
33486 LDKCommitmentUpdate this_ptr_conv;
33487 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33488 this_ptr_conv.is_owned = false;
33489 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33490 LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_conv);
33491 uint32_tArray ret_arr = NULL;
33492 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
33493 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
33494 for (size_t z = 0; z < ret_var.datalen; z++) {
33495 LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z];
33496 uint32_t ret_conv_25_ref = 0;
33497 CHECK((((uintptr_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33498 CHECK((((uintptr_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33499 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_25_var);
33500 ret_conv_25_ref = (uintptr_t)ret_conv_25_var.inner;
33501 if (ret_conv_25_var.is_owned) {
33502 ret_conv_25_ref |= 1;
33504 ret_arr_ptr[z] = ret_conv_25_ref;
33507 FREE(ret_var.data);
33511 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fail_malformed_htlcs"))) TS_CommitmentUpdate_set_update_fail_malformed_htlcs(uint32_t this_ptr, uint32_tArray val) {
33512 LDKCommitmentUpdate this_ptr_conv;
33513 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33514 this_ptr_conv.is_owned = false;
33515 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33516 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
33517 val_constr.datalen = val->arr_len;
33518 if (val_constr.datalen > 0)
33519 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
33521 val_constr.data = NULL;
33522 uint32_t* val_vals = val->elems;
33523 for (size_t z = 0; z < val_constr.datalen; z++) {
33524 uint32_t val_conv_25 = val_vals[z];
33525 LDKUpdateFailMalformedHTLC val_conv_25_conv;
33526 val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
33527 val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
33528 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_25_conv);
33529 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
33530 val_constr.data[z] = val_conv_25_conv;
33533 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
33536 uint32_t __attribute__((export_name("TS_CommitmentUpdate_get_update_fee"))) TS_CommitmentUpdate_get_update_fee(uint32_t this_ptr) {
33537 LDKCommitmentUpdate this_ptr_conv;
33538 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33539 this_ptr_conv.is_owned = false;
33540 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33541 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
33542 uint32_t ret_ref = 0;
33543 if ((uintptr_t)ret_var.inner > 4096) {
33544 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33545 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33546 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33547 ret_ref = (uintptr_t)ret_var.inner;
33548 if (ret_var.is_owned) {
33555 void __attribute__((export_name("TS_CommitmentUpdate_set_update_fee"))) TS_CommitmentUpdate_set_update_fee(uint32_t this_ptr, uint32_t val) {
33556 LDKCommitmentUpdate this_ptr_conv;
33557 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33558 this_ptr_conv.is_owned = false;
33559 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33560 LDKUpdateFee val_conv;
33561 val_conv.inner = (void*)(val & (~1));
33562 val_conv.is_owned = (val & 1) || (val == 0);
33563 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33564 val_conv = UpdateFee_clone(&val_conv);
33565 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
33568 uint32_t __attribute__((export_name("TS_CommitmentUpdate_get_commitment_signed"))) TS_CommitmentUpdate_get_commitment_signed(uint32_t this_ptr) {
33569 LDKCommitmentUpdate this_ptr_conv;
33570 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33571 this_ptr_conv.is_owned = false;
33572 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33573 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
33574 uint32_t ret_ref = 0;
33575 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33576 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33577 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33578 ret_ref = (uintptr_t)ret_var.inner;
33579 if (ret_var.is_owned) {
33585 void __attribute__((export_name("TS_CommitmentUpdate_set_commitment_signed"))) TS_CommitmentUpdate_set_commitment_signed(uint32_t this_ptr, uint32_t val) {
33586 LDKCommitmentUpdate this_ptr_conv;
33587 this_ptr_conv.inner = (void*)(this_ptr & (~1));
33588 this_ptr_conv.is_owned = false;
33589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
33590 LDKCommitmentSigned val_conv;
33591 val_conv.inner = (void*)(val & (~1));
33592 val_conv.is_owned = (val & 1) || (val == 0);
33593 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
33594 val_conv = CommitmentSigned_clone(&val_conv);
33595 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
33598 uint32_t __attribute__((export_name("TS_CommitmentUpdate_new"))) TS_CommitmentUpdate_new(uint32_tArray update_add_htlcs_arg, uint32_tArray update_fulfill_htlcs_arg, uint32_tArray update_fail_htlcs_arg, uint32_tArray update_fail_malformed_htlcs_arg, uint32_t update_fee_arg, uint32_t commitment_signed_arg) {
33599 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
33600 update_add_htlcs_arg_constr.datalen = update_add_htlcs_arg->arr_len;
33601 if (update_add_htlcs_arg_constr.datalen > 0)
33602 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
33604 update_add_htlcs_arg_constr.data = NULL;
33605 uint32_t* update_add_htlcs_arg_vals = update_add_htlcs_arg->elems;
33606 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
33607 uint32_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
33608 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
33609 update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
33610 update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
33611 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_add_htlcs_arg_conv_15_conv);
33612 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
33613 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
33615 FREE(update_add_htlcs_arg);
33616 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
33617 update_fulfill_htlcs_arg_constr.datalen = update_fulfill_htlcs_arg->arr_len;
33618 if (update_fulfill_htlcs_arg_constr.datalen > 0)
33619 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
33621 update_fulfill_htlcs_arg_constr.data = NULL;
33622 uint32_t* update_fulfill_htlcs_arg_vals = update_fulfill_htlcs_arg->elems;
33623 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
33624 uint32_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
33625 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
33626 update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
33627 update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
33628 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fulfill_htlcs_arg_conv_19_conv);
33629 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
33630 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
33632 FREE(update_fulfill_htlcs_arg);
33633 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
33634 update_fail_htlcs_arg_constr.datalen = update_fail_htlcs_arg->arr_len;
33635 if (update_fail_htlcs_arg_constr.datalen > 0)
33636 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
33638 update_fail_htlcs_arg_constr.data = NULL;
33639 uint32_t* update_fail_htlcs_arg_vals = update_fail_htlcs_arg->elems;
33640 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
33641 uint32_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
33642 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
33643 update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
33644 update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
33645 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_htlcs_arg_conv_16_conv);
33646 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
33647 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
33649 FREE(update_fail_htlcs_arg);
33650 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
33651 update_fail_malformed_htlcs_arg_constr.datalen = update_fail_malformed_htlcs_arg->arr_len;
33652 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
33653 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
33655 update_fail_malformed_htlcs_arg_constr.data = NULL;
33656 uint32_t* update_fail_malformed_htlcs_arg_vals = update_fail_malformed_htlcs_arg->elems;
33657 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
33658 uint32_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
33659 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
33660 update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
33661 update_fail_malformed_htlcs_arg_conv_25_conv.is_owned = (update_fail_malformed_htlcs_arg_conv_25 & 1) || (update_fail_malformed_htlcs_arg_conv_25 == 0);
33662 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fail_malformed_htlcs_arg_conv_25_conv);
33663 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
33664 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
33666 FREE(update_fail_malformed_htlcs_arg);
33667 LDKUpdateFee update_fee_arg_conv;
33668 update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
33669 update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
33670 CHECK_INNER_FIELD_ACCESS_OR_NULL(update_fee_arg_conv);
33671 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
33672 LDKCommitmentSigned commitment_signed_arg_conv;
33673 commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
33674 commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
33675 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_signed_arg_conv);
33676 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
33677 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);
33678 uint32_t ret_ref = 0;
33679 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33680 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33681 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33682 ret_ref = (uintptr_t)ret_var.inner;
33683 if (ret_var.is_owned) {
33689 static inline uintptr_t CommitmentUpdate_clone_ptr(LDKCommitmentUpdate *NONNULL_PTR arg) {
33690 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(arg);
33691 uint32_t ret_ref = 0;
33692 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33693 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33694 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33695 ret_ref = (uintptr_t)ret_var.inner;
33696 if (ret_var.is_owned) {
33701 uint32_t __attribute__((export_name("TS_CommitmentUpdate_clone_ptr"))) TS_CommitmentUpdate_clone_ptr(uint32_t arg) {
33702 LDKCommitmentUpdate arg_conv;
33703 arg_conv.inner = (void*)(arg & (~1));
33704 arg_conv.is_owned = false;
33705 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
33706 uint32_t ret_conv = CommitmentUpdate_clone_ptr(&arg_conv);
33710 uint32_t __attribute__((export_name("TS_CommitmentUpdate_clone"))) TS_CommitmentUpdate_clone(uint32_t orig) {
33711 LDKCommitmentUpdate orig_conv;
33712 orig_conv.inner = (void*)(orig & (~1));
33713 orig_conv.is_owned = false;
33714 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
33715 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
33716 uint32_t ret_ref = 0;
33717 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
33718 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
33719 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
33720 ret_ref = (uintptr_t)ret_var.inner;
33721 if (ret_var.is_owned) {
33727 void __attribute__((export_name("TS_ChannelMessageHandler_free"))) TS_ChannelMessageHandler_free(uint32_t this_ptr) {
33728 if ((this_ptr & 1) != 0) return;
33729 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
33730 CHECK_ACCESS(this_ptr_ptr);
33731 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(this_ptr_ptr);
33732 FREE((void*)this_ptr);
33733 ChannelMessageHandler_free(this_ptr_conv);
33736 void __attribute__((export_name("TS_RoutingMessageHandler_free"))) TS_RoutingMessageHandler_free(uint32_t this_ptr) {
33737 if ((this_ptr & 1) != 0) return;
33738 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
33739 CHECK_ACCESS(this_ptr_ptr);
33740 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(this_ptr_ptr);
33741 FREE((void*)this_ptr);
33742 RoutingMessageHandler_free(this_ptr_conv);
33745 int8_tArray __attribute__((export_name("TS_AcceptChannel_write"))) TS_AcceptChannel_write(uint32_t obj) {
33746 LDKAcceptChannel obj_conv;
33747 obj_conv.inner = (void*)(obj & (~1));
33748 obj_conv.is_owned = false;
33749 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33750 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
33751 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33752 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33753 CVec_u8Z_free(ret_var);
33757 uint32_t __attribute__((export_name("TS_AcceptChannel_read"))) TS_AcceptChannel_read(int8_tArray ser) {
33758 LDKu8slice ser_ref;
33759 ser_ref.datalen = ser->arr_len;
33760 ser_ref.data = ser->elems;
33761 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
33762 *ret_conv = AcceptChannel_read(ser_ref);
33764 return (uint32_t)ret_conv;
33767 int8_tArray __attribute__((export_name("TS_AnnouncementSignatures_write"))) TS_AnnouncementSignatures_write(uint32_t obj) {
33768 LDKAnnouncementSignatures obj_conv;
33769 obj_conv.inner = (void*)(obj & (~1));
33770 obj_conv.is_owned = false;
33771 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33772 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
33773 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33774 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33775 CVec_u8Z_free(ret_var);
33779 uint32_t __attribute__((export_name("TS_AnnouncementSignatures_read"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
33780 LDKu8slice ser_ref;
33781 ser_ref.datalen = ser->arr_len;
33782 ser_ref.data = ser->elems;
33783 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
33784 *ret_conv = AnnouncementSignatures_read(ser_ref);
33786 return (uint32_t)ret_conv;
33789 int8_tArray __attribute__((export_name("TS_ChannelReestablish_write"))) TS_ChannelReestablish_write(uint32_t obj) {
33790 LDKChannelReestablish obj_conv;
33791 obj_conv.inner = (void*)(obj & (~1));
33792 obj_conv.is_owned = false;
33793 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33794 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
33795 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33796 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33797 CVec_u8Z_free(ret_var);
33801 uint32_t __attribute__((export_name("TS_ChannelReestablish_read"))) TS_ChannelReestablish_read(int8_tArray ser) {
33802 LDKu8slice ser_ref;
33803 ser_ref.datalen = ser->arr_len;
33804 ser_ref.data = ser->elems;
33805 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
33806 *ret_conv = ChannelReestablish_read(ser_ref);
33808 return (uint32_t)ret_conv;
33811 int8_tArray __attribute__((export_name("TS_ClosingSigned_write"))) TS_ClosingSigned_write(uint32_t obj) {
33812 LDKClosingSigned obj_conv;
33813 obj_conv.inner = (void*)(obj & (~1));
33814 obj_conv.is_owned = false;
33815 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33816 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
33817 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33818 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33819 CVec_u8Z_free(ret_var);
33823 uint32_t __attribute__((export_name("TS_ClosingSigned_read"))) TS_ClosingSigned_read(int8_tArray ser) {
33824 LDKu8slice ser_ref;
33825 ser_ref.datalen = ser->arr_len;
33826 ser_ref.data = ser->elems;
33827 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
33828 *ret_conv = ClosingSigned_read(ser_ref);
33830 return (uint32_t)ret_conv;
33833 int8_tArray __attribute__((export_name("TS_ClosingSignedFeeRange_write"))) TS_ClosingSignedFeeRange_write(uint32_t obj) {
33834 LDKClosingSignedFeeRange obj_conv;
33835 obj_conv.inner = (void*)(obj & (~1));
33836 obj_conv.is_owned = false;
33837 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33838 LDKCVec_u8Z ret_var = ClosingSignedFeeRange_write(&obj_conv);
33839 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33840 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33841 CVec_u8Z_free(ret_var);
33845 uint32_t __attribute__((export_name("TS_ClosingSignedFeeRange_read"))) TS_ClosingSignedFeeRange_read(int8_tArray ser) {
33846 LDKu8slice ser_ref;
33847 ser_ref.datalen = ser->arr_len;
33848 ser_ref.data = ser->elems;
33849 LDKCResult_ClosingSignedFeeRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedFeeRangeDecodeErrorZ), "LDKCResult_ClosingSignedFeeRangeDecodeErrorZ");
33850 *ret_conv = ClosingSignedFeeRange_read(ser_ref);
33852 return (uint32_t)ret_conv;
33855 int8_tArray __attribute__((export_name("TS_CommitmentSigned_write"))) TS_CommitmentSigned_write(uint32_t obj) {
33856 LDKCommitmentSigned obj_conv;
33857 obj_conv.inner = (void*)(obj & (~1));
33858 obj_conv.is_owned = false;
33859 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33860 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
33861 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33862 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33863 CVec_u8Z_free(ret_var);
33867 uint32_t __attribute__((export_name("TS_CommitmentSigned_read"))) TS_CommitmentSigned_read(int8_tArray ser) {
33868 LDKu8slice ser_ref;
33869 ser_ref.datalen = ser->arr_len;
33870 ser_ref.data = ser->elems;
33871 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
33872 *ret_conv = CommitmentSigned_read(ser_ref);
33874 return (uint32_t)ret_conv;
33877 int8_tArray __attribute__((export_name("TS_FundingCreated_write"))) TS_FundingCreated_write(uint32_t obj) {
33878 LDKFundingCreated obj_conv;
33879 obj_conv.inner = (void*)(obj & (~1));
33880 obj_conv.is_owned = false;
33881 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33882 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
33883 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33884 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33885 CVec_u8Z_free(ret_var);
33889 uint32_t __attribute__((export_name("TS_FundingCreated_read"))) TS_FundingCreated_read(int8_tArray ser) {
33890 LDKu8slice ser_ref;
33891 ser_ref.datalen = ser->arr_len;
33892 ser_ref.data = ser->elems;
33893 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
33894 *ret_conv = FundingCreated_read(ser_ref);
33896 return (uint32_t)ret_conv;
33899 int8_tArray __attribute__((export_name("TS_FundingSigned_write"))) TS_FundingSigned_write(uint32_t obj) {
33900 LDKFundingSigned obj_conv;
33901 obj_conv.inner = (void*)(obj & (~1));
33902 obj_conv.is_owned = false;
33903 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33904 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
33905 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33906 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33907 CVec_u8Z_free(ret_var);
33911 uint32_t __attribute__((export_name("TS_FundingSigned_read"))) TS_FundingSigned_read(int8_tArray ser) {
33912 LDKu8slice ser_ref;
33913 ser_ref.datalen = ser->arr_len;
33914 ser_ref.data = ser->elems;
33915 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
33916 *ret_conv = FundingSigned_read(ser_ref);
33918 return (uint32_t)ret_conv;
33921 int8_tArray __attribute__((export_name("TS_ChannelReady_write"))) TS_ChannelReady_write(uint32_t obj) {
33922 LDKChannelReady obj_conv;
33923 obj_conv.inner = (void*)(obj & (~1));
33924 obj_conv.is_owned = false;
33925 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33926 LDKCVec_u8Z ret_var = ChannelReady_write(&obj_conv);
33927 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33928 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33929 CVec_u8Z_free(ret_var);
33933 uint32_t __attribute__((export_name("TS_ChannelReady_read"))) TS_ChannelReady_read(int8_tArray ser) {
33934 LDKu8slice ser_ref;
33935 ser_ref.datalen = ser->arr_len;
33936 ser_ref.data = ser->elems;
33937 LDKCResult_ChannelReadyDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReadyDecodeErrorZ), "LDKCResult_ChannelReadyDecodeErrorZ");
33938 *ret_conv = ChannelReady_read(ser_ref);
33940 return (uint32_t)ret_conv;
33943 int8_tArray __attribute__((export_name("TS_Init_write"))) TS_Init_write(uint32_t obj) {
33945 obj_conv.inner = (void*)(obj & (~1));
33946 obj_conv.is_owned = false;
33947 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33948 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
33949 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33950 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33951 CVec_u8Z_free(ret_var);
33955 uint32_t __attribute__((export_name("TS_Init_read"))) TS_Init_read(int8_tArray ser) {
33956 LDKu8slice ser_ref;
33957 ser_ref.datalen = ser->arr_len;
33958 ser_ref.data = ser->elems;
33959 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
33960 *ret_conv = Init_read(ser_ref);
33962 return (uint32_t)ret_conv;
33965 int8_tArray __attribute__((export_name("TS_OpenChannel_write"))) TS_OpenChannel_write(uint32_t obj) {
33966 LDKOpenChannel obj_conv;
33967 obj_conv.inner = (void*)(obj & (~1));
33968 obj_conv.is_owned = false;
33969 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33970 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
33971 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33972 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33973 CVec_u8Z_free(ret_var);
33977 uint32_t __attribute__((export_name("TS_OpenChannel_read"))) TS_OpenChannel_read(int8_tArray ser) {
33978 LDKu8slice ser_ref;
33979 ser_ref.datalen = ser->arr_len;
33980 ser_ref.data = ser->elems;
33981 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
33982 *ret_conv = OpenChannel_read(ser_ref);
33984 return (uint32_t)ret_conv;
33987 int8_tArray __attribute__((export_name("TS_RevokeAndACK_write"))) TS_RevokeAndACK_write(uint32_t obj) {
33988 LDKRevokeAndACK obj_conv;
33989 obj_conv.inner = (void*)(obj & (~1));
33990 obj_conv.is_owned = false;
33991 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
33992 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
33993 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
33994 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
33995 CVec_u8Z_free(ret_var);
33999 uint32_t __attribute__((export_name("TS_RevokeAndACK_read"))) TS_RevokeAndACK_read(int8_tArray ser) {
34000 LDKu8slice ser_ref;
34001 ser_ref.datalen = ser->arr_len;
34002 ser_ref.data = ser->elems;
34003 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
34004 *ret_conv = RevokeAndACK_read(ser_ref);
34006 return (uint32_t)ret_conv;
34009 int8_tArray __attribute__((export_name("TS_Shutdown_write"))) TS_Shutdown_write(uint32_t obj) {
34010 LDKShutdown obj_conv;
34011 obj_conv.inner = (void*)(obj & (~1));
34012 obj_conv.is_owned = false;
34013 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34014 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
34015 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34016 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34017 CVec_u8Z_free(ret_var);
34021 uint32_t __attribute__((export_name("TS_Shutdown_read"))) TS_Shutdown_read(int8_tArray ser) {
34022 LDKu8slice ser_ref;
34023 ser_ref.datalen = ser->arr_len;
34024 ser_ref.data = ser->elems;
34025 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
34026 *ret_conv = Shutdown_read(ser_ref);
34028 return (uint32_t)ret_conv;
34031 int8_tArray __attribute__((export_name("TS_UpdateFailHTLC_write"))) TS_UpdateFailHTLC_write(uint32_t obj) {
34032 LDKUpdateFailHTLC obj_conv;
34033 obj_conv.inner = (void*)(obj & (~1));
34034 obj_conv.is_owned = false;
34035 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34036 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
34037 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34038 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34039 CVec_u8Z_free(ret_var);
34043 uint32_t __attribute__((export_name("TS_UpdateFailHTLC_read"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
34044 LDKu8slice ser_ref;
34045 ser_ref.datalen = ser->arr_len;
34046 ser_ref.data = ser->elems;
34047 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
34048 *ret_conv = UpdateFailHTLC_read(ser_ref);
34050 return (uint32_t)ret_conv;
34053 int8_tArray __attribute__((export_name("TS_UpdateFailMalformedHTLC_write"))) TS_UpdateFailMalformedHTLC_write(uint32_t obj) {
34054 LDKUpdateFailMalformedHTLC obj_conv;
34055 obj_conv.inner = (void*)(obj & (~1));
34056 obj_conv.is_owned = false;
34057 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34058 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
34059 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34060 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34061 CVec_u8Z_free(ret_var);
34065 uint32_t __attribute__((export_name("TS_UpdateFailMalformedHTLC_read"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
34066 LDKu8slice ser_ref;
34067 ser_ref.datalen = ser->arr_len;
34068 ser_ref.data = ser->elems;
34069 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
34070 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
34072 return (uint32_t)ret_conv;
34075 int8_tArray __attribute__((export_name("TS_UpdateFee_write"))) TS_UpdateFee_write(uint32_t obj) {
34076 LDKUpdateFee obj_conv;
34077 obj_conv.inner = (void*)(obj & (~1));
34078 obj_conv.is_owned = false;
34079 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34080 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
34081 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34082 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34083 CVec_u8Z_free(ret_var);
34087 uint32_t __attribute__((export_name("TS_UpdateFee_read"))) TS_UpdateFee_read(int8_tArray ser) {
34088 LDKu8slice ser_ref;
34089 ser_ref.datalen = ser->arr_len;
34090 ser_ref.data = ser->elems;
34091 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
34092 *ret_conv = UpdateFee_read(ser_ref);
34094 return (uint32_t)ret_conv;
34097 int8_tArray __attribute__((export_name("TS_UpdateFulfillHTLC_write"))) TS_UpdateFulfillHTLC_write(uint32_t obj) {
34098 LDKUpdateFulfillHTLC obj_conv;
34099 obj_conv.inner = (void*)(obj & (~1));
34100 obj_conv.is_owned = false;
34101 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34102 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
34103 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34104 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34105 CVec_u8Z_free(ret_var);
34109 uint32_t __attribute__((export_name("TS_UpdateFulfillHTLC_read"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
34110 LDKu8slice ser_ref;
34111 ser_ref.datalen = ser->arr_len;
34112 ser_ref.data = ser->elems;
34113 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
34114 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
34116 return (uint32_t)ret_conv;
34119 int8_tArray __attribute__((export_name("TS_UpdateAddHTLC_write"))) TS_UpdateAddHTLC_write(uint32_t obj) {
34120 LDKUpdateAddHTLC obj_conv;
34121 obj_conv.inner = (void*)(obj & (~1));
34122 obj_conv.is_owned = false;
34123 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34124 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
34125 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34126 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34127 CVec_u8Z_free(ret_var);
34131 uint32_t __attribute__((export_name("TS_UpdateAddHTLC_read"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
34132 LDKu8slice ser_ref;
34133 ser_ref.datalen = ser->arr_len;
34134 ser_ref.data = ser->elems;
34135 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
34136 *ret_conv = UpdateAddHTLC_read(ser_ref);
34138 return (uint32_t)ret_conv;
34141 int8_tArray __attribute__((export_name("TS_Ping_write"))) TS_Ping_write(uint32_t obj) {
34143 obj_conv.inner = (void*)(obj & (~1));
34144 obj_conv.is_owned = false;
34145 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34146 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
34147 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34148 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34149 CVec_u8Z_free(ret_var);
34153 uint32_t __attribute__((export_name("TS_Ping_read"))) TS_Ping_read(int8_tArray ser) {
34154 LDKu8slice ser_ref;
34155 ser_ref.datalen = ser->arr_len;
34156 ser_ref.data = ser->elems;
34157 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
34158 *ret_conv = Ping_read(ser_ref);
34160 return (uint32_t)ret_conv;
34163 int8_tArray __attribute__((export_name("TS_Pong_write"))) TS_Pong_write(uint32_t obj) {
34165 obj_conv.inner = (void*)(obj & (~1));
34166 obj_conv.is_owned = false;
34167 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34168 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
34169 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34170 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34171 CVec_u8Z_free(ret_var);
34175 uint32_t __attribute__((export_name("TS_Pong_read"))) TS_Pong_read(int8_tArray ser) {
34176 LDKu8slice ser_ref;
34177 ser_ref.datalen = ser->arr_len;
34178 ser_ref.data = ser->elems;
34179 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
34180 *ret_conv = Pong_read(ser_ref);
34182 return (uint32_t)ret_conv;
34185 int8_tArray __attribute__((export_name("TS_UnsignedChannelAnnouncement_write"))) TS_UnsignedChannelAnnouncement_write(uint32_t obj) {
34186 LDKUnsignedChannelAnnouncement obj_conv;
34187 obj_conv.inner = (void*)(obj & (~1));
34188 obj_conv.is_owned = false;
34189 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34190 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
34191 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34192 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34193 CVec_u8Z_free(ret_var);
34197 uint32_t __attribute__((export_name("TS_UnsignedChannelAnnouncement_read"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
34198 LDKu8slice ser_ref;
34199 ser_ref.datalen = ser->arr_len;
34200 ser_ref.data = ser->elems;
34201 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
34202 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
34204 return (uint32_t)ret_conv;
34207 int8_tArray __attribute__((export_name("TS_ChannelAnnouncement_write"))) TS_ChannelAnnouncement_write(uint32_t obj) {
34208 LDKChannelAnnouncement obj_conv;
34209 obj_conv.inner = (void*)(obj & (~1));
34210 obj_conv.is_owned = false;
34211 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34212 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
34213 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34214 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34215 CVec_u8Z_free(ret_var);
34219 uint32_t __attribute__((export_name("TS_ChannelAnnouncement_read"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
34220 LDKu8slice ser_ref;
34221 ser_ref.datalen = ser->arr_len;
34222 ser_ref.data = ser->elems;
34223 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
34224 *ret_conv = ChannelAnnouncement_read(ser_ref);
34226 return (uint32_t)ret_conv;
34229 int8_tArray __attribute__((export_name("TS_UnsignedChannelUpdate_write"))) TS_UnsignedChannelUpdate_write(uint32_t obj) {
34230 LDKUnsignedChannelUpdate obj_conv;
34231 obj_conv.inner = (void*)(obj & (~1));
34232 obj_conv.is_owned = false;
34233 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34234 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
34235 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34236 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34237 CVec_u8Z_free(ret_var);
34241 uint32_t __attribute__((export_name("TS_UnsignedChannelUpdate_read"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
34242 LDKu8slice ser_ref;
34243 ser_ref.datalen = ser->arr_len;
34244 ser_ref.data = ser->elems;
34245 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
34246 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
34248 return (uint32_t)ret_conv;
34251 int8_tArray __attribute__((export_name("TS_ChannelUpdate_write"))) TS_ChannelUpdate_write(uint32_t obj) {
34252 LDKChannelUpdate obj_conv;
34253 obj_conv.inner = (void*)(obj & (~1));
34254 obj_conv.is_owned = false;
34255 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34256 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
34257 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34258 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34259 CVec_u8Z_free(ret_var);
34263 uint32_t __attribute__((export_name("TS_ChannelUpdate_read"))) TS_ChannelUpdate_read(int8_tArray ser) {
34264 LDKu8slice ser_ref;
34265 ser_ref.datalen = ser->arr_len;
34266 ser_ref.data = ser->elems;
34267 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
34268 *ret_conv = ChannelUpdate_read(ser_ref);
34270 return (uint32_t)ret_conv;
34273 int8_tArray __attribute__((export_name("TS_ErrorMessage_write"))) TS_ErrorMessage_write(uint32_t obj) {
34274 LDKErrorMessage obj_conv;
34275 obj_conv.inner = (void*)(obj & (~1));
34276 obj_conv.is_owned = false;
34277 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34278 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
34279 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34280 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34281 CVec_u8Z_free(ret_var);
34285 uint32_t __attribute__((export_name("TS_ErrorMessage_read"))) TS_ErrorMessage_read(int8_tArray ser) {
34286 LDKu8slice ser_ref;
34287 ser_ref.datalen = ser->arr_len;
34288 ser_ref.data = ser->elems;
34289 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
34290 *ret_conv = ErrorMessage_read(ser_ref);
34292 return (uint32_t)ret_conv;
34295 int8_tArray __attribute__((export_name("TS_WarningMessage_write"))) TS_WarningMessage_write(uint32_t obj) {
34296 LDKWarningMessage obj_conv;
34297 obj_conv.inner = (void*)(obj & (~1));
34298 obj_conv.is_owned = false;
34299 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34300 LDKCVec_u8Z ret_var = WarningMessage_write(&obj_conv);
34301 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34302 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34303 CVec_u8Z_free(ret_var);
34307 uint32_t __attribute__((export_name("TS_WarningMessage_read"))) TS_WarningMessage_read(int8_tArray ser) {
34308 LDKu8slice ser_ref;
34309 ser_ref.datalen = ser->arr_len;
34310 ser_ref.data = ser->elems;
34311 LDKCResult_WarningMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_WarningMessageDecodeErrorZ), "LDKCResult_WarningMessageDecodeErrorZ");
34312 *ret_conv = WarningMessage_read(ser_ref);
34314 return (uint32_t)ret_conv;
34317 int8_tArray __attribute__((export_name("TS_UnsignedNodeAnnouncement_write"))) TS_UnsignedNodeAnnouncement_write(uint32_t obj) {
34318 LDKUnsignedNodeAnnouncement obj_conv;
34319 obj_conv.inner = (void*)(obj & (~1));
34320 obj_conv.is_owned = false;
34321 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34322 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
34323 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34324 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34325 CVec_u8Z_free(ret_var);
34329 uint32_t __attribute__((export_name("TS_UnsignedNodeAnnouncement_read"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
34330 LDKu8slice ser_ref;
34331 ser_ref.datalen = ser->arr_len;
34332 ser_ref.data = ser->elems;
34333 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
34334 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
34336 return (uint32_t)ret_conv;
34339 int8_tArray __attribute__((export_name("TS_NodeAnnouncement_write"))) TS_NodeAnnouncement_write(uint32_t obj) {
34340 LDKNodeAnnouncement obj_conv;
34341 obj_conv.inner = (void*)(obj & (~1));
34342 obj_conv.is_owned = false;
34343 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34344 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
34345 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34346 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34347 CVec_u8Z_free(ret_var);
34351 uint32_t __attribute__((export_name("TS_NodeAnnouncement_read"))) TS_NodeAnnouncement_read(int8_tArray ser) {
34352 LDKu8slice ser_ref;
34353 ser_ref.datalen = ser->arr_len;
34354 ser_ref.data = ser->elems;
34355 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
34356 *ret_conv = NodeAnnouncement_read(ser_ref);
34358 return (uint32_t)ret_conv;
34361 uint32_t __attribute__((export_name("TS_QueryShortChannelIds_read"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
34362 LDKu8slice ser_ref;
34363 ser_ref.datalen = ser->arr_len;
34364 ser_ref.data = ser->elems;
34365 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
34366 *ret_conv = QueryShortChannelIds_read(ser_ref);
34368 return (uint32_t)ret_conv;
34371 int8_tArray __attribute__((export_name("TS_QueryShortChannelIds_write"))) TS_QueryShortChannelIds_write(uint32_t obj) {
34372 LDKQueryShortChannelIds obj_conv;
34373 obj_conv.inner = (void*)(obj & (~1));
34374 obj_conv.is_owned = false;
34375 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34376 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
34377 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34378 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34379 CVec_u8Z_free(ret_var);
34383 int8_tArray __attribute__((export_name("TS_ReplyShortChannelIdsEnd_write"))) TS_ReplyShortChannelIdsEnd_write(uint32_t obj) {
34384 LDKReplyShortChannelIdsEnd obj_conv;
34385 obj_conv.inner = (void*)(obj & (~1));
34386 obj_conv.is_owned = false;
34387 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34388 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
34389 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34390 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34391 CVec_u8Z_free(ret_var);
34395 uint32_t __attribute__((export_name("TS_ReplyShortChannelIdsEnd_read"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
34396 LDKu8slice ser_ref;
34397 ser_ref.datalen = ser->arr_len;
34398 ser_ref.data = ser->elems;
34399 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
34400 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
34402 return (uint32_t)ret_conv;
34405 int32_t __attribute__((export_name("TS_QueryChannelRange_end_blocknum"))) TS_QueryChannelRange_end_blocknum(uint32_t this_arg) {
34406 LDKQueryChannelRange this_arg_conv;
34407 this_arg_conv.inner = (void*)(this_arg & (~1));
34408 this_arg_conv.is_owned = false;
34409 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34410 int32_t ret_conv = QueryChannelRange_end_blocknum(&this_arg_conv);
34414 int8_tArray __attribute__((export_name("TS_QueryChannelRange_write"))) TS_QueryChannelRange_write(uint32_t obj) {
34415 LDKQueryChannelRange obj_conv;
34416 obj_conv.inner = (void*)(obj & (~1));
34417 obj_conv.is_owned = false;
34418 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34419 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
34420 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34421 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34422 CVec_u8Z_free(ret_var);
34426 uint32_t __attribute__((export_name("TS_QueryChannelRange_read"))) TS_QueryChannelRange_read(int8_tArray ser) {
34427 LDKu8slice ser_ref;
34428 ser_ref.datalen = ser->arr_len;
34429 ser_ref.data = ser->elems;
34430 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
34431 *ret_conv = QueryChannelRange_read(ser_ref);
34433 return (uint32_t)ret_conv;
34436 uint32_t __attribute__((export_name("TS_ReplyChannelRange_read"))) TS_ReplyChannelRange_read(int8_tArray ser) {
34437 LDKu8slice ser_ref;
34438 ser_ref.datalen = ser->arr_len;
34439 ser_ref.data = ser->elems;
34440 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
34441 *ret_conv = ReplyChannelRange_read(ser_ref);
34443 return (uint32_t)ret_conv;
34446 int8_tArray __attribute__((export_name("TS_ReplyChannelRange_write"))) TS_ReplyChannelRange_write(uint32_t obj) {
34447 LDKReplyChannelRange obj_conv;
34448 obj_conv.inner = (void*)(obj & (~1));
34449 obj_conv.is_owned = false;
34450 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34451 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
34452 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34453 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34454 CVec_u8Z_free(ret_var);
34458 int8_tArray __attribute__((export_name("TS_GossipTimestampFilter_write"))) TS_GossipTimestampFilter_write(uint32_t obj) {
34459 LDKGossipTimestampFilter obj_conv;
34460 obj_conv.inner = (void*)(obj & (~1));
34461 obj_conv.is_owned = false;
34462 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
34463 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
34464 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
34465 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
34466 CVec_u8Z_free(ret_var);
34470 uint32_t __attribute__((export_name("TS_GossipTimestampFilter_read"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
34471 LDKu8slice ser_ref;
34472 ser_ref.datalen = ser->arr_len;
34473 ser_ref.data = ser->elems;
34474 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
34475 *ret_conv = GossipTimestampFilter_read(ser_ref);
34477 return (uint32_t)ret_conv;
34480 void __attribute__((export_name("TS_CustomMessageHandler_free"))) TS_CustomMessageHandler_free(uint32_t this_ptr) {
34481 if ((this_ptr & 1) != 0) return;
34482 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
34483 CHECK_ACCESS(this_ptr_ptr);
34484 LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(this_ptr_ptr);
34485 FREE((void*)this_ptr);
34486 CustomMessageHandler_free(this_ptr_conv);
34489 void __attribute__((export_name("TS_IgnoringMessageHandler_free"))) TS_IgnoringMessageHandler_free(uint32_t this_obj) {
34490 LDKIgnoringMessageHandler this_obj_conv;
34491 this_obj_conv.inner = (void*)(this_obj & (~1));
34492 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
34493 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34494 IgnoringMessageHandler_free(this_obj_conv);
34497 uint32_t __attribute__((export_name("TS_IgnoringMessageHandler_new"))) TS_IgnoringMessageHandler_new() {
34498 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
34499 uint32_t ret_ref = 0;
34500 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34501 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34502 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34503 ret_ref = (uintptr_t)ret_var.inner;
34504 if (ret_var.is_owned) {
34510 uint32_t __attribute__((export_name("TS_IgnoringMessageHandler_as_MessageSendEventsProvider"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
34511 LDKIgnoringMessageHandler this_arg_conv;
34512 this_arg_conv.inner = (void*)(this_arg & (~1));
34513 this_arg_conv.is_owned = false;
34514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34515 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
34516 *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
34517 return (uint32_t)ret_ret;
34520 uint32_t __attribute__((export_name("TS_IgnoringMessageHandler_as_RoutingMessageHandler"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint32_t this_arg) {
34521 LDKIgnoringMessageHandler this_arg_conv;
34522 this_arg_conv.inner = (void*)(this_arg & (~1));
34523 this_arg_conv.is_owned = false;
34524 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34525 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
34526 *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
34527 return (uint32_t)ret_ret;
34530 uint32_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageReader"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint32_t this_arg) {
34531 LDKIgnoringMessageHandler this_arg_conv;
34532 this_arg_conv.inner = (void*)(this_arg & (~1));
34533 this_arg_conv.is_owned = false;
34534 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34535 LDKCustomMessageReader* ret_ret = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader");
34536 *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv);
34537 return (uint32_t)ret_ret;
34540 uint32_t __attribute__((export_name("TS_IgnoringMessageHandler_as_CustomMessageHandler"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint32_t this_arg) {
34541 LDKIgnoringMessageHandler this_arg_conv;
34542 this_arg_conv.inner = (void*)(this_arg & (~1));
34543 this_arg_conv.is_owned = false;
34544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34545 LDKCustomMessageHandler* ret_ret = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler");
34546 *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv);
34547 return (uint32_t)ret_ret;
34550 void __attribute__((export_name("TS_ErroringMessageHandler_free"))) TS_ErroringMessageHandler_free(uint32_t this_obj) {
34551 LDKErroringMessageHandler this_obj_conv;
34552 this_obj_conv.inner = (void*)(this_obj & (~1));
34553 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
34554 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34555 ErroringMessageHandler_free(this_obj_conv);
34558 uint32_t __attribute__((export_name("TS_ErroringMessageHandler_new"))) TS_ErroringMessageHandler_new() {
34559 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
34560 uint32_t ret_ref = 0;
34561 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34562 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34563 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34564 ret_ref = (uintptr_t)ret_var.inner;
34565 if (ret_var.is_owned) {
34571 uint32_t __attribute__((export_name("TS_ErroringMessageHandler_as_MessageSendEventsProvider"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
34572 LDKErroringMessageHandler this_arg_conv;
34573 this_arg_conv.inner = (void*)(this_arg & (~1));
34574 this_arg_conv.is_owned = false;
34575 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34576 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
34577 *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
34578 return (uint32_t)ret_ret;
34581 uint32_t __attribute__((export_name("TS_ErroringMessageHandler_as_ChannelMessageHandler"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint32_t this_arg) {
34582 LDKErroringMessageHandler this_arg_conv;
34583 this_arg_conv.inner = (void*)(this_arg & (~1));
34584 this_arg_conv.is_owned = false;
34585 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34586 LDKChannelMessageHandler* ret_ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
34587 *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
34588 return (uint32_t)ret_ret;
34591 void __attribute__((export_name("TS_MessageHandler_free"))) TS_MessageHandler_free(uint32_t this_obj) {
34592 LDKMessageHandler this_obj_conv;
34593 this_obj_conv.inner = (void*)(this_obj & (~1));
34594 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
34595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34596 MessageHandler_free(this_obj_conv);
34599 uint32_t __attribute__((export_name("TS_MessageHandler_get_chan_handler"))) TS_MessageHandler_get_chan_handler(uint32_t this_ptr) {
34600 LDKMessageHandler this_ptr_conv;
34601 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34602 this_ptr_conv.is_owned = false;
34603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34604 // WARNING: This object doesn't live past this scope, needs clone!
34605 uint32_t ret_ret = ((uintptr_t)MessageHandler_get_chan_handler(&this_ptr_conv)) | 1;
34609 void __attribute__((export_name("TS_MessageHandler_set_chan_handler"))) TS_MessageHandler_set_chan_handler(uint32_t this_ptr, uint32_t val) {
34610 LDKMessageHandler this_ptr_conv;
34611 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34612 this_ptr_conv.is_owned = false;
34613 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34614 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
34615 CHECK_ACCESS(val_ptr);
34616 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(val_ptr);
34617 if (val_conv.free == LDKChannelMessageHandler_JCalls_free) {
34618 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34619 LDKChannelMessageHandler_JCalls_cloned(&val_conv);
34621 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
34624 uint32_t __attribute__((export_name("TS_MessageHandler_get_route_handler"))) TS_MessageHandler_get_route_handler(uint32_t this_ptr) {
34625 LDKMessageHandler this_ptr_conv;
34626 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34627 this_ptr_conv.is_owned = false;
34628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34629 // WARNING: This object doesn't live past this scope, needs clone!
34630 uint32_t ret_ret = ((uintptr_t)MessageHandler_get_route_handler(&this_ptr_conv)) | 1;
34634 void __attribute__((export_name("TS_MessageHandler_set_route_handler"))) TS_MessageHandler_set_route_handler(uint32_t this_ptr, uint32_t val) {
34635 LDKMessageHandler this_ptr_conv;
34636 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34637 this_ptr_conv.is_owned = false;
34638 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34639 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
34640 CHECK_ACCESS(val_ptr);
34641 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(val_ptr);
34642 if (val_conv.free == LDKRoutingMessageHandler_JCalls_free) {
34643 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34644 LDKRoutingMessageHandler_JCalls_cloned(&val_conv);
34646 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
34649 uint32_t __attribute__((export_name("TS_MessageHandler_new"))) TS_MessageHandler_new(uint32_t chan_handler_arg, uint32_t route_handler_arg) {
34650 void* chan_handler_arg_ptr = (void*)(((uintptr_t)chan_handler_arg) & ~1);
34651 CHECK_ACCESS(chan_handler_arg_ptr);
34652 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(chan_handler_arg_ptr);
34653 if (chan_handler_arg_conv.free == LDKChannelMessageHandler_JCalls_free) {
34654 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34655 LDKChannelMessageHandler_JCalls_cloned(&chan_handler_arg_conv);
34657 void* route_handler_arg_ptr = (void*)(((uintptr_t)route_handler_arg) & ~1);
34658 CHECK_ACCESS(route_handler_arg_ptr);
34659 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(route_handler_arg_ptr);
34660 if (route_handler_arg_conv.free == LDKRoutingMessageHandler_JCalls_free) {
34661 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34662 LDKRoutingMessageHandler_JCalls_cloned(&route_handler_arg_conv);
34664 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv);
34665 uint32_t ret_ref = 0;
34666 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34667 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34668 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34669 ret_ref = (uintptr_t)ret_var.inner;
34670 if (ret_var.is_owned) {
34676 static inline uintptr_t SocketDescriptor_clone_ptr(LDKSocketDescriptor *NONNULL_PTR arg) {
34677 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
34678 *ret_ret = SocketDescriptor_clone(arg);
34679 return (uint32_t)ret_ret;
34681 uint32_t __attribute__((export_name("TS_SocketDescriptor_clone_ptr"))) TS_SocketDescriptor_clone_ptr(uint32_t arg) {
34682 void* arg_ptr = (void*)(((uintptr_t)arg) & ~1);
34683 if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
34684 LDKSocketDescriptor* arg_conv = (LDKSocketDescriptor*)arg_ptr;
34685 uint32_t ret_conv = SocketDescriptor_clone_ptr(arg_conv);
34689 uint32_t __attribute__((export_name("TS_SocketDescriptor_clone"))) TS_SocketDescriptor_clone(uint32_t orig) {
34690 void* orig_ptr = (void*)(((uintptr_t)orig) & ~1);
34691 if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
34692 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)orig_ptr;
34693 LDKSocketDescriptor* ret_ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
34694 *ret_ret = SocketDescriptor_clone(orig_conv);
34695 return (uint32_t)ret_ret;
34698 void __attribute__((export_name("TS_SocketDescriptor_free"))) TS_SocketDescriptor_free(uint32_t this_ptr) {
34699 if ((this_ptr & 1) != 0) return;
34700 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
34701 CHECK_ACCESS(this_ptr_ptr);
34702 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(this_ptr_ptr);
34703 FREE((void*)this_ptr);
34704 SocketDescriptor_free(this_ptr_conv);
34707 void __attribute__((export_name("TS_PeerHandleError_free"))) TS_PeerHandleError_free(uint32_t this_obj) {
34708 LDKPeerHandleError this_obj_conv;
34709 this_obj_conv.inner = (void*)(this_obj & (~1));
34710 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
34711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34712 PeerHandleError_free(this_obj_conv);
34715 jboolean __attribute__((export_name("TS_PeerHandleError_get_no_connection_possible"))) TS_PeerHandleError_get_no_connection_possible(uint32_t this_ptr) {
34716 LDKPeerHandleError this_ptr_conv;
34717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34718 this_ptr_conv.is_owned = false;
34719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34720 jboolean ret_conv = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
34724 void __attribute__((export_name("TS_PeerHandleError_set_no_connection_possible"))) TS_PeerHandleError_set_no_connection_possible(uint32_t this_ptr, jboolean val) {
34725 LDKPeerHandleError this_ptr_conv;
34726 this_ptr_conv.inner = (void*)(this_ptr & (~1));
34727 this_ptr_conv.is_owned = false;
34728 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
34729 PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
34732 uint32_t __attribute__((export_name("TS_PeerHandleError_new"))) TS_PeerHandleError_new(jboolean no_connection_possible_arg) {
34733 LDKPeerHandleError ret_var = PeerHandleError_new(no_connection_possible_arg);
34734 uint32_t ret_ref = 0;
34735 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34736 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34737 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34738 ret_ref = (uintptr_t)ret_var.inner;
34739 if (ret_var.is_owned) {
34745 static inline uintptr_t PeerHandleError_clone_ptr(LDKPeerHandleError *NONNULL_PTR arg) {
34746 LDKPeerHandleError ret_var = PeerHandleError_clone(arg);
34747 uint32_t ret_ref = 0;
34748 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34749 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34750 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34751 ret_ref = (uintptr_t)ret_var.inner;
34752 if (ret_var.is_owned) {
34757 uint32_t __attribute__((export_name("TS_PeerHandleError_clone_ptr"))) TS_PeerHandleError_clone_ptr(uint32_t arg) {
34758 LDKPeerHandleError arg_conv;
34759 arg_conv.inner = (void*)(arg & (~1));
34760 arg_conv.is_owned = false;
34761 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
34762 uint32_t ret_conv = PeerHandleError_clone_ptr(&arg_conv);
34766 uint32_t __attribute__((export_name("TS_PeerHandleError_clone"))) TS_PeerHandleError_clone(uint32_t orig) {
34767 LDKPeerHandleError orig_conv;
34768 orig_conv.inner = (void*)(orig & (~1));
34769 orig_conv.is_owned = false;
34770 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
34771 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
34772 uint32_t ret_ref = 0;
34773 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34774 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34775 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34776 ret_ref = (uintptr_t)ret_var.inner;
34777 if (ret_var.is_owned) {
34783 void __attribute__((export_name("TS_PeerManager_free"))) TS_PeerManager_free(uint32_t this_obj) {
34784 LDKPeerManager this_obj_conv;
34785 this_obj_conv.inner = (void*)(this_obj & (~1));
34786 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
34787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
34788 PeerManager_free(this_obj_conv);
34791 uint32_t __attribute__((export_name("TS_PeerManager_new"))) TS_PeerManager_new(uint32_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, uint32_t logger, uint32_t custom_message_handler) {
34792 LDKMessageHandler message_handler_conv;
34793 message_handler_conv.inner = (void*)(message_handler & (~1));
34794 message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
34795 CHECK_INNER_FIELD_ACCESS_OR_NULL(message_handler_conv);
34796 // WARNING: we need a move here but no clone is available for LDKMessageHandler
34797 LDKSecretKey our_node_secret_ref;
34798 CHECK(our_node_secret->arr_len == 32);
34799 memcpy(our_node_secret_ref.bytes, our_node_secret->elems, 32); FREE(our_node_secret);
34800 unsigned char ephemeral_random_data_arr[32];
34801 CHECK(ephemeral_random_data->arr_len == 32);
34802 memcpy(ephemeral_random_data_arr, ephemeral_random_data->elems, 32); FREE(ephemeral_random_data);
34803 unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
34804 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
34805 CHECK_ACCESS(logger_ptr);
34806 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
34807 if (logger_conv.free == LDKLogger_JCalls_free) {
34808 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34809 LDKLogger_JCalls_cloned(&logger_conv);
34811 void* custom_message_handler_ptr = (void*)(((uintptr_t)custom_message_handler) & ~1);
34812 CHECK_ACCESS(custom_message_handler_ptr);
34813 LDKCustomMessageHandler custom_message_handler_conv = *(LDKCustomMessageHandler*)(custom_message_handler_ptr);
34814 if (custom_message_handler_conv.free == LDKCustomMessageHandler_JCalls_free) {
34815 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34816 LDKCustomMessageHandler_JCalls_cloned(&custom_message_handler_conv);
34818 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv, custom_message_handler_conv);
34819 uint32_t ret_ref = 0;
34820 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
34821 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
34822 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
34823 ret_ref = (uintptr_t)ret_var.inner;
34824 if (ret_var.is_owned) {
34830 ptrArray __attribute__((export_name("TS_PeerManager_get_peer_node_ids"))) TS_PeerManager_get_peer_node_ids(uint32_t this_arg) {
34831 LDKPeerManager this_arg_conv;
34832 this_arg_conv.inner = (void*)(this_arg & (~1));
34833 this_arg_conv.is_owned = false;
34834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34835 LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
34836 ptrArray ret_arr = NULL;
34837 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
34838 int8_tArray *ret_arr_ptr = (int8_tArray*)(((uint8_t*)ret_arr) + 4);
34839 for (size_t m = 0; m < ret_var.datalen; m++) {
34840 int8_tArray ret_conv_12_arr = init_int8_tArray(33, __LINE__);
34841 memcpy(ret_conv_12_arr->elems, ret_var.data[m].compressed_form, 33);
34842 ret_arr_ptr[m] = ret_conv_12_arr;
34845 FREE(ret_var.data);
34849 uint32_t __attribute__((export_name("TS_PeerManager_new_outbound_connection"))) TS_PeerManager_new_outbound_connection(uint32_t this_arg, int8_tArray their_node_id, uint32_t descriptor, uint32_t remote_network_address) {
34850 LDKPeerManager this_arg_conv;
34851 this_arg_conv.inner = (void*)(this_arg & (~1));
34852 this_arg_conv.is_owned = false;
34853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34854 LDKPublicKey their_node_id_ref;
34855 CHECK(their_node_id->arr_len == 33);
34856 memcpy(their_node_id_ref.compressed_form, their_node_id->elems, 33); FREE(their_node_id);
34857 void* descriptor_ptr = (void*)(((uintptr_t)descriptor) & ~1);
34858 CHECK_ACCESS(descriptor_ptr);
34859 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
34860 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
34861 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34862 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
34864 void* remote_network_address_ptr = (void*)(((uintptr_t)remote_network_address) & ~1);
34865 CHECK_ACCESS(remote_network_address_ptr);
34866 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
34867 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
34868 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv, remote_network_address_conv);
34869 return (uint32_t)ret_conv;
34872 uint32_t __attribute__((export_name("TS_PeerManager_new_inbound_connection"))) TS_PeerManager_new_inbound_connection(uint32_t this_arg, uint32_t descriptor, uint32_t remote_network_address) {
34873 LDKPeerManager this_arg_conv;
34874 this_arg_conv.inner = (void*)(this_arg & (~1));
34875 this_arg_conv.is_owned = false;
34876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34877 void* descriptor_ptr = (void*)(((uintptr_t)descriptor) & ~1);
34878 CHECK_ACCESS(descriptor_ptr);
34879 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(descriptor_ptr);
34880 if (descriptor_conv.free == LDKSocketDescriptor_JCalls_free) {
34881 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
34882 LDKSocketDescriptor_JCalls_cloned(&descriptor_conv);
34884 void* remote_network_address_ptr = (void*)(((uintptr_t)remote_network_address) & ~1);
34885 CHECK_ACCESS(remote_network_address_ptr);
34886 LDKCOption_NetAddressZ remote_network_address_conv = *(LDKCOption_NetAddressZ*)(remote_network_address_ptr);
34887 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
34888 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv, remote_network_address_conv);
34889 return (uint32_t)ret_conv;
34892 uint32_t __attribute__((export_name("TS_PeerManager_write_buffer_space_avail"))) TS_PeerManager_write_buffer_space_avail(uint32_t this_arg, uint32_t descriptor) {
34893 LDKPeerManager this_arg_conv;
34894 this_arg_conv.inner = (void*)(this_arg & (~1));
34895 this_arg_conv.is_owned = false;
34896 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34897 void* descriptor_ptr = (void*)(((uintptr_t)descriptor) & ~1);
34898 if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
34899 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
34900 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
34901 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
34902 return (uint32_t)ret_conv;
34905 uint32_t __attribute__((export_name("TS_PeerManager_read_event"))) TS_PeerManager_read_event(uint32_t this_arg, uint32_t peer_descriptor, int8_tArray data) {
34906 LDKPeerManager this_arg_conv;
34907 this_arg_conv.inner = (void*)(this_arg & (~1));
34908 this_arg_conv.is_owned = false;
34909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34910 void* peer_descriptor_ptr = (void*)(((uintptr_t)peer_descriptor) & ~1);
34911 if (!(peer_descriptor & 1)) { CHECK_ACCESS(peer_descriptor_ptr); }
34912 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)peer_descriptor_ptr;
34913 LDKu8slice data_ref;
34914 data_ref.datalen = data->arr_len;
34915 data_ref.data = data->elems;
34916 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
34917 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
34919 return (uint32_t)ret_conv;
34922 void __attribute__((export_name("TS_PeerManager_process_events"))) TS_PeerManager_process_events(uint32_t this_arg) {
34923 LDKPeerManager this_arg_conv;
34924 this_arg_conv.inner = (void*)(this_arg & (~1));
34925 this_arg_conv.is_owned = false;
34926 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34927 PeerManager_process_events(&this_arg_conv);
34930 void __attribute__((export_name("TS_PeerManager_socket_disconnected"))) TS_PeerManager_socket_disconnected(uint32_t this_arg, uint32_t descriptor) {
34931 LDKPeerManager this_arg_conv;
34932 this_arg_conv.inner = (void*)(this_arg & (~1));
34933 this_arg_conv.is_owned = false;
34934 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34935 void* descriptor_ptr = (void*)(((uintptr_t)descriptor) & ~1);
34936 if (!(descriptor & 1)) { CHECK_ACCESS(descriptor_ptr); }
34937 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)descriptor_ptr;
34938 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
34941 void __attribute__((export_name("TS_PeerManager_disconnect_by_node_id"))) TS_PeerManager_disconnect_by_node_id(uint32_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
34942 LDKPeerManager this_arg_conv;
34943 this_arg_conv.inner = (void*)(this_arg & (~1));
34944 this_arg_conv.is_owned = false;
34945 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34946 LDKPublicKey node_id_ref;
34947 CHECK(node_id->arr_len == 33);
34948 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
34949 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
34952 void __attribute__((export_name("TS_PeerManager_disconnect_all_peers"))) TS_PeerManager_disconnect_all_peers(uint32_t this_arg) {
34953 LDKPeerManager this_arg_conv;
34954 this_arg_conv.inner = (void*)(this_arg & (~1));
34955 this_arg_conv.is_owned = false;
34956 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34957 PeerManager_disconnect_all_peers(&this_arg_conv);
34960 void __attribute__((export_name("TS_PeerManager_timer_tick_occurred"))) TS_PeerManager_timer_tick_occurred(uint32_t this_arg) {
34961 LDKPeerManager this_arg_conv;
34962 this_arg_conv.inner = (void*)(this_arg & (~1));
34963 this_arg_conv.is_owned = false;
34964 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
34965 PeerManager_timer_tick_occurred(&this_arg_conv);
34968 int64_t __attribute__((export_name("TS_htlc_success_tx_weight"))) TS_htlc_success_tx_weight(jboolean opt_anchors) {
34969 int64_t ret_conv = htlc_success_tx_weight(opt_anchors);
34973 int64_t __attribute__((export_name("TS_htlc_timeout_tx_weight"))) TS_htlc_timeout_tx_weight(jboolean opt_anchors) {
34974 int64_t ret_conv = htlc_timeout_tx_weight(opt_anchors);
34978 int8_tArray __attribute__((export_name("TS_build_commitment_secret"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
34979 unsigned char commitment_seed_arr[32];
34980 CHECK(commitment_seed->arr_len == 32);
34981 memcpy(commitment_seed_arr, commitment_seed->elems, 32); FREE(commitment_seed);
34982 unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr;
34983 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
34984 memcpy(ret_arr->elems, build_commitment_secret(commitment_seed_ref, idx).data, 32);
34988 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, uint32_t funding_outpoint) {
34989 LDKCVec_u8Z to_holder_script_ref;
34990 to_holder_script_ref.datalen = to_holder_script->arr_len;
34991 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
34992 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
34993 LDKCVec_u8Z to_counterparty_script_ref;
34994 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
34995 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
34996 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
34997 LDKOutPoint funding_outpoint_conv;
34998 funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
34999 funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
35000 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
35001 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
35002 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);
35003 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35004 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35005 Transaction_free(ret_var);
35009 void __attribute__((export_name("TS_CounterpartyCommitmentSecrets_free"))) TS_CounterpartyCommitmentSecrets_free(uint32_t this_obj) {
35010 LDKCounterpartyCommitmentSecrets this_obj_conv;
35011 this_obj_conv.inner = (void*)(this_obj & (~1));
35012 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
35013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35014 CounterpartyCommitmentSecrets_free(this_obj_conv);
35017 static inline uintptr_t CounterpartyCommitmentSecrets_clone_ptr(LDKCounterpartyCommitmentSecrets *NONNULL_PTR arg) {
35018 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(arg);
35019 uint32_t ret_ref = 0;
35020 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35021 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35022 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35023 ret_ref = (uintptr_t)ret_var.inner;
35024 if (ret_var.is_owned) {
35029 uint32_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone_ptr"))) TS_CounterpartyCommitmentSecrets_clone_ptr(uint32_t arg) {
35030 LDKCounterpartyCommitmentSecrets arg_conv;
35031 arg_conv.inner = (void*)(arg & (~1));
35032 arg_conv.is_owned = false;
35033 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35034 uint32_t ret_conv = CounterpartyCommitmentSecrets_clone_ptr(&arg_conv);
35038 uint32_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_clone"))) TS_CounterpartyCommitmentSecrets_clone(uint32_t orig) {
35039 LDKCounterpartyCommitmentSecrets orig_conv;
35040 orig_conv.inner = (void*)(orig & (~1));
35041 orig_conv.is_owned = false;
35042 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35043 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_clone(&orig_conv);
35044 uint32_t ret_ref = 0;
35045 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35046 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35047 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35048 ret_ref = (uintptr_t)ret_var.inner;
35049 if (ret_var.is_owned) {
35055 uint32_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_new"))) TS_CounterpartyCommitmentSecrets_new() {
35056 LDKCounterpartyCommitmentSecrets ret_var = CounterpartyCommitmentSecrets_new();
35057 uint32_t ret_ref = 0;
35058 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35059 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35060 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35061 ret_ref = (uintptr_t)ret_var.inner;
35062 if (ret_var.is_owned) {
35068 int64_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_min_seen_secret"))) TS_CounterpartyCommitmentSecrets_get_min_seen_secret(uint32_t this_arg) {
35069 LDKCounterpartyCommitmentSecrets this_arg_conv;
35070 this_arg_conv.inner = (void*)(this_arg & (~1));
35071 this_arg_conv.is_owned = false;
35072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35073 int64_t ret_conv = CounterpartyCommitmentSecrets_get_min_seen_secret(&this_arg_conv);
35077 uint32_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_provide_secret"))) TS_CounterpartyCommitmentSecrets_provide_secret(uint32_t this_arg, int64_t idx, int8_tArray secret) {
35078 LDKCounterpartyCommitmentSecrets this_arg_conv;
35079 this_arg_conv.inner = (void*)(this_arg & (~1));
35080 this_arg_conv.is_owned = false;
35081 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35082 LDKThirtyTwoBytes secret_ref;
35083 CHECK(secret->arr_len == 32);
35084 memcpy(secret_ref.data, secret->elems, 32); FREE(secret);
35085 LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ");
35086 *ret_conv = CounterpartyCommitmentSecrets_provide_secret(&this_arg_conv, idx, secret_ref);
35087 return (uint32_t)ret_conv;
35090 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_get_secret"))) TS_CounterpartyCommitmentSecrets_get_secret(uint32_t this_arg, int64_t idx) {
35091 LDKCounterpartyCommitmentSecrets this_arg_conv;
35092 this_arg_conv.inner = (void*)(this_arg & (~1));
35093 this_arg_conv.is_owned = false;
35094 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
35095 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35096 memcpy(ret_arr->elems, CounterpartyCommitmentSecrets_get_secret(&this_arg_conv, idx).data, 32);
35100 int8_tArray __attribute__((export_name("TS_CounterpartyCommitmentSecrets_write"))) TS_CounterpartyCommitmentSecrets_write(uint32_t obj) {
35101 LDKCounterpartyCommitmentSecrets obj_conv;
35102 obj_conv.inner = (void*)(obj & (~1));
35103 obj_conv.is_owned = false;
35104 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35105 LDKCVec_u8Z ret_var = CounterpartyCommitmentSecrets_write(&obj_conv);
35106 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35107 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35108 CVec_u8Z_free(ret_var);
35112 uint32_t __attribute__((export_name("TS_CounterpartyCommitmentSecrets_read"))) TS_CounterpartyCommitmentSecrets_read(int8_tArray ser) {
35113 LDKu8slice ser_ref;
35114 ser_ref.datalen = ser->arr_len;
35115 ser_ref.data = ser->elems;
35116 LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ), "LDKCResult_CounterpartyCommitmentSecretsDecodeErrorZ");
35117 *ret_conv = CounterpartyCommitmentSecrets_read(ser_ref);
35119 return (uint32_t)ret_conv;
35122 uint32_t __attribute__((export_name("TS_derive_private_key"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
35123 LDKPublicKey per_commitment_point_ref;
35124 CHECK(per_commitment_point->arr_len == 33);
35125 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
35126 unsigned char base_secret_arr[32];
35127 CHECK(base_secret->arr_len == 32);
35128 memcpy(base_secret_arr, base_secret->elems, 32); FREE(base_secret);
35129 unsigned char (*base_secret_ref)[32] = &base_secret_arr;
35130 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
35131 *ret_conv = derive_private_key(per_commitment_point_ref, base_secret_ref);
35132 return (uint32_t)ret_conv;
35135 uint32_t __attribute__((export_name("TS_derive_public_key"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
35136 LDKPublicKey per_commitment_point_ref;
35137 CHECK(per_commitment_point->arr_len == 33);
35138 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
35139 LDKPublicKey base_point_ref;
35140 CHECK(base_point->arr_len == 33);
35141 memcpy(base_point_ref.compressed_form, base_point->elems, 33); FREE(base_point);
35142 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
35143 *ret_conv = derive_public_key(per_commitment_point_ref, base_point_ref);
35144 return (uint32_t)ret_conv;
35147 uint32_t __attribute__((export_name("TS_derive_private_revocation_key"))) TS_derive_private_revocation_key(int8_tArray per_commitment_secret, int8_tArray countersignatory_revocation_base_secret) {
35148 unsigned char per_commitment_secret_arr[32];
35149 CHECK(per_commitment_secret->arr_len == 32);
35150 memcpy(per_commitment_secret_arr, per_commitment_secret->elems, 32); FREE(per_commitment_secret);
35151 unsigned char (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
35152 unsigned char countersignatory_revocation_base_secret_arr[32];
35153 CHECK(countersignatory_revocation_base_secret->arr_len == 32);
35154 memcpy(countersignatory_revocation_base_secret_arr, countersignatory_revocation_base_secret->elems, 32); FREE(countersignatory_revocation_base_secret);
35155 unsigned char (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
35156 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
35157 *ret_conv = derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref);
35158 return (uint32_t)ret_conv;
35161 uint32_t __attribute__((export_name("TS_derive_public_revocation_key"))) TS_derive_public_revocation_key(int8_tArray per_commitment_point, int8_tArray countersignatory_revocation_base_point) {
35162 LDKPublicKey per_commitment_point_ref;
35163 CHECK(per_commitment_point->arr_len == 33);
35164 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
35165 LDKPublicKey countersignatory_revocation_base_point_ref;
35166 CHECK(countersignatory_revocation_base_point->arr_len == 33);
35167 memcpy(countersignatory_revocation_base_point_ref.compressed_form, countersignatory_revocation_base_point->elems, 33); FREE(countersignatory_revocation_base_point);
35168 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
35169 *ret_conv = derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref);
35170 return (uint32_t)ret_conv;
35173 void __attribute__((export_name("TS_TxCreationKeys_free"))) TS_TxCreationKeys_free(uint32_t this_obj) {
35174 LDKTxCreationKeys this_obj_conv;
35175 this_obj_conv.inner = (void*)(this_obj & (~1));
35176 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
35177 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35178 TxCreationKeys_free(this_obj_conv);
35181 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_per_commitment_point"))) TS_TxCreationKeys_get_per_commitment_point(uint32_t this_ptr) {
35182 LDKTxCreationKeys this_ptr_conv;
35183 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35184 this_ptr_conv.is_owned = false;
35185 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35186 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35187 memcpy(ret_arr->elems, TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
35191 void __attribute__((export_name("TS_TxCreationKeys_set_per_commitment_point"))) TS_TxCreationKeys_set_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
35192 LDKTxCreationKeys this_ptr_conv;
35193 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35194 this_ptr_conv.is_owned = false;
35195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35196 LDKPublicKey val_ref;
35197 CHECK(val->arr_len == 33);
35198 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35199 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
35202 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_revocation_key"))) TS_TxCreationKeys_get_revocation_key(uint32_t this_ptr) {
35203 LDKTxCreationKeys this_ptr_conv;
35204 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35205 this_ptr_conv.is_owned = false;
35206 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35207 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35208 memcpy(ret_arr->elems, TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
35212 void __attribute__((export_name("TS_TxCreationKeys_set_revocation_key"))) TS_TxCreationKeys_set_revocation_key(uint32_t this_ptr, int8_tArray val) {
35213 LDKTxCreationKeys this_ptr_conv;
35214 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35215 this_ptr_conv.is_owned = false;
35216 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35217 LDKPublicKey val_ref;
35218 CHECK(val->arr_len == 33);
35219 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35220 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
35223 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_htlc_key"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint32_t this_ptr) {
35224 LDKTxCreationKeys this_ptr_conv;
35225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35226 this_ptr_conv.is_owned = false;
35227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35228 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35229 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
35233 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_htlc_key"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint32_t this_ptr, int8_tArray val) {
35234 LDKTxCreationKeys this_ptr_conv;
35235 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35236 this_ptr_conv.is_owned = false;
35237 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35238 LDKPublicKey val_ref;
35239 CHECK(val->arr_len == 33);
35240 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35241 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
35244 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_countersignatory_htlc_key"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint32_t this_ptr) {
35245 LDKTxCreationKeys this_ptr_conv;
35246 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35247 this_ptr_conv.is_owned = false;
35248 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35249 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35250 memcpy(ret_arr->elems, TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
35254 void __attribute__((export_name("TS_TxCreationKeys_set_countersignatory_htlc_key"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint32_t this_ptr, int8_tArray val) {
35255 LDKTxCreationKeys this_ptr_conv;
35256 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35257 this_ptr_conv.is_owned = false;
35258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35259 LDKPublicKey val_ref;
35260 CHECK(val->arr_len == 33);
35261 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35262 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
35265 int8_tArray __attribute__((export_name("TS_TxCreationKeys_get_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint32_t this_ptr) {
35266 LDKTxCreationKeys this_ptr_conv;
35267 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35268 this_ptr_conv.is_owned = false;
35269 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35270 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35271 memcpy(ret_arr->elems, TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
35275 void __attribute__((export_name("TS_TxCreationKeys_set_broadcaster_delayed_payment_key"))) TS_TxCreationKeys_set_broadcaster_delayed_payment_key(uint32_t this_ptr, int8_tArray val) {
35276 LDKTxCreationKeys this_ptr_conv;
35277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35278 this_ptr_conv.is_owned = false;
35279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35280 LDKPublicKey val_ref;
35281 CHECK(val->arr_len == 33);
35282 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35283 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
35286 uint32_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) {
35287 LDKPublicKey per_commitment_point_arg_ref;
35288 CHECK(per_commitment_point_arg->arr_len == 33);
35289 memcpy(per_commitment_point_arg_ref.compressed_form, per_commitment_point_arg->elems, 33); FREE(per_commitment_point_arg);
35290 LDKPublicKey revocation_key_arg_ref;
35291 CHECK(revocation_key_arg->arr_len == 33);
35292 memcpy(revocation_key_arg_ref.compressed_form, revocation_key_arg->elems, 33); FREE(revocation_key_arg);
35293 LDKPublicKey broadcaster_htlc_key_arg_ref;
35294 CHECK(broadcaster_htlc_key_arg->arr_len == 33);
35295 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, broadcaster_htlc_key_arg->elems, 33); FREE(broadcaster_htlc_key_arg);
35296 LDKPublicKey countersignatory_htlc_key_arg_ref;
35297 CHECK(countersignatory_htlc_key_arg->arr_len == 33);
35298 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, countersignatory_htlc_key_arg->elems, 33); FREE(countersignatory_htlc_key_arg);
35299 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
35300 CHECK(broadcaster_delayed_payment_key_arg->arr_len == 33);
35301 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, broadcaster_delayed_payment_key_arg->elems, 33); FREE(broadcaster_delayed_payment_key_arg);
35302 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);
35303 uint32_t ret_ref = 0;
35304 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35305 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35306 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35307 ret_ref = (uintptr_t)ret_var.inner;
35308 if (ret_var.is_owned) {
35314 static inline uintptr_t TxCreationKeys_clone_ptr(LDKTxCreationKeys *NONNULL_PTR arg) {
35315 LDKTxCreationKeys ret_var = TxCreationKeys_clone(arg);
35316 uint32_t ret_ref = 0;
35317 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35318 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35319 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35320 ret_ref = (uintptr_t)ret_var.inner;
35321 if (ret_var.is_owned) {
35326 uint32_t __attribute__((export_name("TS_TxCreationKeys_clone_ptr"))) TS_TxCreationKeys_clone_ptr(uint32_t arg) {
35327 LDKTxCreationKeys arg_conv;
35328 arg_conv.inner = (void*)(arg & (~1));
35329 arg_conv.is_owned = false;
35330 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35331 uint32_t ret_conv = TxCreationKeys_clone_ptr(&arg_conv);
35335 uint32_t __attribute__((export_name("TS_TxCreationKeys_clone"))) TS_TxCreationKeys_clone(uint32_t orig) {
35336 LDKTxCreationKeys orig_conv;
35337 orig_conv.inner = (void*)(orig & (~1));
35338 orig_conv.is_owned = false;
35339 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35340 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
35341 uint32_t ret_ref = 0;
35342 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35343 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35344 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35345 ret_ref = (uintptr_t)ret_var.inner;
35346 if (ret_var.is_owned) {
35352 int8_tArray __attribute__((export_name("TS_TxCreationKeys_write"))) TS_TxCreationKeys_write(uint32_t obj) {
35353 LDKTxCreationKeys obj_conv;
35354 obj_conv.inner = (void*)(obj & (~1));
35355 obj_conv.is_owned = false;
35356 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35357 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
35358 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35359 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35360 CVec_u8Z_free(ret_var);
35364 uint32_t __attribute__((export_name("TS_TxCreationKeys_read"))) TS_TxCreationKeys_read(int8_tArray ser) {
35365 LDKu8slice ser_ref;
35366 ser_ref.datalen = ser->arr_len;
35367 ser_ref.data = ser->elems;
35368 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
35369 *ret_conv = TxCreationKeys_read(ser_ref);
35371 return (uint32_t)ret_conv;
35374 void __attribute__((export_name("TS_ChannelPublicKeys_free"))) TS_ChannelPublicKeys_free(uint32_t this_obj) {
35375 LDKChannelPublicKeys this_obj_conv;
35376 this_obj_conv.inner = (void*)(this_obj & (~1));
35377 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
35378 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35379 ChannelPublicKeys_free(this_obj_conv);
35382 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_funding_pubkey"))) TS_ChannelPublicKeys_get_funding_pubkey(uint32_t this_ptr) {
35383 LDKChannelPublicKeys this_ptr_conv;
35384 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35385 this_ptr_conv.is_owned = false;
35386 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35387 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35388 memcpy(ret_arr->elems, ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
35392 void __attribute__((export_name("TS_ChannelPublicKeys_set_funding_pubkey"))) TS_ChannelPublicKeys_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
35393 LDKChannelPublicKeys this_ptr_conv;
35394 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35395 this_ptr_conv.is_owned = false;
35396 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35397 LDKPublicKey val_ref;
35398 CHECK(val->arr_len == 33);
35399 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35400 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
35403 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_revocation_basepoint"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint32_t this_ptr) {
35404 LDKChannelPublicKeys this_ptr_conv;
35405 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35406 this_ptr_conv.is_owned = false;
35407 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35408 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35409 memcpy(ret_arr->elems, ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
35413 void __attribute__((export_name("TS_ChannelPublicKeys_set_revocation_basepoint"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
35414 LDKChannelPublicKeys this_ptr_conv;
35415 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35416 this_ptr_conv.is_owned = false;
35417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35418 LDKPublicKey val_ref;
35419 CHECK(val->arr_len == 33);
35420 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35421 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
35424 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_payment_point"))) TS_ChannelPublicKeys_get_payment_point(uint32_t this_ptr) {
35425 LDKChannelPublicKeys this_ptr_conv;
35426 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35427 this_ptr_conv.is_owned = false;
35428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35429 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35430 memcpy(ret_arr->elems, ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
35434 void __attribute__((export_name("TS_ChannelPublicKeys_set_payment_point"))) TS_ChannelPublicKeys_set_payment_point(uint32_t this_ptr, int8_tArray val) {
35435 LDKChannelPublicKeys this_ptr_conv;
35436 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35437 this_ptr_conv.is_owned = false;
35438 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35439 LDKPublicKey val_ref;
35440 CHECK(val->arr_len == 33);
35441 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35442 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
35445 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_delayed_payment_basepoint"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint32_t this_ptr) {
35446 LDKChannelPublicKeys this_ptr_conv;
35447 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35448 this_ptr_conv.is_owned = false;
35449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35450 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35451 memcpy(ret_arr->elems, ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
35455 void __attribute__((export_name("TS_ChannelPublicKeys_set_delayed_payment_basepoint"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
35456 LDKChannelPublicKeys this_ptr_conv;
35457 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35458 this_ptr_conv.is_owned = false;
35459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35460 LDKPublicKey val_ref;
35461 CHECK(val->arr_len == 33);
35462 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35463 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
35466 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_get_htlc_basepoint"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint32_t this_ptr) {
35467 LDKChannelPublicKeys this_ptr_conv;
35468 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35469 this_ptr_conv.is_owned = false;
35470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35471 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
35472 memcpy(ret_arr->elems, ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
35476 void __attribute__((export_name("TS_ChannelPublicKeys_set_htlc_basepoint"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
35477 LDKChannelPublicKeys this_ptr_conv;
35478 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35479 this_ptr_conv.is_owned = false;
35480 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35481 LDKPublicKey val_ref;
35482 CHECK(val->arr_len == 33);
35483 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
35484 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
35487 uint32_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) {
35488 LDKPublicKey funding_pubkey_arg_ref;
35489 CHECK(funding_pubkey_arg->arr_len == 33);
35490 memcpy(funding_pubkey_arg_ref.compressed_form, funding_pubkey_arg->elems, 33); FREE(funding_pubkey_arg);
35491 LDKPublicKey revocation_basepoint_arg_ref;
35492 CHECK(revocation_basepoint_arg->arr_len == 33);
35493 memcpy(revocation_basepoint_arg_ref.compressed_form, revocation_basepoint_arg->elems, 33); FREE(revocation_basepoint_arg);
35494 LDKPublicKey payment_point_arg_ref;
35495 CHECK(payment_point_arg->arr_len == 33);
35496 memcpy(payment_point_arg_ref.compressed_form, payment_point_arg->elems, 33); FREE(payment_point_arg);
35497 LDKPublicKey delayed_payment_basepoint_arg_ref;
35498 CHECK(delayed_payment_basepoint_arg->arr_len == 33);
35499 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, delayed_payment_basepoint_arg->elems, 33); FREE(delayed_payment_basepoint_arg);
35500 LDKPublicKey htlc_basepoint_arg_ref;
35501 CHECK(htlc_basepoint_arg->arr_len == 33);
35502 memcpy(htlc_basepoint_arg_ref.compressed_form, htlc_basepoint_arg->elems, 33); FREE(htlc_basepoint_arg);
35503 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);
35504 uint32_t ret_ref = 0;
35505 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35506 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35507 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35508 ret_ref = (uintptr_t)ret_var.inner;
35509 if (ret_var.is_owned) {
35515 static inline uintptr_t ChannelPublicKeys_clone_ptr(LDKChannelPublicKeys *NONNULL_PTR arg) {
35516 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(arg);
35517 uint32_t ret_ref = 0;
35518 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35519 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35520 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35521 ret_ref = (uintptr_t)ret_var.inner;
35522 if (ret_var.is_owned) {
35527 uint32_t __attribute__((export_name("TS_ChannelPublicKeys_clone_ptr"))) TS_ChannelPublicKeys_clone_ptr(uint32_t arg) {
35528 LDKChannelPublicKeys arg_conv;
35529 arg_conv.inner = (void*)(arg & (~1));
35530 arg_conv.is_owned = false;
35531 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35532 uint32_t ret_conv = ChannelPublicKeys_clone_ptr(&arg_conv);
35536 uint32_t __attribute__((export_name("TS_ChannelPublicKeys_clone"))) TS_ChannelPublicKeys_clone(uint32_t orig) {
35537 LDKChannelPublicKeys orig_conv;
35538 orig_conv.inner = (void*)(orig & (~1));
35539 orig_conv.is_owned = false;
35540 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35541 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
35542 uint32_t ret_ref = 0;
35543 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35544 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35545 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35546 ret_ref = (uintptr_t)ret_var.inner;
35547 if (ret_var.is_owned) {
35553 int8_tArray __attribute__((export_name("TS_ChannelPublicKeys_write"))) TS_ChannelPublicKeys_write(uint32_t obj) {
35554 LDKChannelPublicKeys obj_conv;
35555 obj_conv.inner = (void*)(obj & (~1));
35556 obj_conv.is_owned = false;
35557 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35558 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
35559 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35560 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35561 CVec_u8Z_free(ret_var);
35565 uint32_t __attribute__((export_name("TS_ChannelPublicKeys_read"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
35566 LDKu8slice ser_ref;
35567 ser_ref.datalen = ser->arr_len;
35568 ser_ref.data = ser->elems;
35569 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
35570 *ret_conv = ChannelPublicKeys_read(ser_ref);
35572 return (uint32_t)ret_conv;
35575 uint32_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) {
35576 LDKPublicKey per_commitment_point_ref;
35577 CHECK(per_commitment_point->arr_len == 33);
35578 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
35579 LDKPublicKey broadcaster_delayed_payment_base_ref;
35580 CHECK(broadcaster_delayed_payment_base->arr_len == 33);
35581 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, broadcaster_delayed_payment_base->elems, 33); FREE(broadcaster_delayed_payment_base);
35582 LDKPublicKey broadcaster_htlc_base_ref;
35583 CHECK(broadcaster_htlc_base->arr_len == 33);
35584 memcpy(broadcaster_htlc_base_ref.compressed_form, broadcaster_htlc_base->elems, 33); FREE(broadcaster_htlc_base);
35585 LDKPublicKey countersignatory_revocation_base_ref;
35586 CHECK(countersignatory_revocation_base->arr_len == 33);
35587 memcpy(countersignatory_revocation_base_ref.compressed_form, countersignatory_revocation_base->elems, 33); FREE(countersignatory_revocation_base);
35588 LDKPublicKey countersignatory_htlc_base_ref;
35589 CHECK(countersignatory_htlc_base->arr_len == 33);
35590 memcpy(countersignatory_htlc_base_ref.compressed_form, countersignatory_htlc_base->elems, 33); FREE(countersignatory_htlc_base);
35591 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
35592 *ret_conv = TxCreationKeys_derive_new(per_commitment_point_ref, broadcaster_delayed_payment_base_ref, broadcaster_htlc_base_ref, countersignatory_revocation_base_ref, countersignatory_htlc_base_ref);
35593 return (uint32_t)ret_conv;
35596 uint32_t __attribute__((export_name("TS_TxCreationKeys_from_channel_static_keys"))) TS_TxCreationKeys_from_channel_static_keys(int8_tArray per_commitment_point, uint32_t broadcaster_keys, uint32_t countersignatory_keys) {
35597 LDKPublicKey per_commitment_point_ref;
35598 CHECK(per_commitment_point->arr_len == 33);
35599 memcpy(per_commitment_point_ref.compressed_form, per_commitment_point->elems, 33); FREE(per_commitment_point);
35600 LDKChannelPublicKeys broadcaster_keys_conv;
35601 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
35602 broadcaster_keys_conv.is_owned = false;
35603 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
35604 LDKChannelPublicKeys countersignatory_keys_conv;
35605 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
35606 countersignatory_keys_conv.is_owned = false;
35607 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
35608 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
35609 *ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
35610 return (uint32_t)ret_conv;
35613 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) {
35614 LDKPublicKey revocation_key_ref;
35615 CHECK(revocation_key->arr_len == 33);
35616 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
35617 LDKPublicKey broadcaster_delayed_payment_key_ref;
35618 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
35619 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
35620 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
35621 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35622 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35623 CVec_u8Z_free(ret_var);
35627 void __attribute__((export_name("TS_HTLCOutputInCommitment_free"))) TS_HTLCOutputInCommitment_free(uint32_t this_obj) {
35628 LDKHTLCOutputInCommitment this_obj_conv;
35629 this_obj_conv.inner = (void*)(this_obj & (~1));
35630 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
35631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35632 HTLCOutputInCommitment_free(this_obj_conv);
35635 jboolean __attribute__((export_name("TS_HTLCOutputInCommitment_get_offered"))) TS_HTLCOutputInCommitment_get_offered(uint32_t this_ptr) {
35636 LDKHTLCOutputInCommitment this_ptr_conv;
35637 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35638 this_ptr_conv.is_owned = false;
35639 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35640 jboolean ret_conv = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
35644 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_offered"))) TS_HTLCOutputInCommitment_set_offered(uint32_t this_ptr, jboolean val) {
35645 LDKHTLCOutputInCommitment this_ptr_conv;
35646 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35647 this_ptr_conv.is_owned = false;
35648 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35649 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
35652 int64_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_amount_msat"))) TS_HTLCOutputInCommitment_get_amount_msat(uint32_t this_ptr) {
35653 LDKHTLCOutputInCommitment this_ptr_conv;
35654 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35655 this_ptr_conv.is_owned = false;
35656 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35657 int64_t ret_conv = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
35661 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_amount_msat"))) TS_HTLCOutputInCommitment_set_amount_msat(uint32_t this_ptr, int64_t val) {
35662 LDKHTLCOutputInCommitment this_ptr_conv;
35663 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35664 this_ptr_conv.is_owned = false;
35665 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35666 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
35669 int32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_cltv_expiry"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint32_t this_ptr) {
35670 LDKHTLCOutputInCommitment this_ptr_conv;
35671 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35672 this_ptr_conv.is_owned = false;
35673 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35674 int32_t ret_conv = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
35678 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_cltv_expiry"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint32_t this_ptr, int32_t val) {
35679 LDKHTLCOutputInCommitment this_ptr_conv;
35680 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35681 this_ptr_conv.is_owned = false;
35682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35683 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
35686 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_get_payment_hash"))) TS_HTLCOutputInCommitment_get_payment_hash(uint32_t this_ptr) {
35687 LDKHTLCOutputInCommitment this_ptr_conv;
35688 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35689 this_ptr_conv.is_owned = false;
35690 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35691 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
35692 memcpy(ret_arr->elems, *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
35696 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_payment_hash"))) TS_HTLCOutputInCommitment_set_payment_hash(uint32_t this_ptr, int8_tArray val) {
35697 LDKHTLCOutputInCommitment this_ptr_conv;
35698 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35699 this_ptr_conv.is_owned = false;
35700 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35701 LDKThirtyTwoBytes val_ref;
35702 CHECK(val->arr_len == 32);
35703 memcpy(val_ref.data, val->elems, 32); FREE(val);
35704 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
35707 uint32_t __attribute__((export_name("TS_HTLCOutputInCommitment_get_transaction_output_index"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint32_t this_ptr) {
35708 LDKHTLCOutputInCommitment this_ptr_conv;
35709 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35710 this_ptr_conv.is_owned = false;
35711 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35712 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
35713 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
35714 uint32_t ret_ref = (uintptr_t)ret_copy;
35718 void __attribute__((export_name("TS_HTLCOutputInCommitment_set_transaction_output_index"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint32_t this_ptr, uint32_t val) {
35719 LDKHTLCOutputInCommitment this_ptr_conv;
35720 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35721 this_ptr_conv.is_owned = false;
35722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35723 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
35724 CHECK_ACCESS(val_ptr);
35725 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(val_ptr);
35726 val_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uintptr_t)val) & ~1));
35727 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
35730 uint32_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, uint32_t transaction_output_index_arg) {
35731 LDKThirtyTwoBytes payment_hash_arg_ref;
35732 CHECK(payment_hash_arg->arr_len == 32);
35733 memcpy(payment_hash_arg_ref.data, payment_hash_arg->elems, 32); FREE(payment_hash_arg);
35734 void* transaction_output_index_arg_ptr = (void*)(((uintptr_t)transaction_output_index_arg) & ~1);
35735 CHECK_ACCESS(transaction_output_index_arg_ptr);
35736 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(transaction_output_index_arg_ptr);
35737 transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uintptr_t)transaction_output_index_arg) & ~1));
35738 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
35739 uint32_t ret_ref = 0;
35740 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35741 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35742 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35743 ret_ref = (uintptr_t)ret_var.inner;
35744 if (ret_var.is_owned) {
35750 static inline uintptr_t HTLCOutputInCommitment_clone_ptr(LDKHTLCOutputInCommitment *NONNULL_PTR arg) {
35751 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(arg);
35752 uint32_t ret_ref = 0;
35753 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35754 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35755 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35756 ret_ref = (uintptr_t)ret_var.inner;
35757 if (ret_var.is_owned) {
35762 uint32_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone_ptr"))) TS_HTLCOutputInCommitment_clone_ptr(uint32_t arg) {
35763 LDKHTLCOutputInCommitment arg_conv;
35764 arg_conv.inner = (void*)(arg & (~1));
35765 arg_conv.is_owned = false;
35766 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
35767 uint32_t ret_conv = HTLCOutputInCommitment_clone_ptr(&arg_conv);
35771 uint32_t __attribute__((export_name("TS_HTLCOutputInCommitment_clone"))) TS_HTLCOutputInCommitment_clone(uint32_t orig) {
35772 LDKHTLCOutputInCommitment orig_conv;
35773 orig_conv.inner = (void*)(orig & (~1));
35774 orig_conv.is_owned = false;
35775 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
35776 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
35777 uint32_t ret_ref = 0;
35778 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35779 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35780 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35781 ret_ref = (uintptr_t)ret_var.inner;
35782 if (ret_var.is_owned) {
35788 int8_tArray __attribute__((export_name("TS_HTLCOutputInCommitment_write"))) TS_HTLCOutputInCommitment_write(uint32_t obj) {
35789 LDKHTLCOutputInCommitment obj_conv;
35790 obj_conv.inner = (void*)(obj & (~1));
35791 obj_conv.is_owned = false;
35792 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
35793 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
35794 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35795 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35796 CVec_u8Z_free(ret_var);
35800 uint32_t __attribute__((export_name("TS_HTLCOutputInCommitment_read"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
35801 LDKu8slice ser_ref;
35802 ser_ref.datalen = ser->arr_len;
35803 ser_ref.data = ser->elems;
35804 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
35805 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
35807 return (uint32_t)ret_conv;
35810 int8_tArray __attribute__((export_name("TS_get_htlc_redeemscript"))) TS_get_htlc_redeemscript(uint32_t htlc, jboolean opt_anchors, uint32_t keys) {
35811 LDKHTLCOutputInCommitment htlc_conv;
35812 htlc_conv.inner = (void*)(htlc & (~1));
35813 htlc_conv.is_owned = false;
35814 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
35815 LDKTxCreationKeys keys_conv;
35816 keys_conv.inner = (void*)(keys & (~1));
35817 keys_conv.is_owned = false;
35818 CHECK_INNER_FIELD_ACCESS_OR_NULL(keys_conv);
35819 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, opt_anchors, &keys_conv);
35820 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35821 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35822 CVec_u8Z_free(ret_var);
35826 int8_tArray __attribute__((export_name("TS_make_funding_redeemscript"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
35827 LDKPublicKey broadcaster_ref;
35828 CHECK(broadcaster->arr_len == 33);
35829 memcpy(broadcaster_ref.compressed_form, broadcaster->elems, 33); FREE(broadcaster);
35830 LDKPublicKey countersignatory_ref;
35831 CHECK(countersignatory->arr_len == 33);
35832 memcpy(countersignatory_ref.compressed_form, countersignatory->elems, 33); FREE(countersignatory);
35833 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
35834 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35835 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35836 CVec_u8Z_free(ret_var);
35840 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, uint32_t htlc, jboolean opt_anchors, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
35841 unsigned char commitment_txid_arr[32];
35842 CHECK(commitment_txid->arr_len == 32);
35843 memcpy(commitment_txid_arr, commitment_txid->elems, 32); FREE(commitment_txid);
35844 unsigned char (*commitment_txid_ref)[32] = &commitment_txid_arr;
35845 LDKHTLCOutputInCommitment htlc_conv;
35846 htlc_conv.inner = (void*)(htlc & (~1));
35847 htlc_conv.is_owned = false;
35848 CHECK_INNER_FIELD_ACCESS_OR_NULL(htlc_conv);
35849 LDKPublicKey broadcaster_delayed_payment_key_ref;
35850 CHECK(broadcaster_delayed_payment_key->arr_len == 33);
35851 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, broadcaster_delayed_payment_key->elems, 33); FREE(broadcaster_delayed_payment_key);
35852 LDKPublicKey revocation_key_ref;
35853 CHECK(revocation_key->arr_len == 33);
35854 memcpy(revocation_key_ref.compressed_form, revocation_key->elems, 33); FREE(revocation_key);
35855 LDKTransaction ret_var = build_htlc_transaction(commitment_txid_ref, feerate_per_kw, contest_delay, &htlc_conv, opt_anchors, broadcaster_delayed_payment_key_ref, revocation_key_ref);
35856 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35857 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35858 Transaction_free(ret_var);
35862 int8_tArray __attribute__((export_name("TS_get_anchor_redeemscript"))) TS_get_anchor_redeemscript(int8_tArray funding_pubkey) {
35863 LDKPublicKey funding_pubkey_ref;
35864 CHECK(funding_pubkey->arr_len == 33);
35865 memcpy(funding_pubkey_ref.compressed_form, funding_pubkey->elems, 33); FREE(funding_pubkey);
35866 LDKCVec_u8Z ret_var = get_anchor_redeemscript(funding_pubkey_ref);
35867 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
35868 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
35869 CVec_u8Z_free(ret_var);
35873 void __attribute__((export_name("TS_ChannelTransactionParameters_free"))) TS_ChannelTransactionParameters_free(uint32_t this_obj) {
35874 LDKChannelTransactionParameters this_obj_conv;
35875 this_obj_conv.inner = (void*)(this_obj & (~1));
35876 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
35877 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
35878 ChannelTransactionParameters_free(this_obj_conv);
35881 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_pubkeys"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint32_t this_ptr) {
35882 LDKChannelTransactionParameters this_ptr_conv;
35883 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35884 this_ptr_conv.is_owned = false;
35885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35886 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
35887 uint32_t ret_ref = 0;
35888 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35889 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35890 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35891 ret_ref = (uintptr_t)ret_var.inner;
35892 if (ret_var.is_owned) {
35898 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_pubkeys"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint32_t this_ptr, uint32_t val) {
35899 LDKChannelTransactionParameters this_ptr_conv;
35900 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35901 this_ptr_conv.is_owned = false;
35902 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35903 LDKChannelPublicKeys val_conv;
35904 val_conv.inner = (void*)(val & (~1));
35905 val_conv.is_owned = (val & 1) || (val == 0);
35906 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35907 val_conv = ChannelPublicKeys_clone(&val_conv);
35908 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
35911 int16_t __attribute__((export_name("TS_ChannelTransactionParameters_get_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint32_t this_ptr) {
35912 LDKChannelTransactionParameters this_ptr_conv;
35913 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35914 this_ptr_conv.is_owned = false;
35915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35916 int16_t ret_conv = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
35920 void __attribute__((export_name("TS_ChannelTransactionParameters_set_holder_selected_contest_delay"))) TS_ChannelTransactionParameters_set_holder_selected_contest_delay(uint32_t this_ptr, int16_t val) {
35921 LDKChannelTransactionParameters this_ptr_conv;
35922 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35923 this_ptr_conv.is_owned = false;
35924 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35925 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
35928 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_get_is_outbound_from_holder"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint32_t this_ptr) {
35929 LDKChannelTransactionParameters this_ptr_conv;
35930 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35931 this_ptr_conv.is_owned = false;
35932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35933 jboolean ret_conv = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
35937 void __attribute__((export_name("TS_ChannelTransactionParameters_set_is_outbound_from_holder"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint32_t this_ptr, jboolean val) {
35938 LDKChannelTransactionParameters this_ptr_conv;
35939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35940 this_ptr_conv.is_owned = false;
35941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35942 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
35945 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_counterparty_parameters"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint32_t this_ptr) {
35946 LDKChannelTransactionParameters this_ptr_conv;
35947 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35948 this_ptr_conv.is_owned = false;
35949 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35950 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
35951 uint32_t ret_ref = 0;
35952 if ((uintptr_t)ret_var.inner > 4096) {
35953 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35954 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35955 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35956 ret_ref = (uintptr_t)ret_var.inner;
35957 if (ret_var.is_owned) {
35964 void __attribute__((export_name("TS_ChannelTransactionParameters_set_counterparty_parameters"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint32_t this_ptr, uint32_t val) {
35965 LDKChannelTransactionParameters this_ptr_conv;
35966 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35967 this_ptr_conv.is_owned = false;
35968 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35969 LDKCounterpartyChannelTransactionParameters val_conv;
35970 val_conv.inner = (void*)(val & (~1));
35971 val_conv.is_owned = (val & 1) || (val == 0);
35972 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
35973 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
35974 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
35977 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_funding_outpoint"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint32_t this_ptr) {
35978 LDKChannelTransactionParameters this_ptr_conv;
35979 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35980 this_ptr_conv.is_owned = false;
35981 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
35982 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
35983 uint32_t ret_ref = 0;
35984 if ((uintptr_t)ret_var.inner > 4096) {
35985 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
35986 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
35987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
35988 ret_ref = (uintptr_t)ret_var.inner;
35989 if (ret_var.is_owned) {
35996 void __attribute__((export_name("TS_ChannelTransactionParameters_set_funding_outpoint"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint32_t this_ptr, uint32_t val) {
35997 LDKChannelTransactionParameters this_ptr_conv;
35998 this_ptr_conv.inner = (void*)(this_ptr & (~1));
35999 this_ptr_conv.is_owned = false;
36000 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36001 LDKOutPoint val_conv;
36002 val_conv.inner = (void*)(val & (~1));
36003 val_conv.is_owned = (val & 1) || (val == 0);
36004 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36005 val_conv = OutPoint_clone(&val_conv);
36006 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
36009 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_get_opt_anchors"))) TS_ChannelTransactionParameters_get_opt_anchors(uint32_t this_ptr) {
36010 LDKChannelTransactionParameters this_ptr_conv;
36011 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36012 this_ptr_conv.is_owned = false;
36013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36014 uint32_t ret_conv = LDKCOption_NoneZ_to_js(ChannelTransactionParameters_get_opt_anchors(&this_ptr_conv));
36018 void __attribute__((export_name("TS_ChannelTransactionParameters_set_opt_anchors"))) TS_ChannelTransactionParameters_set_opt_anchors(uint32_t this_ptr, uint32_t val) {
36019 LDKChannelTransactionParameters this_ptr_conv;
36020 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36021 this_ptr_conv.is_owned = false;
36022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36023 LDKCOption_NoneZ val_conv = LDKCOption_NoneZ_from_js(val);
36024 ChannelTransactionParameters_set_opt_anchors(&this_ptr_conv, val_conv);
36027 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_new"))) TS_ChannelTransactionParameters_new(uint32_t holder_pubkeys_arg, int16_t holder_selected_contest_delay_arg, jboolean is_outbound_from_holder_arg, uint32_t counterparty_parameters_arg, uint32_t funding_outpoint_arg, uint32_t opt_anchors_arg) {
36028 LDKChannelPublicKeys holder_pubkeys_arg_conv;
36029 holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
36030 holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
36031 CHECK_INNER_FIELD_ACCESS_OR_NULL(holder_pubkeys_arg_conv);
36032 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
36033 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
36034 counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
36035 counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
36036 CHECK_INNER_FIELD_ACCESS_OR_NULL(counterparty_parameters_arg_conv);
36037 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
36038 LDKOutPoint funding_outpoint_arg_conv;
36039 funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
36040 funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
36041 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_arg_conv);
36042 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
36043 LDKCOption_NoneZ opt_anchors_arg_conv = LDKCOption_NoneZ_from_js(opt_anchors_arg);
36044 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_new(holder_pubkeys_arg_conv, holder_selected_contest_delay_arg, is_outbound_from_holder_arg, counterparty_parameters_arg_conv, funding_outpoint_arg_conv, opt_anchors_arg_conv);
36045 uint32_t ret_ref = 0;
36046 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36047 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36048 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36049 ret_ref = (uintptr_t)ret_var.inner;
36050 if (ret_var.is_owned) {
36056 static inline uintptr_t ChannelTransactionParameters_clone_ptr(LDKChannelTransactionParameters *NONNULL_PTR arg) {
36057 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(arg);
36058 uint32_t ret_ref = 0;
36059 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36060 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36061 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36062 ret_ref = (uintptr_t)ret_var.inner;
36063 if (ret_var.is_owned) {
36068 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_clone_ptr"))) TS_ChannelTransactionParameters_clone_ptr(uint32_t arg) {
36069 LDKChannelTransactionParameters arg_conv;
36070 arg_conv.inner = (void*)(arg & (~1));
36071 arg_conv.is_owned = false;
36072 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36073 uint32_t ret_conv = ChannelTransactionParameters_clone_ptr(&arg_conv);
36077 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_clone"))) TS_ChannelTransactionParameters_clone(uint32_t orig) {
36078 LDKChannelTransactionParameters orig_conv;
36079 orig_conv.inner = (void*)(orig & (~1));
36080 orig_conv.is_owned = false;
36081 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36082 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
36083 uint32_t ret_ref = 0;
36084 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36085 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36086 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36087 ret_ref = (uintptr_t)ret_var.inner;
36088 if (ret_var.is_owned) {
36094 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_free"))) TS_CounterpartyChannelTransactionParameters_free(uint32_t this_obj) {
36095 LDKCounterpartyChannelTransactionParameters this_obj_conv;
36096 this_obj_conv.inner = (void*)(this_obj & (~1));
36097 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36098 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36099 CounterpartyChannelTransactionParameters_free(this_obj_conv);
36102 uint32_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_pubkeys"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint32_t this_ptr) {
36103 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
36104 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36105 this_ptr_conv.is_owned = false;
36106 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36107 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
36108 uint32_t ret_ref = 0;
36109 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36110 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36111 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36112 ret_ref = (uintptr_t)ret_var.inner;
36113 if (ret_var.is_owned) {
36119 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_pubkeys"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint32_t this_ptr, uint32_t val) {
36120 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
36121 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36122 this_ptr_conv.is_owned = false;
36123 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36124 LDKChannelPublicKeys val_conv;
36125 val_conv.inner = (void*)(val & (~1));
36126 val_conv.is_owned = (val & 1) || (val == 0);
36127 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
36128 val_conv = ChannelPublicKeys_clone(&val_conv);
36129 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
36132 int16_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint32_t this_ptr) {
36133 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
36134 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36135 this_ptr_conv.is_owned = false;
36136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36137 int16_t ret_conv = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
36141 void __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint32_t this_ptr, int16_t val) {
36142 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
36143 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36144 this_ptr_conv.is_owned = false;
36145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36146 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
36149 uint32_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_new"))) TS_CounterpartyChannelTransactionParameters_new(uint32_t pubkeys_arg, int16_t selected_contest_delay_arg) {
36150 LDKChannelPublicKeys pubkeys_arg_conv;
36151 pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
36152 pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
36153 CHECK_INNER_FIELD_ACCESS_OR_NULL(pubkeys_arg_conv);
36154 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
36155 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
36156 uint32_t ret_ref = 0;
36157 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36158 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36159 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36160 ret_ref = (uintptr_t)ret_var.inner;
36161 if (ret_var.is_owned) {
36167 static inline uintptr_t CounterpartyChannelTransactionParameters_clone_ptr(LDKCounterpartyChannelTransactionParameters *NONNULL_PTR arg) {
36168 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(arg);
36169 uint32_t ret_ref = 0;
36170 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36171 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36172 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36173 ret_ref = (uintptr_t)ret_var.inner;
36174 if (ret_var.is_owned) {
36179 uint32_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone_ptr"))) TS_CounterpartyChannelTransactionParameters_clone_ptr(uint32_t arg) {
36180 LDKCounterpartyChannelTransactionParameters arg_conv;
36181 arg_conv.inner = (void*)(arg & (~1));
36182 arg_conv.is_owned = false;
36183 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36184 uint32_t ret_conv = CounterpartyChannelTransactionParameters_clone_ptr(&arg_conv);
36188 uint32_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_clone"))) TS_CounterpartyChannelTransactionParameters_clone(uint32_t orig) {
36189 LDKCounterpartyChannelTransactionParameters orig_conv;
36190 orig_conv.inner = (void*)(orig & (~1));
36191 orig_conv.is_owned = false;
36192 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36193 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
36194 uint32_t ret_ref = 0;
36195 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36196 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36197 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36198 ret_ref = (uintptr_t)ret_var.inner;
36199 if (ret_var.is_owned) {
36205 jboolean __attribute__((export_name("TS_ChannelTransactionParameters_is_populated"))) TS_ChannelTransactionParameters_is_populated(uint32_t this_arg) {
36206 LDKChannelTransactionParameters this_arg_conv;
36207 this_arg_conv.inner = (void*)(this_arg & (~1));
36208 this_arg_conv.is_owned = false;
36209 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36210 jboolean ret_conv = ChannelTransactionParameters_is_populated(&this_arg_conv);
36214 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_as_holder_broadcastable"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint32_t this_arg) {
36215 LDKChannelTransactionParameters this_arg_conv;
36216 this_arg_conv.inner = (void*)(this_arg & (~1));
36217 this_arg_conv.is_owned = false;
36218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36219 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
36220 uint32_t ret_ref = 0;
36221 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36222 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36223 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36224 ret_ref = (uintptr_t)ret_var.inner;
36225 if (ret_var.is_owned) {
36231 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_as_counterparty_broadcastable"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint32_t this_arg) {
36232 LDKChannelTransactionParameters this_arg_conv;
36233 this_arg_conv.inner = (void*)(this_arg & (~1));
36234 this_arg_conv.is_owned = false;
36235 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36236 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
36237 uint32_t ret_ref = 0;
36238 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36239 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36240 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36241 ret_ref = (uintptr_t)ret_var.inner;
36242 if (ret_var.is_owned) {
36248 int8_tArray __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_write"))) TS_CounterpartyChannelTransactionParameters_write(uint32_t obj) {
36249 LDKCounterpartyChannelTransactionParameters obj_conv;
36250 obj_conv.inner = (void*)(obj & (~1));
36251 obj_conv.is_owned = false;
36252 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36253 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
36254 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36255 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36256 CVec_u8Z_free(ret_var);
36260 uint32_t __attribute__((export_name("TS_CounterpartyChannelTransactionParameters_read"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
36261 LDKu8slice ser_ref;
36262 ser_ref.datalen = ser->arr_len;
36263 ser_ref.data = ser->elems;
36264 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
36265 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
36267 return (uint32_t)ret_conv;
36270 int8_tArray __attribute__((export_name("TS_ChannelTransactionParameters_write"))) TS_ChannelTransactionParameters_write(uint32_t obj) {
36271 LDKChannelTransactionParameters obj_conv;
36272 obj_conv.inner = (void*)(obj & (~1));
36273 obj_conv.is_owned = false;
36274 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36275 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
36276 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36277 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36278 CVec_u8Z_free(ret_var);
36282 uint32_t __attribute__((export_name("TS_ChannelTransactionParameters_read"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
36283 LDKu8slice ser_ref;
36284 ser_ref.datalen = ser->arr_len;
36285 ser_ref.data = ser->elems;
36286 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
36287 *ret_conv = ChannelTransactionParameters_read(ser_ref);
36289 return (uint32_t)ret_conv;
36292 void __attribute__((export_name("TS_DirectedChannelTransactionParameters_free"))) TS_DirectedChannelTransactionParameters_free(uint32_t this_obj) {
36293 LDKDirectedChannelTransactionParameters this_obj_conv;
36294 this_obj_conv.inner = (void*)(this_obj & (~1));
36295 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36296 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36297 DirectedChannelTransactionParameters_free(this_obj_conv);
36300 uint32_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_broadcaster_pubkeys"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint32_t this_arg) {
36301 LDKDirectedChannelTransactionParameters this_arg_conv;
36302 this_arg_conv.inner = (void*)(this_arg & (~1));
36303 this_arg_conv.is_owned = false;
36304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36305 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
36306 uint32_t ret_ref = 0;
36307 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36308 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36309 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36310 ret_ref = (uintptr_t)ret_var.inner;
36311 if (ret_var.is_owned) {
36317 uint32_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_countersignatory_pubkeys"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint32_t this_arg) {
36318 LDKDirectedChannelTransactionParameters this_arg_conv;
36319 this_arg_conv.inner = (void*)(this_arg & (~1));
36320 this_arg_conv.is_owned = false;
36321 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36322 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
36323 uint32_t ret_ref = 0;
36324 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36325 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36326 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36327 ret_ref = (uintptr_t)ret_var.inner;
36328 if (ret_var.is_owned) {
36334 int16_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_contest_delay"))) TS_DirectedChannelTransactionParameters_contest_delay(uint32_t this_arg) {
36335 LDKDirectedChannelTransactionParameters this_arg_conv;
36336 this_arg_conv.inner = (void*)(this_arg & (~1));
36337 this_arg_conv.is_owned = false;
36338 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36339 int16_t ret_conv = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
36343 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_is_outbound"))) TS_DirectedChannelTransactionParameters_is_outbound(uint32_t this_arg) {
36344 LDKDirectedChannelTransactionParameters this_arg_conv;
36345 this_arg_conv.inner = (void*)(this_arg & (~1));
36346 this_arg_conv.is_owned = false;
36347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36348 jboolean ret_conv = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
36352 uint32_t __attribute__((export_name("TS_DirectedChannelTransactionParameters_funding_outpoint"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint32_t this_arg) {
36353 LDKDirectedChannelTransactionParameters this_arg_conv;
36354 this_arg_conv.inner = (void*)(this_arg & (~1));
36355 this_arg_conv.is_owned = false;
36356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36357 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
36358 uint32_t ret_ref = 0;
36359 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36360 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36361 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36362 ret_ref = (uintptr_t)ret_var.inner;
36363 if (ret_var.is_owned) {
36369 jboolean __attribute__((export_name("TS_DirectedChannelTransactionParameters_opt_anchors"))) TS_DirectedChannelTransactionParameters_opt_anchors(uint32_t this_arg) {
36370 LDKDirectedChannelTransactionParameters this_arg_conv;
36371 this_arg_conv.inner = (void*)(this_arg & (~1));
36372 this_arg_conv.is_owned = false;
36373 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36374 jboolean ret_conv = DirectedChannelTransactionParameters_opt_anchors(&this_arg_conv);
36378 void __attribute__((export_name("TS_HolderCommitmentTransaction_free"))) TS_HolderCommitmentTransaction_free(uint32_t this_obj) {
36379 LDKHolderCommitmentTransaction this_obj_conv;
36380 this_obj_conv.inner = (void*)(this_obj & (~1));
36381 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36383 HolderCommitmentTransaction_free(this_obj_conv);
36386 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_get_counterparty_sig"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint32_t this_ptr) {
36387 LDKHolderCommitmentTransaction this_ptr_conv;
36388 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36389 this_ptr_conv.is_owned = false;
36390 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36391 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
36392 memcpy(ret_arr->elems, HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
36396 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_sig"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint32_t this_ptr, int8_tArray val) {
36397 LDKHolderCommitmentTransaction this_ptr_conv;
36398 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36399 this_ptr_conv.is_owned = false;
36400 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36401 LDKSignature val_ref;
36402 CHECK(val->arr_len == 64);
36403 memcpy(val_ref.compact_form, val->elems, 64); FREE(val);
36404 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
36407 void __attribute__((export_name("TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint32_t this_ptr, ptrArray val) {
36408 LDKHolderCommitmentTransaction this_ptr_conv;
36409 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36410 this_ptr_conv.is_owned = false;
36411 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36412 LDKCVec_SignatureZ val_constr;
36413 val_constr.datalen = val->arr_len;
36414 if (val_constr.datalen > 0)
36415 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
36417 val_constr.data = NULL;
36418 int8_tArray* val_vals = (void*) val->elems;
36419 for (size_t m = 0; m < val_constr.datalen; m++) {
36420 int8_tArray val_conv_12 = val_vals[m];
36421 LDKSignature val_conv_12_ref;
36422 CHECK(val_conv_12->arr_len == 64);
36423 memcpy(val_conv_12_ref.compact_form, val_conv_12->elems, 64); FREE(val_conv_12);
36424 val_constr.data[m] = val_conv_12_ref;
36427 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
36430 static inline uintptr_t HolderCommitmentTransaction_clone_ptr(LDKHolderCommitmentTransaction *NONNULL_PTR arg) {
36431 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(arg);
36432 uint32_t ret_ref = 0;
36433 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36434 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36435 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36436 ret_ref = (uintptr_t)ret_var.inner;
36437 if (ret_var.is_owned) {
36442 uint32_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone_ptr"))) TS_HolderCommitmentTransaction_clone_ptr(uint32_t arg) {
36443 LDKHolderCommitmentTransaction arg_conv;
36444 arg_conv.inner = (void*)(arg & (~1));
36445 arg_conv.is_owned = false;
36446 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36447 uint32_t ret_conv = HolderCommitmentTransaction_clone_ptr(&arg_conv);
36451 uint32_t __attribute__((export_name("TS_HolderCommitmentTransaction_clone"))) TS_HolderCommitmentTransaction_clone(uint32_t orig) {
36452 LDKHolderCommitmentTransaction orig_conv;
36453 orig_conv.inner = (void*)(orig & (~1));
36454 orig_conv.is_owned = false;
36455 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36456 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
36457 uint32_t ret_ref = 0;
36458 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36459 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36460 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36461 ret_ref = (uintptr_t)ret_var.inner;
36462 if (ret_var.is_owned) {
36468 int8_tArray __attribute__((export_name("TS_HolderCommitmentTransaction_write"))) TS_HolderCommitmentTransaction_write(uint32_t obj) {
36469 LDKHolderCommitmentTransaction obj_conv;
36470 obj_conv.inner = (void*)(obj & (~1));
36471 obj_conv.is_owned = false;
36472 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36473 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
36474 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36475 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36476 CVec_u8Z_free(ret_var);
36480 uint32_t __attribute__((export_name("TS_HolderCommitmentTransaction_read"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
36481 LDKu8slice ser_ref;
36482 ser_ref.datalen = ser->arr_len;
36483 ser_ref.data = ser->elems;
36484 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
36485 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
36487 return (uint32_t)ret_conv;
36490 uint32_t __attribute__((export_name("TS_HolderCommitmentTransaction_new"))) TS_HolderCommitmentTransaction_new(uint32_t commitment_tx, int8_tArray counterparty_sig, ptrArray counterparty_htlc_sigs, int8_tArray holder_funding_key, int8_tArray counterparty_funding_key) {
36491 LDKCommitmentTransaction commitment_tx_conv;
36492 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
36493 commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
36494 CHECK_INNER_FIELD_ACCESS_OR_NULL(commitment_tx_conv);
36495 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
36496 LDKSignature counterparty_sig_ref;
36497 CHECK(counterparty_sig->arr_len == 64);
36498 memcpy(counterparty_sig_ref.compact_form, counterparty_sig->elems, 64); FREE(counterparty_sig);
36499 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
36500 counterparty_htlc_sigs_constr.datalen = counterparty_htlc_sigs->arr_len;
36501 if (counterparty_htlc_sigs_constr.datalen > 0)
36502 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
36504 counterparty_htlc_sigs_constr.data = NULL;
36505 int8_tArray* counterparty_htlc_sigs_vals = (void*) counterparty_htlc_sigs->elems;
36506 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
36507 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
36508 LDKSignature counterparty_htlc_sigs_conv_12_ref;
36509 CHECK(counterparty_htlc_sigs_conv_12->arr_len == 64);
36510 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, counterparty_htlc_sigs_conv_12->elems, 64); FREE(counterparty_htlc_sigs_conv_12);
36511 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
36513 FREE(counterparty_htlc_sigs);
36514 LDKPublicKey holder_funding_key_ref;
36515 CHECK(holder_funding_key->arr_len == 33);
36516 memcpy(holder_funding_key_ref.compressed_form, holder_funding_key->elems, 33); FREE(holder_funding_key);
36517 LDKPublicKey counterparty_funding_key_ref;
36518 CHECK(counterparty_funding_key->arr_len == 33);
36519 memcpy(counterparty_funding_key_ref.compressed_form, counterparty_funding_key->elems, 33); FREE(counterparty_funding_key);
36520 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
36521 uint32_t ret_ref = 0;
36522 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36523 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36524 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36525 ret_ref = (uintptr_t)ret_var.inner;
36526 if (ret_var.is_owned) {
36532 void __attribute__((export_name("TS_BuiltCommitmentTransaction_free"))) TS_BuiltCommitmentTransaction_free(uint32_t this_obj) {
36533 LDKBuiltCommitmentTransaction this_obj_conv;
36534 this_obj_conv.inner = (void*)(this_obj & (~1));
36535 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36537 BuiltCommitmentTransaction_free(this_obj_conv);
36540 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_transaction"))) TS_BuiltCommitmentTransaction_get_transaction(uint32_t this_ptr) {
36541 LDKBuiltCommitmentTransaction this_ptr_conv;
36542 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36543 this_ptr_conv.is_owned = false;
36544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36545 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
36546 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36547 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36548 Transaction_free(ret_var);
36552 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_transaction"))) TS_BuiltCommitmentTransaction_set_transaction(uint32_t this_ptr, int8_tArray val) {
36553 LDKBuiltCommitmentTransaction this_ptr_conv;
36554 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36555 this_ptr_conv.is_owned = false;
36556 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36557 LDKTransaction val_ref;
36558 val_ref.datalen = val->arr_len;
36559 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
36560 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
36561 val_ref.data_is_owned = true;
36562 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
36565 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_txid"))) TS_BuiltCommitmentTransaction_get_txid(uint32_t this_ptr) {
36566 LDKBuiltCommitmentTransaction this_ptr_conv;
36567 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36568 this_ptr_conv.is_owned = false;
36569 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36570 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36571 memcpy(ret_arr->elems, *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
36575 void __attribute__((export_name("TS_BuiltCommitmentTransaction_set_txid"))) TS_BuiltCommitmentTransaction_set_txid(uint32_t this_ptr, int8_tArray val) {
36576 LDKBuiltCommitmentTransaction this_ptr_conv;
36577 this_ptr_conv.inner = (void*)(this_ptr & (~1));
36578 this_ptr_conv.is_owned = false;
36579 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
36580 LDKThirtyTwoBytes val_ref;
36581 CHECK(val->arr_len == 32);
36582 memcpy(val_ref.data, val->elems, 32); FREE(val);
36583 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
36586 uint32_t __attribute__((export_name("TS_BuiltCommitmentTransaction_new"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
36587 LDKTransaction transaction_arg_ref;
36588 transaction_arg_ref.datalen = transaction_arg->arr_len;
36589 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
36590 memcpy(transaction_arg_ref.data, transaction_arg->elems, transaction_arg_ref.datalen); FREE(transaction_arg);
36591 transaction_arg_ref.data_is_owned = true;
36592 LDKThirtyTwoBytes txid_arg_ref;
36593 CHECK(txid_arg->arr_len == 32);
36594 memcpy(txid_arg_ref.data, txid_arg->elems, 32); FREE(txid_arg);
36595 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
36596 uint32_t ret_ref = 0;
36597 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36598 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36599 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36600 ret_ref = (uintptr_t)ret_var.inner;
36601 if (ret_var.is_owned) {
36607 static inline uintptr_t BuiltCommitmentTransaction_clone_ptr(LDKBuiltCommitmentTransaction *NONNULL_PTR arg) {
36608 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(arg);
36609 uint32_t ret_ref = 0;
36610 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36611 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36612 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36613 ret_ref = (uintptr_t)ret_var.inner;
36614 if (ret_var.is_owned) {
36619 uint32_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone_ptr"))) TS_BuiltCommitmentTransaction_clone_ptr(uint32_t arg) {
36620 LDKBuiltCommitmentTransaction arg_conv;
36621 arg_conv.inner = (void*)(arg & (~1));
36622 arg_conv.is_owned = false;
36623 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36624 uint32_t ret_conv = BuiltCommitmentTransaction_clone_ptr(&arg_conv);
36628 uint32_t __attribute__((export_name("TS_BuiltCommitmentTransaction_clone"))) TS_BuiltCommitmentTransaction_clone(uint32_t orig) {
36629 LDKBuiltCommitmentTransaction orig_conv;
36630 orig_conv.inner = (void*)(orig & (~1));
36631 orig_conv.is_owned = false;
36632 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36633 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
36634 uint32_t ret_ref = 0;
36635 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36636 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36637 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36638 ret_ref = (uintptr_t)ret_var.inner;
36639 if (ret_var.is_owned) {
36645 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_write"))) TS_BuiltCommitmentTransaction_write(uint32_t obj) {
36646 LDKBuiltCommitmentTransaction obj_conv;
36647 obj_conv.inner = (void*)(obj & (~1));
36648 obj_conv.is_owned = false;
36649 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36650 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
36651 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36652 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36653 CVec_u8Z_free(ret_var);
36657 uint32_t __attribute__((export_name("TS_BuiltCommitmentTransaction_read"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
36658 LDKu8slice ser_ref;
36659 ser_ref.datalen = ser->arr_len;
36660 ser_ref.data = ser->elems;
36661 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
36662 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
36664 return (uint32_t)ret_conv;
36667 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_get_sighash_all"))) TS_BuiltCommitmentTransaction_get_sighash_all(uint32_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
36668 LDKBuiltCommitmentTransaction this_arg_conv;
36669 this_arg_conv.inner = (void*)(this_arg & (~1));
36670 this_arg_conv.is_owned = false;
36671 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36672 LDKu8slice funding_redeemscript_ref;
36673 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
36674 funding_redeemscript_ref.data = funding_redeemscript->elems;
36675 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36676 memcpy(ret_arr->elems, BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
36677 FREE(funding_redeemscript);
36681 int8_tArray __attribute__((export_name("TS_BuiltCommitmentTransaction_sign"))) TS_BuiltCommitmentTransaction_sign(uint32_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
36682 LDKBuiltCommitmentTransaction this_arg_conv;
36683 this_arg_conv.inner = (void*)(this_arg & (~1));
36684 this_arg_conv.is_owned = false;
36685 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36686 unsigned char funding_key_arr[32];
36687 CHECK(funding_key->arr_len == 32);
36688 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
36689 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
36690 LDKu8slice funding_redeemscript_ref;
36691 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
36692 funding_redeemscript_ref.data = funding_redeemscript->elems;
36693 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
36694 memcpy(ret_arr->elems, BuiltCommitmentTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
36695 FREE(funding_redeemscript);
36699 void __attribute__((export_name("TS_ClosingTransaction_free"))) TS_ClosingTransaction_free(uint32_t this_obj) {
36700 LDKClosingTransaction this_obj_conv;
36701 this_obj_conv.inner = (void*)(this_obj & (~1));
36702 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36703 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36704 ClosingTransaction_free(this_obj_conv);
36707 static inline uintptr_t ClosingTransaction_clone_ptr(LDKClosingTransaction *NONNULL_PTR arg) {
36708 LDKClosingTransaction ret_var = ClosingTransaction_clone(arg);
36709 uint32_t ret_ref = 0;
36710 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36711 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36713 ret_ref = (uintptr_t)ret_var.inner;
36714 if (ret_var.is_owned) {
36719 uint32_t __attribute__((export_name("TS_ClosingTransaction_clone_ptr"))) TS_ClosingTransaction_clone_ptr(uint32_t arg) {
36720 LDKClosingTransaction arg_conv;
36721 arg_conv.inner = (void*)(arg & (~1));
36722 arg_conv.is_owned = false;
36723 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36724 uint32_t ret_conv = ClosingTransaction_clone_ptr(&arg_conv);
36728 uint32_t __attribute__((export_name("TS_ClosingTransaction_clone"))) TS_ClosingTransaction_clone(uint32_t orig) {
36729 LDKClosingTransaction orig_conv;
36730 orig_conv.inner = (void*)(orig & (~1));
36731 orig_conv.is_owned = false;
36732 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36733 LDKClosingTransaction ret_var = ClosingTransaction_clone(&orig_conv);
36734 uint32_t ret_ref = 0;
36735 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36736 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36737 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36738 ret_ref = (uintptr_t)ret_var.inner;
36739 if (ret_var.is_owned) {
36745 int64_t __attribute__((export_name("TS_ClosingTransaction_hash"))) TS_ClosingTransaction_hash(uint32_t o) {
36746 LDKClosingTransaction o_conv;
36747 o_conv.inner = (void*)(o & (~1));
36748 o_conv.is_owned = false;
36749 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
36750 int64_t ret_conv = ClosingTransaction_hash(&o_conv);
36754 uint32_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, uint32_t funding_outpoint) {
36755 LDKCVec_u8Z to_holder_script_ref;
36756 to_holder_script_ref.datalen = to_holder_script->arr_len;
36757 to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes");
36758 memcpy(to_holder_script_ref.data, to_holder_script->elems, to_holder_script_ref.datalen); FREE(to_holder_script);
36759 LDKCVec_u8Z to_counterparty_script_ref;
36760 to_counterparty_script_ref.datalen = to_counterparty_script->arr_len;
36761 to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes");
36762 memcpy(to_counterparty_script_ref.data, to_counterparty_script->elems, to_counterparty_script_ref.datalen); FREE(to_counterparty_script);
36763 LDKOutPoint funding_outpoint_conv;
36764 funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
36765 funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
36766 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
36767 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
36768 LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv);
36769 uint32_t ret_ref = 0;
36770 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36771 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36772 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36773 ret_ref = (uintptr_t)ret_var.inner;
36774 if (ret_var.is_owned) {
36780 uint32_t __attribute__((export_name("TS_ClosingTransaction_trust"))) TS_ClosingTransaction_trust(uint32_t this_arg) {
36781 LDKClosingTransaction this_arg_conv;
36782 this_arg_conv.inner = (void*)(this_arg & (~1));
36783 this_arg_conv.is_owned = false;
36784 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36785 LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_conv);
36786 uint32_t ret_ref = 0;
36787 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36788 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36789 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36790 ret_ref = (uintptr_t)ret_var.inner;
36791 if (ret_var.is_owned) {
36797 uint32_t __attribute__((export_name("TS_ClosingTransaction_verify"))) TS_ClosingTransaction_verify(uint32_t this_arg, uint32_t funding_outpoint) {
36798 LDKClosingTransaction this_arg_conv;
36799 this_arg_conv.inner = (void*)(this_arg & (~1));
36800 this_arg_conv.is_owned = false;
36801 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36802 LDKOutPoint funding_outpoint_conv;
36803 funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1));
36804 funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0);
36805 CHECK_INNER_FIELD_ACCESS_OR_NULL(funding_outpoint_conv);
36806 funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv);
36807 LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ");
36808 *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv);
36809 return (uint32_t)ret_conv;
36812 int64_t __attribute__((export_name("TS_ClosingTransaction_to_holder_value_sat"))) TS_ClosingTransaction_to_holder_value_sat(uint32_t this_arg) {
36813 LDKClosingTransaction this_arg_conv;
36814 this_arg_conv.inner = (void*)(this_arg & (~1));
36815 this_arg_conv.is_owned = false;
36816 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36817 int64_t ret_conv = ClosingTransaction_to_holder_value_sat(&this_arg_conv);
36821 int64_t __attribute__((export_name("TS_ClosingTransaction_to_counterparty_value_sat"))) TS_ClosingTransaction_to_counterparty_value_sat(uint32_t this_arg) {
36822 LDKClosingTransaction this_arg_conv;
36823 this_arg_conv.inner = (void*)(this_arg & (~1));
36824 this_arg_conv.is_owned = false;
36825 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36826 int64_t ret_conv = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv);
36830 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_holder_script"))) TS_ClosingTransaction_to_holder_script(uint32_t this_arg) {
36831 LDKClosingTransaction this_arg_conv;
36832 this_arg_conv.inner = (void*)(this_arg & (~1));
36833 this_arg_conv.is_owned = false;
36834 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36835 LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_conv);
36836 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36837 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36841 int8_tArray __attribute__((export_name("TS_ClosingTransaction_to_counterparty_script"))) TS_ClosingTransaction_to_counterparty_script(uint32_t this_arg) {
36842 LDKClosingTransaction this_arg_conv;
36843 this_arg_conv.inner = (void*)(this_arg & (~1));
36844 this_arg_conv.is_owned = false;
36845 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36846 LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_conv);
36847 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36848 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36852 void __attribute__((export_name("TS_TrustedClosingTransaction_free"))) TS_TrustedClosingTransaction_free(uint32_t this_obj) {
36853 LDKTrustedClosingTransaction this_obj_conv;
36854 this_obj_conv.inner = (void*)(this_obj & (~1));
36855 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36856 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36857 TrustedClosingTransaction_free(this_obj_conv);
36860 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_built_transaction"))) TS_TrustedClosingTransaction_built_transaction(uint32_t this_arg) {
36861 LDKTrustedClosingTransaction this_arg_conv;
36862 this_arg_conv.inner = (void*)(this_arg & (~1));
36863 this_arg_conv.is_owned = false;
36864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36865 LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_conv);
36866 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36867 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36868 Transaction_free(ret_var);
36872 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_get_sighash_all"))) TS_TrustedClosingTransaction_get_sighash_all(uint32_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
36873 LDKTrustedClosingTransaction this_arg_conv;
36874 this_arg_conv.inner = (void*)(this_arg & (~1));
36875 this_arg_conv.is_owned = false;
36876 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36877 LDKu8slice funding_redeemscript_ref;
36878 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
36879 funding_redeemscript_ref.data = funding_redeemscript->elems;
36880 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
36881 memcpy(ret_arr->elems, TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
36882 FREE(funding_redeemscript);
36886 int8_tArray __attribute__((export_name("TS_TrustedClosingTransaction_sign"))) TS_TrustedClosingTransaction_sign(uint32_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
36887 LDKTrustedClosingTransaction this_arg_conv;
36888 this_arg_conv.inner = (void*)(this_arg & (~1));
36889 this_arg_conv.is_owned = false;
36890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36891 unsigned char funding_key_arr[32];
36892 CHECK(funding_key->arr_len == 32);
36893 memcpy(funding_key_arr, funding_key->elems, 32); FREE(funding_key);
36894 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
36895 LDKu8slice funding_redeemscript_ref;
36896 funding_redeemscript_ref.datalen = funding_redeemscript->arr_len;
36897 funding_redeemscript_ref.data = funding_redeemscript->elems;
36898 int8_tArray ret_arr = init_int8_tArray(64, __LINE__);
36899 memcpy(ret_arr->elems, TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
36900 FREE(funding_redeemscript);
36904 void __attribute__((export_name("TS_CommitmentTransaction_free"))) TS_CommitmentTransaction_free(uint32_t this_obj) {
36905 LDKCommitmentTransaction this_obj_conv;
36906 this_obj_conv.inner = (void*)(this_obj & (~1));
36907 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
36908 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
36909 CommitmentTransaction_free(this_obj_conv);
36912 static inline uintptr_t CommitmentTransaction_clone_ptr(LDKCommitmentTransaction *NONNULL_PTR arg) {
36913 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(arg);
36914 uint32_t ret_ref = 0;
36915 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36916 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36917 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36918 ret_ref = (uintptr_t)ret_var.inner;
36919 if (ret_var.is_owned) {
36924 uint32_t __attribute__((export_name("TS_CommitmentTransaction_clone_ptr"))) TS_CommitmentTransaction_clone_ptr(uint32_t arg) {
36925 LDKCommitmentTransaction arg_conv;
36926 arg_conv.inner = (void*)(arg & (~1));
36927 arg_conv.is_owned = false;
36928 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
36929 uint32_t ret_conv = CommitmentTransaction_clone_ptr(&arg_conv);
36933 uint32_t __attribute__((export_name("TS_CommitmentTransaction_clone"))) TS_CommitmentTransaction_clone(uint32_t orig) {
36934 LDKCommitmentTransaction orig_conv;
36935 orig_conv.inner = (void*)(orig & (~1));
36936 orig_conv.is_owned = false;
36937 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
36938 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
36939 uint32_t ret_ref = 0;
36940 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
36941 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
36942 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
36943 ret_ref = (uintptr_t)ret_var.inner;
36944 if (ret_var.is_owned) {
36950 int8_tArray __attribute__((export_name("TS_CommitmentTransaction_write"))) TS_CommitmentTransaction_write(uint32_t obj) {
36951 LDKCommitmentTransaction obj_conv;
36952 obj_conv.inner = (void*)(obj & (~1));
36953 obj_conv.is_owned = false;
36954 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
36955 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
36956 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
36957 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
36958 CVec_u8Z_free(ret_var);
36962 uint32_t __attribute__((export_name("TS_CommitmentTransaction_read"))) TS_CommitmentTransaction_read(int8_tArray ser) {
36963 LDKu8slice ser_ref;
36964 ser_ref.datalen = ser->arr_len;
36965 ser_ref.data = ser->elems;
36966 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
36967 *ret_conv = CommitmentTransaction_read(ser_ref);
36969 return (uint32_t)ret_conv;
36972 int64_t __attribute__((export_name("TS_CommitmentTransaction_commitment_number"))) TS_CommitmentTransaction_commitment_number(uint32_t this_arg) {
36973 LDKCommitmentTransaction this_arg_conv;
36974 this_arg_conv.inner = (void*)(this_arg & (~1));
36975 this_arg_conv.is_owned = false;
36976 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36977 int64_t ret_conv = CommitmentTransaction_commitment_number(&this_arg_conv);
36981 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_broadcaster_value_sat"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint32_t this_arg) {
36982 LDKCommitmentTransaction this_arg_conv;
36983 this_arg_conv.inner = (void*)(this_arg & (~1));
36984 this_arg_conv.is_owned = false;
36985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36986 int64_t ret_conv = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
36990 int64_t __attribute__((export_name("TS_CommitmentTransaction_to_countersignatory_value_sat"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint32_t this_arg) {
36991 LDKCommitmentTransaction this_arg_conv;
36992 this_arg_conv.inner = (void*)(this_arg & (~1));
36993 this_arg_conv.is_owned = false;
36994 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
36995 int64_t ret_conv = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
36999 int32_t __attribute__((export_name("TS_CommitmentTransaction_feerate_per_kw"))) TS_CommitmentTransaction_feerate_per_kw(uint32_t this_arg) {
37000 LDKCommitmentTransaction this_arg_conv;
37001 this_arg_conv.inner = (void*)(this_arg & (~1));
37002 this_arg_conv.is_owned = false;
37003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37004 int32_t ret_conv = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
37008 uint32_t __attribute__((export_name("TS_CommitmentTransaction_trust"))) TS_CommitmentTransaction_trust(uint32_t this_arg) {
37009 LDKCommitmentTransaction this_arg_conv;
37010 this_arg_conv.inner = (void*)(this_arg & (~1));
37011 this_arg_conv.is_owned = false;
37012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37013 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
37014 uint32_t ret_ref = 0;
37015 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37016 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37017 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37018 ret_ref = (uintptr_t)ret_var.inner;
37019 if (ret_var.is_owned) {
37025 uint32_t __attribute__((export_name("TS_CommitmentTransaction_verify"))) TS_CommitmentTransaction_verify(uint32_t this_arg, uint32_t channel_parameters, uint32_t broadcaster_keys, uint32_t countersignatory_keys) {
37026 LDKCommitmentTransaction this_arg_conv;
37027 this_arg_conv.inner = (void*)(this_arg & (~1));
37028 this_arg_conv.is_owned = false;
37029 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37030 LDKDirectedChannelTransactionParameters channel_parameters_conv;
37031 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
37032 channel_parameters_conv.is_owned = false;
37033 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
37034 LDKChannelPublicKeys broadcaster_keys_conv;
37035 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
37036 broadcaster_keys_conv.is_owned = false;
37037 CHECK_INNER_FIELD_ACCESS_OR_NULL(broadcaster_keys_conv);
37038 LDKChannelPublicKeys countersignatory_keys_conv;
37039 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
37040 countersignatory_keys_conv.is_owned = false;
37041 CHECK_INNER_FIELD_ACCESS_OR_NULL(countersignatory_keys_conv);
37042 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
37043 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
37044 return (uint32_t)ret_conv;
37047 void __attribute__((export_name("TS_TrustedCommitmentTransaction_free"))) TS_TrustedCommitmentTransaction_free(uint32_t this_obj) {
37048 LDKTrustedCommitmentTransaction this_obj_conv;
37049 this_obj_conv.inner = (void*)(this_obj & (~1));
37050 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37051 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37052 TrustedCommitmentTransaction_free(this_obj_conv);
37055 int8_tArray __attribute__((export_name("TS_TrustedCommitmentTransaction_txid"))) TS_TrustedCommitmentTransaction_txid(uint32_t this_arg) {
37056 LDKTrustedCommitmentTransaction this_arg_conv;
37057 this_arg_conv.inner = (void*)(this_arg & (~1));
37058 this_arg_conv.is_owned = false;
37059 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37060 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
37061 memcpy(ret_arr->elems, TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
37065 uint32_t __attribute__((export_name("TS_TrustedCommitmentTransaction_built_transaction"))) TS_TrustedCommitmentTransaction_built_transaction(uint32_t this_arg) {
37066 LDKTrustedCommitmentTransaction this_arg_conv;
37067 this_arg_conv.inner = (void*)(this_arg & (~1));
37068 this_arg_conv.is_owned = false;
37069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37070 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
37071 uint32_t ret_ref = 0;
37072 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37073 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37074 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37075 ret_ref = (uintptr_t)ret_var.inner;
37076 if (ret_var.is_owned) {
37082 uint32_t __attribute__((export_name("TS_TrustedCommitmentTransaction_keys"))) TS_TrustedCommitmentTransaction_keys(uint32_t this_arg) {
37083 LDKTrustedCommitmentTransaction this_arg_conv;
37084 this_arg_conv.inner = (void*)(this_arg & (~1));
37085 this_arg_conv.is_owned = false;
37086 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37087 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
37088 uint32_t ret_ref = 0;
37089 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37090 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37091 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37092 ret_ref = (uintptr_t)ret_var.inner;
37093 if (ret_var.is_owned) {
37099 jboolean __attribute__((export_name("TS_TrustedCommitmentTransaction_opt_anchors"))) TS_TrustedCommitmentTransaction_opt_anchors(uint32_t this_arg) {
37100 LDKTrustedCommitmentTransaction this_arg_conv;
37101 this_arg_conv.inner = (void*)(this_arg & (~1));
37102 this_arg_conv.is_owned = false;
37103 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37104 jboolean ret_conv = TrustedCommitmentTransaction_opt_anchors(&this_arg_conv);
37108 uint32_t __attribute__((export_name("TS_TrustedCommitmentTransaction_get_htlc_sigs"))) TS_TrustedCommitmentTransaction_get_htlc_sigs(uint32_t this_arg, int8_tArray htlc_base_key, uint32_t channel_parameters) {
37109 LDKTrustedCommitmentTransaction this_arg_conv;
37110 this_arg_conv.inner = (void*)(this_arg & (~1));
37111 this_arg_conv.is_owned = false;
37112 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37113 unsigned char htlc_base_key_arr[32];
37114 CHECK(htlc_base_key->arr_len == 32);
37115 memcpy(htlc_base_key_arr, htlc_base_key->elems, 32); FREE(htlc_base_key);
37116 unsigned char (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
37117 LDKDirectedChannelTransactionParameters channel_parameters_conv;
37118 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
37119 channel_parameters_conv.is_owned = false;
37120 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_parameters_conv);
37121 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
37122 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
37123 return (uint32_t)ret_conv;
37126 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) {
37127 LDKPublicKey broadcaster_payment_basepoint_ref;
37128 CHECK(broadcaster_payment_basepoint->arr_len == 33);
37129 memcpy(broadcaster_payment_basepoint_ref.compressed_form, broadcaster_payment_basepoint->elems, 33); FREE(broadcaster_payment_basepoint);
37130 LDKPublicKey countersignatory_payment_basepoint_ref;
37131 CHECK(countersignatory_payment_basepoint->arr_len == 33);
37132 memcpy(countersignatory_payment_basepoint_ref.compressed_form, countersignatory_payment_basepoint->elems, 33); FREE(countersignatory_payment_basepoint);
37133 int64_t ret_conv = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
37137 jboolean __attribute__((export_name("TS_InitFeatures_eq"))) TS_InitFeatures_eq(uint32_t a, uint32_t b) {
37138 LDKInitFeatures a_conv;
37139 a_conv.inner = (void*)(a & (~1));
37140 a_conv.is_owned = false;
37141 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37142 LDKInitFeatures b_conv;
37143 b_conv.inner = (void*)(b & (~1));
37144 b_conv.is_owned = false;
37145 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37146 jboolean ret_conv = InitFeatures_eq(&a_conv, &b_conv);
37150 jboolean __attribute__((export_name("TS_NodeFeatures_eq"))) TS_NodeFeatures_eq(uint32_t a, uint32_t b) {
37151 LDKNodeFeatures a_conv;
37152 a_conv.inner = (void*)(a & (~1));
37153 a_conv.is_owned = false;
37154 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37155 LDKNodeFeatures b_conv;
37156 b_conv.inner = (void*)(b & (~1));
37157 b_conv.is_owned = false;
37158 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37159 jboolean ret_conv = NodeFeatures_eq(&a_conv, &b_conv);
37163 jboolean __attribute__((export_name("TS_ChannelFeatures_eq"))) TS_ChannelFeatures_eq(uint32_t a, uint32_t b) {
37164 LDKChannelFeatures a_conv;
37165 a_conv.inner = (void*)(a & (~1));
37166 a_conv.is_owned = false;
37167 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37168 LDKChannelFeatures b_conv;
37169 b_conv.inner = (void*)(b & (~1));
37170 b_conv.is_owned = false;
37171 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37172 jboolean ret_conv = ChannelFeatures_eq(&a_conv, &b_conv);
37176 jboolean __attribute__((export_name("TS_InvoiceFeatures_eq"))) TS_InvoiceFeatures_eq(uint32_t a, uint32_t b) {
37177 LDKInvoiceFeatures a_conv;
37178 a_conv.inner = (void*)(a & (~1));
37179 a_conv.is_owned = false;
37180 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37181 LDKInvoiceFeatures b_conv;
37182 b_conv.inner = (void*)(b & (~1));
37183 b_conv.is_owned = false;
37184 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37185 jboolean ret_conv = InvoiceFeatures_eq(&a_conv, &b_conv);
37189 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_eq"))) TS_ChannelTypeFeatures_eq(uint32_t a, uint32_t b) {
37190 LDKChannelTypeFeatures a_conv;
37191 a_conv.inner = (void*)(a & (~1));
37192 a_conv.is_owned = false;
37193 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
37194 LDKChannelTypeFeatures b_conv;
37195 b_conv.inner = (void*)(b & (~1));
37196 b_conv.is_owned = false;
37197 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
37198 jboolean ret_conv = ChannelTypeFeatures_eq(&a_conv, &b_conv);
37202 static inline uintptr_t InitFeatures_clone_ptr(LDKInitFeatures *NONNULL_PTR arg) {
37203 LDKInitFeatures ret_var = InitFeatures_clone(arg);
37204 uint32_t ret_ref = 0;
37205 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37206 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37207 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37208 ret_ref = (uintptr_t)ret_var.inner;
37209 if (ret_var.is_owned) {
37214 uint32_t __attribute__((export_name("TS_InitFeatures_clone_ptr"))) TS_InitFeatures_clone_ptr(uint32_t arg) {
37215 LDKInitFeatures arg_conv;
37216 arg_conv.inner = (void*)(arg & (~1));
37217 arg_conv.is_owned = false;
37218 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37219 uint32_t ret_conv = InitFeatures_clone_ptr(&arg_conv);
37223 uint32_t __attribute__((export_name("TS_InitFeatures_clone"))) TS_InitFeatures_clone(uint32_t orig) {
37224 LDKInitFeatures orig_conv;
37225 orig_conv.inner = (void*)(orig & (~1));
37226 orig_conv.is_owned = false;
37227 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37228 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
37229 uint32_t ret_ref = 0;
37230 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37231 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37232 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37233 ret_ref = (uintptr_t)ret_var.inner;
37234 if (ret_var.is_owned) {
37240 static inline uintptr_t NodeFeatures_clone_ptr(LDKNodeFeatures *NONNULL_PTR arg) {
37241 LDKNodeFeatures ret_var = NodeFeatures_clone(arg);
37242 uint32_t ret_ref = 0;
37243 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37244 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37245 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37246 ret_ref = (uintptr_t)ret_var.inner;
37247 if (ret_var.is_owned) {
37252 uint32_t __attribute__((export_name("TS_NodeFeatures_clone_ptr"))) TS_NodeFeatures_clone_ptr(uint32_t arg) {
37253 LDKNodeFeatures arg_conv;
37254 arg_conv.inner = (void*)(arg & (~1));
37255 arg_conv.is_owned = false;
37256 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37257 uint32_t ret_conv = NodeFeatures_clone_ptr(&arg_conv);
37261 uint32_t __attribute__((export_name("TS_NodeFeatures_clone"))) TS_NodeFeatures_clone(uint32_t orig) {
37262 LDKNodeFeatures orig_conv;
37263 orig_conv.inner = (void*)(orig & (~1));
37264 orig_conv.is_owned = false;
37265 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37266 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
37267 uint32_t ret_ref = 0;
37268 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37269 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37270 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37271 ret_ref = (uintptr_t)ret_var.inner;
37272 if (ret_var.is_owned) {
37278 static inline uintptr_t ChannelFeatures_clone_ptr(LDKChannelFeatures *NONNULL_PTR arg) {
37279 LDKChannelFeatures ret_var = ChannelFeatures_clone(arg);
37280 uint32_t ret_ref = 0;
37281 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37282 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37283 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37284 ret_ref = (uintptr_t)ret_var.inner;
37285 if (ret_var.is_owned) {
37290 uint32_t __attribute__((export_name("TS_ChannelFeatures_clone_ptr"))) TS_ChannelFeatures_clone_ptr(uint32_t arg) {
37291 LDKChannelFeatures arg_conv;
37292 arg_conv.inner = (void*)(arg & (~1));
37293 arg_conv.is_owned = false;
37294 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37295 uint32_t ret_conv = ChannelFeatures_clone_ptr(&arg_conv);
37299 uint32_t __attribute__((export_name("TS_ChannelFeatures_clone"))) TS_ChannelFeatures_clone(uint32_t orig) {
37300 LDKChannelFeatures orig_conv;
37301 orig_conv.inner = (void*)(orig & (~1));
37302 orig_conv.is_owned = false;
37303 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37304 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
37305 uint32_t ret_ref = 0;
37306 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37307 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37308 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37309 ret_ref = (uintptr_t)ret_var.inner;
37310 if (ret_var.is_owned) {
37316 static inline uintptr_t InvoiceFeatures_clone_ptr(LDKInvoiceFeatures *NONNULL_PTR arg) {
37317 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(arg);
37318 uint32_t ret_ref = 0;
37319 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37320 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37321 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37322 ret_ref = (uintptr_t)ret_var.inner;
37323 if (ret_var.is_owned) {
37328 uint32_t __attribute__((export_name("TS_InvoiceFeatures_clone_ptr"))) TS_InvoiceFeatures_clone_ptr(uint32_t arg) {
37329 LDKInvoiceFeatures arg_conv;
37330 arg_conv.inner = (void*)(arg & (~1));
37331 arg_conv.is_owned = false;
37332 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37333 uint32_t ret_conv = InvoiceFeatures_clone_ptr(&arg_conv);
37337 uint32_t __attribute__((export_name("TS_InvoiceFeatures_clone"))) TS_InvoiceFeatures_clone(uint32_t orig) {
37338 LDKInvoiceFeatures orig_conv;
37339 orig_conv.inner = (void*)(orig & (~1));
37340 orig_conv.is_owned = false;
37341 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37342 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
37343 uint32_t ret_ref = 0;
37344 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37345 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37346 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37347 ret_ref = (uintptr_t)ret_var.inner;
37348 if (ret_var.is_owned) {
37354 static inline uintptr_t ChannelTypeFeatures_clone_ptr(LDKChannelTypeFeatures *NONNULL_PTR arg) {
37355 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(arg);
37356 uint32_t ret_ref = 0;
37357 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37358 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37359 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37360 ret_ref = (uintptr_t)ret_var.inner;
37361 if (ret_var.is_owned) {
37366 uint32_t __attribute__((export_name("TS_ChannelTypeFeatures_clone_ptr"))) TS_ChannelTypeFeatures_clone_ptr(uint32_t arg) {
37367 LDKChannelTypeFeatures arg_conv;
37368 arg_conv.inner = (void*)(arg & (~1));
37369 arg_conv.is_owned = false;
37370 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
37371 uint32_t ret_conv = ChannelTypeFeatures_clone_ptr(&arg_conv);
37375 uint32_t __attribute__((export_name("TS_ChannelTypeFeatures_clone"))) TS_ChannelTypeFeatures_clone(uint32_t orig) {
37376 LDKChannelTypeFeatures orig_conv;
37377 orig_conv.inner = (void*)(orig & (~1));
37378 orig_conv.is_owned = false;
37379 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
37380 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_clone(&orig_conv);
37381 uint32_t ret_ref = 0;
37382 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37383 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37384 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37385 ret_ref = (uintptr_t)ret_var.inner;
37386 if (ret_var.is_owned) {
37392 void __attribute__((export_name("TS_InitFeatures_free"))) TS_InitFeatures_free(uint32_t this_obj) {
37393 LDKInitFeatures this_obj_conv;
37394 this_obj_conv.inner = (void*)(this_obj & (~1));
37395 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37396 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37397 InitFeatures_free(this_obj_conv);
37400 void __attribute__((export_name("TS_NodeFeatures_free"))) TS_NodeFeatures_free(uint32_t this_obj) {
37401 LDKNodeFeatures this_obj_conv;
37402 this_obj_conv.inner = (void*)(this_obj & (~1));
37403 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37404 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37405 NodeFeatures_free(this_obj_conv);
37408 void __attribute__((export_name("TS_ChannelFeatures_free"))) TS_ChannelFeatures_free(uint32_t this_obj) {
37409 LDKChannelFeatures this_obj_conv;
37410 this_obj_conv.inner = (void*)(this_obj & (~1));
37411 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37412 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37413 ChannelFeatures_free(this_obj_conv);
37416 void __attribute__((export_name("TS_InvoiceFeatures_free"))) TS_InvoiceFeatures_free(uint32_t this_obj) {
37417 LDKInvoiceFeatures this_obj_conv;
37418 this_obj_conv.inner = (void*)(this_obj & (~1));
37419 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37420 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37421 InvoiceFeatures_free(this_obj_conv);
37424 void __attribute__((export_name("TS_ChannelTypeFeatures_free"))) TS_ChannelTypeFeatures_free(uint32_t this_obj) {
37425 LDKChannelTypeFeatures this_obj_conv;
37426 this_obj_conv.inner = (void*)(this_obj & (~1));
37427 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
37428 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
37429 ChannelTypeFeatures_free(this_obj_conv);
37432 uint32_t __attribute__((export_name("TS_InitFeatures_empty"))) TS_InitFeatures_empty() {
37433 LDKInitFeatures ret_var = InitFeatures_empty();
37434 uint32_t ret_ref = 0;
37435 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37436 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37437 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37438 ret_ref = (uintptr_t)ret_var.inner;
37439 if (ret_var.is_owned) {
37445 uint32_t __attribute__((export_name("TS_InitFeatures_known"))) TS_InitFeatures_known() {
37446 LDKInitFeatures ret_var = InitFeatures_known();
37447 uint32_t ret_ref = 0;
37448 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37449 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37451 ret_ref = (uintptr_t)ret_var.inner;
37452 if (ret_var.is_owned) {
37458 jboolean __attribute__((export_name("TS_InitFeatures_requires_unknown_bits"))) TS_InitFeatures_requires_unknown_bits(uint32_t this_arg) {
37459 LDKInitFeatures this_arg_conv;
37460 this_arg_conv.inner = (void*)(this_arg & (~1));
37461 this_arg_conv.is_owned = false;
37462 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37463 jboolean ret_conv = InitFeatures_requires_unknown_bits(&this_arg_conv);
37467 uint32_t __attribute__((export_name("TS_NodeFeatures_empty"))) TS_NodeFeatures_empty() {
37468 LDKNodeFeatures ret_var = NodeFeatures_empty();
37469 uint32_t ret_ref = 0;
37470 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37471 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37472 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37473 ret_ref = (uintptr_t)ret_var.inner;
37474 if (ret_var.is_owned) {
37480 uint32_t __attribute__((export_name("TS_NodeFeatures_known"))) TS_NodeFeatures_known() {
37481 LDKNodeFeatures ret_var = NodeFeatures_known();
37482 uint32_t ret_ref = 0;
37483 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37484 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37485 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37486 ret_ref = (uintptr_t)ret_var.inner;
37487 if (ret_var.is_owned) {
37493 jboolean __attribute__((export_name("TS_NodeFeatures_requires_unknown_bits"))) TS_NodeFeatures_requires_unknown_bits(uint32_t this_arg) {
37494 LDKNodeFeatures this_arg_conv;
37495 this_arg_conv.inner = (void*)(this_arg & (~1));
37496 this_arg_conv.is_owned = false;
37497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37498 jboolean ret_conv = NodeFeatures_requires_unknown_bits(&this_arg_conv);
37502 uint32_t __attribute__((export_name("TS_ChannelFeatures_empty"))) TS_ChannelFeatures_empty() {
37503 LDKChannelFeatures ret_var = ChannelFeatures_empty();
37504 uint32_t ret_ref = 0;
37505 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37506 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37507 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37508 ret_ref = (uintptr_t)ret_var.inner;
37509 if (ret_var.is_owned) {
37515 uint32_t __attribute__((export_name("TS_ChannelFeatures_known"))) TS_ChannelFeatures_known() {
37516 LDKChannelFeatures ret_var = ChannelFeatures_known();
37517 uint32_t ret_ref = 0;
37518 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37519 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37520 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37521 ret_ref = (uintptr_t)ret_var.inner;
37522 if (ret_var.is_owned) {
37528 jboolean __attribute__((export_name("TS_ChannelFeatures_requires_unknown_bits"))) TS_ChannelFeatures_requires_unknown_bits(uint32_t this_arg) {
37529 LDKChannelFeatures this_arg_conv;
37530 this_arg_conv.inner = (void*)(this_arg & (~1));
37531 this_arg_conv.is_owned = false;
37532 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37533 jboolean ret_conv = ChannelFeatures_requires_unknown_bits(&this_arg_conv);
37537 uint32_t __attribute__((export_name("TS_InvoiceFeatures_empty"))) TS_InvoiceFeatures_empty() {
37538 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
37539 uint32_t ret_ref = 0;
37540 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37541 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37542 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37543 ret_ref = (uintptr_t)ret_var.inner;
37544 if (ret_var.is_owned) {
37550 uint32_t __attribute__((export_name("TS_InvoiceFeatures_known"))) TS_InvoiceFeatures_known() {
37551 LDKInvoiceFeatures ret_var = InvoiceFeatures_known();
37552 uint32_t ret_ref = 0;
37553 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37554 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37555 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37556 ret_ref = (uintptr_t)ret_var.inner;
37557 if (ret_var.is_owned) {
37563 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_unknown_bits"))) TS_InvoiceFeatures_requires_unknown_bits(uint32_t this_arg) {
37564 LDKInvoiceFeatures this_arg_conv;
37565 this_arg_conv.inner = (void*)(this_arg & (~1));
37566 this_arg_conv.is_owned = false;
37567 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37568 jboolean ret_conv = InvoiceFeatures_requires_unknown_bits(&this_arg_conv);
37572 uint32_t __attribute__((export_name("TS_ChannelTypeFeatures_empty"))) TS_ChannelTypeFeatures_empty() {
37573 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_empty();
37574 uint32_t ret_ref = 0;
37575 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37576 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37577 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37578 ret_ref = (uintptr_t)ret_var.inner;
37579 if (ret_var.is_owned) {
37585 uint32_t __attribute__((export_name("TS_ChannelTypeFeatures_known"))) TS_ChannelTypeFeatures_known() {
37586 LDKChannelTypeFeatures ret_var = ChannelTypeFeatures_known();
37587 uint32_t ret_ref = 0;
37588 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
37589 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
37590 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
37591 ret_ref = (uintptr_t)ret_var.inner;
37592 if (ret_var.is_owned) {
37598 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_unknown_bits"))) TS_ChannelTypeFeatures_requires_unknown_bits(uint32_t this_arg) {
37599 LDKChannelTypeFeatures this_arg_conv;
37600 this_arg_conv.inner = (void*)(this_arg & (~1));
37601 this_arg_conv.is_owned = false;
37602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37603 jboolean ret_conv = ChannelTypeFeatures_requires_unknown_bits(&this_arg_conv);
37607 int8_tArray __attribute__((export_name("TS_InitFeatures_write"))) TS_InitFeatures_write(uint32_t obj) {
37608 LDKInitFeatures obj_conv;
37609 obj_conv.inner = (void*)(obj & (~1));
37610 obj_conv.is_owned = false;
37611 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37612 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
37613 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37614 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37615 CVec_u8Z_free(ret_var);
37619 uint32_t __attribute__((export_name("TS_InitFeatures_read"))) TS_InitFeatures_read(int8_tArray ser) {
37620 LDKu8slice ser_ref;
37621 ser_ref.datalen = ser->arr_len;
37622 ser_ref.data = ser->elems;
37623 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
37624 *ret_conv = InitFeatures_read(ser_ref);
37626 return (uint32_t)ret_conv;
37629 int8_tArray __attribute__((export_name("TS_ChannelFeatures_write"))) TS_ChannelFeatures_write(uint32_t obj) {
37630 LDKChannelFeatures obj_conv;
37631 obj_conv.inner = (void*)(obj & (~1));
37632 obj_conv.is_owned = false;
37633 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37634 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
37635 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37636 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37637 CVec_u8Z_free(ret_var);
37641 uint32_t __attribute__((export_name("TS_ChannelFeatures_read"))) TS_ChannelFeatures_read(int8_tArray ser) {
37642 LDKu8slice ser_ref;
37643 ser_ref.datalen = ser->arr_len;
37644 ser_ref.data = ser->elems;
37645 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
37646 *ret_conv = ChannelFeatures_read(ser_ref);
37648 return (uint32_t)ret_conv;
37651 int8_tArray __attribute__((export_name("TS_NodeFeatures_write"))) TS_NodeFeatures_write(uint32_t obj) {
37652 LDKNodeFeatures obj_conv;
37653 obj_conv.inner = (void*)(obj & (~1));
37654 obj_conv.is_owned = false;
37655 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37656 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
37657 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37658 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37659 CVec_u8Z_free(ret_var);
37663 uint32_t __attribute__((export_name("TS_NodeFeatures_read"))) TS_NodeFeatures_read(int8_tArray ser) {
37664 LDKu8slice ser_ref;
37665 ser_ref.datalen = ser->arr_len;
37666 ser_ref.data = ser->elems;
37667 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
37668 *ret_conv = NodeFeatures_read(ser_ref);
37670 return (uint32_t)ret_conv;
37673 int8_tArray __attribute__((export_name("TS_InvoiceFeatures_write"))) TS_InvoiceFeatures_write(uint32_t obj) {
37674 LDKInvoiceFeatures obj_conv;
37675 obj_conv.inner = (void*)(obj & (~1));
37676 obj_conv.is_owned = false;
37677 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37678 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
37679 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37680 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37681 CVec_u8Z_free(ret_var);
37685 uint32_t __attribute__((export_name("TS_InvoiceFeatures_read"))) TS_InvoiceFeatures_read(int8_tArray ser) {
37686 LDKu8slice ser_ref;
37687 ser_ref.datalen = ser->arr_len;
37688 ser_ref.data = ser->elems;
37689 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
37690 *ret_conv = InvoiceFeatures_read(ser_ref);
37692 return (uint32_t)ret_conv;
37695 int8_tArray __attribute__((export_name("TS_ChannelTypeFeatures_write"))) TS_ChannelTypeFeatures_write(uint32_t obj) {
37696 LDKChannelTypeFeatures obj_conv;
37697 obj_conv.inner = (void*)(obj & (~1));
37698 obj_conv.is_owned = false;
37699 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
37700 LDKCVec_u8Z ret_var = ChannelTypeFeatures_write(&obj_conv);
37701 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
37702 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
37703 CVec_u8Z_free(ret_var);
37707 uint32_t __attribute__((export_name("TS_ChannelTypeFeatures_read"))) TS_ChannelTypeFeatures_read(int8_tArray ser) {
37708 LDKu8slice ser_ref;
37709 ser_ref.datalen = ser->arr_len;
37710 ser_ref.data = ser->elems;
37711 LDKCResult_ChannelTypeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTypeFeaturesDecodeErrorZ), "LDKCResult_ChannelTypeFeaturesDecodeErrorZ");
37712 *ret_conv = ChannelTypeFeatures_read(ser_ref);
37714 return (uint32_t)ret_conv;
37717 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_optional"))) TS_InitFeatures_set_data_loss_protect_optional(uint32_t this_arg) {
37718 LDKInitFeatures this_arg_conv;
37719 this_arg_conv.inner = (void*)(this_arg & (~1));
37720 this_arg_conv.is_owned = false;
37721 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37722 InitFeatures_set_data_loss_protect_optional(&this_arg_conv);
37725 void __attribute__((export_name("TS_InitFeatures_set_data_loss_protect_required"))) TS_InitFeatures_set_data_loss_protect_required(uint32_t this_arg) {
37726 LDKInitFeatures this_arg_conv;
37727 this_arg_conv.inner = (void*)(this_arg & (~1));
37728 this_arg_conv.is_owned = false;
37729 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37730 InitFeatures_set_data_loss_protect_required(&this_arg_conv);
37733 jboolean __attribute__((export_name("TS_InitFeatures_supports_data_loss_protect"))) TS_InitFeatures_supports_data_loss_protect(uint32_t this_arg) {
37734 LDKInitFeatures this_arg_conv;
37735 this_arg_conv.inner = (void*)(this_arg & (~1));
37736 this_arg_conv.is_owned = false;
37737 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37738 jboolean ret_conv = InitFeatures_supports_data_loss_protect(&this_arg_conv);
37742 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_optional"))) TS_NodeFeatures_set_data_loss_protect_optional(uint32_t this_arg) {
37743 LDKNodeFeatures this_arg_conv;
37744 this_arg_conv.inner = (void*)(this_arg & (~1));
37745 this_arg_conv.is_owned = false;
37746 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37747 NodeFeatures_set_data_loss_protect_optional(&this_arg_conv);
37750 void __attribute__((export_name("TS_NodeFeatures_set_data_loss_protect_required"))) TS_NodeFeatures_set_data_loss_protect_required(uint32_t this_arg) {
37751 LDKNodeFeatures this_arg_conv;
37752 this_arg_conv.inner = (void*)(this_arg & (~1));
37753 this_arg_conv.is_owned = false;
37754 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37755 NodeFeatures_set_data_loss_protect_required(&this_arg_conv);
37758 jboolean __attribute__((export_name("TS_NodeFeatures_supports_data_loss_protect"))) TS_NodeFeatures_supports_data_loss_protect(uint32_t this_arg) {
37759 LDKNodeFeatures this_arg_conv;
37760 this_arg_conv.inner = (void*)(this_arg & (~1));
37761 this_arg_conv.is_owned = false;
37762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37763 jboolean ret_conv = NodeFeatures_supports_data_loss_protect(&this_arg_conv);
37767 jboolean __attribute__((export_name("TS_InitFeatures_requires_data_loss_protect"))) TS_InitFeatures_requires_data_loss_protect(uint32_t this_arg) {
37768 LDKInitFeatures this_arg_conv;
37769 this_arg_conv.inner = (void*)(this_arg & (~1));
37770 this_arg_conv.is_owned = false;
37771 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37772 jboolean ret_conv = InitFeatures_requires_data_loss_protect(&this_arg_conv);
37776 jboolean __attribute__((export_name("TS_NodeFeatures_requires_data_loss_protect"))) TS_NodeFeatures_requires_data_loss_protect(uint32_t this_arg) {
37777 LDKNodeFeatures this_arg_conv;
37778 this_arg_conv.inner = (void*)(this_arg & (~1));
37779 this_arg_conv.is_owned = false;
37780 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37781 jboolean ret_conv = NodeFeatures_requires_data_loss_protect(&this_arg_conv);
37785 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_optional"))) TS_InitFeatures_set_initial_routing_sync_optional(uint32_t this_arg) {
37786 LDKInitFeatures this_arg_conv;
37787 this_arg_conv.inner = (void*)(this_arg & (~1));
37788 this_arg_conv.is_owned = false;
37789 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37790 InitFeatures_set_initial_routing_sync_optional(&this_arg_conv);
37793 void __attribute__((export_name("TS_InitFeatures_set_initial_routing_sync_required"))) TS_InitFeatures_set_initial_routing_sync_required(uint32_t this_arg) {
37794 LDKInitFeatures this_arg_conv;
37795 this_arg_conv.inner = (void*)(this_arg & (~1));
37796 this_arg_conv.is_owned = false;
37797 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37798 InitFeatures_set_initial_routing_sync_required(&this_arg_conv);
37801 jboolean __attribute__((export_name("TS_InitFeatures_initial_routing_sync"))) TS_InitFeatures_initial_routing_sync(uint32_t this_arg) {
37802 LDKInitFeatures this_arg_conv;
37803 this_arg_conv.inner = (void*)(this_arg & (~1));
37804 this_arg_conv.is_owned = false;
37805 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37806 jboolean ret_conv = InitFeatures_initial_routing_sync(&this_arg_conv);
37810 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_optional"))) TS_InitFeatures_set_upfront_shutdown_script_optional(uint32_t this_arg) {
37811 LDKInitFeatures this_arg_conv;
37812 this_arg_conv.inner = (void*)(this_arg & (~1));
37813 this_arg_conv.is_owned = false;
37814 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37815 InitFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
37818 void __attribute__((export_name("TS_InitFeatures_set_upfront_shutdown_script_required"))) TS_InitFeatures_set_upfront_shutdown_script_required(uint32_t this_arg) {
37819 LDKInitFeatures this_arg_conv;
37820 this_arg_conv.inner = (void*)(this_arg & (~1));
37821 this_arg_conv.is_owned = false;
37822 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37823 InitFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
37826 jboolean __attribute__((export_name("TS_InitFeatures_supports_upfront_shutdown_script"))) TS_InitFeatures_supports_upfront_shutdown_script(uint32_t this_arg) {
37827 LDKInitFeatures this_arg_conv;
37828 this_arg_conv.inner = (void*)(this_arg & (~1));
37829 this_arg_conv.is_owned = false;
37830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37831 jboolean ret_conv = InitFeatures_supports_upfront_shutdown_script(&this_arg_conv);
37835 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_optional"))) TS_NodeFeatures_set_upfront_shutdown_script_optional(uint32_t this_arg) {
37836 LDKNodeFeatures this_arg_conv;
37837 this_arg_conv.inner = (void*)(this_arg & (~1));
37838 this_arg_conv.is_owned = false;
37839 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37840 NodeFeatures_set_upfront_shutdown_script_optional(&this_arg_conv);
37843 void __attribute__((export_name("TS_NodeFeatures_set_upfront_shutdown_script_required"))) TS_NodeFeatures_set_upfront_shutdown_script_required(uint32_t this_arg) {
37844 LDKNodeFeatures this_arg_conv;
37845 this_arg_conv.inner = (void*)(this_arg & (~1));
37846 this_arg_conv.is_owned = false;
37847 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37848 NodeFeatures_set_upfront_shutdown_script_required(&this_arg_conv);
37851 jboolean __attribute__((export_name("TS_NodeFeatures_supports_upfront_shutdown_script"))) TS_NodeFeatures_supports_upfront_shutdown_script(uint32_t this_arg) {
37852 LDKNodeFeatures this_arg_conv;
37853 this_arg_conv.inner = (void*)(this_arg & (~1));
37854 this_arg_conv.is_owned = false;
37855 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37856 jboolean ret_conv = NodeFeatures_supports_upfront_shutdown_script(&this_arg_conv);
37860 jboolean __attribute__((export_name("TS_InitFeatures_requires_upfront_shutdown_script"))) TS_InitFeatures_requires_upfront_shutdown_script(uint32_t this_arg) {
37861 LDKInitFeatures this_arg_conv;
37862 this_arg_conv.inner = (void*)(this_arg & (~1));
37863 this_arg_conv.is_owned = false;
37864 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37865 jboolean ret_conv = InitFeatures_requires_upfront_shutdown_script(&this_arg_conv);
37869 jboolean __attribute__((export_name("TS_NodeFeatures_requires_upfront_shutdown_script"))) TS_NodeFeatures_requires_upfront_shutdown_script(uint32_t this_arg) {
37870 LDKNodeFeatures this_arg_conv;
37871 this_arg_conv.inner = (void*)(this_arg & (~1));
37872 this_arg_conv.is_owned = false;
37873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37874 jboolean ret_conv = NodeFeatures_requires_upfront_shutdown_script(&this_arg_conv);
37878 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_optional"))) TS_InitFeatures_set_gossip_queries_optional(uint32_t this_arg) {
37879 LDKInitFeatures this_arg_conv;
37880 this_arg_conv.inner = (void*)(this_arg & (~1));
37881 this_arg_conv.is_owned = false;
37882 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37883 InitFeatures_set_gossip_queries_optional(&this_arg_conv);
37886 void __attribute__((export_name("TS_InitFeatures_set_gossip_queries_required"))) TS_InitFeatures_set_gossip_queries_required(uint32_t this_arg) {
37887 LDKInitFeatures this_arg_conv;
37888 this_arg_conv.inner = (void*)(this_arg & (~1));
37889 this_arg_conv.is_owned = false;
37890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37891 InitFeatures_set_gossip_queries_required(&this_arg_conv);
37894 jboolean __attribute__((export_name("TS_InitFeatures_supports_gossip_queries"))) TS_InitFeatures_supports_gossip_queries(uint32_t this_arg) {
37895 LDKInitFeatures this_arg_conv;
37896 this_arg_conv.inner = (void*)(this_arg & (~1));
37897 this_arg_conv.is_owned = false;
37898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37899 jboolean ret_conv = InitFeatures_supports_gossip_queries(&this_arg_conv);
37903 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_optional"))) TS_NodeFeatures_set_gossip_queries_optional(uint32_t this_arg) {
37904 LDKNodeFeatures this_arg_conv;
37905 this_arg_conv.inner = (void*)(this_arg & (~1));
37906 this_arg_conv.is_owned = false;
37907 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37908 NodeFeatures_set_gossip_queries_optional(&this_arg_conv);
37911 void __attribute__((export_name("TS_NodeFeatures_set_gossip_queries_required"))) TS_NodeFeatures_set_gossip_queries_required(uint32_t this_arg) {
37912 LDKNodeFeatures this_arg_conv;
37913 this_arg_conv.inner = (void*)(this_arg & (~1));
37914 this_arg_conv.is_owned = false;
37915 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37916 NodeFeatures_set_gossip_queries_required(&this_arg_conv);
37919 jboolean __attribute__((export_name("TS_NodeFeatures_supports_gossip_queries"))) TS_NodeFeatures_supports_gossip_queries(uint32_t this_arg) {
37920 LDKNodeFeatures this_arg_conv;
37921 this_arg_conv.inner = (void*)(this_arg & (~1));
37922 this_arg_conv.is_owned = false;
37923 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37924 jboolean ret_conv = NodeFeatures_supports_gossip_queries(&this_arg_conv);
37928 jboolean __attribute__((export_name("TS_InitFeatures_requires_gossip_queries"))) TS_InitFeatures_requires_gossip_queries(uint32_t this_arg) {
37929 LDKInitFeatures this_arg_conv;
37930 this_arg_conv.inner = (void*)(this_arg & (~1));
37931 this_arg_conv.is_owned = false;
37932 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37933 jboolean ret_conv = InitFeatures_requires_gossip_queries(&this_arg_conv);
37937 jboolean __attribute__((export_name("TS_NodeFeatures_requires_gossip_queries"))) TS_NodeFeatures_requires_gossip_queries(uint32_t this_arg) {
37938 LDKNodeFeatures this_arg_conv;
37939 this_arg_conv.inner = (void*)(this_arg & (~1));
37940 this_arg_conv.is_owned = false;
37941 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37942 jboolean ret_conv = NodeFeatures_requires_gossip_queries(&this_arg_conv);
37946 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_optional"))) TS_InitFeatures_set_variable_length_onion_optional(uint32_t this_arg) {
37947 LDKInitFeatures this_arg_conv;
37948 this_arg_conv.inner = (void*)(this_arg & (~1));
37949 this_arg_conv.is_owned = false;
37950 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37951 InitFeatures_set_variable_length_onion_optional(&this_arg_conv);
37954 void __attribute__((export_name("TS_InitFeatures_set_variable_length_onion_required"))) TS_InitFeatures_set_variable_length_onion_required(uint32_t this_arg) {
37955 LDKInitFeatures this_arg_conv;
37956 this_arg_conv.inner = (void*)(this_arg & (~1));
37957 this_arg_conv.is_owned = false;
37958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37959 InitFeatures_set_variable_length_onion_required(&this_arg_conv);
37962 jboolean __attribute__((export_name("TS_InitFeatures_supports_variable_length_onion"))) TS_InitFeatures_supports_variable_length_onion(uint32_t this_arg) {
37963 LDKInitFeatures this_arg_conv;
37964 this_arg_conv.inner = (void*)(this_arg & (~1));
37965 this_arg_conv.is_owned = false;
37966 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37967 jboolean ret_conv = InitFeatures_supports_variable_length_onion(&this_arg_conv);
37971 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_optional"))) TS_NodeFeatures_set_variable_length_onion_optional(uint32_t this_arg) {
37972 LDKNodeFeatures this_arg_conv;
37973 this_arg_conv.inner = (void*)(this_arg & (~1));
37974 this_arg_conv.is_owned = false;
37975 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37976 NodeFeatures_set_variable_length_onion_optional(&this_arg_conv);
37979 void __attribute__((export_name("TS_NodeFeatures_set_variable_length_onion_required"))) TS_NodeFeatures_set_variable_length_onion_required(uint32_t this_arg) {
37980 LDKNodeFeatures this_arg_conv;
37981 this_arg_conv.inner = (void*)(this_arg & (~1));
37982 this_arg_conv.is_owned = false;
37983 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37984 NodeFeatures_set_variable_length_onion_required(&this_arg_conv);
37987 jboolean __attribute__((export_name("TS_NodeFeatures_supports_variable_length_onion"))) TS_NodeFeatures_supports_variable_length_onion(uint32_t this_arg) {
37988 LDKNodeFeatures this_arg_conv;
37989 this_arg_conv.inner = (void*)(this_arg & (~1));
37990 this_arg_conv.is_owned = false;
37991 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
37992 jboolean ret_conv = NodeFeatures_supports_variable_length_onion(&this_arg_conv);
37996 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_optional"))) TS_InvoiceFeatures_set_variable_length_onion_optional(uint32_t this_arg) {
37997 LDKInvoiceFeatures this_arg_conv;
37998 this_arg_conv.inner = (void*)(this_arg & (~1));
37999 this_arg_conv.is_owned = false;
38000 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38001 InvoiceFeatures_set_variable_length_onion_optional(&this_arg_conv);
38004 void __attribute__((export_name("TS_InvoiceFeatures_set_variable_length_onion_required"))) TS_InvoiceFeatures_set_variable_length_onion_required(uint32_t this_arg) {
38005 LDKInvoiceFeatures this_arg_conv;
38006 this_arg_conv.inner = (void*)(this_arg & (~1));
38007 this_arg_conv.is_owned = false;
38008 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38009 InvoiceFeatures_set_variable_length_onion_required(&this_arg_conv);
38012 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_variable_length_onion"))) TS_InvoiceFeatures_supports_variable_length_onion(uint32_t this_arg) {
38013 LDKInvoiceFeatures this_arg_conv;
38014 this_arg_conv.inner = (void*)(this_arg & (~1));
38015 this_arg_conv.is_owned = false;
38016 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38017 jboolean ret_conv = InvoiceFeatures_supports_variable_length_onion(&this_arg_conv);
38021 jboolean __attribute__((export_name("TS_InitFeatures_requires_variable_length_onion"))) TS_InitFeatures_requires_variable_length_onion(uint32_t this_arg) {
38022 LDKInitFeatures this_arg_conv;
38023 this_arg_conv.inner = (void*)(this_arg & (~1));
38024 this_arg_conv.is_owned = false;
38025 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38026 jboolean ret_conv = InitFeatures_requires_variable_length_onion(&this_arg_conv);
38030 jboolean __attribute__((export_name("TS_NodeFeatures_requires_variable_length_onion"))) TS_NodeFeatures_requires_variable_length_onion(uint32_t this_arg) {
38031 LDKNodeFeatures this_arg_conv;
38032 this_arg_conv.inner = (void*)(this_arg & (~1));
38033 this_arg_conv.is_owned = false;
38034 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38035 jboolean ret_conv = NodeFeatures_requires_variable_length_onion(&this_arg_conv);
38039 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_variable_length_onion"))) TS_InvoiceFeatures_requires_variable_length_onion(uint32_t this_arg) {
38040 LDKInvoiceFeatures this_arg_conv;
38041 this_arg_conv.inner = (void*)(this_arg & (~1));
38042 this_arg_conv.is_owned = false;
38043 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38044 jboolean ret_conv = InvoiceFeatures_requires_variable_length_onion(&this_arg_conv);
38048 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_optional"))) TS_InitFeatures_set_static_remote_key_optional(uint32_t this_arg) {
38049 LDKInitFeatures this_arg_conv;
38050 this_arg_conv.inner = (void*)(this_arg & (~1));
38051 this_arg_conv.is_owned = false;
38052 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38053 InitFeatures_set_static_remote_key_optional(&this_arg_conv);
38056 void __attribute__((export_name("TS_InitFeatures_set_static_remote_key_required"))) TS_InitFeatures_set_static_remote_key_required(uint32_t this_arg) {
38057 LDKInitFeatures this_arg_conv;
38058 this_arg_conv.inner = (void*)(this_arg & (~1));
38059 this_arg_conv.is_owned = false;
38060 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38061 InitFeatures_set_static_remote_key_required(&this_arg_conv);
38064 jboolean __attribute__((export_name("TS_InitFeatures_supports_static_remote_key"))) TS_InitFeatures_supports_static_remote_key(uint32_t this_arg) {
38065 LDKInitFeatures this_arg_conv;
38066 this_arg_conv.inner = (void*)(this_arg & (~1));
38067 this_arg_conv.is_owned = false;
38068 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38069 jboolean ret_conv = InitFeatures_supports_static_remote_key(&this_arg_conv);
38073 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_optional"))) TS_NodeFeatures_set_static_remote_key_optional(uint32_t this_arg) {
38074 LDKNodeFeatures this_arg_conv;
38075 this_arg_conv.inner = (void*)(this_arg & (~1));
38076 this_arg_conv.is_owned = false;
38077 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38078 NodeFeatures_set_static_remote_key_optional(&this_arg_conv);
38081 void __attribute__((export_name("TS_NodeFeatures_set_static_remote_key_required"))) TS_NodeFeatures_set_static_remote_key_required(uint32_t this_arg) {
38082 LDKNodeFeatures this_arg_conv;
38083 this_arg_conv.inner = (void*)(this_arg & (~1));
38084 this_arg_conv.is_owned = false;
38085 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38086 NodeFeatures_set_static_remote_key_required(&this_arg_conv);
38089 jboolean __attribute__((export_name("TS_NodeFeatures_supports_static_remote_key"))) TS_NodeFeatures_supports_static_remote_key(uint32_t this_arg) {
38090 LDKNodeFeatures this_arg_conv;
38091 this_arg_conv.inner = (void*)(this_arg & (~1));
38092 this_arg_conv.is_owned = false;
38093 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38094 jboolean ret_conv = NodeFeatures_supports_static_remote_key(&this_arg_conv);
38098 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_optional"))) TS_ChannelTypeFeatures_set_static_remote_key_optional(uint32_t this_arg) {
38099 LDKChannelTypeFeatures this_arg_conv;
38100 this_arg_conv.inner = (void*)(this_arg & (~1));
38101 this_arg_conv.is_owned = false;
38102 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38103 ChannelTypeFeatures_set_static_remote_key_optional(&this_arg_conv);
38106 void __attribute__((export_name("TS_ChannelTypeFeatures_set_static_remote_key_required"))) TS_ChannelTypeFeatures_set_static_remote_key_required(uint32_t this_arg) {
38107 LDKChannelTypeFeatures this_arg_conv;
38108 this_arg_conv.inner = (void*)(this_arg & (~1));
38109 this_arg_conv.is_owned = false;
38110 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38111 ChannelTypeFeatures_set_static_remote_key_required(&this_arg_conv);
38114 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_static_remote_key"))) TS_ChannelTypeFeatures_supports_static_remote_key(uint32_t this_arg) {
38115 LDKChannelTypeFeatures this_arg_conv;
38116 this_arg_conv.inner = (void*)(this_arg & (~1));
38117 this_arg_conv.is_owned = false;
38118 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38119 jboolean ret_conv = ChannelTypeFeatures_supports_static_remote_key(&this_arg_conv);
38123 jboolean __attribute__((export_name("TS_InitFeatures_requires_static_remote_key"))) TS_InitFeatures_requires_static_remote_key(uint32_t this_arg) {
38124 LDKInitFeatures this_arg_conv;
38125 this_arg_conv.inner = (void*)(this_arg & (~1));
38126 this_arg_conv.is_owned = false;
38127 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38128 jboolean ret_conv = InitFeatures_requires_static_remote_key(&this_arg_conv);
38132 jboolean __attribute__((export_name("TS_NodeFeatures_requires_static_remote_key"))) TS_NodeFeatures_requires_static_remote_key(uint32_t this_arg) {
38133 LDKNodeFeatures this_arg_conv;
38134 this_arg_conv.inner = (void*)(this_arg & (~1));
38135 this_arg_conv.is_owned = false;
38136 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38137 jboolean ret_conv = NodeFeatures_requires_static_remote_key(&this_arg_conv);
38141 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_static_remote_key"))) TS_ChannelTypeFeatures_requires_static_remote_key(uint32_t this_arg) {
38142 LDKChannelTypeFeatures this_arg_conv;
38143 this_arg_conv.inner = (void*)(this_arg & (~1));
38144 this_arg_conv.is_owned = false;
38145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38146 jboolean ret_conv = ChannelTypeFeatures_requires_static_remote_key(&this_arg_conv);
38150 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_optional"))) TS_InitFeatures_set_payment_secret_optional(uint32_t this_arg) {
38151 LDKInitFeatures this_arg_conv;
38152 this_arg_conv.inner = (void*)(this_arg & (~1));
38153 this_arg_conv.is_owned = false;
38154 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38155 InitFeatures_set_payment_secret_optional(&this_arg_conv);
38158 void __attribute__((export_name("TS_InitFeatures_set_payment_secret_required"))) TS_InitFeatures_set_payment_secret_required(uint32_t this_arg) {
38159 LDKInitFeatures this_arg_conv;
38160 this_arg_conv.inner = (void*)(this_arg & (~1));
38161 this_arg_conv.is_owned = false;
38162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38163 InitFeatures_set_payment_secret_required(&this_arg_conv);
38166 jboolean __attribute__((export_name("TS_InitFeatures_supports_payment_secret"))) TS_InitFeatures_supports_payment_secret(uint32_t this_arg) {
38167 LDKInitFeatures this_arg_conv;
38168 this_arg_conv.inner = (void*)(this_arg & (~1));
38169 this_arg_conv.is_owned = false;
38170 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38171 jboolean ret_conv = InitFeatures_supports_payment_secret(&this_arg_conv);
38175 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_optional"))) TS_NodeFeatures_set_payment_secret_optional(uint32_t this_arg) {
38176 LDKNodeFeatures this_arg_conv;
38177 this_arg_conv.inner = (void*)(this_arg & (~1));
38178 this_arg_conv.is_owned = false;
38179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38180 NodeFeatures_set_payment_secret_optional(&this_arg_conv);
38183 void __attribute__((export_name("TS_NodeFeatures_set_payment_secret_required"))) TS_NodeFeatures_set_payment_secret_required(uint32_t this_arg) {
38184 LDKNodeFeatures this_arg_conv;
38185 this_arg_conv.inner = (void*)(this_arg & (~1));
38186 this_arg_conv.is_owned = false;
38187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38188 NodeFeatures_set_payment_secret_required(&this_arg_conv);
38191 jboolean __attribute__((export_name("TS_NodeFeatures_supports_payment_secret"))) TS_NodeFeatures_supports_payment_secret(uint32_t this_arg) {
38192 LDKNodeFeatures this_arg_conv;
38193 this_arg_conv.inner = (void*)(this_arg & (~1));
38194 this_arg_conv.is_owned = false;
38195 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38196 jboolean ret_conv = NodeFeatures_supports_payment_secret(&this_arg_conv);
38200 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_optional"))) TS_InvoiceFeatures_set_payment_secret_optional(uint32_t this_arg) {
38201 LDKInvoiceFeatures this_arg_conv;
38202 this_arg_conv.inner = (void*)(this_arg & (~1));
38203 this_arg_conv.is_owned = false;
38204 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38205 InvoiceFeatures_set_payment_secret_optional(&this_arg_conv);
38208 void __attribute__((export_name("TS_InvoiceFeatures_set_payment_secret_required"))) TS_InvoiceFeatures_set_payment_secret_required(uint32_t this_arg) {
38209 LDKInvoiceFeatures this_arg_conv;
38210 this_arg_conv.inner = (void*)(this_arg & (~1));
38211 this_arg_conv.is_owned = false;
38212 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38213 InvoiceFeatures_set_payment_secret_required(&this_arg_conv);
38216 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_payment_secret"))) TS_InvoiceFeatures_supports_payment_secret(uint32_t this_arg) {
38217 LDKInvoiceFeatures this_arg_conv;
38218 this_arg_conv.inner = (void*)(this_arg & (~1));
38219 this_arg_conv.is_owned = false;
38220 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38221 jboolean ret_conv = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
38225 jboolean __attribute__((export_name("TS_InitFeatures_requires_payment_secret"))) TS_InitFeatures_requires_payment_secret(uint32_t this_arg) {
38226 LDKInitFeatures this_arg_conv;
38227 this_arg_conv.inner = (void*)(this_arg & (~1));
38228 this_arg_conv.is_owned = false;
38229 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38230 jboolean ret_conv = InitFeatures_requires_payment_secret(&this_arg_conv);
38234 jboolean __attribute__((export_name("TS_NodeFeatures_requires_payment_secret"))) TS_NodeFeatures_requires_payment_secret(uint32_t this_arg) {
38235 LDKNodeFeatures this_arg_conv;
38236 this_arg_conv.inner = (void*)(this_arg & (~1));
38237 this_arg_conv.is_owned = false;
38238 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38239 jboolean ret_conv = NodeFeatures_requires_payment_secret(&this_arg_conv);
38243 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_payment_secret"))) TS_InvoiceFeatures_requires_payment_secret(uint32_t this_arg) {
38244 LDKInvoiceFeatures this_arg_conv;
38245 this_arg_conv.inner = (void*)(this_arg & (~1));
38246 this_arg_conv.is_owned = false;
38247 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38248 jboolean ret_conv = InvoiceFeatures_requires_payment_secret(&this_arg_conv);
38252 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_optional"))) TS_InitFeatures_set_basic_mpp_optional(uint32_t this_arg) {
38253 LDKInitFeatures this_arg_conv;
38254 this_arg_conv.inner = (void*)(this_arg & (~1));
38255 this_arg_conv.is_owned = false;
38256 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38257 InitFeatures_set_basic_mpp_optional(&this_arg_conv);
38260 void __attribute__((export_name("TS_InitFeatures_set_basic_mpp_required"))) TS_InitFeatures_set_basic_mpp_required(uint32_t this_arg) {
38261 LDKInitFeatures this_arg_conv;
38262 this_arg_conv.inner = (void*)(this_arg & (~1));
38263 this_arg_conv.is_owned = false;
38264 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38265 InitFeatures_set_basic_mpp_required(&this_arg_conv);
38268 jboolean __attribute__((export_name("TS_InitFeatures_supports_basic_mpp"))) TS_InitFeatures_supports_basic_mpp(uint32_t this_arg) {
38269 LDKInitFeatures this_arg_conv;
38270 this_arg_conv.inner = (void*)(this_arg & (~1));
38271 this_arg_conv.is_owned = false;
38272 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38273 jboolean ret_conv = InitFeatures_supports_basic_mpp(&this_arg_conv);
38277 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_optional"))) TS_NodeFeatures_set_basic_mpp_optional(uint32_t this_arg) {
38278 LDKNodeFeatures this_arg_conv;
38279 this_arg_conv.inner = (void*)(this_arg & (~1));
38280 this_arg_conv.is_owned = false;
38281 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38282 NodeFeatures_set_basic_mpp_optional(&this_arg_conv);
38285 void __attribute__((export_name("TS_NodeFeatures_set_basic_mpp_required"))) TS_NodeFeatures_set_basic_mpp_required(uint32_t this_arg) {
38286 LDKNodeFeatures this_arg_conv;
38287 this_arg_conv.inner = (void*)(this_arg & (~1));
38288 this_arg_conv.is_owned = false;
38289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38290 NodeFeatures_set_basic_mpp_required(&this_arg_conv);
38293 jboolean __attribute__((export_name("TS_NodeFeatures_supports_basic_mpp"))) TS_NodeFeatures_supports_basic_mpp(uint32_t this_arg) {
38294 LDKNodeFeatures this_arg_conv;
38295 this_arg_conv.inner = (void*)(this_arg & (~1));
38296 this_arg_conv.is_owned = false;
38297 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38298 jboolean ret_conv = NodeFeatures_supports_basic_mpp(&this_arg_conv);
38302 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_optional"))) TS_InvoiceFeatures_set_basic_mpp_optional(uint32_t this_arg) {
38303 LDKInvoiceFeatures this_arg_conv;
38304 this_arg_conv.inner = (void*)(this_arg & (~1));
38305 this_arg_conv.is_owned = false;
38306 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38307 InvoiceFeatures_set_basic_mpp_optional(&this_arg_conv);
38310 void __attribute__((export_name("TS_InvoiceFeatures_set_basic_mpp_required"))) TS_InvoiceFeatures_set_basic_mpp_required(uint32_t this_arg) {
38311 LDKInvoiceFeatures this_arg_conv;
38312 this_arg_conv.inner = (void*)(this_arg & (~1));
38313 this_arg_conv.is_owned = false;
38314 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38315 InvoiceFeatures_set_basic_mpp_required(&this_arg_conv);
38318 jboolean __attribute__((export_name("TS_InvoiceFeatures_supports_basic_mpp"))) TS_InvoiceFeatures_supports_basic_mpp(uint32_t this_arg) {
38319 LDKInvoiceFeatures this_arg_conv;
38320 this_arg_conv.inner = (void*)(this_arg & (~1));
38321 this_arg_conv.is_owned = false;
38322 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38323 jboolean ret_conv = InvoiceFeatures_supports_basic_mpp(&this_arg_conv);
38327 jboolean __attribute__((export_name("TS_InitFeatures_requires_basic_mpp"))) TS_InitFeatures_requires_basic_mpp(uint32_t this_arg) {
38328 LDKInitFeatures this_arg_conv;
38329 this_arg_conv.inner = (void*)(this_arg & (~1));
38330 this_arg_conv.is_owned = false;
38331 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38332 jboolean ret_conv = InitFeatures_requires_basic_mpp(&this_arg_conv);
38336 jboolean __attribute__((export_name("TS_NodeFeatures_requires_basic_mpp"))) TS_NodeFeatures_requires_basic_mpp(uint32_t this_arg) {
38337 LDKNodeFeatures this_arg_conv;
38338 this_arg_conv.inner = (void*)(this_arg & (~1));
38339 this_arg_conv.is_owned = false;
38340 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38341 jboolean ret_conv = NodeFeatures_requires_basic_mpp(&this_arg_conv);
38345 jboolean __attribute__((export_name("TS_InvoiceFeatures_requires_basic_mpp"))) TS_InvoiceFeatures_requires_basic_mpp(uint32_t this_arg) {
38346 LDKInvoiceFeatures this_arg_conv;
38347 this_arg_conv.inner = (void*)(this_arg & (~1));
38348 this_arg_conv.is_owned = false;
38349 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38350 jboolean ret_conv = InvoiceFeatures_requires_basic_mpp(&this_arg_conv);
38354 void __attribute__((export_name("TS_InitFeatures_set_wumbo_optional"))) TS_InitFeatures_set_wumbo_optional(uint32_t this_arg) {
38355 LDKInitFeatures this_arg_conv;
38356 this_arg_conv.inner = (void*)(this_arg & (~1));
38357 this_arg_conv.is_owned = false;
38358 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38359 InitFeatures_set_wumbo_optional(&this_arg_conv);
38362 void __attribute__((export_name("TS_InitFeatures_set_wumbo_required"))) TS_InitFeatures_set_wumbo_required(uint32_t this_arg) {
38363 LDKInitFeatures this_arg_conv;
38364 this_arg_conv.inner = (void*)(this_arg & (~1));
38365 this_arg_conv.is_owned = false;
38366 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38367 InitFeatures_set_wumbo_required(&this_arg_conv);
38370 jboolean __attribute__((export_name("TS_InitFeatures_supports_wumbo"))) TS_InitFeatures_supports_wumbo(uint32_t this_arg) {
38371 LDKInitFeatures this_arg_conv;
38372 this_arg_conv.inner = (void*)(this_arg & (~1));
38373 this_arg_conv.is_owned = false;
38374 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38375 jboolean ret_conv = InitFeatures_supports_wumbo(&this_arg_conv);
38379 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_optional"))) TS_NodeFeatures_set_wumbo_optional(uint32_t this_arg) {
38380 LDKNodeFeatures this_arg_conv;
38381 this_arg_conv.inner = (void*)(this_arg & (~1));
38382 this_arg_conv.is_owned = false;
38383 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38384 NodeFeatures_set_wumbo_optional(&this_arg_conv);
38387 void __attribute__((export_name("TS_NodeFeatures_set_wumbo_required"))) TS_NodeFeatures_set_wumbo_required(uint32_t this_arg) {
38388 LDKNodeFeatures this_arg_conv;
38389 this_arg_conv.inner = (void*)(this_arg & (~1));
38390 this_arg_conv.is_owned = false;
38391 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38392 NodeFeatures_set_wumbo_required(&this_arg_conv);
38395 jboolean __attribute__((export_name("TS_NodeFeatures_supports_wumbo"))) TS_NodeFeatures_supports_wumbo(uint32_t this_arg) {
38396 LDKNodeFeatures this_arg_conv;
38397 this_arg_conv.inner = (void*)(this_arg & (~1));
38398 this_arg_conv.is_owned = false;
38399 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38400 jboolean ret_conv = NodeFeatures_supports_wumbo(&this_arg_conv);
38404 jboolean __attribute__((export_name("TS_InitFeatures_requires_wumbo"))) TS_InitFeatures_requires_wumbo(uint32_t this_arg) {
38405 LDKInitFeatures this_arg_conv;
38406 this_arg_conv.inner = (void*)(this_arg & (~1));
38407 this_arg_conv.is_owned = false;
38408 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38409 jboolean ret_conv = InitFeatures_requires_wumbo(&this_arg_conv);
38413 jboolean __attribute__((export_name("TS_NodeFeatures_requires_wumbo"))) TS_NodeFeatures_requires_wumbo(uint32_t this_arg) {
38414 LDKNodeFeatures this_arg_conv;
38415 this_arg_conv.inner = (void*)(this_arg & (~1));
38416 this_arg_conv.is_owned = false;
38417 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38418 jboolean ret_conv = NodeFeatures_requires_wumbo(&this_arg_conv);
38422 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_optional"))) TS_InitFeatures_set_shutdown_any_segwit_optional(uint32_t this_arg) {
38423 LDKInitFeatures this_arg_conv;
38424 this_arg_conv.inner = (void*)(this_arg & (~1));
38425 this_arg_conv.is_owned = false;
38426 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38427 InitFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
38430 void __attribute__((export_name("TS_InitFeatures_set_shutdown_any_segwit_required"))) TS_InitFeatures_set_shutdown_any_segwit_required(uint32_t this_arg) {
38431 LDKInitFeatures this_arg_conv;
38432 this_arg_conv.inner = (void*)(this_arg & (~1));
38433 this_arg_conv.is_owned = false;
38434 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38435 InitFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
38438 jboolean __attribute__((export_name("TS_InitFeatures_supports_shutdown_anysegwit"))) TS_InitFeatures_supports_shutdown_anysegwit(uint32_t this_arg) {
38439 LDKInitFeatures this_arg_conv;
38440 this_arg_conv.inner = (void*)(this_arg & (~1));
38441 this_arg_conv.is_owned = false;
38442 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38443 jboolean ret_conv = InitFeatures_supports_shutdown_anysegwit(&this_arg_conv);
38447 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_optional"))) TS_NodeFeatures_set_shutdown_any_segwit_optional(uint32_t this_arg) {
38448 LDKNodeFeatures this_arg_conv;
38449 this_arg_conv.inner = (void*)(this_arg & (~1));
38450 this_arg_conv.is_owned = false;
38451 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38452 NodeFeatures_set_shutdown_any_segwit_optional(&this_arg_conv);
38455 void __attribute__((export_name("TS_NodeFeatures_set_shutdown_any_segwit_required"))) TS_NodeFeatures_set_shutdown_any_segwit_required(uint32_t this_arg) {
38456 LDKNodeFeatures this_arg_conv;
38457 this_arg_conv.inner = (void*)(this_arg & (~1));
38458 this_arg_conv.is_owned = false;
38459 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38460 NodeFeatures_set_shutdown_any_segwit_required(&this_arg_conv);
38463 jboolean __attribute__((export_name("TS_NodeFeatures_supports_shutdown_anysegwit"))) TS_NodeFeatures_supports_shutdown_anysegwit(uint32_t this_arg) {
38464 LDKNodeFeatures this_arg_conv;
38465 this_arg_conv.inner = (void*)(this_arg & (~1));
38466 this_arg_conv.is_owned = false;
38467 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38468 jboolean ret_conv = NodeFeatures_supports_shutdown_anysegwit(&this_arg_conv);
38472 jboolean __attribute__((export_name("TS_InitFeatures_requires_shutdown_anysegwit"))) TS_InitFeatures_requires_shutdown_anysegwit(uint32_t this_arg) {
38473 LDKInitFeatures this_arg_conv;
38474 this_arg_conv.inner = (void*)(this_arg & (~1));
38475 this_arg_conv.is_owned = false;
38476 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38477 jboolean ret_conv = InitFeatures_requires_shutdown_anysegwit(&this_arg_conv);
38481 jboolean __attribute__((export_name("TS_NodeFeatures_requires_shutdown_anysegwit"))) TS_NodeFeatures_requires_shutdown_anysegwit(uint32_t this_arg) {
38482 LDKNodeFeatures this_arg_conv;
38483 this_arg_conv.inner = (void*)(this_arg & (~1));
38484 this_arg_conv.is_owned = false;
38485 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38486 jboolean ret_conv = NodeFeatures_requires_shutdown_anysegwit(&this_arg_conv);
38490 void __attribute__((export_name("TS_InitFeatures_set_channel_type_optional"))) TS_InitFeatures_set_channel_type_optional(uint32_t this_arg) {
38491 LDKInitFeatures this_arg_conv;
38492 this_arg_conv.inner = (void*)(this_arg & (~1));
38493 this_arg_conv.is_owned = false;
38494 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38495 InitFeatures_set_channel_type_optional(&this_arg_conv);
38498 void __attribute__((export_name("TS_InitFeatures_set_channel_type_required"))) TS_InitFeatures_set_channel_type_required(uint32_t this_arg) {
38499 LDKInitFeatures this_arg_conv;
38500 this_arg_conv.inner = (void*)(this_arg & (~1));
38501 this_arg_conv.is_owned = false;
38502 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38503 InitFeatures_set_channel_type_required(&this_arg_conv);
38506 jboolean __attribute__((export_name("TS_InitFeatures_supports_channel_type"))) TS_InitFeatures_supports_channel_type(uint32_t this_arg) {
38507 LDKInitFeatures this_arg_conv;
38508 this_arg_conv.inner = (void*)(this_arg & (~1));
38509 this_arg_conv.is_owned = false;
38510 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38511 jboolean ret_conv = InitFeatures_supports_channel_type(&this_arg_conv);
38515 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_optional"))) TS_NodeFeatures_set_channel_type_optional(uint32_t this_arg) {
38516 LDKNodeFeatures this_arg_conv;
38517 this_arg_conv.inner = (void*)(this_arg & (~1));
38518 this_arg_conv.is_owned = false;
38519 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38520 NodeFeatures_set_channel_type_optional(&this_arg_conv);
38523 void __attribute__((export_name("TS_NodeFeatures_set_channel_type_required"))) TS_NodeFeatures_set_channel_type_required(uint32_t this_arg) {
38524 LDKNodeFeatures this_arg_conv;
38525 this_arg_conv.inner = (void*)(this_arg & (~1));
38526 this_arg_conv.is_owned = false;
38527 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38528 NodeFeatures_set_channel_type_required(&this_arg_conv);
38531 jboolean __attribute__((export_name("TS_NodeFeatures_supports_channel_type"))) TS_NodeFeatures_supports_channel_type(uint32_t this_arg) {
38532 LDKNodeFeatures this_arg_conv;
38533 this_arg_conv.inner = (void*)(this_arg & (~1));
38534 this_arg_conv.is_owned = false;
38535 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38536 jboolean ret_conv = NodeFeatures_supports_channel_type(&this_arg_conv);
38540 jboolean __attribute__((export_name("TS_InitFeatures_requires_channel_type"))) TS_InitFeatures_requires_channel_type(uint32_t this_arg) {
38541 LDKInitFeatures this_arg_conv;
38542 this_arg_conv.inner = (void*)(this_arg & (~1));
38543 this_arg_conv.is_owned = false;
38544 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38545 jboolean ret_conv = InitFeatures_requires_channel_type(&this_arg_conv);
38549 jboolean __attribute__((export_name("TS_NodeFeatures_requires_channel_type"))) TS_NodeFeatures_requires_channel_type(uint32_t this_arg) {
38550 LDKNodeFeatures this_arg_conv;
38551 this_arg_conv.inner = (void*)(this_arg & (~1));
38552 this_arg_conv.is_owned = false;
38553 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38554 jboolean ret_conv = NodeFeatures_requires_channel_type(&this_arg_conv);
38558 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_optional"))) TS_InitFeatures_set_scid_privacy_optional(uint32_t this_arg) {
38559 LDKInitFeatures this_arg_conv;
38560 this_arg_conv.inner = (void*)(this_arg & (~1));
38561 this_arg_conv.is_owned = false;
38562 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38563 InitFeatures_set_scid_privacy_optional(&this_arg_conv);
38566 void __attribute__((export_name("TS_InitFeatures_set_scid_privacy_required"))) TS_InitFeatures_set_scid_privacy_required(uint32_t this_arg) {
38567 LDKInitFeatures this_arg_conv;
38568 this_arg_conv.inner = (void*)(this_arg & (~1));
38569 this_arg_conv.is_owned = false;
38570 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38571 InitFeatures_set_scid_privacy_required(&this_arg_conv);
38574 jboolean __attribute__((export_name("TS_InitFeatures_supports_scid_privacy"))) TS_InitFeatures_supports_scid_privacy(uint32_t this_arg) {
38575 LDKInitFeatures this_arg_conv;
38576 this_arg_conv.inner = (void*)(this_arg & (~1));
38577 this_arg_conv.is_owned = false;
38578 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38579 jboolean ret_conv = InitFeatures_supports_scid_privacy(&this_arg_conv);
38583 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_optional"))) TS_NodeFeatures_set_scid_privacy_optional(uint32_t this_arg) {
38584 LDKNodeFeatures this_arg_conv;
38585 this_arg_conv.inner = (void*)(this_arg & (~1));
38586 this_arg_conv.is_owned = false;
38587 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38588 NodeFeatures_set_scid_privacy_optional(&this_arg_conv);
38591 void __attribute__((export_name("TS_NodeFeatures_set_scid_privacy_required"))) TS_NodeFeatures_set_scid_privacy_required(uint32_t this_arg) {
38592 LDKNodeFeatures this_arg_conv;
38593 this_arg_conv.inner = (void*)(this_arg & (~1));
38594 this_arg_conv.is_owned = false;
38595 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38596 NodeFeatures_set_scid_privacy_required(&this_arg_conv);
38599 jboolean __attribute__((export_name("TS_NodeFeatures_supports_scid_privacy"))) TS_NodeFeatures_supports_scid_privacy(uint32_t this_arg) {
38600 LDKNodeFeatures this_arg_conv;
38601 this_arg_conv.inner = (void*)(this_arg & (~1));
38602 this_arg_conv.is_owned = false;
38603 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38604 jboolean ret_conv = NodeFeatures_supports_scid_privacy(&this_arg_conv);
38608 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_optional"))) TS_ChannelTypeFeatures_set_scid_privacy_optional(uint32_t this_arg) {
38609 LDKChannelTypeFeatures this_arg_conv;
38610 this_arg_conv.inner = (void*)(this_arg & (~1));
38611 this_arg_conv.is_owned = false;
38612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38613 ChannelTypeFeatures_set_scid_privacy_optional(&this_arg_conv);
38616 void __attribute__((export_name("TS_ChannelTypeFeatures_set_scid_privacy_required"))) TS_ChannelTypeFeatures_set_scid_privacy_required(uint32_t this_arg) {
38617 LDKChannelTypeFeatures this_arg_conv;
38618 this_arg_conv.inner = (void*)(this_arg & (~1));
38619 this_arg_conv.is_owned = false;
38620 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38621 ChannelTypeFeatures_set_scid_privacy_required(&this_arg_conv);
38624 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_scid_privacy"))) TS_ChannelTypeFeatures_supports_scid_privacy(uint32_t this_arg) {
38625 LDKChannelTypeFeatures this_arg_conv;
38626 this_arg_conv.inner = (void*)(this_arg & (~1));
38627 this_arg_conv.is_owned = false;
38628 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38629 jboolean ret_conv = ChannelTypeFeatures_supports_scid_privacy(&this_arg_conv);
38633 jboolean __attribute__((export_name("TS_InitFeatures_requires_scid_privacy"))) TS_InitFeatures_requires_scid_privacy(uint32_t this_arg) {
38634 LDKInitFeatures this_arg_conv;
38635 this_arg_conv.inner = (void*)(this_arg & (~1));
38636 this_arg_conv.is_owned = false;
38637 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38638 jboolean ret_conv = InitFeatures_requires_scid_privacy(&this_arg_conv);
38642 jboolean __attribute__((export_name("TS_NodeFeatures_requires_scid_privacy"))) TS_NodeFeatures_requires_scid_privacy(uint32_t this_arg) {
38643 LDKNodeFeatures this_arg_conv;
38644 this_arg_conv.inner = (void*)(this_arg & (~1));
38645 this_arg_conv.is_owned = false;
38646 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38647 jboolean ret_conv = NodeFeatures_requires_scid_privacy(&this_arg_conv);
38651 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_scid_privacy"))) TS_ChannelTypeFeatures_requires_scid_privacy(uint32_t this_arg) {
38652 LDKChannelTypeFeatures this_arg_conv;
38653 this_arg_conv.inner = (void*)(this_arg & (~1));
38654 this_arg_conv.is_owned = false;
38655 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38656 jboolean ret_conv = ChannelTypeFeatures_requires_scid_privacy(&this_arg_conv);
38660 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_optional"))) TS_InitFeatures_set_zero_conf_optional(uint32_t this_arg) {
38661 LDKInitFeatures this_arg_conv;
38662 this_arg_conv.inner = (void*)(this_arg & (~1));
38663 this_arg_conv.is_owned = false;
38664 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38665 InitFeatures_set_zero_conf_optional(&this_arg_conv);
38668 void __attribute__((export_name("TS_InitFeatures_set_zero_conf_required"))) TS_InitFeatures_set_zero_conf_required(uint32_t this_arg) {
38669 LDKInitFeatures this_arg_conv;
38670 this_arg_conv.inner = (void*)(this_arg & (~1));
38671 this_arg_conv.is_owned = false;
38672 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38673 InitFeatures_set_zero_conf_required(&this_arg_conv);
38676 jboolean __attribute__((export_name("TS_InitFeatures_supports_zero_conf"))) TS_InitFeatures_supports_zero_conf(uint32_t this_arg) {
38677 LDKInitFeatures this_arg_conv;
38678 this_arg_conv.inner = (void*)(this_arg & (~1));
38679 this_arg_conv.is_owned = false;
38680 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38681 jboolean ret_conv = InitFeatures_supports_zero_conf(&this_arg_conv);
38685 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_optional"))) TS_NodeFeatures_set_zero_conf_optional(uint32_t this_arg) {
38686 LDKNodeFeatures this_arg_conv;
38687 this_arg_conv.inner = (void*)(this_arg & (~1));
38688 this_arg_conv.is_owned = false;
38689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38690 NodeFeatures_set_zero_conf_optional(&this_arg_conv);
38693 void __attribute__((export_name("TS_NodeFeatures_set_zero_conf_required"))) TS_NodeFeatures_set_zero_conf_required(uint32_t this_arg) {
38694 LDKNodeFeatures this_arg_conv;
38695 this_arg_conv.inner = (void*)(this_arg & (~1));
38696 this_arg_conv.is_owned = false;
38697 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38698 NodeFeatures_set_zero_conf_required(&this_arg_conv);
38701 jboolean __attribute__((export_name("TS_NodeFeatures_supports_zero_conf"))) TS_NodeFeatures_supports_zero_conf(uint32_t this_arg) {
38702 LDKNodeFeatures this_arg_conv;
38703 this_arg_conv.inner = (void*)(this_arg & (~1));
38704 this_arg_conv.is_owned = false;
38705 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38706 jboolean ret_conv = NodeFeatures_supports_zero_conf(&this_arg_conv);
38710 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_optional"))) TS_ChannelTypeFeatures_set_zero_conf_optional(uint32_t this_arg) {
38711 LDKChannelTypeFeatures this_arg_conv;
38712 this_arg_conv.inner = (void*)(this_arg & (~1));
38713 this_arg_conv.is_owned = false;
38714 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38715 ChannelTypeFeatures_set_zero_conf_optional(&this_arg_conv);
38718 void __attribute__((export_name("TS_ChannelTypeFeatures_set_zero_conf_required"))) TS_ChannelTypeFeatures_set_zero_conf_required(uint32_t this_arg) {
38719 LDKChannelTypeFeatures this_arg_conv;
38720 this_arg_conv.inner = (void*)(this_arg & (~1));
38721 this_arg_conv.is_owned = false;
38722 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38723 ChannelTypeFeatures_set_zero_conf_required(&this_arg_conv);
38726 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_supports_zero_conf"))) TS_ChannelTypeFeatures_supports_zero_conf(uint32_t this_arg) {
38727 LDKChannelTypeFeatures this_arg_conv;
38728 this_arg_conv.inner = (void*)(this_arg & (~1));
38729 this_arg_conv.is_owned = false;
38730 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38731 jboolean ret_conv = ChannelTypeFeatures_supports_zero_conf(&this_arg_conv);
38735 jboolean __attribute__((export_name("TS_InitFeatures_requires_zero_conf"))) TS_InitFeatures_requires_zero_conf(uint32_t this_arg) {
38736 LDKInitFeatures this_arg_conv;
38737 this_arg_conv.inner = (void*)(this_arg & (~1));
38738 this_arg_conv.is_owned = false;
38739 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38740 jboolean ret_conv = InitFeatures_requires_zero_conf(&this_arg_conv);
38744 jboolean __attribute__((export_name("TS_NodeFeatures_requires_zero_conf"))) TS_NodeFeatures_requires_zero_conf(uint32_t this_arg) {
38745 LDKNodeFeatures this_arg_conv;
38746 this_arg_conv.inner = (void*)(this_arg & (~1));
38747 this_arg_conv.is_owned = false;
38748 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38749 jboolean ret_conv = NodeFeatures_requires_zero_conf(&this_arg_conv);
38753 jboolean __attribute__((export_name("TS_ChannelTypeFeatures_requires_zero_conf"))) TS_ChannelTypeFeatures_requires_zero_conf(uint32_t this_arg) {
38754 LDKChannelTypeFeatures this_arg_conv;
38755 this_arg_conv.inner = (void*)(this_arg & (~1));
38756 this_arg_conv.is_owned = false;
38757 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38758 jboolean ret_conv = ChannelTypeFeatures_requires_zero_conf(&this_arg_conv);
38762 void __attribute__((export_name("TS_NodeFeatures_set_keysend_optional"))) TS_NodeFeatures_set_keysend_optional(uint32_t this_arg) {
38763 LDKNodeFeatures this_arg_conv;
38764 this_arg_conv.inner = (void*)(this_arg & (~1));
38765 this_arg_conv.is_owned = false;
38766 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38767 NodeFeatures_set_keysend_optional(&this_arg_conv);
38770 void __attribute__((export_name("TS_NodeFeatures_set_keysend_required"))) TS_NodeFeatures_set_keysend_required(uint32_t this_arg) {
38771 LDKNodeFeatures this_arg_conv;
38772 this_arg_conv.inner = (void*)(this_arg & (~1));
38773 this_arg_conv.is_owned = false;
38774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38775 NodeFeatures_set_keysend_required(&this_arg_conv);
38778 jboolean __attribute__((export_name("TS_NodeFeatures_supports_keysend"))) TS_NodeFeatures_supports_keysend(uint32_t this_arg) {
38779 LDKNodeFeatures this_arg_conv;
38780 this_arg_conv.inner = (void*)(this_arg & (~1));
38781 this_arg_conv.is_owned = false;
38782 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38783 jboolean ret_conv = NodeFeatures_supports_keysend(&this_arg_conv);
38787 jboolean __attribute__((export_name("TS_NodeFeatures_requires_keysend"))) TS_NodeFeatures_requires_keysend(uint32_t this_arg) {
38788 LDKNodeFeatures this_arg_conv;
38789 this_arg_conv.inner = (void*)(this_arg & (~1));
38790 this_arg_conv.is_owned = false;
38791 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
38792 jboolean ret_conv = NodeFeatures_requires_keysend(&this_arg_conv);
38796 void __attribute__((export_name("TS_ShutdownScript_free"))) TS_ShutdownScript_free(uint32_t this_obj) {
38797 LDKShutdownScript this_obj_conv;
38798 this_obj_conv.inner = (void*)(this_obj & (~1));
38799 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
38800 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38801 ShutdownScript_free(this_obj_conv);
38804 static inline uintptr_t ShutdownScript_clone_ptr(LDKShutdownScript *NONNULL_PTR arg) {
38805 LDKShutdownScript ret_var = ShutdownScript_clone(arg);
38806 uint32_t ret_ref = 0;
38807 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38808 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38809 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38810 ret_ref = (uintptr_t)ret_var.inner;
38811 if (ret_var.is_owned) {
38816 uint32_t __attribute__((export_name("TS_ShutdownScript_clone_ptr"))) TS_ShutdownScript_clone_ptr(uint32_t arg) {
38817 LDKShutdownScript arg_conv;
38818 arg_conv.inner = (void*)(arg & (~1));
38819 arg_conv.is_owned = false;
38820 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38821 uint32_t ret_conv = ShutdownScript_clone_ptr(&arg_conv);
38825 uint32_t __attribute__((export_name("TS_ShutdownScript_clone"))) TS_ShutdownScript_clone(uint32_t orig) {
38826 LDKShutdownScript orig_conv;
38827 orig_conv.inner = (void*)(orig & (~1));
38828 orig_conv.is_owned = false;
38829 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38830 LDKShutdownScript ret_var = ShutdownScript_clone(&orig_conv);
38831 uint32_t ret_ref = 0;
38832 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38833 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38834 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38835 ret_ref = (uintptr_t)ret_var.inner;
38836 if (ret_var.is_owned) {
38842 void __attribute__((export_name("TS_InvalidShutdownScript_free"))) TS_InvalidShutdownScript_free(uint32_t this_obj) {
38843 LDKInvalidShutdownScript this_obj_conv;
38844 this_obj_conv.inner = (void*)(this_obj & (~1));
38845 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
38846 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
38847 InvalidShutdownScript_free(this_obj_conv);
38850 int8_tArray __attribute__((export_name("TS_InvalidShutdownScript_get_script"))) TS_InvalidShutdownScript_get_script(uint32_t this_ptr) {
38851 LDKInvalidShutdownScript this_ptr_conv;
38852 this_ptr_conv.inner = (void*)(this_ptr & (~1));
38853 this_ptr_conv.is_owned = false;
38854 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38855 LDKu8slice ret_var = InvalidShutdownScript_get_script(&this_ptr_conv);
38856 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38857 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38861 void __attribute__((export_name("TS_InvalidShutdownScript_set_script"))) TS_InvalidShutdownScript_set_script(uint32_t this_ptr, int8_tArray val) {
38862 LDKInvalidShutdownScript this_ptr_conv;
38863 this_ptr_conv.inner = (void*)(this_ptr & (~1));
38864 this_ptr_conv.is_owned = false;
38865 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
38866 LDKCVec_u8Z val_ref;
38867 val_ref.datalen = val->arr_len;
38868 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
38869 memcpy(val_ref.data, val->elems, val_ref.datalen); FREE(val);
38870 InvalidShutdownScript_set_script(&this_ptr_conv, val_ref);
38873 uint32_t __attribute__((export_name("TS_InvalidShutdownScript_new"))) TS_InvalidShutdownScript_new(int8_tArray script_arg) {
38874 LDKCVec_u8Z script_arg_ref;
38875 script_arg_ref.datalen = script_arg->arr_len;
38876 script_arg_ref.data = MALLOC(script_arg_ref.datalen, "LDKCVec_u8Z Bytes");
38877 memcpy(script_arg_ref.data, script_arg->elems, script_arg_ref.datalen); FREE(script_arg);
38878 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_new(script_arg_ref);
38879 uint32_t ret_ref = 0;
38880 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38881 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38882 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38883 ret_ref = (uintptr_t)ret_var.inner;
38884 if (ret_var.is_owned) {
38890 static inline uintptr_t InvalidShutdownScript_clone_ptr(LDKInvalidShutdownScript *NONNULL_PTR arg) {
38891 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(arg);
38892 uint32_t ret_ref = 0;
38893 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38894 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38895 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38896 ret_ref = (uintptr_t)ret_var.inner;
38897 if (ret_var.is_owned) {
38902 uint32_t __attribute__((export_name("TS_InvalidShutdownScript_clone_ptr"))) TS_InvalidShutdownScript_clone_ptr(uint32_t arg) {
38903 LDKInvalidShutdownScript arg_conv;
38904 arg_conv.inner = (void*)(arg & (~1));
38905 arg_conv.is_owned = false;
38906 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
38907 uint32_t ret_conv = InvalidShutdownScript_clone_ptr(&arg_conv);
38911 uint32_t __attribute__((export_name("TS_InvalidShutdownScript_clone"))) TS_InvalidShutdownScript_clone(uint32_t orig) {
38912 LDKInvalidShutdownScript orig_conv;
38913 orig_conv.inner = (void*)(orig & (~1));
38914 orig_conv.is_owned = false;
38915 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
38916 LDKInvalidShutdownScript ret_var = InvalidShutdownScript_clone(&orig_conv);
38917 uint32_t ret_ref = 0;
38918 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38919 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38920 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38921 ret_ref = (uintptr_t)ret_var.inner;
38922 if (ret_var.is_owned) {
38928 int8_tArray __attribute__((export_name("TS_ShutdownScript_write"))) TS_ShutdownScript_write(uint32_t obj) {
38929 LDKShutdownScript obj_conv;
38930 obj_conv.inner = (void*)(obj & (~1));
38931 obj_conv.is_owned = false;
38932 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
38933 LDKCVec_u8Z ret_var = ShutdownScript_write(&obj_conv);
38934 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
38935 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
38936 CVec_u8Z_free(ret_var);
38940 uint32_t __attribute__((export_name("TS_ShutdownScript_read"))) TS_ShutdownScript_read(int8_tArray ser) {
38941 LDKu8slice ser_ref;
38942 ser_ref.datalen = ser->arr_len;
38943 ser_ref.data = ser->elems;
38944 LDKCResult_ShutdownScriptDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptDecodeErrorZ), "LDKCResult_ShutdownScriptDecodeErrorZ");
38945 *ret_conv = ShutdownScript_read(ser_ref);
38947 return (uint32_t)ret_conv;
38950 uint32_t __attribute__((export_name("TS_ShutdownScript_new_p2wpkh"))) TS_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) {
38951 unsigned char pubkey_hash_arr[20];
38952 CHECK(pubkey_hash->arr_len == 20);
38953 memcpy(pubkey_hash_arr, pubkey_hash->elems, 20); FREE(pubkey_hash);
38954 unsigned char (*pubkey_hash_ref)[20] = &pubkey_hash_arr;
38955 LDKShutdownScript ret_var = ShutdownScript_new_p2wpkh(pubkey_hash_ref);
38956 uint32_t ret_ref = 0;
38957 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38958 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38959 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38960 ret_ref = (uintptr_t)ret_var.inner;
38961 if (ret_var.is_owned) {
38967 uint32_t __attribute__((export_name("TS_ShutdownScript_new_p2wsh"))) TS_ShutdownScript_new_p2wsh(int8_tArray script_hash) {
38968 unsigned char script_hash_arr[32];
38969 CHECK(script_hash->arr_len == 32);
38970 memcpy(script_hash_arr, script_hash->elems, 32); FREE(script_hash);
38971 unsigned char (*script_hash_ref)[32] = &script_hash_arr;
38972 LDKShutdownScript ret_var = ShutdownScript_new_p2wsh(script_hash_ref);
38973 uint32_t ret_ref = 0;
38974 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
38975 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
38976 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
38977 ret_ref = (uintptr_t)ret_var.inner;
38978 if (ret_var.is_owned) {
38984 uint32_t __attribute__((export_name("TS_ShutdownScript_new_witness_program"))) TS_ShutdownScript_new_witness_program(int8_t version, int8_tArray program) {
38986 LDKu8slice program_ref;
38987 program_ref.datalen = program->arr_len;
38988 program_ref.data = program->elems;
38989 LDKCResult_ShutdownScriptInvalidShutdownScriptZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownScriptInvalidShutdownScriptZ), "LDKCResult_ShutdownScriptInvalidShutdownScriptZ");
38990 *ret_conv = ShutdownScript_new_witness_program((LDKWitnessVersion){ ._0 = version }, program_ref);
38992 return (uint32_t)ret_conv;
38995 int8_tArray __attribute__((export_name("TS_ShutdownScript_into_inner"))) TS_ShutdownScript_into_inner(uint32_t this_arg) {
38996 LDKShutdownScript this_arg_conv;
38997 this_arg_conv.inner = (void*)(this_arg & (~1));
38998 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
38999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39000 this_arg_conv = ShutdownScript_clone(&this_arg_conv);
39001 LDKCVec_u8Z ret_var = ShutdownScript_into_inner(this_arg_conv);
39002 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39003 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39004 CVec_u8Z_free(ret_var);
39008 int8_tArray __attribute__((export_name("TS_ShutdownScript_as_legacy_pubkey"))) TS_ShutdownScript_as_legacy_pubkey(uint32_t this_arg) {
39009 LDKShutdownScript this_arg_conv;
39010 this_arg_conv.inner = (void*)(this_arg & (~1));
39011 this_arg_conv.is_owned = false;
39012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39013 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
39014 memcpy(ret_arr->elems, ShutdownScript_as_legacy_pubkey(&this_arg_conv).compressed_form, 33);
39018 jboolean __attribute__((export_name("TS_ShutdownScript_is_compatible"))) TS_ShutdownScript_is_compatible(uint32_t this_arg, uint32_t features) {
39019 LDKShutdownScript this_arg_conv;
39020 this_arg_conv.inner = (void*)(this_arg & (~1));
39021 this_arg_conv.is_owned = false;
39022 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39023 LDKInitFeatures features_conv;
39024 features_conv.inner = (void*)(features & (~1));
39025 features_conv.is_owned = false;
39026 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
39027 jboolean ret_conv = ShutdownScript_is_compatible(&this_arg_conv, &features_conv);
39031 void __attribute__((export_name("TS_CustomMessageReader_free"))) TS_CustomMessageReader_free(uint32_t this_ptr) {
39032 if ((this_ptr & 1) != 0) return;
39033 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
39034 CHECK_ACCESS(this_ptr_ptr);
39035 LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(this_ptr_ptr);
39036 FREE((void*)this_ptr);
39037 CustomMessageReader_free(this_ptr_conv);
39040 static inline uintptr_t Type_clone_ptr(LDKType *NONNULL_PTR arg) {
39041 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
39042 *ret_ret = Type_clone(arg);
39043 return (uint32_t)ret_ret;
39045 uint32_t __attribute__((export_name("TS_Type_clone_ptr"))) TS_Type_clone_ptr(uint32_t arg) {
39046 void* arg_ptr = (void*)(((uintptr_t)arg) & ~1);
39047 if (!(arg & 1)) { CHECK_ACCESS(arg_ptr); }
39048 LDKType* arg_conv = (LDKType*)arg_ptr;
39049 uint32_t ret_conv = Type_clone_ptr(arg_conv);
39053 uint32_t __attribute__((export_name("TS_Type_clone"))) TS_Type_clone(uint32_t orig) {
39054 void* orig_ptr = (void*)(((uintptr_t)orig) & ~1);
39055 if (!(orig & 1)) { CHECK_ACCESS(orig_ptr); }
39056 LDKType* orig_conv = (LDKType*)orig_ptr;
39057 LDKType* ret_ret = MALLOC(sizeof(LDKType), "LDKType");
39058 *ret_ret = Type_clone(orig_conv);
39059 return (uint32_t)ret_ret;
39062 void __attribute__((export_name("TS_Type_free"))) TS_Type_free(uint32_t this_ptr) {
39063 if ((this_ptr & 1) != 0) return;
39064 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
39065 CHECK_ACCESS(this_ptr_ptr);
39066 LDKType this_ptr_conv = *(LDKType*)(this_ptr_ptr);
39067 FREE((void*)this_ptr);
39068 Type_free(this_ptr_conv);
39071 void __attribute__((export_name("TS_NodeId_free"))) TS_NodeId_free(uint32_t this_obj) {
39072 LDKNodeId this_obj_conv;
39073 this_obj_conv.inner = (void*)(this_obj & (~1));
39074 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39075 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39076 NodeId_free(this_obj_conv);
39079 static inline uintptr_t NodeId_clone_ptr(LDKNodeId *NONNULL_PTR arg) {
39080 LDKNodeId ret_var = NodeId_clone(arg);
39081 uint32_t ret_ref = 0;
39082 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39083 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39084 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39085 ret_ref = (uintptr_t)ret_var.inner;
39086 if (ret_var.is_owned) {
39091 uint32_t __attribute__((export_name("TS_NodeId_clone_ptr"))) TS_NodeId_clone_ptr(uint32_t arg) {
39092 LDKNodeId arg_conv;
39093 arg_conv.inner = (void*)(arg & (~1));
39094 arg_conv.is_owned = false;
39095 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39096 uint32_t ret_conv = NodeId_clone_ptr(&arg_conv);
39100 uint32_t __attribute__((export_name("TS_NodeId_clone"))) TS_NodeId_clone(uint32_t orig) {
39101 LDKNodeId orig_conv;
39102 orig_conv.inner = (void*)(orig & (~1));
39103 orig_conv.is_owned = false;
39104 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39105 LDKNodeId ret_var = NodeId_clone(&orig_conv);
39106 uint32_t ret_ref = 0;
39107 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39108 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39109 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39110 ret_ref = (uintptr_t)ret_var.inner;
39111 if (ret_var.is_owned) {
39117 uint32_t __attribute__((export_name("TS_NodeId_from_pubkey"))) TS_NodeId_from_pubkey(int8_tArray pubkey) {
39118 LDKPublicKey pubkey_ref;
39119 CHECK(pubkey->arr_len == 33);
39120 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
39121 LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref);
39122 uint32_t ret_ref = 0;
39123 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39124 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39125 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39126 ret_ref = (uintptr_t)ret_var.inner;
39127 if (ret_var.is_owned) {
39133 int8_tArray __attribute__((export_name("TS_NodeId_as_slice"))) TS_NodeId_as_slice(uint32_t this_arg) {
39134 LDKNodeId this_arg_conv;
39135 this_arg_conv.inner = (void*)(this_arg & (~1));
39136 this_arg_conv.is_owned = false;
39137 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39138 LDKu8slice ret_var = NodeId_as_slice(&this_arg_conv);
39139 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39140 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39144 int64_t __attribute__((export_name("TS_NodeId_hash"))) TS_NodeId_hash(uint32_t o) {
39146 o_conv.inner = (void*)(o & (~1));
39147 o_conv.is_owned = false;
39148 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
39149 int64_t ret_conv = NodeId_hash(&o_conv);
39153 int8_tArray __attribute__((export_name("TS_NodeId_write"))) TS_NodeId_write(uint32_t obj) {
39154 LDKNodeId obj_conv;
39155 obj_conv.inner = (void*)(obj & (~1));
39156 obj_conv.is_owned = false;
39157 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39158 LDKCVec_u8Z ret_var = NodeId_write(&obj_conv);
39159 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39160 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39161 CVec_u8Z_free(ret_var);
39165 uint32_t __attribute__((export_name("TS_NodeId_read"))) TS_NodeId_read(int8_tArray ser) {
39166 LDKu8slice ser_ref;
39167 ser_ref.datalen = ser->arr_len;
39168 ser_ref.data = ser->elems;
39169 LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ");
39170 *ret_conv = NodeId_read(ser_ref);
39172 return (uint32_t)ret_conv;
39175 void __attribute__((export_name("TS_NetworkGraph_free"))) TS_NetworkGraph_free(uint32_t this_obj) {
39176 LDKNetworkGraph this_obj_conv;
39177 this_obj_conv.inner = (void*)(this_obj & (~1));
39178 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39179 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39180 NetworkGraph_free(this_obj_conv);
39183 void __attribute__((export_name("TS_ReadOnlyNetworkGraph_free"))) TS_ReadOnlyNetworkGraph_free(uint32_t this_obj) {
39184 LDKReadOnlyNetworkGraph this_obj_conv;
39185 this_obj_conv.inner = (void*)(this_obj & (~1));
39186 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39187 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39188 ReadOnlyNetworkGraph_free(this_obj_conv);
39191 void __attribute__((export_name("TS_NetworkUpdate_free"))) TS_NetworkUpdate_free(uint32_t this_ptr) {
39192 if ((this_ptr & 1) != 0) return;
39193 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
39194 CHECK_ACCESS(this_ptr_ptr);
39195 LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(this_ptr_ptr);
39196 FREE((void*)this_ptr);
39197 NetworkUpdate_free(this_ptr_conv);
39200 static inline uintptr_t NetworkUpdate_clone_ptr(LDKNetworkUpdate *NONNULL_PTR arg) {
39201 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
39202 *ret_copy = NetworkUpdate_clone(arg);
39203 uint32_t ret_ref = (uintptr_t)ret_copy;
39206 uint32_t __attribute__((export_name("TS_NetworkUpdate_clone_ptr"))) TS_NetworkUpdate_clone_ptr(uint32_t arg) {
39207 LDKNetworkUpdate* arg_conv = (LDKNetworkUpdate*)arg;
39208 uint32_t ret_conv = NetworkUpdate_clone_ptr(arg_conv);
39212 uint32_t __attribute__((export_name("TS_NetworkUpdate_clone"))) TS_NetworkUpdate_clone(uint32_t orig) {
39213 LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig;
39214 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
39215 *ret_copy = NetworkUpdate_clone(orig_conv);
39216 uint32_t ret_ref = (uintptr_t)ret_copy;
39220 uint32_t __attribute__((export_name("TS_NetworkUpdate_channel_update_message"))) TS_NetworkUpdate_channel_update_message(uint32_t msg) {
39221 LDKChannelUpdate msg_conv;
39222 msg_conv.inner = (void*)(msg & (~1));
39223 msg_conv.is_owned = (msg & 1) || (msg == 0);
39224 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
39225 msg_conv = ChannelUpdate_clone(&msg_conv);
39226 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
39227 *ret_copy = NetworkUpdate_channel_update_message(msg_conv);
39228 uint32_t ret_ref = (uintptr_t)ret_copy;
39232 uint32_t __attribute__((export_name("TS_NetworkUpdate_channel_failure"))) TS_NetworkUpdate_channel_failure(int64_t short_channel_id, jboolean is_permanent) {
39233 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
39234 *ret_copy = NetworkUpdate_channel_failure(short_channel_id, is_permanent);
39235 uint32_t ret_ref = (uintptr_t)ret_copy;
39239 uint32_t __attribute__((export_name("TS_NetworkUpdate_node_failure"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) {
39240 LDKPublicKey node_id_ref;
39241 CHECK(node_id->arr_len == 33);
39242 memcpy(node_id_ref.compressed_form, node_id->elems, 33); FREE(node_id);
39243 LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate");
39244 *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent);
39245 uint32_t ret_ref = (uintptr_t)ret_copy;
39249 int8_tArray __attribute__((export_name("TS_NetworkUpdate_write"))) TS_NetworkUpdate_write(uint32_t obj) {
39250 LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)obj;
39251 LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_conv);
39252 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39253 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39254 CVec_u8Z_free(ret_var);
39258 uint32_t __attribute__((export_name("TS_NetworkUpdate_read"))) TS_NetworkUpdate_read(int8_tArray ser) {
39259 LDKu8slice ser_ref;
39260 ser_ref.datalen = ser->arr_len;
39261 ser_ref.data = ser->elems;
39262 LDKCResult_COption_NetworkUpdateZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_NetworkUpdateZDecodeErrorZ), "LDKCResult_COption_NetworkUpdateZDecodeErrorZ");
39263 *ret_conv = NetworkUpdate_read(ser_ref);
39265 return (uint32_t)ret_conv;
39268 void __attribute__((export_name("TS_P2PGossipSync_free"))) TS_P2PGossipSync_free(uint32_t this_obj) {
39269 LDKP2PGossipSync this_obj_conv;
39270 this_obj_conv.inner = (void*)(this_obj & (~1));
39271 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39272 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39273 P2PGossipSync_free(this_obj_conv);
39276 uint32_t __attribute__((export_name("TS_P2PGossipSync_new"))) TS_P2PGossipSync_new(uint32_t network_graph, uint32_t chain_access, uint32_t logger) {
39277 LDKNetworkGraph network_graph_conv;
39278 network_graph_conv.inner = (void*)(network_graph & (~1));
39279 network_graph_conv.is_owned = false;
39280 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
39281 void* chain_access_ptr = (void*)(((uintptr_t)chain_access) & ~1);
39282 CHECK_ACCESS(chain_access_ptr);
39283 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
39284 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
39285 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
39286 // Manually implement clone for Java trait instances
39287 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
39288 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
39289 LDKAccess_JCalls_cloned(&chain_access_conv.some);
39292 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
39293 CHECK_ACCESS(logger_ptr);
39294 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
39295 if (logger_conv.free == LDKLogger_JCalls_free) {
39296 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
39297 LDKLogger_JCalls_cloned(&logger_conv);
39299 LDKP2PGossipSync ret_var = P2PGossipSync_new(&network_graph_conv, chain_access_conv, logger_conv);
39300 uint32_t ret_ref = 0;
39301 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39302 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39303 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39304 ret_ref = (uintptr_t)ret_var.inner;
39305 if (ret_var.is_owned) {
39311 void __attribute__((export_name("TS_P2PGossipSync_add_chain_access"))) TS_P2PGossipSync_add_chain_access(uint32_t this_arg, uint32_t chain_access) {
39312 LDKP2PGossipSync this_arg_conv;
39313 this_arg_conv.inner = (void*)(this_arg & (~1));
39314 this_arg_conv.is_owned = false;
39315 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39316 void* chain_access_ptr = (void*)(((uintptr_t)chain_access) & ~1);
39317 CHECK_ACCESS(chain_access_ptr);
39318 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
39319 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
39320 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
39321 // Manually implement clone for Java trait instances
39322 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
39323 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
39324 LDKAccess_JCalls_cloned(&chain_access_conv.some);
39327 P2PGossipSync_add_chain_access(&this_arg_conv, chain_access_conv);
39330 uint32_t __attribute__((export_name("TS_NetworkGraph_as_EventHandler"))) TS_NetworkGraph_as_EventHandler(uint32_t this_arg) {
39331 LDKNetworkGraph this_arg_conv;
39332 this_arg_conv.inner = (void*)(this_arg & (~1));
39333 this_arg_conv.is_owned = false;
39334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39335 LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
39336 *ret_ret = NetworkGraph_as_EventHandler(&this_arg_conv);
39337 return (uint32_t)ret_ret;
39340 uint32_t __attribute__((export_name("TS_P2PGossipSync_as_RoutingMessageHandler"))) TS_P2PGossipSync_as_RoutingMessageHandler(uint32_t this_arg) {
39341 LDKP2PGossipSync this_arg_conv;
39342 this_arg_conv.inner = (void*)(this_arg & (~1));
39343 this_arg_conv.is_owned = false;
39344 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39345 LDKRoutingMessageHandler* ret_ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
39346 *ret_ret = P2PGossipSync_as_RoutingMessageHandler(&this_arg_conv);
39347 return (uint32_t)ret_ret;
39350 uint32_t __attribute__((export_name("TS_P2PGossipSync_as_MessageSendEventsProvider"))) TS_P2PGossipSync_as_MessageSendEventsProvider(uint32_t this_arg) {
39351 LDKP2PGossipSync this_arg_conv;
39352 this_arg_conv.inner = (void*)(this_arg & (~1));
39353 this_arg_conv.is_owned = false;
39354 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39355 LDKMessageSendEventsProvider* ret_ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
39356 *ret_ret = P2PGossipSync_as_MessageSendEventsProvider(&this_arg_conv);
39357 return (uint32_t)ret_ret;
39360 void __attribute__((export_name("TS_ChannelUpdateInfo_free"))) TS_ChannelUpdateInfo_free(uint32_t this_obj) {
39361 LDKChannelUpdateInfo this_obj_conv;
39362 this_obj_conv.inner = (void*)(this_obj & (~1));
39363 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39365 ChannelUpdateInfo_free(this_obj_conv);
39368 int32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update"))) TS_ChannelUpdateInfo_get_last_update(uint32_t this_ptr) {
39369 LDKChannelUpdateInfo this_ptr_conv;
39370 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39371 this_ptr_conv.is_owned = false;
39372 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39373 int32_t ret_conv = ChannelUpdateInfo_get_last_update(&this_ptr_conv);
39377 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update"))) TS_ChannelUpdateInfo_set_last_update(uint32_t this_ptr, int32_t val) {
39378 LDKChannelUpdateInfo this_ptr_conv;
39379 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39380 this_ptr_conv.is_owned = false;
39381 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39382 ChannelUpdateInfo_set_last_update(&this_ptr_conv, val);
39385 jboolean __attribute__((export_name("TS_ChannelUpdateInfo_get_enabled"))) TS_ChannelUpdateInfo_get_enabled(uint32_t this_ptr) {
39386 LDKChannelUpdateInfo this_ptr_conv;
39387 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39388 this_ptr_conv.is_owned = false;
39389 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39390 jboolean ret_conv = ChannelUpdateInfo_get_enabled(&this_ptr_conv);
39394 void __attribute__((export_name("TS_ChannelUpdateInfo_set_enabled"))) TS_ChannelUpdateInfo_set_enabled(uint32_t this_ptr, jboolean val) {
39395 LDKChannelUpdateInfo this_ptr_conv;
39396 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39397 this_ptr_conv.is_owned = false;
39398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39399 ChannelUpdateInfo_set_enabled(&this_ptr_conv, val);
39402 int16_t __attribute__((export_name("TS_ChannelUpdateInfo_get_cltv_expiry_delta"))) TS_ChannelUpdateInfo_get_cltv_expiry_delta(uint32_t this_ptr) {
39403 LDKChannelUpdateInfo this_ptr_conv;
39404 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39405 this_ptr_conv.is_owned = false;
39406 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39407 int16_t ret_conv = ChannelUpdateInfo_get_cltv_expiry_delta(&this_ptr_conv);
39411 void __attribute__((export_name("TS_ChannelUpdateInfo_set_cltv_expiry_delta"))) TS_ChannelUpdateInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
39412 LDKChannelUpdateInfo this_ptr_conv;
39413 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39414 this_ptr_conv.is_owned = false;
39415 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39416 ChannelUpdateInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
39419 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_minimum_msat"))) TS_ChannelUpdateInfo_get_htlc_minimum_msat(uint32_t this_ptr) {
39420 LDKChannelUpdateInfo this_ptr_conv;
39421 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39422 this_ptr_conv.is_owned = false;
39423 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39424 int64_t ret_conv = ChannelUpdateInfo_get_htlc_minimum_msat(&this_ptr_conv);
39428 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_minimum_msat"))) TS_ChannelUpdateInfo_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
39429 LDKChannelUpdateInfo this_ptr_conv;
39430 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39431 this_ptr_conv.is_owned = false;
39432 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39433 ChannelUpdateInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
39436 int64_t __attribute__((export_name("TS_ChannelUpdateInfo_get_htlc_maximum_msat"))) TS_ChannelUpdateInfo_get_htlc_maximum_msat(uint32_t this_ptr) {
39437 LDKChannelUpdateInfo this_ptr_conv;
39438 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39439 this_ptr_conv.is_owned = false;
39440 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39441 int64_t ret_conv = ChannelUpdateInfo_get_htlc_maximum_msat(&this_ptr_conv);
39445 void __attribute__((export_name("TS_ChannelUpdateInfo_set_htlc_maximum_msat"))) TS_ChannelUpdateInfo_set_htlc_maximum_msat(uint32_t this_ptr, int64_t val) {
39446 LDKChannelUpdateInfo this_ptr_conv;
39447 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39448 this_ptr_conv.is_owned = false;
39449 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39450 ChannelUpdateInfo_set_htlc_maximum_msat(&this_ptr_conv, val);
39453 uint32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_fees"))) TS_ChannelUpdateInfo_get_fees(uint32_t this_ptr) {
39454 LDKChannelUpdateInfo this_ptr_conv;
39455 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39456 this_ptr_conv.is_owned = false;
39457 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39458 LDKRoutingFees ret_var = ChannelUpdateInfo_get_fees(&this_ptr_conv);
39459 uint32_t ret_ref = 0;
39460 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39461 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39462 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39463 ret_ref = (uintptr_t)ret_var.inner;
39464 if (ret_var.is_owned) {
39470 void __attribute__((export_name("TS_ChannelUpdateInfo_set_fees"))) TS_ChannelUpdateInfo_set_fees(uint32_t this_ptr, uint32_t val) {
39471 LDKChannelUpdateInfo this_ptr_conv;
39472 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39473 this_ptr_conv.is_owned = false;
39474 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39475 LDKRoutingFees val_conv;
39476 val_conv.inner = (void*)(val & (~1));
39477 val_conv.is_owned = (val & 1) || (val == 0);
39478 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39479 val_conv = RoutingFees_clone(&val_conv);
39480 ChannelUpdateInfo_set_fees(&this_ptr_conv, val_conv);
39483 uint32_t __attribute__((export_name("TS_ChannelUpdateInfo_get_last_update_message"))) TS_ChannelUpdateInfo_get_last_update_message(uint32_t this_ptr) {
39484 LDKChannelUpdateInfo this_ptr_conv;
39485 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39486 this_ptr_conv.is_owned = false;
39487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39488 LDKChannelUpdate ret_var = ChannelUpdateInfo_get_last_update_message(&this_ptr_conv);
39489 uint32_t ret_ref = 0;
39490 if ((uintptr_t)ret_var.inner > 4096) {
39491 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39492 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39493 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39494 ret_ref = (uintptr_t)ret_var.inner;
39495 if (ret_var.is_owned) {
39502 void __attribute__((export_name("TS_ChannelUpdateInfo_set_last_update_message"))) TS_ChannelUpdateInfo_set_last_update_message(uint32_t this_ptr, uint32_t val) {
39503 LDKChannelUpdateInfo this_ptr_conv;
39504 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39505 this_ptr_conv.is_owned = false;
39506 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39507 LDKChannelUpdate val_conv;
39508 val_conv.inner = (void*)(val & (~1));
39509 val_conv.is_owned = (val & 1) || (val == 0);
39510 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39511 val_conv = ChannelUpdate_clone(&val_conv);
39512 ChannelUpdateInfo_set_last_update_message(&this_ptr_conv, val_conv);
39515 uint32_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, uint32_t fees_arg, uint32_t last_update_message_arg) {
39516 LDKRoutingFees fees_arg_conv;
39517 fees_arg_conv.inner = (void*)(fees_arg & (~1));
39518 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
39519 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
39520 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
39521 LDKChannelUpdate last_update_message_arg_conv;
39522 last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
39523 last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
39524 CHECK_INNER_FIELD_ACCESS_OR_NULL(last_update_message_arg_conv);
39525 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
39526 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);
39527 uint32_t ret_ref = 0;
39528 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39529 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39530 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39531 ret_ref = (uintptr_t)ret_var.inner;
39532 if (ret_var.is_owned) {
39538 static inline uintptr_t ChannelUpdateInfo_clone_ptr(LDKChannelUpdateInfo *NONNULL_PTR arg) {
39539 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(arg);
39540 uint32_t ret_ref = 0;
39541 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39542 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39543 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39544 ret_ref = (uintptr_t)ret_var.inner;
39545 if (ret_var.is_owned) {
39550 uint32_t __attribute__((export_name("TS_ChannelUpdateInfo_clone_ptr"))) TS_ChannelUpdateInfo_clone_ptr(uint32_t arg) {
39551 LDKChannelUpdateInfo arg_conv;
39552 arg_conv.inner = (void*)(arg & (~1));
39553 arg_conv.is_owned = false;
39554 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39555 uint32_t ret_conv = ChannelUpdateInfo_clone_ptr(&arg_conv);
39559 uint32_t __attribute__((export_name("TS_ChannelUpdateInfo_clone"))) TS_ChannelUpdateInfo_clone(uint32_t orig) {
39560 LDKChannelUpdateInfo orig_conv;
39561 orig_conv.inner = (void*)(orig & (~1));
39562 orig_conv.is_owned = false;
39563 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39564 LDKChannelUpdateInfo ret_var = ChannelUpdateInfo_clone(&orig_conv);
39565 uint32_t ret_ref = 0;
39566 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39567 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39568 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39569 ret_ref = (uintptr_t)ret_var.inner;
39570 if (ret_var.is_owned) {
39576 int8_tArray __attribute__((export_name("TS_ChannelUpdateInfo_write"))) TS_ChannelUpdateInfo_write(uint32_t obj) {
39577 LDKChannelUpdateInfo obj_conv;
39578 obj_conv.inner = (void*)(obj & (~1));
39579 obj_conv.is_owned = false;
39580 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39581 LDKCVec_u8Z ret_var = ChannelUpdateInfo_write(&obj_conv);
39582 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39583 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39584 CVec_u8Z_free(ret_var);
39588 uint32_t __attribute__((export_name("TS_ChannelUpdateInfo_read"))) TS_ChannelUpdateInfo_read(int8_tArray ser) {
39589 LDKu8slice ser_ref;
39590 ser_ref.datalen = ser->arr_len;
39591 ser_ref.data = ser->elems;
39592 LDKCResult_ChannelUpdateInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateInfoDecodeErrorZ), "LDKCResult_ChannelUpdateInfoDecodeErrorZ");
39593 *ret_conv = ChannelUpdateInfo_read(ser_ref);
39595 return (uint32_t)ret_conv;
39598 void __attribute__((export_name("TS_ChannelInfo_free"))) TS_ChannelInfo_free(uint32_t this_obj) {
39599 LDKChannelInfo this_obj_conv;
39600 this_obj_conv.inner = (void*)(this_obj & (~1));
39601 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39602 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39603 ChannelInfo_free(this_obj_conv);
39606 uint32_t __attribute__((export_name("TS_ChannelInfo_get_features"))) TS_ChannelInfo_get_features(uint32_t this_ptr) {
39607 LDKChannelInfo this_ptr_conv;
39608 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39609 this_ptr_conv.is_owned = false;
39610 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39611 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
39612 uint32_t ret_ref = 0;
39613 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39614 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39615 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39616 ret_ref = (uintptr_t)ret_var.inner;
39617 if (ret_var.is_owned) {
39623 void __attribute__((export_name("TS_ChannelInfo_set_features"))) TS_ChannelInfo_set_features(uint32_t this_ptr, uint32_t val) {
39624 LDKChannelInfo this_ptr_conv;
39625 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39626 this_ptr_conv.is_owned = false;
39627 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39628 LDKChannelFeatures val_conv;
39629 val_conv.inner = (void*)(val & (~1));
39630 val_conv.is_owned = (val & 1) || (val == 0);
39631 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39632 val_conv = ChannelFeatures_clone(&val_conv);
39633 ChannelInfo_set_features(&this_ptr_conv, val_conv);
39636 uint32_t __attribute__((export_name("TS_ChannelInfo_get_node_one"))) TS_ChannelInfo_get_node_one(uint32_t this_ptr) {
39637 LDKChannelInfo this_ptr_conv;
39638 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39639 this_ptr_conv.is_owned = false;
39640 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39641 LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_conv);
39642 uint32_t ret_ref = 0;
39643 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39644 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39645 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39646 ret_ref = (uintptr_t)ret_var.inner;
39647 if (ret_var.is_owned) {
39653 void __attribute__((export_name("TS_ChannelInfo_set_node_one"))) TS_ChannelInfo_set_node_one(uint32_t this_ptr, uint32_t val) {
39654 LDKChannelInfo this_ptr_conv;
39655 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39656 this_ptr_conv.is_owned = false;
39657 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39658 LDKNodeId val_conv;
39659 val_conv.inner = (void*)(val & (~1));
39660 val_conv.is_owned = (val & 1) || (val == 0);
39661 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39662 val_conv = NodeId_clone(&val_conv);
39663 ChannelInfo_set_node_one(&this_ptr_conv, val_conv);
39666 uint32_t __attribute__((export_name("TS_ChannelInfo_get_one_to_two"))) TS_ChannelInfo_get_one_to_two(uint32_t this_ptr) {
39667 LDKChannelInfo this_ptr_conv;
39668 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39669 this_ptr_conv.is_owned = false;
39670 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39671 LDKChannelUpdateInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
39672 uint32_t ret_ref = 0;
39673 if ((uintptr_t)ret_var.inner > 4096) {
39674 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39675 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39676 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39677 ret_ref = (uintptr_t)ret_var.inner;
39678 if (ret_var.is_owned) {
39685 void __attribute__((export_name("TS_ChannelInfo_set_one_to_two"))) TS_ChannelInfo_set_one_to_two(uint32_t this_ptr, uint32_t val) {
39686 LDKChannelInfo this_ptr_conv;
39687 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39688 this_ptr_conv.is_owned = false;
39689 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39690 LDKChannelUpdateInfo val_conv;
39691 val_conv.inner = (void*)(val & (~1));
39692 val_conv.is_owned = (val & 1) || (val == 0);
39693 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39694 val_conv = ChannelUpdateInfo_clone(&val_conv);
39695 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
39698 uint32_t __attribute__((export_name("TS_ChannelInfo_get_node_two"))) TS_ChannelInfo_get_node_two(uint32_t this_ptr) {
39699 LDKChannelInfo this_ptr_conv;
39700 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39701 this_ptr_conv.is_owned = false;
39702 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39703 LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_conv);
39704 uint32_t ret_ref = 0;
39705 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39706 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39707 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39708 ret_ref = (uintptr_t)ret_var.inner;
39709 if (ret_var.is_owned) {
39715 void __attribute__((export_name("TS_ChannelInfo_set_node_two"))) TS_ChannelInfo_set_node_two(uint32_t this_ptr, uint32_t val) {
39716 LDKChannelInfo this_ptr_conv;
39717 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39718 this_ptr_conv.is_owned = false;
39719 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39720 LDKNodeId val_conv;
39721 val_conv.inner = (void*)(val & (~1));
39722 val_conv.is_owned = (val & 1) || (val == 0);
39723 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39724 val_conv = NodeId_clone(&val_conv);
39725 ChannelInfo_set_node_two(&this_ptr_conv, val_conv);
39728 uint32_t __attribute__((export_name("TS_ChannelInfo_get_two_to_one"))) TS_ChannelInfo_get_two_to_one(uint32_t this_ptr) {
39729 LDKChannelInfo this_ptr_conv;
39730 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39731 this_ptr_conv.is_owned = false;
39732 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39733 LDKChannelUpdateInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
39734 uint32_t ret_ref = 0;
39735 if ((uintptr_t)ret_var.inner > 4096) {
39736 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39737 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39738 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39739 ret_ref = (uintptr_t)ret_var.inner;
39740 if (ret_var.is_owned) {
39747 void __attribute__((export_name("TS_ChannelInfo_set_two_to_one"))) TS_ChannelInfo_set_two_to_one(uint32_t this_ptr, uint32_t val) {
39748 LDKChannelInfo this_ptr_conv;
39749 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39750 this_ptr_conv.is_owned = false;
39751 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39752 LDKChannelUpdateInfo val_conv;
39753 val_conv.inner = (void*)(val & (~1));
39754 val_conv.is_owned = (val & 1) || (val == 0);
39755 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39756 val_conv = ChannelUpdateInfo_clone(&val_conv);
39757 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
39760 uint32_t __attribute__((export_name("TS_ChannelInfo_get_capacity_sats"))) TS_ChannelInfo_get_capacity_sats(uint32_t this_ptr) {
39761 LDKChannelInfo this_ptr_conv;
39762 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39763 this_ptr_conv.is_owned = false;
39764 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39765 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
39766 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
39767 uint32_t ret_ref = (uintptr_t)ret_copy;
39771 void __attribute__((export_name("TS_ChannelInfo_set_capacity_sats"))) TS_ChannelInfo_set_capacity_sats(uint32_t this_ptr, uint32_t val) {
39772 LDKChannelInfo this_ptr_conv;
39773 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39774 this_ptr_conv.is_owned = false;
39775 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39776 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
39777 CHECK_ACCESS(val_ptr);
39778 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
39779 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
39780 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
39783 uint32_t __attribute__((export_name("TS_ChannelInfo_get_announcement_message"))) TS_ChannelInfo_get_announcement_message(uint32_t this_ptr) {
39784 LDKChannelInfo this_ptr_conv;
39785 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39786 this_ptr_conv.is_owned = false;
39787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39788 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
39789 uint32_t ret_ref = 0;
39790 if ((uintptr_t)ret_var.inner > 4096) {
39791 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39792 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39793 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39794 ret_ref = (uintptr_t)ret_var.inner;
39795 if (ret_var.is_owned) {
39802 void __attribute__((export_name("TS_ChannelInfo_set_announcement_message"))) TS_ChannelInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) {
39803 LDKChannelInfo this_ptr_conv;
39804 this_ptr_conv.inner = (void*)(this_ptr & (~1));
39805 this_ptr_conv.is_owned = false;
39806 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
39807 LDKChannelAnnouncement val_conv;
39808 val_conv.inner = (void*)(val & (~1));
39809 val_conv.is_owned = (val & 1) || (val == 0);
39810 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
39811 val_conv = ChannelAnnouncement_clone(&val_conv);
39812 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
39815 static inline uintptr_t ChannelInfo_clone_ptr(LDKChannelInfo *NONNULL_PTR arg) {
39816 LDKChannelInfo ret_var = ChannelInfo_clone(arg);
39817 uint32_t ret_ref = 0;
39818 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39819 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39820 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39821 ret_ref = (uintptr_t)ret_var.inner;
39822 if (ret_var.is_owned) {
39827 uint32_t __attribute__((export_name("TS_ChannelInfo_clone_ptr"))) TS_ChannelInfo_clone_ptr(uint32_t arg) {
39828 LDKChannelInfo arg_conv;
39829 arg_conv.inner = (void*)(arg & (~1));
39830 arg_conv.is_owned = false;
39831 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39832 uint32_t ret_conv = ChannelInfo_clone_ptr(&arg_conv);
39836 uint32_t __attribute__((export_name("TS_ChannelInfo_clone"))) TS_ChannelInfo_clone(uint32_t orig) {
39837 LDKChannelInfo orig_conv;
39838 orig_conv.inner = (void*)(orig & (~1));
39839 orig_conv.is_owned = false;
39840 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39841 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
39842 uint32_t ret_ref = 0;
39843 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39844 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39845 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39846 ret_ref = (uintptr_t)ret_var.inner;
39847 if (ret_var.is_owned) {
39853 uint32_t __attribute__((export_name("TS_ChannelInfo_get_directional_info"))) TS_ChannelInfo_get_directional_info(uint32_t this_arg, int8_t channel_flags) {
39854 LDKChannelInfo this_arg_conv;
39855 this_arg_conv.inner = (void*)(this_arg & (~1));
39856 this_arg_conv.is_owned = false;
39857 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39858 LDKChannelUpdateInfo ret_var = ChannelInfo_get_directional_info(&this_arg_conv, channel_flags);
39859 uint32_t ret_ref = 0;
39860 if ((uintptr_t)ret_var.inner > 4096) {
39861 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39862 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39863 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39864 ret_ref = (uintptr_t)ret_var.inner;
39865 if (ret_var.is_owned) {
39872 int8_tArray __attribute__((export_name("TS_ChannelInfo_write"))) TS_ChannelInfo_write(uint32_t obj) {
39873 LDKChannelInfo obj_conv;
39874 obj_conv.inner = (void*)(obj & (~1));
39875 obj_conv.is_owned = false;
39876 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
39877 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
39878 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
39879 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
39880 CVec_u8Z_free(ret_var);
39884 uint32_t __attribute__((export_name("TS_ChannelInfo_read"))) TS_ChannelInfo_read(int8_tArray ser) {
39885 LDKu8slice ser_ref;
39886 ser_ref.datalen = ser->arr_len;
39887 ser_ref.data = ser->elems;
39888 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
39889 *ret_conv = ChannelInfo_read(ser_ref);
39891 return (uint32_t)ret_conv;
39894 void __attribute__((export_name("TS_DirectedChannelInfo_free"))) TS_DirectedChannelInfo_free(uint32_t this_obj) {
39895 LDKDirectedChannelInfo this_obj_conv;
39896 this_obj_conv.inner = (void*)(this_obj & (~1));
39897 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
39898 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
39899 DirectedChannelInfo_free(this_obj_conv);
39902 static inline uintptr_t DirectedChannelInfo_clone_ptr(LDKDirectedChannelInfo *NONNULL_PTR arg) {
39903 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(arg);
39904 uint32_t ret_ref = 0;
39905 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39906 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39907 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39908 ret_ref = (uintptr_t)ret_var.inner;
39909 if (ret_var.is_owned) {
39914 uint32_t __attribute__((export_name("TS_DirectedChannelInfo_clone_ptr"))) TS_DirectedChannelInfo_clone_ptr(uint32_t arg) {
39915 LDKDirectedChannelInfo arg_conv;
39916 arg_conv.inner = (void*)(arg & (~1));
39917 arg_conv.is_owned = false;
39918 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
39919 uint32_t ret_conv = DirectedChannelInfo_clone_ptr(&arg_conv);
39923 uint32_t __attribute__((export_name("TS_DirectedChannelInfo_clone"))) TS_DirectedChannelInfo_clone(uint32_t orig) {
39924 LDKDirectedChannelInfo orig_conv;
39925 orig_conv.inner = (void*)(orig & (~1));
39926 orig_conv.is_owned = false;
39927 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
39928 LDKDirectedChannelInfo ret_var = DirectedChannelInfo_clone(&orig_conv);
39929 uint32_t ret_ref = 0;
39930 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39931 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39932 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39933 ret_ref = (uintptr_t)ret_var.inner;
39934 if (ret_var.is_owned) {
39940 uint32_t __attribute__((export_name("TS_DirectedChannelInfo_channel"))) TS_DirectedChannelInfo_channel(uint32_t this_arg) {
39941 LDKDirectedChannelInfo this_arg_conv;
39942 this_arg_conv.inner = (void*)(this_arg & (~1));
39943 this_arg_conv.is_owned = false;
39944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39945 LDKChannelInfo ret_var = DirectedChannelInfo_channel(&this_arg_conv);
39946 uint32_t ret_ref = 0;
39947 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39948 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39949 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39950 ret_ref = (uintptr_t)ret_var.inner;
39951 if (ret_var.is_owned) {
39957 uint32_t __attribute__((export_name("TS_DirectedChannelInfo_direction"))) TS_DirectedChannelInfo_direction(uint32_t this_arg) {
39958 LDKDirectedChannelInfo this_arg_conv;
39959 this_arg_conv.inner = (void*)(this_arg & (~1));
39960 this_arg_conv.is_owned = false;
39961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39962 LDKChannelUpdateInfo ret_var = DirectedChannelInfo_direction(&this_arg_conv);
39963 uint32_t ret_ref = 0;
39964 if ((uintptr_t)ret_var.inner > 4096) {
39965 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
39966 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
39967 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
39968 ret_ref = (uintptr_t)ret_var.inner;
39969 if (ret_var.is_owned) {
39976 int64_t __attribute__((export_name("TS_DirectedChannelInfo_htlc_maximum_msat"))) TS_DirectedChannelInfo_htlc_maximum_msat(uint32_t this_arg) {
39977 LDKDirectedChannelInfo this_arg_conv;
39978 this_arg_conv.inner = (void*)(this_arg & (~1));
39979 this_arg_conv.is_owned = false;
39980 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39981 int64_t ret_conv = DirectedChannelInfo_htlc_maximum_msat(&this_arg_conv);
39985 uint32_t __attribute__((export_name("TS_DirectedChannelInfo_effective_capacity"))) TS_DirectedChannelInfo_effective_capacity(uint32_t this_arg) {
39986 LDKDirectedChannelInfo this_arg_conv;
39987 this_arg_conv.inner = (void*)(this_arg & (~1));
39988 this_arg_conv.is_owned = false;
39989 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
39990 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
39991 *ret_copy = DirectedChannelInfo_effective_capacity(&this_arg_conv);
39992 uint32_t ret_ref = (uintptr_t)ret_copy;
39996 void __attribute__((export_name("TS_EffectiveCapacity_free"))) TS_EffectiveCapacity_free(uint32_t this_ptr) {
39997 if ((this_ptr & 1) != 0) return;
39998 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
39999 CHECK_ACCESS(this_ptr_ptr);
40000 LDKEffectiveCapacity this_ptr_conv = *(LDKEffectiveCapacity*)(this_ptr_ptr);
40001 FREE((void*)this_ptr);
40002 EffectiveCapacity_free(this_ptr_conv);
40005 static inline uintptr_t EffectiveCapacity_clone_ptr(LDKEffectiveCapacity *NONNULL_PTR arg) {
40006 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40007 *ret_copy = EffectiveCapacity_clone(arg);
40008 uint32_t ret_ref = (uintptr_t)ret_copy;
40011 uint32_t __attribute__((export_name("TS_EffectiveCapacity_clone_ptr"))) TS_EffectiveCapacity_clone_ptr(uint32_t arg) {
40012 LDKEffectiveCapacity* arg_conv = (LDKEffectiveCapacity*)arg;
40013 uint32_t ret_conv = EffectiveCapacity_clone_ptr(arg_conv);
40017 uint32_t __attribute__((export_name("TS_EffectiveCapacity_clone"))) TS_EffectiveCapacity_clone(uint32_t orig) {
40018 LDKEffectiveCapacity* orig_conv = (LDKEffectiveCapacity*)orig;
40019 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40020 *ret_copy = EffectiveCapacity_clone(orig_conv);
40021 uint32_t ret_ref = (uintptr_t)ret_copy;
40025 uint32_t __attribute__((export_name("TS_EffectiveCapacity_exact_liquidity"))) TS_EffectiveCapacity_exact_liquidity(int64_t liquidity_msat) {
40026 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40027 *ret_copy = EffectiveCapacity_exact_liquidity(liquidity_msat);
40028 uint32_t ret_ref = (uintptr_t)ret_copy;
40032 uint32_t __attribute__((export_name("TS_EffectiveCapacity_maximum_htlc"))) TS_EffectiveCapacity_maximum_htlc(int64_t amount_msat) {
40033 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40034 *ret_copy = EffectiveCapacity_maximum_htlc(amount_msat);
40035 uint32_t ret_ref = (uintptr_t)ret_copy;
40039 uint32_t __attribute__((export_name("TS_EffectiveCapacity_total"))) TS_EffectiveCapacity_total(int64_t capacity_msat, uint32_t htlc_maximum_msat) {
40040 void* htlc_maximum_msat_ptr = (void*)(((uintptr_t)htlc_maximum_msat) & ~1);
40041 CHECK_ACCESS(htlc_maximum_msat_ptr);
40042 LDKCOption_u64Z htlc_maximum_msat_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_ptr);
40043 htlc_maximum_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)htlc_maximum_msat) & ~1));
40044 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40045 *ret_copy = EffectiveCapacity_total(capacity_msat, htlc_maximum_msat_conv);
40046 uint32_t ret_ref = (uintptr_t)ret_copy;
40050 uint32_t __attribute__((export_name("TS_EffectiveCapacity_infinite"))) TS_EffectiveCapacity_infinite() {
40051 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40052 *ret_copy = EffectiveCapacity_infinite();
40053 uint32_t ret_ref = (uintptr_t)ret_copy;
40057 uint32_t __attribute__((export_name("TS_EffectiveCapacity_unknown"))) TS_EffectiveCapacity_unknown() {
40058 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
40059 *ret_copy = EffectiveCapacity_unknown();
40060 uint32_t ret_ref = (uintptr_t)ret_copy;
40064 int64_t __attribute__((export_name("TS_EffectiveCapacity_as_msat"))) TS_EffectiveCapacity_as_msat(uint32_t this_arg) {
40065 LDKEffectiveCapacity* this_arg_conv = (LDKEffectiveCapacity*)this_arg;
40066 int64_t ret_conv = EffectiveCapacity_as_msat(this_arg_conv);
40070 void __attribute__((export_name("TS_RoutingFees_free"))) TS_RoutingFees_free(uint32_t this_obj) {
40071 LDKRoutingFees this_obj_conv;
40072 this_obj_conv.inner = (void*)(this_obj & (~1));
40073 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
40074 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40075 RoutingFees_free(this_obj_conv);
40078 int32_t __attribute__((export_name("TS_RoutingFees_get_base_msat"))) TS_RoutingFees_get_base_msat(uint32_t this_ptr) {
40079 LDKRoutingFees this_ptr_conv;
40080 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40081 this_ptr_conv.is_owned = false;
40082 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40083 int32_t ret_conv = RoutingFees_get_base_msat(&this_ptr_conv);
40087 void __attribute__((export_name("TS_RoutingFees_set_base_msat"))) TS_RoutingFees_set_base_msat(uint32_t this_ptr, int32_t val) {
40088 LDKRoutingFees this_ptr_conv;
40089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40090 this_ptr_conv.is_owned = false;
40091 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40092 RoutingFees_set_base_msat(&this_ptr_conv, val);
40095 int32_t __attribute__((export_name("TS_RoutingFees_get_proportional_millionths"))) TS_RoutingFees_get_proportional_millionths(uint32_t this_ptr) {
40096 LDKRoutingFees this_ptr_conv;
40097 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40098 this_ptr_conv.is_owned = false;
40099 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40100 int32_t ret_conv = RoutingFees_get_proportional_millionths(&this_ptr_conv);
40104 void __attribute__((export_name("TS_RoutingFees_set_proportional_millionths"))) TS_RoutingFees_set_proportional_millionths(uint32_t this_ptr, int32_t val) {
40105 LDKRoutingFees this_ptr_conv;
40106 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40107 this_ptr_conv.is_owned = false;
40108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40109 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
40112 uint32_t __attribute__((export_name("TS_RoutingFees_new"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
40113 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
40114 uint32_t ret_ref = 0;
40115 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40116 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40117 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40118 ret_ref = (uintptr_t)ret_var.inner;
40119 if (ret_var.is_owned) {
40125 jboolean __attribute__((export_name("TS_RoutingFees_eq"))) TS_RoutingFees_eq(uint32_t a, uint32_t b) {
40126 LDKRoutingFees a_conv;
40127 a_conv.inner = (void*)(a & (~1));
40128 a_conv.is_owned = false;
40129 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
40130 LDKRoutingFees b_conv;
40131 b_conv.inner = (void*)(b & (~1));
40132 b_conv.is_owned = false;
40133 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
40134 jboolean ret_conv = RoutingFees_eq(&a_conv, &b_conv);
40138 static inline uintptr_t RoutingFees_clone_ptr(LDKRoutingFees *NONNULL_PTR arg) {
40139 LDKRoutingFees ret_var = RoutingFees_clone(arg);
40140 uint32_t ret_ref = 0;
40141 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40142 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40143 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40144 ret_ref = (uintptr_t)ret_var.inner;
40145 if (ret_var.is_owned) {
40150 uint32_t __attribute__((export_name("TS_RoutingFees_clone_ptr"))) TS_RoutingFees_clone_ptr(uint32_t arg) {
40151 LDKRoutingFees arg_conv;
40152 arg_conv.inner = (void*)(arg & (~1));
40153 arg_conv.is_owned = false;
40154 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40155 uint32_t ret_conv = RoutingFees_clone_ptr(&arg_conv);
40159 uint32_t __attribute__((export_name("TS_RoutingFees_clone"))) TS_RoutingFees_clone(uint32_t orig) {
40160 LDKRoutingFees orig_conv;
40161 orig_conv.inner = (void*)(orig & (~1));
40162 orig_conv.is_owned = false;
40163 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40164 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
40165 uint32_t ret_ref = 0;
40166 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40167 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40168 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40169 ret_ref = (uintptr_t)ret_var.inner;
40170 if (ret_var.is_owned) {
40176 int64_t __attribute__((export_name("TS_RoutingFees_hash"))) TS_RoutingFees_hash(uint32_t o) {
40177 LDKRoutingFees o_conv;
40178 o_conv.inner = (void*)(o & (~1));
40179 o_conv.is_owned = false;
40180 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
40181 int64_t ret_conv = RoutingFees_hash(&o_conv);
40185 int8_tArray __attribute__((export_name("TS_RoutingFees_write"))) TS_RoutingFees_write(uint32_t obj) {
40186 LDKRoutingFees obj_conv;
40187 obj_conv.inner = (void*)(obj & (~1));
40188 obj_conv.is_owned = false;
40189 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40190 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
40191 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40192 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40193 CVec_u8Z_free(ret_var);
40197 uint32_t __attribute__((export_name("TS_RoutingFees_read"))) TS_RoutingFees_read(int8_tArray ser) {
40198 LDKu8slice ser_ref;
40199 ser_ref.datalen = ser->arr_len;
40200 ser_ref.data = ser->elems;
40201 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
40202 *ret_conv = RoutingFees_read(ser_ref);
40204 return (uint32_t)ret_conv;
40207 void __attribute__((export_name("TS_NodeAnnouncementInfo_free"))) TS_NodeAnnouncementInfo_free(uint32_t this_obj) {
40208 LDKNodeAnnouncementInfo this_obj_conv;
40209 this_obj_conv.inner = (void*)(this_obj & (~1));
40210 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
40211 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40212 NodeAnnouncementInfo_free(this_obj_conv);
40215 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_features"))) TS_NodeAnnouncementInfo_get_features(uint32_t this_ptr) {
40216 LDKNodeAnnouncementInfo this_ptr_conv;
40217 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40218 this_ptr_conv.is_owned = false;
40219 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40220 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
40221 uint32_t ret_ref = 0;
40222 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40223 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40224 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40225 ret_ref = (uintptr_t)ret_var.inner;
40226 if (ret_var.is_owned) {
40232 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_features"))) TS_NodeAnnouncementInfo_set_features(uint32_t this_ptr, uint32_t val) {
40233 LDKNodeAnnouncementInfo this_ptr_conv;
40234 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40235 this_ptr_conv.is_owned = false;
40236 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40237 LDKNodeFeatures val_conv;
40238 val_conv.inner = (void*)(val & (~1));
40239 val_conv.is_owned = (val & 1) || (val == 0);
40240 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40241 val_conv = NodeFeatures_clone(&val_conv);
40242 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
40245 int32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_last_update"))) TS_NodeAnnouncementInfo_get_last_update(uint32_t this_ptr) {
40246 LDKNodeAnnouncementInfo this_ptr_conv;
40247 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40248 this_ptr_conv.is_owned = false;
40249 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40250 int32_t ret_conv = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
40254 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_last_update"))) TS_NodeAnnouncementInfo_set_last_update(uint32_t this_ptr, int32_t val) {
40255 LDKNodeAnnouncementInfo this_ptr_conv;
40256 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40257 this_ptr_conv.is_owned = false;
40258 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40259 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
40262 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_get_rgb"))) TS_NodeAnnouncementInfo_get_rgb(uint32_t this_ptr) {
40263 LDKNodeAnnouncementInfo this_ptr_conv;
40264 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40265 this_ptr_conv.is_owned = false;
40266 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40267 int8_tArray ret_arr = init_int8_tArray(3, __LINE__);
40268 memcpy(ret_arr->elems, *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
40272 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_rgb"))) TS_NodeAnnouncementInfo_set_rgb(uint32_t this_ptr, int8_tArray val) {
40273 LDKNodeAnnouncementInfo this_ptr_conv;
40274 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40275 this_ptr_conv.is_owned = false;
40276 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40277 LDKThreeBytes val_ref;
40278 CHECK(val->arr_len == 3);
40279 memcpy(val_ref.data, val->elems, 3); FREE(val);
40280 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
40283 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_alias"))) TS_NodeAnnouncementInfo_get_alias(uint32_t this_ptr) {
40284 LDKNodeAnnouncementInfo this_ptr_conv;
40285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40286 this_ptr_conv.is_owned = false;
40287 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40288 LDKNodeAlias ret_var = NodeAnnouncementInfo_get_alias(&this_ptr_conv);
40289 uint32_t ret_ref = 0;
40290 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40291 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40292 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40293 ret_ref = (uintptr_t)ret_var.inner;
40294 if (ret_var.is_owned) {
40300 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_alias"))) TS_NodeAnnouncementInfo_set_alias(uint32_t this_ptr, uint32_t val) {
40301 LDKNodeAnnouncementInfo this_ptr_conv;
40302 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40303 this_ptr_conv.is_owned = false;
40304 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40305 LDKNodeAlias val_conv;
40306 val_conv.inner = (void*)(val & (~1));
40307 val_conv.is_owned = (val & 1) || (val == 0);
40308 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40309 val_conv = NodeAlias_clone(&val_conv);
40310 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_conv);
40313 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_addresses"))) TS_NodeAnnouncementInfo_set_addresses(uint32_t this_ptr, uint32_tArray val) {
40314 LDKNodeAnnouncementInfo this_ptr_conv;
40315 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40316 this_ptr_conv.is_owned = false;
40317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40318 LDKCVec_NetAddressZ val_constr;
40319 val_constr.datalen = val->arr_len;
40320 if (val_constr.datalen > 0)
40321 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
40323 val_constr.data = NULL;
40324 uint32_t* val_vals = val->elems;
40325 for (size_t m = 0; m < val_constr.datalen; m++) {
40326 uint32_t val_conv_12 = val_vals[m];
40327 void* val_conv_12_ptr = (void*)(((uintptr_t)val_conv_12) & ~1);
40328 CHECK_ACCESS(val_conv_12_ptr);
40329 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(val_conv_12_ptr);
40330 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uintptr_t)val_conv_12) & ~1));
40331 val_constr.data[m] = val_conv_12_conv;
40334 NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr);
40337 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_get_announcement_message"))) TS_NodeAnnouncementInfo_get_announcement_message(uint32_t this_ptr) {
40338 LDKNodeAnnouncementInfo this_ptr_conv;
40339 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40340 this_ptr_conv.is_owned = false;
40341 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40342 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
40343 uint32_t ret_ref = 0;
40344 if ((uintptr_t)ret_var.inner > 4096) {
40345 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40346 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40347 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40348 ret_ref = (uintptr_t)ret_var.inner;
40349 if (ret_var.is_owned) {
40356 void __attribute__((export_name("TS_NodeAnnouncementInfo_set_announcement_message"))) TS_NodeAnnouncementInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) {
40357 LDKNodeAnnouncementInfo this_ptr_conv;
40358 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40359 this_ptr_conv.is_owned = false;
40360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40361 LDKNodeAnnouncement val_conv;
40362 val_conv.inner = (void*)(val & (~1));
40363 val_conv.is_owned = (val & 1) || (val == 0);
40364 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40365 val_conv = NodeAnnouncement_clone(&val_conv);
40366 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
40369 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_new"))) TS_NodeAnnouncementInfo_new(uint32_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, uint32_t alias_arg, uint32_tArray addresses_arg, uint32_t announcement_message_arg) {
40370 LDKNodeFeatures features_arg_conv;
40371 features_arg_conv.inner = (void*)(features_arg & (~1));
40372 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
40373 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
40374 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
40375 LDKThreeBytes rgb_arg_ref;
40376 CHECK(rgb_arg->arr_len == 3);
40377 memcpy(rgb_arg_ref.data, rgb_arg->elems, 3); FREE(rgb_arg);
40378 LDKNodeAlias alias_arg_conv;
40379 alias_arg_conv.inner = (void*)(alias_arg & (~1));
40380 alias_arg_conv.is_owned = (alias_arg & 1) || (alias_arg == 0);
40381 CHECK_INNER_FIELD_ACCESS_OR_NULL(alias_arg_conv);
40382 alias_arg_conv = NodeAlias_clone(&alias_arg_conv);
40383 LDKCVec_NetAddressZ addresses_arg_constr;
40384 addresses_arg_constr.datalen = addresses_arg->arr_len;
40385 if (addresses_arg_constr.datalen > 0)
40386 addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
40388 addresses_arg_constr.data = NULL;
40389 uint32_t* addresses_arg_vals = addresses_arg->elems;
40390 for (size_t m = 0; m < addresses_arg_constr.datalen; m++) {
40391 uint32_t addresses_arg_conv_12 = addresses_arg_vals[m];
40392 void* addresses_arg_conv_12_ptr = (void*)(((uintptr_t)addresses_arg_conv_12) & ~1);
40393 CHECK_ACCESS(addresses_arg_conv_12_ptr);
40394 LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(addresses_arg_conv_12_ptr);
40395 addresses_arg_constr.data[m] = addresses_arg_conv_12_conv;
40397 FREE(addresses_arg);
40398 LDKNodeAnnouncement announcement_message_arg_conv;
40399 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
40400 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
40401 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_message_arg_conv);
40402 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
40403 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_conv, addresses_arg_constr, announcement_message_arg_conv);
40404 uint32_t ret_ref = 0;
40405 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40406 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40407 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40408 ret_ref = (uintptr_t)ret_var.inner;
40409 if (ret_var.is_owned) {
40415 static inline uintptr_t NodeAnnouncementInfo_clone_ptr(LDKNodeAnnouncementInfo *NONNULL_PTR arg) {
40416 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(arg);
40417 uint32_t ret_ref = 0;
40418 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40419 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40420 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40421 ret_ref = (uintptr_t)ret_var.inner;
40422 if (ret_var.is_owned) {
40427 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone_ptr"))) TS_NodeAnnouncementInfo_clone_ptr(uint32_t arg) {
40428 LDKNodeAnnouncementInfo arg_conv;
40429 arg_conv.inner = (void*)(arg & (~1));
40430 arg_conv.is_owned = false;
40431 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40432 uint32_t ret_conv = NodeAnnouncementInfo_clone_ptr(&arg_conv);
40436 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_clone"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) {
40437 LDKNodeAnnouncementInfo orig_conv;
40438 orig_conv.inner = (void*)(orig & (~1));
40439 orig_conv.is_owned = false;
40440 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40441 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
40442 uint32_t ret_ref = 0;
40443 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40444 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40445 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40446 ret_ref = (uintptr_t)ret_var.inner;
40447 if (ret_var.is_owned) {
40453 int8_tArray __attribute__((export_name("TS_NodeAnnouncementInfo_write"))) TS_NodeAnnouncementInfo_write(uint32_t obj) {
40454 LDKNodeAnnouncementInfo obj_conv;
40455 obj_conv.inner = (void*)(obj & (~1));
40456 obj_conv.is_owned = false;
40457 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40458 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
40459 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40460 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40461 CVec_u8Z_free(ret_var);
40465 uint32_t __attribute__((export_name("TS_NodeAnnouncementInfo_read"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
40466 LDKu8slice ser_ref;
40467 ser_ref.datalen = ser->arr_len;
40468 ser_ref.data = ser->elems;
40469 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
40470 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
40472 return (uint32_t)ret_conv;
40475 void __attribute__((export_name("TS_NodeAlias_free"))) TS_NodeAlias_free(uint32_t this_obj) {
40476 LDKNodeAlias this_obj_conv;
40477 this_obj_conv.inner = (void*)(this_obj & (~1));
40478 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
40479 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40480 NodeAlias_free(this_obj_conv);
40483 int8_tArray __attribute__((export_name("TS_NodeAlias_get_a"))) TS_NodeAlias_get_a(uint32_t this_ptr) {
40484 LDKNodeAlias this_ptr_conv;
40485 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40486 this_ptr_conv.is_owned = false;
40487 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40488 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
40489 memcpy(ret_arr->elems, *NodeAlias_get_a(&this_ptr_conv), 32);
40493 void __attribute__((export_name("TS_NodeAlias_set_a"))) TS_NodeAlias_set_a(uint32_t this_ptr, int8_tArray val) {
40494 LDKNodeAlias this_ptr_conv;
40495 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40496 this_ptr_conv.is_owned = false;
40497 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40498 LDKThirtyTwoBytes val_ref;
40499 CHECK(val->arr_len == 32);
40500 memcpy(val_ref.data, val->elems, 32); FREE(val);
40501 NodeAlias_set_a(&this_ptr_conv, val_ref);
40504 uint32_t __attribute__((export_name("TS_NodeAlias_new"))) TS_NodeAlias_new(int8_tArray a_arg) {
40505 LDKThirtyTwoBytes a_arg_ref;
40506 CHECK(a_arg->arr_len == 32);
40507 memcpy(a_arg_ref.data, a_arg->elems, 32); FREE(a_arg);
40508 LDKNodeAlias ret_var = NodeAlias_new(a_arg_ref);
40509 uint32_t ret_ref = 0;
40510 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40511 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40512 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40513 ret_ref = (uintptr_t)ret_var.inner;
40514 if (ret_var.is_owned) {
40520 static inline uintptr_t NodeAlias_clone_ptr(LDKNodeAlias *NONNULL_PTR arg) {
40521 LDKNodeAlias ret_var = NodeAlias_clone(arg);
40522 uint32_t ret_ref = 0;
40523 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40524 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40526 ret_ref = (uintptr_t)ret_var.inner;
40527 if (ret_var.is_owned) {
40532 uint32_t __attribute__((export_name("TS_NodeAlias_clone_ptr"))) TS_NodeAlias_clone_ptr(uint32_t arg) {
40533 LDKNodeAlias arg_conv;
40534 arg_conv.inner = (void*)(arg & (~1));
40535 arg_conv.is_owned = false;
40536 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40537 uint32_t ret_conv = NodeAlias_clone_ptr(&arg_conv);
40541 uint32_t __attribute__((export_name("TS_NodeAlias_clone"))) TS_NodeAlias_clone(uint32_t orig) {
40542 LDKNodeAlias orig_conv;
40543 orig_conv.inner = (void*)(orig & (~1));
40544 orig_conv.is_owned = false;
40545 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40546 LDKNodeAlias ret_var = NodeAlias_clone(&orig_conv);
40547 uint32_t ret_ref = 0;
40548 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40549 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40550 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40551 ret_ref = (uintptr_t)ret_var.inner;
40552 if (ret_var.is_owned) {
40558 int8_tArray __attribute__((export_name("TS_NodeAlias_write"))) TS_NodeAlias_write(uint32_t obj) {
40559 LDKNodeAlias obj_conv;
40560 obj_conv.inner = (void*)(obj & (~1));
40561 obj_conv.is_owned = false;
40562 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40563 LDKCVec_u8Z ret_var = NodeAlias_write(&obj_conv);
40564 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40565 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40566 CVec_u8Z_free(ret_var);
40570 uint32_t __attribute__((export_name("TS_NodeAlias_read"))) TS_NodeAlias_read(int8_tArray ser) {
40571 LDKu8slice ser_ref;
40572 ser_ref.datalen = ser->arr_len;
40573 ser_ref.data = ser->elems;
40574 LDKCResult_NodeAliasDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAliasDecodeErrorZ), "LDKCResult_NodeAliasDecodeErrorZ");
40575 *ret_conv = NodeAlias_read(ser_ref);
40577 return (uint32_t)ret_conv;
40580 void __attribute__((export_name("TS_NodeInfo_free"))) TS_NodeInfo_free(uint32_t this_obj) {
40581 LDKNodeInfo this_obj_conv;
40582 this_obj_conv.inner = (void*)(this_obj & (~1));
40583 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
40584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
40585 NodeInfo_free(this_obj_conv);
40588 void __attribute__((export_name("TS_NodeInfo_set_channels"))) TS_NodeInfo_set_channels(uint32_t this_ptr, int64_tArray val) {
40589 LDKNodeInfo this_ptr_conv;
40590 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40591 this_ptr_conv.is_owned = false;
40592 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40593 LDKCVec_u64Z val_constr;
40594 val_constr.datalen = val->arr_len;
40595 if (val_constr.datalen > 0)
40596 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
40598 val_constr.data = NULL;
40599 int64_t* val_vals = val->elems;
40600 for (size_t i = 0; i < val_constr.datalen; i++) {
40601 int64_t val_conv_8 = val_vals[i];
40602 val_constr.data[i] = val_conv_8;
40605 NodeInfo_set_channels(&this_ptr_conv, val_constr);
40608 uint32_t __attribute__((export_name("TS_NodeInfo_get_lowest_inbound_channel_fees"))) TS_NodeInfo_get_lowest_inbound_channel_fees(uint32_t this_ptr) {
40609 LDKNodeInfo this_ptr_conv;
40610 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40611 this_ptr_conv.is_owned = false;
40612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40613 LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
40614 uint32_t ret_ref = 0;
40615 if ((uintptr_t)ret_var.inner > 4096) {
40616 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40617 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40618 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40619 ret_ref = (uintptr_t)ret_var.inner;
40620 if (ret_var.is_owned) {
40627 void __attribute__((export_name("TS_NodeInfo_set_lowest_inbound_channel_fees"))) TS_NodeInfo_set_lowest_inbound_channel_fees(uint32_t this_ptr, uint32_t val) {
40628 LDKNodeInfo this_ptr_conv;
40629 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40630 this_ptr_conv.is_owned = false;
40631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40632 LDKRoutingFees val_conv;
40633 val_conv.inner = (void*)(val & (~1));
40634 val_conv.is_owned = (val & 1) || (val == 0);
40635 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40636 val_conv = RoutingFees_clone(&val_conv);
40637 NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
40640 uint32_t __attribute__((export_name("TS_NodeInfo_get_announcement_info"))) TS_NodeInfo_get_announcement_info(uint32_t this_ptr) {
40641 LDKNodeInfo this_ptr_conv;
40642 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40643 this_ptr_conv.is_owned = false;
40644 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40645 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
40646 uint32_t ret_ref = 0;
40647 if ((uintptr_t)ret_var.inner > 4096) {
40648 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40649 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40650 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40651 ret_ref = (uintptr_t)ret_var.inner;
40652 if (ret_var.is_owned) {
40659 void __attribute__((export_name("TS_NodeInfo_set_announcement_info"))) TS_NodeInfo_set_announcement_info(uint32_t this_ptr, uint32_t val) {
40660 LDKNodeInfo this_ptr_conv;
40661 this_ptr_conv.inner = (void*)(this_ptr & (~1));
40662 this_ptr_conv.is_owned = false;
40663 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
40664 LDKNodeAnnouncementInfo val_conv;
40665 val_conv.inner = (void*)(val & (~1));
40666 val_conv.is_owned = (val & 1) || (val == 0);
40667 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
40668 val_conv = NodeAnnouncementInfo_clone(&val_conv);
40669 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
40672 uint32_t __attribute__((export_name("TS_NodeInfo_new"))) TS_NodeInfo_new(int64_tArray channels_arg, uint32_t lowest_inbound_channel_fees_arg, uint32_t announcement_info_arg) {
40673 LDKCVec_u64Z channels_arg_constr;
40674 channels_arg_constr.datalen = channels_arg->arr_len;
40675 if (channels_arg_constr.datalen > 0)
40676 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
40678 channels_arg_constr.data = NULL;
40679 int64_t* channels_arg_vals = channels_arg->elems;
40680 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
40681 int64_t channels_arg_conv_8 = channels_arg_vals[i];
40682 channels_arg_constr.data[i] = channels_arg_conv_8;
40684 FREE(channels_arg);
40685 LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
40686 lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
40687 lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
40688 CHECK_INNER_FIELD_ACCESS_OR_NULL(lowest_inbound_channel_fees_arg_conv);
40689 lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
40690 LDKNodeAnnouncementInfo announcement_info_arg_conv;
40691 announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
40692 announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
40693 CHECK_INNER_FIELD_ACCESS_OR_NULL(announcement_info_arg_conv);
40694 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
40695 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
40696 uint32_t ret_ref = 0;
40697 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40698 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40699 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40700 ret_ref = (uintptr_t)ret_var.inner;
40701 if (ret_var.is_owned) {
40707 static inline uintptr_t NodeInfo_clone_ptr(LDKNodeInfo *NONNULL_PTR arg) {
40708 LDKNodeInfo ret_var = NodeInfo_clone(arg);
40709 uint32_t ret_ref = 0;
40710 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40711 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40712 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40713 ret_ref = (uintptr_t)ret_var.inner;
40714 if (ret_var.is_owned) {
40719 uint32_t __attribute__((export_name("TS_NodeInfo_clone_ptr"))) TS_NodeInfo_clone_ptr(uint32_t arg) {
40720 LDKNodeInfo arg_conv;
40721 arg_conv.inner = (void*)(arg & (~1));
40722 arg_conv.is_owned = false;
40723 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
40724 uint32_t ret_conv = NodeInfo_clone_ptr(&arg_conv);
40728 uint32_t __attribute__((export_name("TS_NodeInfo_clone"))) TS_NodeInfo_clone(uint32_t orig) {
40729 LDKNodeInfo orig_conv;
40730 orig_conv.inner = (void*)(orig & (~1));
40731 orig_conv.is_owned = false;
40732 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
40733 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
40734 uint32_t ret_ref = 0;
40735 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40736 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40737 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40738 ret_ref = (uintptr_t)ret_var.inner;
40739 if (ret_var.is_owned) {
40745 int8_tArray __attribute__((export_name("TS_NodeInfo_write"))) TS_NodeInfo_write(uint32_t obj) {
40746 LDKNodeInfo obj_conv;
40747 obj_conv.inner = (void*)(obj & (~1));
40748 obj_conv.is_owned = false;
40749 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40750 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
40751 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40752 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40753 CVec_u8Z_free(ret_var);
40757 uint32_t __attribute__((export_name("TS_NodeInfo_read"))) TS_NodeInfo_read(int8_tArray ser) {
40758 LDKu8slice ser_ref;
40759 ser_ref.datalen = ser->arr_len;
40760 ser_ref.data = ser->elems;
40761 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
40762 *ret_conv = NodeInfo_read(ser_ref);
40764 return (uint32_t)ret_conv;
40767 int8_tArray __attribute__((export_name("TS_NetworkGraph_write"))) TS_NetworkGraph_write(uint32_t obj) {
40768 LDKNetworkGraph obj_conv;
40769 obj_conv.inner = (void*)(obj & (~1));
40770 obj_conv.is_owned = false;
40771 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
40772 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
40773 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
40774 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
40775 CVec_u8Z_free(ret_var);
40779 uint32_t __attribute__((export_name("TS_NetworkGraph_read"))) TS_NetworkGraph_read(int8_tArray ser, uint32_t arg) {
40780 LDKu8slice ser_ref;
40781 ser_ref.datalen = ser->arr_len;
40782 ser_ref.data = ser->elems;
40783 void* arg_ptr = (void*)(((uintptr_t)arg) & ~1);
40784 CHECK_ACCESS(arg_ptr);
40785 LDKLogger arg_conv = *(LDKLogger*)(arg_ptr);
40786 if (arg_conv.free == LDKLogger_JCalls_free) {
40787 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
40788 LDKLogger_JCalls_cloned(&arg_conv);
40790 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
40791 *ret_conv = NetworkGraph_read(ser_ref, arg_conv);
40793 return (uint32_t)ret_conv;
40796 uint32_t __attribute__((export_name("TS_NetworkGraph_new"))) TS_NetworkGraph_new(int8_tArray genesis_hash, uint32_t logger) {
40797 LDKThirtyTwoBytes genesis_hash_ref;
40798 CHECK(genesis_hash->arr_len == 32);
40799 memcpy(genesis_hash_ref.data, genesis_hash->elems, 32); FREE(genesis_hash);
40800 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
40801 CHECK_ACCESS(logger_ptr);
40802 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
40803 if (logger_conv.free == LDKLogger_JCalls_free) {
40804 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
40805 LDKLogger_JCalls_cloned(&logger_conv);
40807 LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref, logger_conv);
40808 uint32_t ret_ref = 0;
40809 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40810 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40811 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40812 ret_ref = (uintptr_t)ret_var.inner;
40813 if (ret_var.is_owned) {
40819 uint32_t __attribute__((export_name("TS_NetworkGraph_read_only"))) TS_NetworkGraph_read_only(uint32_t this_arg) {
40820 LDKNetworkGraph this_arg_conv;
40821 this_arg_conv.inner = (void*)(this_arg & (~1));
40822 this_arg_conv.is_owned = false;
40823 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40824 LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_conv);
40825 uint32_t ret_ref = 0;
40826 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
40827 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
40828 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
40829 ret_ref = (uintptr_t)ret_var.inner;
40830 if (ret_var.is_owned) {
40836 uint32_t __attribute__((export_name("TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp"))) TS_NetworkGraph_get_last_rapid_gossip_sync_timestamp(uint32_t this_arg) {
40837 LDKNetworkGraph this_arg_conv;
40838 this_arg_conv.inner = (void*)(this_arg & (~1));
40839 this_arg_conv.is_owned = false;
40840 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40841 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
40842 *ret_copy = NetworkGraph_get_last_rapid_gossip_sync_timestamp(&this_arg_conv);
40843 uint32_t ret_ref = (uintptr_t)ret_copy;
40847 void __attribute__((export_name("TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp"))) TS_NetworkGraph_set_last_rapid_gossip_sync_timestamp(uint32_t this_arg, int32_t last_rapid_gossip_sync_timestamp) {
40848 LDKNetworkGraph this_arg_conv;
40849 this_arg_conv.inner = (void*)(this_arg & (~1));
40850 this_arg_conv.is_owned = false;
40851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40852 NetworkGraph_set_last_rapid_gossip_sync_timestamp(&this_arg_conv, last_rapid_gossip_sync_timestamp);
40855 uint32_t __attribute__((export_name("TS_NetworkGraph_update_node_from_announcement"))) TS_NetworkGraph_update_node_from_announcement(uint32_t this_arg, uint32_t msg) {
40856 LDKNetworkGraph this_arg_conv;
40857 this_arg_conv.inner = (void*)(this_arg & (~1));
40858 this_arg_conv.is_owned = false;
40859 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40860 LDKNodeAnnouncement msg_conv;
40861 msg_conv.inner = (void*)(msg & (~1));
40862 msg_conv.is_owned = false;
40863 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
40864 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40865 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
40866 return (uint32_t)ret_conv;
40869 uint32_t __attribute__((export_name("TS_NetworkGraph_update_node_from_unsigned_announcement"))) TS_NetworkGraph_update_node_from_unsigned_announcement(uint32_t this_arg, uint32_t msg) {
40870 LDKNetworkGraph this_arg_conv;
40871 this_arg_conv.inner = (void*)(this_arg & (~1));
40872 this_arg_conv.is_owned = false;
40873 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40874 LDKUnsignedNodeAnnouncement msg_conv;
40875 msg_conv.inner = (void*)(msg & (~1));
40876 msg_conv.is_owned = false;
40877 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
40878 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40879 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
40880 return (uint32_t)ret_conv;
40883 uint32_t __attribute__((export_name("TS_NetworkGraph_update_channel_from_announcement"))) TS_NetworkGraph_update_channel_from_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) {
40884 LDKNetworkGraph this_arg_conv;
40885 this_arg_conv.inner = (void*)(this_arg & (~1));
40886 this_arg_conv.is_owned = false;
40887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40888 LDKChannelAnnouncement msg_conv;
40889 msg_conv.inner = (void*)(msg & (~1));
40890 msg_conv.is_owned = false;
40891 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
40892 void* chain_access_ptr = (void*)(((uintptr_t)chain_access) & ~1);
40893 CHECK_ACCESS(chain_access_ptr);
40894 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
40895 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
40896 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
40897 // Manually implement clone for Java trait instances
40898 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
40899 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
40900 LDKAccess_JCalls_cloned(&chain_access_conv.some);
40903 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40904 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv);
40905 return (uint32_t)ret_conv;
40908 uint32_t __attribute__((export_name("TS_NetworkGraph_update_channel_from_unsigned_announcement"))) TS_NetworkGraph_update_channel_from_unsigned_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) {
40909 LDKNetworkGraph this_arg_conv;
40910 this_arg_conv.inner = (void*)(this_arg & (~1));
40911 this_arg_conv.is_owned = false;
40912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40913 LDKUnsignedChannelAnnouncement msg_conv;
40914 msg_conv.inner = (void*)(msg & (~1));
40915 msg_conv.is_owned = false;
40916 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
40917 void* chain_access_ptr = (void*)(((uintptr_t)chain_access) & ~1);
40918 CHECK_ACCESS(chain_access_ptr);
40919 LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(chain_access_ptr);
40920 // WARNING: we may need a move here but no clone is available for LDKCOption_AccessZ
40921 if (chain_access_conv.tag == LDKCOption_AccessZ_Some) {
40922 // Manually implement clone for Java trait instances
40923 if (chain_access_conv.some.free == LDKAccess_JCalls_free) {
40924 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
40925 LDKAccess_JCalls_cloned(&chain_access_conv.some);
40928 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40929 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv);
40930 return (uint32_t)ret_conv;
40933 uint32_t __attribute__((export_name("TS_NetworkGraph_add_channel_from_partial_announcement"))) TS_NetworkGraph_add_channel_from_partial_announcement(uint32_t this_arg, int64_t short_channel_id, int64_t timestamp, uint32_t features, int8_tArray node_id_1, int8_tArray node_id_2) {
40934 LDKNetworkGraph this_arg_conv;
40935 this_arg_conv.inner = (void*)(this_arg & (~1));
40936 this_arg_conv.is_owned = false;
40937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40938 LDKChannelFeatures features_conv;
40939 features_conv.inner = (void*)(features & (~1));
40940 features_conv.is_owned = (features & 1) || (features == 0);
40941 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_conv);
40942 features_conv = ChannelFeatures_clone(&features_conv);
40943 LDKPublicKey node_id_1_ref;
40944 CHECK(node_id_1->arr_len == 33);
40945 memcpy(node_id_1_ref.compressed_form, node_id_1->elems, 33); FREE(node_id_1);
40946 LDKPublicKey node_id_2_ref;
40947 CHECK(node_id_2->arr_len == 33);
40948 memcpy(node_id_2_ref.compressed_form, node_id_2->elems, 33); FREE(node_id_2);
40949 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40950 *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);
40951 return (uint32_t)ret_conv;
40954 void __attribute__((export_name("TS_NetworkGraph_channel_failed"))) TS_NetworkGraph_channel_failed(uint32_t this_arg, int64_t short_channel_id, jboolean is_permanent) {
40955 LDKNetworkGraph this_arg_conv;
40956 this_arg_conv.inner = (void*)(this_arg & (~1));
40957 this_arg_conv.is_owned = false;
40958 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40959 NetworkGraph_channel_failed(&this_arg_conv, short_channel_id, is_permanent);
40962 void __attribute__((export_name("TS_NetworkGraph_node_failed"))) TS_NetworkGraph_node_failed(uint32_t this_arg, int8_tArray _node_id, jboolean is_permanent) {
40963 LDKNetworkGraph this_arg_conv;
40964 this_arg_conv.inner = (void*)(this_arg & (~1));
40965 this_arg_conv.is_owned = false;
40966 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40967 LDKPublicKey _node_id_ref;
40968 CHECK(_node_id->arr_len == 33);
40969 memcpy(_node_id_ref.compressed_form, _node_id->elems, 33); FREE(_node_id);
40970 NetworkGraph_node_failed(&this_arg_conv, _node_id_ref, is_permanent);
40973 void __attribute__((export_name("TS_NetworkGraph_remove_stale_channels_with_time"))) TS_NetworkGraph_remove_stale_channels_with_time(uint32_t this_arg, int64_t current_time_unix) {
40974 LDKNetworkGraph this_arg_conv;
40975 this_arg_conv.inner = (void*)(this_arg & (~1));
40976 this_arg_conv.is_owned = false;
40977 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40978 NetworkGraph_remove_stale_channels_with_time(&this_arg_conv, current_time_unix);
40981 uint32_t __attribute__((export_name("TS_NetworkGraph_update_channel"))) TS_NetworkGraph_update_channel(uint32_t this_arg, uint32_t msg) {
40982 LDKNetworkGraph this_arg_conv;
40983 this_arg_conv.inner = (void*)(this_arg & (~1));
40984 this_arg_conv.is_owned = false;
40985 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
40986 LDKChannelUpdate msg_conv;
40987 msg_conv.inner = (void*)(msg & (~1));
40988 msg_conv.is_owned = false;
40989 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
40990 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
40991 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
40992 return (uint32_t)ret_conv;
40995 uint32_t __attribute__((export_name("TS_NetworkGraph_update_channel_unsigned"))) TS_NetworkGraph_update_channel_unsigned(uint32_t this_arg, uint32_t msg) {
40996 LDKNetworkGraph this_arg_conv;
40997 this_arg_conv.inner = (void*)(this_arg & (~1));
40998 this_arg_conv.is_owned = false;
40999 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41000 LDKUnsignedChannelUpdate msg_conv;
41001 msg_conv.inner = (void*)(msg & (~1));
41002 msg_conv.is_owned = false;
41003 CHECK_INNER_FIELD_ACCESS_OR_NULL(msg_conv);
41004 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
41005 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
41006 return (uint32_t)ret_conv;
41009 uint32_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_channel"))) TS_ReadOnlyNetworkGraph_channel(uint32_t this_arg, int64_t short_channel_id) {
41010 LDKReadOnlyNetworkGraph this_arg_conv;
41011 this_arg_conv.inner = (void*)(this_arg & (~1));
41012 this_arg_conv.is_owned = false;
41013 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41014 LDKChannelInfo ret_var = ReadOnlyNetworkGraph_channel(&this_arg_conv, short_channel_id);
41015 uint32_t ret_ref = 0;
41016 if ((uintptr_t)ret_var.inner > 4096) {
41017 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41018 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41019 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41020 ret_ref = (uintptr_t)ret_var.inner;
41021 if (ret_var.is_owned) {
41028 uint32_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_node"))) TS_ReadOnlyNetworkGraph_node(uint32_t this_arg, uint32_t node_id) {
41029 LDKReadOnlyNetworkGraph this_arg_conv;
41030 this_arg_conv.inner = (void*)(this_arg & (~1));
41031 this_arg_conv.is_owned = false;
41032 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41033 LDKNodeId node_id_conv;
41034 node_id_conv.inner = (void*)(node_id & (~1));
41035 node_id_conv.is_owned = false;
41036 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
41037 LDKNodeInfo ret_var = ReadOnlyNetworkGraph_node(&this_arg_conv, &node_id_conv);
41038 uint32_t ret_ref = 0;
41039 if ((uintptr_t)ret_var.inner > 4096) {
41040 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41041 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41042 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41043 ret_ref = (uintptr_t)ret_var.inner;
41044 if (ret_var.is_owned) {
41051 uint32_t __attribute__((export_name("TS_ReadOnlyNetworkGraph_get_addresses"))) TS_ReadOnlyNetworkGraph_get_addresses(uint32_t this_arg, int8_tArray pubkey) {
41052 LDKReadOnlyNetworkGraph this_arg_conv;
41053 this_arg_conv.inner = (void*)(this_arg & (~1));
41054 this_arg_conv.is_owned = false;
41055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41056 LDKPublicKey pubkey_ref;
41057 CHECK(pubkey->arr_len == 33);
41058 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
41059 LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ");
41060 *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref);
41061 uint32_t ret_ref = (uintptr_t)ret_copy;
41065 void __attribute__((export_name("TS_RouteHop_free"))) TS_RouteHop_free(uint32_t this_obj) {
41066 LDKRouteHop this_obj_conv;
41067 this_obj_conv.inner = (void*)(this_obj & (~1));
41068 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
41069 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41070 RouteHop_free(this_obj_conv);
41073 int8_tArray __attribute__((export_name("TS_RouteHop_get_pubkey"))) TS_RouteHop_get_pubkey(uint32_t this_ptr) {
41074 LDKRouteHop this_ptr_conv;
41075 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41076 this_ptr_conv.is_owned = false;
41077 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41078 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41079 memcpy(ret_arr->elems, RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
41083 void __attribute__((export_name("TS_RouteHop_set_pubkey"))) TS_RouteHop_set_pubkey(uint32_t this_ptr, int8_tArray val) {
41084 LDKRouteHop this_ptr_conv;
41085 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41086 this_ptr_conv.is_owned = false;
41087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41088 LDKPublicKey val_ref;
41089 CHECK(val->arr_len == 33);
41090 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
41091 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
41094 uint32_t __attribute__((export_name("TS_RouteHop_get_node_features"))) TS_RouteHop_get_node_features(uint32_t this_ptr) {
41095 LDKRouteHop this_ptr_conv;
41096 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41097 this_ptr_conv.is_owned = false;
41098 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41099 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
41100 uint32_t ret_ref = 0;
41101 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41102 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41103 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41104 ret_ref = (uintptr_t)ret_var.inner;
41105 if (ret_var.is_owned) {
41111 void __attribute__((export_name("TS_RouteHop_set_node_features"))) TS_RouteHop_set_node_features(uint32_t this_ptr, uint32_t val) {
41112 LDKRouteHop this_ptr_conv;
41113 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41114 this_ptr_conv.is_owned = false;
41115 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41116 LDKNodeFeatures val_conv;
41117 val_conv.inner = (void*)(val & (~1));
41118 val_conv.is_owned = (val & 1) || (val == 0);
41119 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41120 val_conv = NodeFeatures_clone(&val_conv);
41121 RouteHop_set_node_features(&this_ptr_conv, val_conv);
41124 int64_t __attribute__((export_name("TS_RouteHop_get_short_channel_id"))) TS_RouteHop_get_short_channel_id(uint32_t this_ptr) {
41125 LDKRouteHop this_ptr_conv;
41126 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41127 this_ptr_conv.is_owned = false;
41128 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41129 int64_t ret_conv = RouteHop_get_short_channel_id(&this_ptr_conv);
41133 void __attribute__((export_name("TS_RouteHop_set_short_channel_id"))) TS_RouteHop_set_short_channel_id(uint32_t this_ptr, int64_t val) {
41134 LDKRouteHop this_ptr_conv;
41135 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41136 this_ptr_conv.is_owned = false;
41137 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41138 RouteHop_set_short_channel_id(&this_ptr_conv, val);
41141 uint32_t __attribute__((export_name("TS_RouteHop_get_channel_features"))) TS_RouteHop_get_channel_features(uint32_t this_ptr) {
41142 LDKRouteHop this_ptr_conv;
41143 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41144 this_ptr_conv.is_owned = false;
41145 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41146 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
41147 uint32_t ret_ref = 0;
41148 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41149 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41150 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41151 ret_ref = (uintptr_t)ret_var.inner;
41152 if (ret_var.is_owned) {
41158 void __attribute__((export_name("TS_RouteHop_set_channel_features"))) TS_RouteHop_set_channel_features(uint32_t this_ptr, uint32_t val) {
41159 LDKRouteHop this_ptr_conv;
41160 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41161 this_ptr_conv.is_owned = false;
41162 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41163 LDKChannelFeatures val_conv;
41164 val_conv.inner = (void*)(val & (~1));
41165 val_conv.is_owned = (val & 1) || (val == 0);
41166 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41167 val_conv = ChannelFeatures_clone(&val_conv);
41168 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
41171 int64_t __attribute__((export_name("TS_RouteHop_get_fee_msat"))) TS_RouteHop_get_fee_msat(uint32_t this_ptr) {
41172 LDKRouteHop this_ptr_conv;
41173 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41174 this_ptr_conv.is_owned = false;
41175 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41176 int64_t ret_conv = RouteHop_get_fee_msat(&this_ptr_conv);
41180 void __attribute__((export_name("TS_RouteHop_set_fee_msat"))) TS_RouteHop_set_fee_msat(uint32_t this_ptr, int64_t val) {
41181 LDKRouteHop this_ptr_conv;
41182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41183 this_ptr_conv.is_owned = false;
41184 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41185 RouteHop_set_fee_msat(&this_ptr_conv, val);
41188 int32_t __attribute__((export_name("TS_RouteHop_get_cltv_expiry_delta"))) TS_RouteHop_get_cltv_expiry_delta(uint32_t this_ptr) {
41189 LDKRouteHop this_ptr_conv;
41190 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41191 this_ptr_conv.is_owned = false;
41192 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41193 int32_t ret_conv = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
41197 void __attribute__((export_name("TS_RouteHop_set_cltv_expiry_delta"))) TS_RouteHop_set_cltv_expiry_delta(uint32_t this_ptr, int32_t val) {
41198 LDKRouteHop this_ptr_conv;
41199 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41200 this_ptr_conv.is_owned = false;
41201 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41202 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
41205 uint32_t __attribute__((export_name("TS_RouteHop_new"))) TS_RouteHop_new(int8_tArray pubkey_arg, uint32_t node_features_arg, int64_t short_channel_id_arg, uint32_t channel_features_arg, int64_t fee_msat_arg, int32_t cltv_expiry_delta_arg) {
41206 LDKPublicKey pubkey_arg_ref;
41207 CHECK(pubkey_arg->arr_len == 33);
41208 memcpy(pubkey_arg_ref.compressed_form, pubkey_arg->elems, 33); FREE(pubkey_arg);
41209 LDKNodeFeatures node_features_arg_conv;
41210 node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
41211 node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
41212 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_features_arg_conv);
41213 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
41214 LDKChannelFeatures channel_features_arg_conv;
41215 channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
41216 channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
41217 CHECK_INNER_FIELD_ACCESS_OR_NULL(channel_features_arg_conv);
41218 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
41219 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);
41220 uint32_t ret_ref = 0;
41221 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41222 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41223 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41224 ret_ref = (uintptr_t)ret_var.inner;
41225 if (ret_var.is_owned) {
41231 static inline uintptr_t RouteHop_clone_ptr(LDKRouteHop *NONNULL_PTR arg) {
41232 LDKRouteHop ret_var = RouteHop_clone(arg);
41233 uint32_t ret_ref = 0;
41234 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41235 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41237 ret_ref = (uintptr_t)ret_var.inner;
41238 if (ret_var.is_owned) {
41243 uint32_t __attribute__((export_name("TS_RouteHop_clone_ptr"))) TS_RouteHop_clone_ptr(uint32_t arg) {
41244 LDKRouteHop arg_conv;
41245 arg_conv.inner = (void*)(arg & (~1));
41246 arg_conv.is_owned = false;
41247 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41248 uint32_t ret_conv = RouteHop_clone_ptr(&arg_conv);
41252 uint32_t __attribute__((export_name("TS_RouteHop_clone"))) TS_RouteHop_clone(uint32_t orig) {
41253 LDKRouteHop orig_conv;
41254 orig_conv.inner = (void*)(orig & (~1));
41255 orig_conv.is_owned = false;
41256 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41257 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
41258 uint32_t ret_ref = 0;
41259 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41260 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41261 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41262 ret_ref = (uintptr_t)ret_var.inner;
41263 if (ret_var.is_owned) {
41269 int64_t __attribute__((export_name("TS_RouteHop_hash"))) TS_RouteHop_hash(uint32_t o) {
41270 LDKRouteHop o_conv;
41271 o_conv.inner = (void*)(o & (~1));
41272 o_conv.is_owned = false;
41273 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
41274 int64_t ret_conv = RouteHop_hash(&o_conv);
41278 jboolean __attribute__((export_name("TS_RouteHop_eq"))) TS_RouteHop_eq(uint32_t a, uint32_t b) {
41279 LDKRouteHop a_conv;
41280 a_conv.inner = (void*)(a & (~1));
41281 a_conv.is_owned = false;
41282 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41283 LDKRouteHop b_conv;
41284 b_conv.inner = (void*)(b & (~1));
41285 b_conv.is_owned = false;
41286 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41287 jboolean ret_conv = RouteHop_eq(&a_conv, &b_conv);
41291 int8_tArray __attribute__((export_name("TS_RouteHop_write"))) TS_RouteHop_write(uint32_t obj) {
41292 LDKRouteHop obj_conv;
41293 obj_conv.inner = (void*)(obj & (~1));
41294 obj_conv.is_owned = false;
41295 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41296 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
41297 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41298 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41299 CVec_u8Z_free(ret_var);
41303 uint32_t __attribute__((export_name("TS_RouteHop_read"))) TS_RouteHop_read(int8_tArray ser) {
41304 LDKu8slice ser_ref;
41305 ser_ref.datalen = ser->arr_len;
41306 ser_ref.data = ser->elems;
41307 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
41308 *ret_conv = RouteHop_read(ser_ref);
41310 return (uint32_t)ret_conv;
41313 void __attribute__((export_name("TS_Route_free"))) TS_Route_free(uint32_t this_obj) {
41314 LDKRoute this_obj_conv;
41315 this_obj_conv.inner = (void*)(this_obj & (~1));
41316 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
41317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41318 Route_free(this_obj_conv);
41321 ptrArray __attribute__((export_name("TS_Route_get_paths"))) TS_Route_get_paths(uint32_t this_ptr) {
41322 LDKRoute this_ptr_conv;
41323 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41324 this_ptr_conv.is_owned = false;
41325 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41326 LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv);
41327 ptrArray ret_arr = NULL;
41328 ret_arr = init_ptrArray(ret_var.datalen, __LINE__);
41329 uint32_tArray *ret_arr_ptr = (uint32_tArray*)(((uint8_t*)ret_arr) + 4);
41330 for (size_t m = 0; m < ret_var.datalen; m++) {
41331 LDKCVec_RouteHopZ ret_conv_12_var = ret_var.data[m];
41332 uint32_tArray ret_conv_12_arr = NULL;
41333 ret_conv_12_arr = init_uint32_tArray(ret_conv_12_var.datalen, __LINE__);
41334 uint32_t *ret_conv_12_arr_ptr = (uint32_t*)(((uint8_t*)ret_conv_12_arr) + 4);
41335 for (size_t k = 0; k < ret_conv_12_var.datalen; k++) {
41336 LDKRouteHop ret_conv_12_conv_10_var = ret_conv_12_var.data[k];
41337 uint32_t ret_conv_12_conv_10_ref = 0;
41338 CHECK((((uintptr_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41339 CHECK((((uintptr_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41340 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_12_conv_10_var);
41341 ret_conv_12_conv_10_ref = (uintptr_t)ret_conv_12_conv_10_var.inner;
41342 if (ret_conv_12_conv_10_var.is_owned) {
41343 ret_conv_12_conv_10_ref |= 1;
41345 ret_conv_12_arr_ptr[k] = ret_conv_12_conv_10_ref;
41348 FREE(ret_conv_12_var.data);
41349 ret_arr_ptr[m] = ret_conv_12_arr;
41352 FREE(ret_var.data);
41356 void __attribute__((export_name("TS_Route_set_paths"))) TS_Route_set_paths(uint32_t this_ptr, ptrArray val) {
41357 LDKRoute this_ptr_conv;
41358 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41359 this_ptr_conv.is_owned = false;
41360 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41361 LDKCVec_CVec_RouteHopZZ val_constr;
41362 val_constr.datalen = val->arr_len;
41363 if (val_constr.datalen > 0)
41364 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
41366 val_constr.data = NULL;
41367 uint32_tArray* val_vals = (void*) val->elems;
41368 for (size_t m = 0; m < val_constr.datalen; m++) {
41369 uint32_tArray val_conv_12 = val_vals[m];
41370 LDKCVec_RouteHopZ val_conv_12_constr;
41371 val_conv_12_constr.datalen = val_conv_12->arr_len;
41372 if (val_conv_12_constr.datalen > 0)
41373 val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
41375 val_conv_12_constr.data = NULL;
41376 uint32_t* val_conv_12_vals = val_conv_12->elems;
41377 for (size_t k = 0; k < val_conv_12_constr.datalen; k++) {
41378 uint32_t val_conv_12_conv_10 = val_conv_12_vals[k];
41379 LDKRouteHop val_conv_12_conv_10_conv;
41380 val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
41381 val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
41382 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_12_conv_10_conv);
41383 val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
41384 val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
41387 val_constr.data[m] = val_conv_12_constr;
41390 Route_set_paths(&this_ptr_conv, val_constr);
41393 uint32_t __attribute__((export_name("TS_Route_get_payment_params"))) TS_Route_get_payment_params(uint32_t this_ptr) {
41394 LDKRoute this_ptr_conv;
41395 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41396 this_ptr_conv.is_owned = false;
41397 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41398 LDKPaymentParameters ret_var = Route_get_payment_params(&this_ptr_conv);
41399 uint32_t ret_ref = 0;
41400 if ((uintptr_t)ret_var.inner > 4096) {
41401 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41402 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41403 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41404 ret_ref = (uintptr_t)ret_var.inner;
41405 if (ret_var.is_owned) {
41412 void __attribute__((export_name("TS_Route_set_payment_params"))) TS_Route_set_payment_params(uint32_t this_ptr, uint32_t val) {
41413 LDKRoute this_ptr_conv;
41414 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41415 this_ptr_conv.is_owned = false;
41416 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41417 LDKPaymentParameters val_conv;
41418 val_conv.inner = (void*)(val & (~1));
41419 val_conv.is_owned = (val & 1) || (val == 0);
41420 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41421 val_conv = PaymentParameters_clone(&val_conv);
41422 Route_set_payment_params(&this_ptr_conv, val_conv);
41425 uint32_t __attribute__((export_name("TS_Route_new"))) TS_Route_new(ptrArray paths_arg, uint32_t payment_params_arg) {
41426 LDKCVec_CVec_RouteHopZZ paths_arg_constr;
41427 paths_arg_constr.datalen = paths_arg->arr_len;
41428 if (paths_arg_constr.datalen > 0)
41429 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
41431 paths_arg_constr.data = NULL;
41432 uint32_tArray* paths_arg_vals = (void*) paths_arg->elems;
41433 for (size_t m = 0; m < paths_arg_constr.datalen; m++) {
41434 uint32_tArray paths_arg_conv_12 = paths_arg_vals[m];
41435 LDKCVec_RouteHopZ paths_arg_conv_12_constr;
41436 paths_arg_conv_12_constr.datalen = paths_arg_conv_12->arr_len;
41437 if (paths_arg_conv_12_constr.datalen > 0)
41438 paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
41440 paths_arg_conv_12_constr.data = NULL;
41441 uint32_t* paths_arg_conv_12_vals = paths_arg_conv_12->elems;
41442 for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) {
41443 uint32_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k];
41444 LDKRouteHop paths_arg_conv_12_conv_10_conv;
41445 paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
41446 paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
41447 CHECK_INNER_FIELD_ACCESS_OR_NULL(paths_arg_conv_12_conv_10_conv);
41448 paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
41449 paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
41451 FREE(paths_arg_conv_12);
41452 paths_arg_constr.data[m] = paths_arg_conv_12_constr;
41455 LDKPaymentParameters payment_params_arg_conv;
41456 payment_params_arg_conv.inner = (void*)(payment_params_arg & (~1));
41457 payment_params_arg_conv.is_owned = (payment_params_arg & 1) || (payment_params_arg == 0);
41458 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
41459 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
41460 LDKRoute ret_var = Route_new(paths_arg_constr, payment_params_arg_conv);
41461 uint32_t ret_ref = 0;
41462 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41463 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41464 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41465 ret_ref = (uintptr_t)ret_var.inner;
41466 if (ret_var.is_owned) {
41472 static inline uintptr_t Route_clone_ptr(LDKRoute *NONNULL_PTR arg) {
41473 LDKRoute ret_var = Route_clone(arg);
41474 uint32_t ret_ref = 0;
41475 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41476 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41477 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41478 ret_ref = (uintptr_t)ret_var.inner;
41479 if (ret_var.is_owned) {
41484 uint32_t __attribute__((export_name("TS_Route_clone_ptr"))) TS_Route_clone_ptr(uint32_t arg) {
41486 arg_conv.inner = (void*)(arg & (~1));
41487 arg_conv.is_owned = false;
41488 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41489 uint32_t ret_conv = Route_clone_ptr(&arg_conv);
41493 uint32_t __attribute__((export_name("TS_Route_clone"))) TS_Route_clone(uint32_t orig) {
41494 LDKRoute orig_conv;
41495 orig_conv.inner = (void*)(orig & (~1));
41496 orig_conv.is_owned = false;
41497 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41498 LDKRoute ret_var = Route_clone(&orig_conv);
41499 uint32_t ret_ref = 0;
41500 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41501 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41502 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41503 ret_ref = (uintptr_t)ret_var.inner;
41504 if (ret_var.is_owned) {
41510 int64_t __attribute__((export_name("TS_Route_hash"))) TS_Route_hash(uint32_t o) {
41512 o_conv.inner = (void*)(o & (~1));
41513 o_conv.is_owned = false;
41514 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
41515 int64_t ret_conv = Route_hash(&o_conv);
41519 jboolean __attribute__((export_name("TS_Route_eq"))) TS_Route_eq(uint32_t a, uint32_t b) {
41521 a_conv.inner = (void*)(a & (~1));
41522 a_conv.is_owned = false;
41523 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
41525 b_conv.inner = (void*)(b & (~1));
41526 b_conv.is_owned = false;
41527 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
41528 jboolean ret_conv = Route_eq(&a_conv, &b_conv);
41532 int64_t __attribute__((export_name("TS_Route_get_total_fees"))) TS_Route_get_total_fees(uint32_t this_arg) {
41533 LDKRoute this_arg_conv;
41534 this_arg_conv.inner = (void*)(this_arg & (~1));
41535 this_arg_conv.is_owned = false;
41536 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41537 int64_t ret_conv = Route_get_total_fees(&this_arg_conv);
41541 int64_t __attribute__((export_name("TS_Route_get_total_amount"))) TS_Route_get_total_amount(uint32_t this_arg) {
41542 LDKRoute this_arg_conv;
41543 this_arg_conv.inner = (void*)(this_arg & (~1));
41544 this_arg_conv.is_owned = false;
41545 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
41546 int64_t ret_conv = Route_get_total_amount(&this_arg_conv);
41550 int8_tArray __attribute__((export_name("TS_Route_write"))) TS_Route_write(uint32_t obj) {
41552 obj_conv.inner = (void*)(obj & (~1));
41553 obj_conv.is_owned = false;
41554 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41555 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
41556 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41557 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41558 CVec_u8Z_free(ret_var);
41562 uint32_t __attribute__((export_name("TS_Route_read"))) TS_Route_read(int8_tArray ser) {
41563 LDKu8slice ser_ref;
41564 ser_ref.datalen = ser->arr_len;
41565 ser_ref.data = ser->elems;
41566 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
41567 *ret_conv = Route_read(ser_ref);
41569 return (uint32_t)ret_conv;
41572 void __attribute__((export_name("TS_RouteParameters_free"))) TS_RouteParameters_free(uint32_t this_obj) {
41573 LDKRouteParameters this_obj_conv;
41574 this_obj_conv.inner = (void*)(this_obj & (~1));
41575 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
41576 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41577 RouteParameters_free(this_obj_conv);
41580 uint32_t __attribute__((export_name("TS_RouteParameters_get_payment_params"))) TS_RouteParameters_get_payment_params(uint32_t this_ptr) {
41581 LDKRouteParameters this_ptr_conv;
41582 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41583 this_ptr_conv.is_owned = false;
41584 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41585 LDKPaymentParameters ret_var = RouteParameters_get_payment_params(&this_ptr_conv);
41586 uint32_t ret_ref = 0;
41587 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41588 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41589 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41590 ret_ref = (uintptr_t)ret_var.inner;
41591 if (ret_var.is_owned) {
41597 void __attribute__((export_name("TS_RouteParameters_set_payment_params"))) TS_RouteParameters_set_payment_params(uint32_t this_ptr, uint32_t val) {
41598 LDKRouteParameters this_ptr_conv;
41599 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41600 this_ptr_conv.is_owned = false;
41601 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41602 LDKPaymentParameters val_conv;
41603 val_conv.inner = (void*)(val & (~1));
41604 val_conv.is_owned = (val & 1) || (val == 0);
41605 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41606 val_conv = PaymentParameters_clone(&val_conv);
41607 RouteParameters_set_payment_params(&this_ptr_conv, val_conv);
41610 int64_t __attribute__((export_name("TS_RouteParameters_get_final_value_msat"))) TS_RouteParameters_get_final_value_msat(uint32_t this_ptr) {
41611 LDKRouteParameters this_ptr_conv;
41612 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41613 this_ptr_conv.is_owned = false;
41614 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41615 int64_t ret_conv = RouteParameters_get_final_value_msat(&this_ptr_conv);
41619 void __attribute__((export_name("TS_RouteParameters_set_final_value_msat"))) TS_RouteParameters_set_final_value_msat(uint32_t this_ptr, int64_t val) {
41620 LDKRouteParameters this_ptr_conv;
41621 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41622 this_ptr_conv.is_owned = false;
41623 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41624 RouteParameters_set_final_value_msat(&this_ptr_conv, val);
41627 int32_t __attribute__((export_name("TS_RouteParameters_get_final_cltv_expiry_delta"))) TS_RouteParameters_get_final_cltv_expiry_delta(uint32_t this_ptr) {
41628 LDKRouteParameters this_ptr_conv;
41629 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41630 this_ptr_conv.is_owned = false;
41631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41632 int32_t ret_conv = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
41636 void __attribute__((export_name("TS_RouteParameters_set_final_cltv_expiry_delta"))) TS_RouteParameters_set_final_cltv_expiry_delta(uint32_t this_ptr, int32_t val) {
41637 LDKRouteParameters this_ptr_conv;
41638 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41639 this_ptr_conv.is_owned = false;
41640 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41641 RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
41644 uint32_t __attribute__((export_name("TS_RouteParameters_new"))) TS_RouteParameters_new(uint32_t payment_params_arg, int64_t final_value_msat_arg, int32_t final_cltv_expiry_delta_arg) {
41645 LDKPaymentParameters payment_params_arg_conv;
41646 payment_params_arg_conv.inner = (void*)(payment_params_arg & (~1));
41647 payment_params_arg_conv.is_owned = (payment_params_arg & 1) || (payment_params_arg == 0);
41648 CHECK_INNER_FIELD_ACCESS_OR_NULL(payment_params_arg_conv);
41649 payment_params_arg_conv = PaymentParameters_clone(&payment_params_arg_conv);
41650 LDKRouteParameters ret_var = RouteParameters_new(payment_params_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
41651 uint32_t ret_ref = 0;
41652 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41653 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41654 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41655 ret_ref = (uintptr_t)ret_var.inner;
41656 if (ret_var.is_owned) {
41662 static inline uintptr_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
41663 LDKRouteParameters ret_var = RouteParameters_clone(arg);
41664 uint32_t ret_ref = 0;
41665 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41666 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41667 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41668 ret_ref = (uintptr_t)ret_var.inner;
41669 if (ret_var.is_owned) {
41674 uint32_t __attribute__((export_name("TS_RouteParameters_clone_ptr"))) TS_RouteParameters_clone_ptr(uint32_t arg) {
41675 LDKRouteParameters arg_conv;
41676 arg_conv.inner = (void*)(arg & (~1));
41677 arg_conv.is_owned = false;
41678 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41679 uint32_t ret_conv = RouteParameters_clone_ptr(&arg_conv);
41683 uint32_t __attribute__((export_name("TS_RouteParameters_clone"))) TS_RouteParameters_clone(uint32_t orig) {
41684 LDKRouteParameters orig_conv;
41685 orig_conv.inner = (void*)(orig & (~1));
41686 orig_conv.is_owned = false;
41687 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
41688 LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
41689 uint32_t ret_ref = 0;
41690 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41691 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41692 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41693 ret_ref = (uintptr_t)ret_var.inner;
41694 if (ret_var.is_owned) {
41700 int8_tArray __attribute__((export_name("TS_RouteParameters_write"))) TS_RouteParameters_write(uint32_t obj) {
41701 LDKRouteParameters obj_conv;
41702 obj_conv.inner = (void*)(obj & (~1));
41703 obj_conv.is_owned = false;
41704 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
41705 LDKCVec_u8Z ret_var = RouteParameters_write(&obj_conv);
41706 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
41707 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
41708 CVec_u8Z_free(ret_var);
41712 uint32_t __attribute__((export_name("TS_RouteParameters_read"))) TS_RouteParameters_read(int8_tArray ser) {
41713 LDKu8slice ser_ref;
41714 ser_ref.datalen = ser->arr_len;
41715 ser_ref.data = ser->elems;
41716 LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
41717 *ret_conv = RouteParameters_read(ser_ref);
41719 return (uint32_t)ret_conv;
41722 void __attribute__((export_name("TS_PaymentParameters_free"))) TS_PaymentParameters_free(uint32_t this_obj) {
41723 LDKPaymentParameters this_obj_conv;
41724 this_obj_conv.inner = (void*)(this_obj & (~1));
41725 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
41726 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
41727 PaymentParameters_free(this_obj_conv);
41730 int8_tArray __attribute__((export_name("TS_PaymentParameters_get_payee_pubkey"))) TS_PaymentParameters_get_payee_pubkey(uint32_t this_ptr) {
41731 LDKPaymentParameters this_ptr_conv;
41732 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41733 this_ptr_conv.is_owned = false;
41734 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41735 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
41736 memcpy(ret_arr->elems, PaymentParameters_get_payee_pubkey(&this_ptr_conv).compressed_form, 33);
41740 void __attribute__((export_name("TS_PaymentParameters_set_payee_pubkey"))) TS_PaymentParameters_set_payee_pubkey(uint32_t this_ptr, int8_tArray val) {
41741 LDKPaymentParameters this_ptr_conv;
41742 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41743 this_ptr_conv.is_owned = false;
41744 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41745 LDKPublicKey val_ref;
41746 CHECK(val->arr_len == 33);
41747 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
41748 PaymentParameters_set_payee_pubkey(&this_ptr_conv, val_ref);
41751 uint32_t __attribute__((export_name("TS_PaymentParameters_get_features"))) TS_PaymentParameters_get_features(uint32_t this_ptr) {
41752 LDKPaymentParameters this_ptr_conv;
41753 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41754 this_ptr_conv.is_owned = false;
41755 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41756 LDKInvoiceFeatures ret_var = PaymentParameters_get_features(&this_ptr_conv);
41757 uint32_t ret_ref = 0;
41758 if ((uintptr_t)ret_var.inner > 4096) {
41759 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41760 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41761 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41762 ret_ref = (uintptr_t)ret_var.inner;
41763 if (ret_var.is_owned) {
41770 void __attribute__((export_name("TS_PaymentParameters_set_features"))) TS_PaymentParameters_set_features(uint32_t this_ptr, uint32_t val) {
41771 LDKPaymentParameters this_ptr_conv;
41772 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41773 this_ptr_conv.is_owned = false;
41774 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41775 LDKInvoiceFeatures val_conv;
41776 val_conv.inner = (void*)(val & (~1));
41777 val_conv.is_owned = (val & 1) || (val == 0);
41778 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
41779 val_conv = InvoiceFeatures_clone(&val_conv);
41780 PaymentParameters_set_features(&this_ptr_conv, val_conv);
41783 uint32_tArray __attribute__((export_name("TS_PaymentParameters_get_route_hints"))) TS_PaymentParameters_get_route_hints(uint32_t this_ptr) {
41784 LDKPaymentParameters this_ptr_conv;
41785 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41786 this_ptr_conv.is_owned = false;
41787 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41788 LDKCVec_RouteHintZ ret_var = PaymentParameters_get_route_hints(&this_ptr_conv);
41789 uint32_tArray ret_arr = NULL;
41790 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
41791 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
41792 for (size_t l = 0; l < ret_var.datalen; l++) {
41793 LDKRouteHint ret_conv_11_var = ret_var.data[l];
41794 uint32_t ret_conv_11_ref = 0;
41795 CHECK((((uintptr_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41796 CHECK((((uintptr_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41797 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
41798 ret_conv_11_ref = (uintptr_t)ret_conv_11_var.inner;
41799 if (ret_conv_11_var.is_owned) {
41800 ret_conv_11_ref |= 1;
41802 ret_arr_ptr[l] = ret_conv_11_ref;
41805 FREE(ret_var.data);
41809 void __attribute__((export_name("TS_PaymentParameters_set_route_hints"))) TS_PaymentParameters_set_route_hints(uint32_t this_ptr, uint32_tArray val) {
41810 LDKPaymentParameters this_ptr_conv;
41811 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41812 this_ptr_conv.is_owned = false;
41813 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41814 LDKCVec_RouteHintZ val_constr;
41815 val_constr.datalen = val->arr_len;
41816 if (val_constr.datalen > 0)
41817 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
41819 val_constr.data = NULL;
41820 uint32_t* val_vals = val->elems;
41821 for (size_t l = 0; l < val_constr.datalen; l++) {
41822 uint32_t val_conv_11 = val_vals[l];
41823 LDKRouteHint val_conv_11_conv;
41824 val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
41825 val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
41826 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
41827 val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
41828 val_constr.data[l] = val_conv_11_conv;
41831 PaymentParameters_set_route_hints(&this_ptr_conv, val_constr);
41834 uint32_t __attribute__((export_name("TS_PaymentParameters_get_expiry_time"))) TS_PaymentParameters_get_expiry_time(uint32_t this_ptr) {
41835 LDKPaymentParameters this_ptr_conv;
41836 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41837 this_ptr_conv.is_owned = false;
41838 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41839 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
41840 *ret_copy = PaymentParameters_get_expiry_time(&this_ptr_conv);
41841 uint32_t ret_ref = (uintptr_t)ret_copy;
41845 void __attribute__((export_name("TS_PaymentParameters_set_expiry_time"))) TS_PaymentParameters_set_expiry_time(uint32_t this_ptr, uint32_t val) {
41846 LDKPaymentParameters this_ptr_conv;
41847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41848 this_ptr_conv.is_owned = false;
41849 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41850 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
41851 CHECK_ACCESS(val_ptr);
41852 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
41853 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
41854 PaymentParameters_set_expiry_time(&this_ptr_conv, val_conv);
41857 int32_t __attribute__((export_name("TS_PaymentParameters_get_max_total_cltv_expiry_delta"))) TS_PaymentParameters_get_max_total_cltv_expiry_delta(uint32_t this_ptr) {
41858 LDKPaymentParameters this_ptr_conv;
41859 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41860 this_ptr_conv.is_owned = false;
41861 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41862 int32_t ret_conv = PaymentParameters_get_max_total_cltv_expiry_delta(&this_ptr_conv);
41866 void __attribute__((export_name("TS_PaymentParameters_set_max_total_cltv_expiry_delta"))) TS_PaymentParameters_set_max_total_cltv_expiry_delta(uint32_t this_ptr, int32_t val) {
41867 LDKPaymentParameters this_ptr_conv;
41868 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41869 this_ptr_conv.is_owned = false;
41870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41871 PaymentParameters_set_max_total_cltv_expiry_delta(&this_ptr_conv, val);
41874 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_path_count"))) TS_PaymentParameters_get_max_path_count(uint32_t this_ptr) {
41875 LDKPaymentParameters this_ptr_conv;
41876 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41877 this_ptr_conv.is_owned = false;
41878 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41879 int8_t ret_conv = PaymentParameters_get_max_path_count(&this_ptr_conv);
41883 void __attribute__((export_name("TS_PaymentParameters_set_max_path_count"))) TS_PaymentParameters_set_max_path_count(uint32_t this_ptr, int8_t val) {
41884 LDKPaymentParameters this_ptr_conv;
41885 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41886 this_ptr_conv.is_owned = false;
41887 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41888 PaymentParameters_set_max_path_count(&this_ptr_conv, val);
41891 int8_t __attribute__((export_name("TS_PaymentParameters_get_max_channel_saturation_power_of_half"))) TS_PaymentParameters_get_max_channel_saturation_power_of_half(uint32_t this_ptr) {
41892 LDKPaymentParameters this_ptr_conv;
41893 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41894 this_ptr_conv.is_owned = false;
41895 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41896 int8_t ret_conv = PaymentParameters_get_max_channel_saturation_power_of_half(&this_ptr_conv);
41900 void __attribute__((export_name("TS_PaymentParameters_set_max_channel_saturation_power_of_half"))) TS_PaymentParameters_set_max_channel_saturation_power_of_half(uint32_t this_ptr, int8_t val) {
41901 LDKPaymentParameters this_ptr_conv;
41902 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41903 this_ptr_conv.is_owned = false;
41904 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41905 PaymentParameters_set_max_channel_saturation_power_of_half(&this_ptr_conv, val);
41908 void __attribute__((export_name("TS_PaymentParameters_set_previously_failed_channels"))) TS_PaymentParameters_set_previously_failed_channels(uint32_t this_ptr, int64_tArray val) {
41909 LDKPaymentParameters this_ptr_conv;
41910 this_ptr_conv.inner = (void*)(this_ptr & (~1));
41911 this_ptr_conv.is_owned = false;
41912 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
41913 LDKCVec_u64Z val_constr;
41914 val_constr.datalen = val->arr_len;
41915 if (val_constr.datalen > 0)
41916 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
41918 val_constr.data = NULL;
41919 int64_t* val_vals = val->elems;
41920 for (size_t i = 0; i < val_constr.datalen; i++) {
41921 int64_t val_conv_8 = val_vals[i];
41922 val_constr.data[i] = val_conv_8;
41925 PaymentParameters_set_previously_failed_channels(&this_ptr_conv, val_constr);
41928 uint32_t __attribute__((export_name("TS_PaymentParameters_new"))) TS_PaymentParameters_new(int8_tArray payee_pubkey_arg, uint32_t features_arg, uint32_tArray route_hints_arg, uint32_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) {
41929 LDKPublicKey payee_pubkey_arg_ref;
41930 CHECK(payee_pubkey_arg->arr_len == 33);
41931 memcpy(payee_pubkey_arg_ref.compressed_form, payee_pubkey_arg->elems, 33); FREE(payee_pubkey_arg);
41932 LDKInvoiceFeatures features_arg_conv;
41933 features_arg_conv.inner = (void*)(features_arg & (~1));
41934 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
41935 CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
41936 features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
41937 LDKCVec_RouteHintZ route_hints_arg_constr;
41938 route_hints_arg_constr.datalen = route_hints_arg->arr_len;
41939 if (route_hints_arg_constr.datalen > 0)
41940 route_hints_arg_constr.data = MALLOC(route_hints_arg_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
41942 route_hints_arg_constr.data = NULL;
41943 uint32_t* route_hints_arg_vals = route_hints_arg->elems;
41944 for (size_t l = 0; l < route_hints_arg_constr.datalen; l++) {
41945 uint32_t route_hints_arg_conv_11 = route_hints_arg_vals[l];
41946 LDKRouteHint route_hints_arg_conv_11_conv;
41947 route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
41948 route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
41949 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
41950 route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
41951 route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
41953 FREE(route_hints_arg);
41954 void* expiry_time_arg_ptr = (void*)(((uintptr_t)expiry_time_arg) & ~1);
41955 CHECK_ACCESS(expiry_time_arg_ptr);
41956 LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
41957 expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)expiry_time_arg) & ~1));
41958 LDKCVec_u64Z previously_failed_channels_arg_constr;
41959 previously_failed_channels_arg_constr.datalen = previously_failed_channels_arg->arr_len;
41960 if (previously_failed_channels_arg_constr.datalen > 0)
41961 previously_failed_channels_arg_constr.data = MALLOC(previously_failed_channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
41963 previously_failed_channels_arg_constr.data = NULL;
41964 int64_t* previously_failed_channels_arg_vals = previously_failed_channels_arg->elems;
41965 for (size_t i = 0; i < previously_failed_channels_arg_constr.datalen; i++) {
41966 int64_t previously_failed_channels_arg_conv_8 = previously_failed_channels_arg_vals[i];
41967 previously_failed_channels_arg_constr.data[i] = previously_failed_channels_arg_conv_8;
41969 FREE(previously_failed_channels_arg);
41970 LDKPaymentParameters ret_var = PaymentParameters_new(payee_pubkey_arg_ref, features_arg_conv, route_hints_arg_constr, expiry_time_arg_conv, max_total_cltv_expiry_delta_arg, max_path_count_arg, max_channel_saturation_power_of_half_arg, previously_failed_channels_arg_constr);
41971 uint32_t ret_ref = 0;
41972 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41973 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41974 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41975 ret_ref = (uintptr_t)ret_var.inner;
41976 if (ret_var.is_owned) {
41982 static inline uintptr_t PaymentParameters_clone_ptr(LDKPaymentParameters *NONNULL_PTR arg) {
41983 LDKPaymentParameters ret_var = PaymentParameters_clone(arg);
41984 uint32_t ret_ref = 0;
41985 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
41986 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
41987 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
41988 ret_ref = (uintptr_t)ret_var.inner;
41989 if (ret_var.is_owned) {
41994 uint32_t __attribute__((export_name("TS_PaymentParameters_clone_ptr"))) TS_PaymentParameters_clone_ptr(uint32_t arg) {
41995 LDKPaymentParameters arg_conv;
41996 arg_conv.inner = (void*)(arg & (~1));
41997 arg_conv.is_owned = false;
41998 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
41999 uint32_t ret_conv = PaymentParameters_clone_ptr(&arg_conv);
42003 uint32_t __attribute__((export_name("TS_PaymentParameters_clone"))) TS_PaymentParameters_clone(uint32_t orig) {
42004 LDKPaymentParameters orig_conv;
42005 orig_conv.inner = (void*)(orig & (~1));
42006 orig_conv.is_owned = false;
42007 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42008 LDKPaymentParameters ret_var = PaymentParameters_clone(&orig_conv);
42009 uint32_t ret_ref = 0;
42010 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42011 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42012 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42013 ret_ref = (uintptr_t)ret_var.inner;
42014 if (ret_var.is_owned) {
42020 int64_t __attribute__((export_name("TS_PaymentParameters_hash"))) TS_PaymentParameters_hash(uint32_t o) {
42021 LDKPaymentParameters o_conv;
42022 o_conv.inner = (void*)(o & (~1));
42023 o_conv.is_owned = false;
42024 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
42025 int64_t ret_conv = PaymentParameters_hash(&o_conv);
42029 jboolean __attribute__((export_name("TS_PaymentParameters_eq"))) TS_PaymentParameters_eq(uint32_t a, uint32_t b) {
42030 LDKPaymentParameters a_conv;
42031 a_conv.inner = (void*)(a & (~1));
42032 a_conv.is_owned = false;
42033 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42034 LDKPaymentParameters b_conv;
42035 b_conv.inner = (void*)(b & (~1));
42036 b_conv.is_owned = false;
42037 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42038 jboolean ret_conv = PaymentParameters_eq(&a_conv, &b_conv);
42042 int8_tArray __attribute__((export_name("TS_PaymentParameters_write"))) TS_PaymentParameters_write(uint32_t obj) {
42043 LDKPaymentParameters obj_conv;
42044 obj_conv.inner = (void*)(obj & (~1));
42045 obj_conv.is_owned = false;
42046 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42047 LDKCVec_u8Z ret_var = PaymentParameters_write(&obj_conv);
42048 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42049 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42050 CVec_u8Z_free(ret_var);
42054 uint32_t __attribute__((export_name("TS_PaymentParameters_read"))) TS_PaymentParameters_read(int8_tArray ser) {
42055 LDKu8slice ser_ref;
42056 ser_ref.datalen = ser->arr_len;
42057 ser_ref.data = ser->elems;
42058 LDKCResult_PaymentParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentParametersDecodeErrorZ), "LDKCResult_PaymentParametersDecodeErrorZ");
42059 *ret_conv = PaymentParameters_read(ser_ref);
42061 return (uint32_t)ret_conv;
42064 uint32_t __attribute__((export_name("TS_PaymentParameters_from_node_id"))) TS_PaymentParameters_from_node_id(int8_tArray payee_pubkey) {
42065 LDKPublicKey payee_pubkey_ref;
42066 CHECK(payee_pubkey->arr_len == 33);
42067 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
42068 LDKPaymentParameters ret_var = PaymentParameters_from_node_id(payee_pubkey_ref);
42069 uint32_t ret_ref = 0;
42070 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42071 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42072 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42073 ret_ref = (uintptr_t)ret_var.inner;
42074 if (ret_var.is_owned) {
42080 uint32_t __attribute__((export_name("TS_PaymentParameters_for_keysend"))) TS_PaymentParameters_for_keysend(int8_tArray payee_pubkey) {
42081 LDKPublicKey payee_pubkey_ref;
42082 CHECK(payee_pubkey->arr_len == 33);
42083 memcpy(payee_pubkey_ref.compressed_form, payee_pubkey->elems, 33); FREE(payee_pubkey);
42084 LDKPaymentParameters ret_var = PaymentParameters_for_keysend(payee_pubkey_ref);
42085 uint32_t ret_ref = 0;
42086 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42087 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42088 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42089 ret_ref = (uintptr_t)ret_var.inner;
42090 if (ret_var.is_owned) {
42096 void __attribute__((export_name("TS_RouteHint_free"))) TS_RouteHint_free(uint32_t this_obj) {
42097 LDKRouteHint this_obj_conv;
42098 this_obj_conv.inner = (void*)(this_obj & (~1));
42099 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42100 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42101 RouteHint_free(this_obj_conv);
42104 uint32_tArray __attribute__((export_name("TS_RouteHint_get_a"))) TS_RouteHint_get_a(uint32_t this_ptr) {
42105 LDKRouteHint this_ptr_conv;
42106 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42107 this_ptr_conv.is_owned = false;
42108 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42109 LDKCVec_RouteHintHopZ ret_var = RouteHint_get_a(&this_ptr_conv);
42110 uint32_tArray ret_arr = NULL;
42111 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
42112 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
42113 for (size_t o = 0; o < ret_var.datalen; o++) {
42114 LDKRouteHintHop ret_conv_14_var = ret_var.data[o];
42115 uint32_t ret_conv_14_ref = 0;
42116 CHECK((((uintptr_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42117 CHECK((((uintptr_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42118 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
42119 ret_conv_14_ref = (uintptr_t)ret_conv_14_var.inner;
42120 if (ret_conv_14_var.is_owned) {
42121 ret_conv_14_ref |= 1;
42123 ret_arr_ptr[o] = ret_conv_14_ref;
42126 FREE(ret_var.data);
42130 void __attribute__((export_name("TS_RouteHint_set_a"))) TS_RouteHint_set_a(uint32_t this_ptr, uint32_tArray val) {
42131 LDKRouteHint this_ptr_conv;
42132 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42133 this_ptr_conv.is_owned = false;
42134 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42135 LDKCVec_RouteHintHopZ val_constr;
42136 val_constr.datalen = val->arr_len;
42137 if (val_constr.datalen > 0)
42138 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
42140 val_constr.data = NULL;
42141 uint32_t* val_vals = val->elems;
42142 for (size_t o = 0; o < val_constr.datalen; o++) {
42143 uint32_t val_conv_14 = val_vals[o];
42144 LDKRouteHintHop val_conv_14_conv;
42145 val_conv_14_conv.inner = (void*)(val_conv_14 & (~1));
42146 val_conv_14_conv.is_owned = (val_conv_14 & 1) || (val_conv_14 == 0);
42147 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_14_conv);
42148 val_conv_14_conv = RouteHintHop_clone(&val_conv_14_conv);
42149 val_constr.data[o] = val_conv_14_conv;
42152 RouteHint_set_a(&this_ptr_conv, val_constr);
42155 uint32_t __attribute__((export_name("TS_RouteHint_new"))) TS_RouteHint_new(uint32_tArray a_arg) {
42156 LDKCVec_RouteHintHopZ a_arg_constr;
42157 a_arg_constr.datalen = a_arg->arr_len;
42158 if (a_arg_constr.datalen > 0)
42159 a_arg_constr.data = MALLOC(a_arg_constr.datalen * sizeof(LDKRouteHintHop), "LDKCVec_RouteHintHopZ Elements");
42161 a_arg_constr.data = NULL;
42162 uint32_t* a_arg_vals = a_arg->elems;
42163 for (size_t o = 0; o < a_arg_constr.datalen; o++) {
42164 uint32_t a_arg_conv_14 = a_arg_vals[o];
42165 LDKRouteHintHop a_arg_conv_14_conv;
42166 a_arg_conv_14_conv.inner = (void*)(a_arg_conv_14 & (~1));
42167 a_arg_conv_14_conv.is_owned = (a_arg_conv_14 & 1) || (a_arg_conv_14 == 0);
42168 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_arg_conv_14_conv);
42169 a_arg_conv_14_conv = RouteHintHop_clone(&a_arg_conv_14_conv);
42170 a_arg_constr.data[o] = a_arg_conv_14_conv;
42173 LDKRouteHint ret_var = RouteHint_new(a_arg_constr);
42174 uint32_t ret_ref = 0;
42175 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42176 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42177 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42178 ret_ref = (uintptr_t)ret_var.inner;
42179 if (ret_var.is_owned) {
42185 static inline uintptr_t RouteHint_clone_ptr(LDKRouteHint *NONNULL_PTR arg) {
42186 LDKRouteHint ret_var = RouteHint_clone(arg);
42187 uint32_t ret_ref = 0;
42188 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42189 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42190 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42191 ret_ref = (uintptr_t)ret_var.inner;
42192 if (ret_var.is_owned) {
42197 uint32_t __attribute__((export_name("TS_RouteHint_clone_ptr"))) TS_RouteHint_clone_ptr(uint32_t arg) {
42198 LDKRouteHint arg_conv;
42199 arg_conv.inner = (void*)(arg & (~1));
42200 arg_conv.is_owned = false;
42201 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42202 uint32_t ret_conv = RouteHint_clone_ptr(&arg_conv);
42206 uint32_t __attribute__((export_name("TS_RouteHint_clone"))) TS_RouteHint_clone(uint32_t orig) {
42207 LDKRouteHint orig_conv;
42208 orig_conv.inner = (void*)(orig & (~1));
42209 orig_conv.is_owned = false;
42210 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42211 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
42212 uint32_t ret_ref = 0;
42213 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42214 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42215 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42216 ret_ref = (uintptr_t)ret_var.inner;
42217 if (ret_var.is_owned) {
42223 int64_t __attribute__((export_name("TS_RouteHint_hash"))) TS_RouteHint_hash(uint32_t o) {
42224 LDKRouteHint o_conv;
42225 o_conv.inner = (void*)(o & (~1));
42226 o_conv.is_owned = false;
42227 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
42228 int64_t ret_conv = RouteHint_hash(&o_conv);
42232 jboolean __attribute__((export_name("TS_RouteHint_eq"))) TS_RouteHint_eq(uint32_t a, uint32_t b) {
42233 LDKRouteHint a_conv;
42234 a_conv.inner = (void*)(a & (~1));
42235 a_conv.is_owned = false;
42236 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42237 LDKRouteHint b_conv;
42238 b_conv.inner = (void*)(b & (~1));
42239 b_conv.is_owned = false;
42240 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42241 jboolean ret_conv = RouteHint_eq(&a_conv, &b_conv);
42245 int8_tArray __attribute__((export_name("TS_RouteHint_write"))) TS_RouteHint_write(uint32_t obj) {
42246 LDKRouteHint obj_conv;
42247 obj_conv.inner = (void*)(obj & (~1));
42248 obj_conv.is_owned = false;
42249 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42250 LDKCVec_u8Z ret_var = RouteHint_write(&obj_conv);
42251 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42252 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42253 CVec_u8Z_free(ret_var);
42257 uint32_t __attribute__((export_name("TS_RouteHint_read"))) TS_RouteHint_read(int8_tArray ser) {
42258 LDKu8slice ser_ref;
42259 ser_ref.datalen = ser->arr_len;
42260 ser_ref.data = ser->elems;
42261 LDKCResult_RouteHintDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintDecodeErrorZ), "LDKCResult_RouteHintDecodeErrorZ");
42262 *ret_conv = RouteHint_read(ser_ref);
42264 return (uint32_t)ret_conv;
42267 void __attribute__((export_name("TS_RouteHintHop_free"))) TS_RouteHintHop_free(uint32_t this_obj) {
42268 LDKRouteHintHop this_obj_conv;
42269 this_obj_conv.inner = (void*)(this_obj & (~1));
42270 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42271 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42272 RouteHintHop_free(this_obj_conv);
42275 int8_tArray __attribute__((export_name("TS_RouteHintHop_get_src_node_id"))) TS_RouteHintHop_get_src_node_id(uint32_t this_ptr) {
42276 LDKRouteHintHop this_ptr_conv;
42277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42278 this_ptr_conv.is_owned = false;
42279 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42280 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
42281 memcpy(ret_arr->elems, RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
42285 void __attribute__((export_name("TS_RouteHintHop_set_src_node_id"))) TS_RouteHintHop_set_src_node_id(uint32_t this_ptr, int8_tArray val) {
42286 LDKRouteHintHop this_ptr_conv;
42287 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42288 this_ptr_conv.is_owned = false;
42289 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42290 LDKPublicKey val_ref;
42291 CHECK(val->arr_len == 33);
42292 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
42293 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
42296 int64_t __attribute__((export_name("TS_RouteHintHop_get_short_channel_id"))) TS_RouteHintHop_get_short_channel_id(uint32_t this_ptr) {
42297 LDKRouteHintHop this_ptr_conv;
42298 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42299 this_ptr_conv.is_owned = false;
42300 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42301 int64_t ret_conv = RouteHintHop_get_short_channel_id(&this_ptr_conv);
42305 void __attribute__((export_name("TS_RouteHintHop_set_short_channel_id"))) TS_RouteHintHop_set_short_channel_id(uint32_t this_ptr, int64_t val) {
42306 LDKRouteHintHop this_ptr_conv;
42307 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42308 this_ptr_conv.is_owned = false;
42309 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42310 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
42313 uint32_t __attribute__((export_name("TS_RouteHintHop_get_fees"))) TS_RouteHintHop_get_fees(uint32_t this_ptr) {
42314 LDKRouteHintHop this_ptr_conv;
42315 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42316 this_ptr_conv.is_owned = false;
42317 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42318 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
42319 uint32_t ret_ref = 0;
42320 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42321 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42322 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42323 ret_ref = (uintptr_t)ret_var.inner;
42324 if (ret_var.is_owned) {
42330 void __attribute__((export_name("TS_RouteHintHop_set_fees"))) TS_RouteHintHop_set_fees(uint32_t this_ptr, uint32_t val) {
42331 LDKRouteHintHop this_ptr_conv;
42332 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42333 this_ptr_conv.is_owned = false;
42334 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42335 LDKRoutingFees val_conv;
42336 val_conv.inner = (void*)(val & (~1));
42337 val_conv.is_owned = (val & 1) || (val == 0);
42338 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
42339 val_conv = RoutingFees_clone(&val_conv);
42340 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
42343 int16_t __attribute__((export_name("TS_RouteHintHop_get_cltv_expiry_delta"))) TS_RouteHintHop_get_cltv_expiry_delta(uint32_t this_ptr) {
42344 LDKRouteHintHop this_ptr_conv;
42345 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42346 this_ptr_conv.is_owned = false;
42347 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42348 int16_t ret_conv = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
42352 void __attribute__((export_name("TS_RouteHintHop_set_cltv_expiry_delta"))) TS_RouteHintHop_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
42353 LDKRouteHintHop this_ptr_conv;
42354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42355 this_ptr_conv.is_owned = false;
42356 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42357 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
42360 uint32_t __attribute__((export_name("TS_RouteHintHop_get_htlc_minimum_msat"))) TS_RouteHintHop_get_htlc_minimum_msat(uint32_t this_ptr) {
42361 LDKRouteHintHop this_ptr_conv;
42362 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42363 this_ptr_conv.is_owned = false;
42364 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42365 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
42366 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
42367 uint32_t ret_ref = (uintptr_t)ret_copy;
42371 void __attribute__((export_name("TS_RouteHintHop_set_htlc_minimum_msat"))) TS_RouteHintHop_set_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) {
42372 LDKRouteHintHop this_ptr_conv;
42373 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42374 this_ptr_conv.is_owned = false;
42375 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42376 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
42377 CHECK_ACCESS(val_ptr);
42378 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
42379 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
42380 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
42383 uint32_t __attribute__((export_name("TS_RouteHintHop_get_htlc_maximum_msat"))) TS_RouteHintHop_get_htlc_maximum_msat(uint32_t this_ptr) {
42384 LDKRouteHintHop this_ptr_conv;
42385 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42386 this_ptr_conv.is_owned = false;
42387 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42388 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
42389 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
42390 uint32_t ret_ref = (uintptr_t)ret_copy;
42394 void __attribute__((export_name("TS_RouteHintHop_set_htlc_maximum_msat"))) TS_RouteHintHop_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) {
42395 LDKRouteHintHop this_ptr_conv;
42396 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42397 this_ptr_conv.is_owned = false;
42398 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42399 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
42400 CHECK_ACCESS(val_ptr);
42401 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
42402 val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)val) & ~1));
42403 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
42406 uint32_t __attribute__((export_name("TS_RouteHintHop_new"))) TS_RouteHintHop_new(int8_tArray src_node_id_arg, int64_t short_channel_id_arg, uint32_t fees_arg, int16_t cltv_expiry_delta_arg, uint32_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg) {
42407 LDKPublicKey src_node_id_arg_ref;
42408 CHECK(src_node_id_arg->arr_len == 33);
42409 memcpy(src_node_id_arg_ref.compressed_form, src_node_id_arg->elems, 33); FREE(src_node_id_arg);
42410 LDKRoutingFees fees_arg_conv;
42411 fees_arg_conv.inner = (void*)(fees_arg & (~1));
42412 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
42413 CHECK_INNER_FIELD_ACCESS_OR_NULL(fees_arg_conv);
42414 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
42415 void* htlc_minimum_msat_arg_ptr = (void*)(((uintptr_t)htlc_minimum_msat_arg) & ~1);
42416 CHECK_ACCESS(htlc_minimum_msat_arg_ptr);
42417 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_minimum_msat_arg_ptr);
42418 htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)htlc_minimum_msat_arg) & ~1));
42419 void* htlc_maximum_msat_arg_ptr = (void*)(((uintptr_t)htlc_maximum_msat_arg) & ~1);
42420 CHECK_ACCESS(htlc_maximum_msat_arg_ptr);
42421 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(htlc_maximum_msat_arg_ptr);
42422 htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)htlc_maximum_msat_arg) & ~1));
42423 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);
42424 uint32_t ret_ref = 0;
42425 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42426 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42427 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42428 ret_ref = (uintptr_t)ret_var.inner;
42429 if (ret_var.is_owned) {
42435 static inline uintptr_t RouteHintHop_clone_ptr(LDKRouteHintHop *NONNULL_PTR arg) {
42436 LDKRouteHintHop ret_var = RouteHintHop_clone(arg);
42437 uint32_t ret_ref = 0;
42438 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42439 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42440 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42441 ret_ref = (uintptr_t)ret_var.inner;
42442 if (ret_var.is_owned) {
42447 uint32_t __attribute__((export_name("TS_RouteHintHop_clone_ptr"))) TS_RouteHintHop_clone_ptr(uint32_t arg) {
42448 LDKRouteHintHop arg_conv;
42449 arg_conv.inner = (void*)(arg & (~1));
42450 arg_conv.is_owned = false;
42451 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42452 uint32_t ret_conv = RouteHintHop_clone_ptr(&arg_conv);
42456 uint32_t __attribute__((export_name("TS_RouteHintHop_clone"))) TS_RouteHintHop_clone(uint32_t orig) {
42457 LDKRouteHintHop orig_conv;
42458 orig_conv.inner = (void*)(orig & (~1));
42459 orig_conv.is_owned = false;
42460 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42461 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
42462 uint32_t ret_ref = 0;
42463 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42464 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42465 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42466 ret_ref = (uintptr_t)ret_var.inner;
42467 if (ret_var.is_owned) {
42473 int64_t __attribute__((export_name("TS_RouteHintHop_hash"))) TS_RouteHintHop_hash(uint32_t o) {
42474 LDKRouteHintHop o_conv;
42475 o_conv.inner = (void*)(o & (~1));
42476 o_conv.is_owned = false;
42477 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
42478 int64_t ret_conv = RouteHintHop_hash(&o_conv);
42482 jboolean __attribute__((export_name("TS_RouteHintHop_eq"))) TS_RouteHintHop_eq(uint32_t a, uint32_t b) {
42483 LDKRouteHintHop a_conv;
42484 a_conv.inner = (void*)(a & (~1));
42485 a_conv.is_owned = false;
42486 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
42487 LDKRouteHintHop b_conv;
42488 b_conv.inner = (void*)(b & (~1));
42489 b_conv.is_owned = false;
42490 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
42491 jboolean ret_conv = RouteHintHop_eq(&a_conv, &b_conv);
42495 int8_tArray __attribute__((export_name("TS_RouteHintHop_write"))) TS_RouteHintHop_write(uint32_t obj) {
42496 LDKRouteHintHop obj_conv;
42497 obj_conv.inner = (void*)(obj & (~1));
42498 obj_conv.is_owned = false;
42499 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42500 LDKCVec_u8Z ret_var = RouteHintHop_write(&obj_conv);
42501 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42502 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42503 CVec_u8Z_free(ret_var);
42507 uint32_t __attribute__((export_name("TS_RouteHintHop_read"))) TS_RouteHintHop_read(int8_tArray ser) {
42508 LDKu8slice ser_ref;
42509 ser_ref.datalen = ser->arr_len;
42510 ser_ref.data = ser->elems;
42511 LDKCResult_RouteHintHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHintHopDecodeErrorZ), "LDKCResult_RouteHintHopDecodeErrorZ");
42512 *ret_conv = RouteHintHop_read(ser_ref);
42514 return (uint32_t)ret_conv;
42517 uint32_t __attribute__((export_name("TS_find_route"))) TS_find_route(int8_tArray our_node_pubkey, uint32_t route_params, uint32_t network_graph, uint32_tArray first_hops, uint32_t logger, uint32_t scorer, int8_tArray random_seed_bytes) {
42518 LDKPublicKey our_node_pubkey_ref;
42519 CHECK(our_node_pubkey->arr_len == 33);
42520 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
42521 LDKRouteParameters route_params_conv;
42522 route_params_conv.inner = (void*)(route_params & (~1));
42523 route_params_conv.is_owned = false;
42524 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
42525 LDKNetworkGraph network_graph_conv;
42526 network_graph_conv.inner = (void*)(network_graph & (~1));
42527 network_graph_conv.is_owned = false;
42528 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
42529 LDKCVec_ChannelDetailsZ first_hops_constr;
42530 LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL;
42531 if (first_hops != 0) {
42532 first_hops_constr.datalen = first_hops->arr_len;
42533 if (first_hops_constr.datalen > 0)
42534 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
42536 first_hops_constr.data = NULL;
42537 uint32_t* first_hops_vals = first_hops->elems;
42538 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
42539 uint32_t first_hops_conv_16 = first_hops_vals[q];
42540 LDKChannelDetails first_hops_conv_16_conv;
42541 first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
42542 first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
42543 CHECK_INNER_FIELD_ACCESS_OR_NULL(first_hops_conv_16_conv);
42544 first_hops_constr.data[q] = first_hops_conv_16_conv;
42547 first_hops_ptr = &first_hops_constr;
42549 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
42550 CHECK_ACCESS(logger_ptr);
42551 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
42552 if (logger_conv.free == LDKLogger_JCalls_free) {
42553 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
42554 LDKLogger_JCalls_cloned(&logger_conv);
42556 void* scorer_ptr = (void*)(((uintptr_t)scorer) & ~1);
42557 if (!(scorer & 1)) { CHECK_ACCESS(scorer_ptr); }
42558 LDKScore* scorer_conv = (LDKScore*)scorer_ptr;
42559 unsigned char random_seed_bytes_arr[32];
42560 CHECK(random_seed_bytes->arr_len == 32);
42561 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
42562 unsigned char (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
42563 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
42564 *ret_conv = find_route(our_node_pubkey_ref, &route_params_conv, &network_graph_conv, first_hops_ptr, logger_conv, scorer_conv, random_seed_bytes_ref);
42565 if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); }
42566 return (uint32_t)ret_conv;
42569 uint32_t __attribute__((export_name("TS_build_route_from_hops"))) TS_build_route_from_hops(int8_tArray our_node_pubkey, ptrArray hops, uint32_t route_params, uint32_t network_graph, uint32_t logger, int8_tArray random_seed_bytes) {
42570 LDKPublicKey our_node_pubkey_ref;
42571 CHECK(our_node_pubkey->arr_len == 33);
42572 memcpy(our_node_pubkey_ref.compressed_form, our_node_pubkey->elems, 33); FREE(our_node_pubkey);
42573 LDKCVec_PublicKeyZ hops_constr;
42574 hops_constr.datalen = hops->arr_len;
42575 if (hops_constr.datalen > 0)
42576 hops_constr.data = MALLOC(hops_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
42578 hops_constr.data = NULL;
42579 int8_tArray* hops_vals = (void*) hops->elems;
42580 for (size_t m = 0; m < hops_constr.datalen; m++) {
42581 int8_tArray hops_conv_12 = hops_vals[m];
42582 LDKPublicKey hops_conv_12_ref;
42583 CHECK(hops_conv_12->arr_len == 33);
42584 memcpy(hops_conv_12_ref.compressed_form, hops_conv_12->elems, 33); FREE(hops_conv_12);
42585 hops_constr.data[m] = hops_conv_12_ref;
42588 LDKRouteParameters route_params_conv;
42589 route_params_conv.inner = (void*)(route_params & (~1));
42590 route_params_conv.is_owned = false;
42591 CHECK_INNER_FIELD_ACCESS_OR_NULL(route_params_conv);
42592 LDKNetworkGraph network_graph_conv;
42593 network_graph_conv.inner = (void*)(network_graph & (~1));
42594 network_graph_conv.is_owned = false;
42595 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
42596 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
42597 CHECK_ACCESS(logger_ptr);
42598 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
42599 if (logger_conv.free == LDKLogger_JCalls_free) {
42600 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
42601 LDKLogger_JCalls_cloned(&logger_conv);
42603 unsigned char random_seed_bytes_arr[32];
42604 CHECK(random_seed_bytes->arr_len == 32);
42605 memcpy(random_seed_bytes_arr, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
42606 unsigned char (*random_seed_bytes_ref)[32] = &random_seed_bytes_arr;
42607 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
42608 *ret_conv = build_route_from_hops(our_node_pubkey_ref, hops_constr, &route_params_conv, &network_graph_conv, logger_conv, random_seed_bytes_ref);
42609 return (uint32_t)ret_conv;
42612 void __attribute__((export_name("TS_Score_free"))) TS_Score_free(uint32_t this_ptr) {
42613 if ((this_ptr & 1) != 0) return;
42614 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
42615 CHECK_ACCESS(this_ptr_ptr);
42616 LDKScore this_ptr_conv = *(LDKScore*)(this_ptr_ptr);
42617 FREE((void*)this_ptr);
42618 Score_free(this_ptr_conv);
42621 void __attribute__((export_name("TS_LockableScore_free"))) TS_LockableScore_free(uint32_t this_ptr) {
42622 if ((this_ptr & 1) != 0) return;
42623 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
42624 CHECK_ACCESS(this_ptr_ptr);
42625 LDKLockableScore this_ptr_conv = *(LDKLockableScore*)(this_ptr_ptr);
42626 FREE((void*)this_ptr);
42627 LockableScore_free(this_ptr_conv);
42630 void __attribute__((export_name("TS_MultiThreadedLockableScore_free"))) TS_MultiThreadedLockableScore_free(uint32_t this_obj) {
42631 LDKMultiThreadedLockableScore this_obj_conv;
42632 this_obj_conv.inner = (void*)(this_obj & (~1));
42633 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42634 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42635 MultiThreadedLockableScore_free(this_obj_conv);
42638 int8_tArray __attribute__((export_name("TS_MultiThreadedLockableScore_write"))) TS_MultiThreadedLockableScore_write(uint32_t obj) {
42639 LDKMultiThreadedLockableScore obj_conv;
42640 obj_conv.inner = (void*)(obj & (~1));
42641 obj_conv.is_owned = false;
42642 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42643 LDKCVec_u8Z ret_var = MultiThreadedLockableScore_write(&obj_conv);
42644 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42645 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42646 CVec_u8Z_free(ret_var);
42650 uint32_t __attribute__((export_name("TS_MultiThreadedLockableScore_new"))) TS_MultiThreadedLockableScore_new(uint32_t score) {
42651 void* score_ptr = (void*)(((uintptr_t)score) & ~1);
42652 CHECK_ACCESS(score_ptr);
42653 LDKScore score_conv = *(LDKScore*)(score_ptr);
42654 if (score_conv.free == LDKScore_JCalls_free) {
42655 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
42656 LDKScore_JCalls_cloned(&score_conv);
42658 LDKMultiThreadedLockableScore ret_var = MultiThreadedLockableScore_new(score_conv);
42659 uint32_t ret_ref = 0;
42660 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42661 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42662 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42663 ret_ref = (uintptr_t)ret_var.inner;
42664 if (ret_var.is_owned) {
42670 void __attribute__((export_name("TS_ChannelUsage_free"))) TS_ChannelUsage_free(uint32_t this_obj) {
42671 LDKChannelUsage this_obj_conv;
42672 this_obj_conv.inner = (void*)(this_obj & (~1));
42673 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42674 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42675 ChannelUsage_free(this_obj_conv);
42678 int64_t __attribute__((export_name("TS_ChannelUsage_get_amount_msat"))) TS_ChannelUsage_get_amount_msat(uint32_t this_ptr) {
42679 LDKChannelUsage this_ptr_conv;
42680 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42681 this_ptr_conv.is_owned = false;
42682 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42683 int64_t ret_conv = ChannelUsage_get_amount_msat(&this_ptr_conv);
42687 void __attribute__((export_name("TS_ChannelUsage_set_amount_msat"))) TS_ChannelUsage_set_amount_msat(uint32_t this_ptr, int64_t val) {
42688 LDKChannelUsage this_ptr_conv;
42689 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42690 this_ptr_conv.is_owned = false;
42691 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42692 ChannelUsage_set_amount_msat(&this_ptr_conv, val);
42695 int64_t __attribute__((export_name("TS_ChannelUsage_get_inflight_htlc_msat"))) TS_ChannelUsage_get_inflight_htlc_msat(uint32_t this_ptr) {
42696 LDKChannelUsage this_ptr_conv;
42697 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42698 this_ptr_conv.is_owned = false;
42699 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42700 int64_t ret_conv = ChannelUsage_get_inflight_htlc_msat(&this_ptr_conv);
42704 void __attribute__((export_name("TS_ChannelUsage_set_inflight_htlc_msat"))) TS_ChannelUsage_set_inflight_htlc_msat(uint32_t this_ptr, int64_t val) {
42705 LDKChannelUsage this_ptr_conv;
42706 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42707 this_ptr_conv.is_owned = false;
42708 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42709 ChannelUsage_set_inflight_htlc_msat(&this_ptr_conv, val);
42712 uint32_t __attribute__((export_name("TS_ChannelUsage_get_effective_capacity"))) TS_ChannelUsage_get_effective_capacity(uint32_t this_ptr) {
42713 LDKChannelUsage this_ptr_conv;
42714 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42715 this_ptr_conv.is_owned = false;
42716 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42717 LDKEffectiveCapacity *ret_copy = MALLOC(sizeof(LDKEffectiveCapacity), "LDKEffectiveCapacity");
42718 *ret_copy = ChannelUsage_get_effective_capacity(&this_ptr_conv);
42719 uint32_t ret_ref = (uintptr_t)ret_copy;
42723 void __attribute__((export_name("TS_ChannelUsage_set_effective_capacity"))) TS_ChannelUsage_set_effective_capacity(uint32_t this_ptr, uint32_t val) {
42724 LDKChannelUsage this_ptr_conv;
42725 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42726 this_ptr_conv.is_owned = false;
42727 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42728 void* val_ptr = (void*)(((uintptr_t)val) & ~1);
42729 CHECK_ACCESS(val_ptr);
42730 LDKEffectiveCapacity val_conv = *(LDKEffectiveCapacity*)(val_ptr);
42731 val_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)(((uintptr_t)val) & ~1));
42732 ChannelUsage_set_effective_capacity(&this_ptr_conv, val_conv);
42735 uint32_t __attribute__((export_name("TS_ChannelUsage_new"))) TS_ChannelUsage_new(int64_t amount_msat_arg, int64_t inflight_htlc_msat_arg, uint32_t effective_capacity_arg) {
42736 void* effective_capacity_arg_ptr = (void*)(((uintptr_t)effective_capacity_arg) & ~1);
42737 CHECK_ACCESS(effective_capacity_arg_ptr);
42738 LDKEffectiveCapacity effective_capacity_arg_conv = *(LDKEffectiveCapacity*)(effective_capacity_arg_ptr);
42739 effective_capacity_arg_conv = EffectiveCapacity_clone((LDKEffectiveCapacity*)(((uintptr_t)effective_capacity_arg) & ~1));
42740 LDKChannelUsage ret_var = ChannelUsage_new(amount_msat_arg, inflight_htlc_msat_arg, effective_capacity_arg_conv);
42741 uint32_t ret_ref = 0;
42742 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42743 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42744 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42745 ret_ref = (uintptr_t)ret_var.inner;
42746 if (ret_var.is_owned) {
42752 static inline uintptr_t ChannelUsage_clone_ptr(LDKChannelUsage *NONNULL_PTR arg) {
42753 LDKChannelUsage ret_var = ChannelUsage_clone(arg);
42754 uint32_t ret_ref = 0;
42755 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42756 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42757 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42758 ret_ref = (uintptr_t)ret_var.inner;
42759 if (ret_var.is_owned) {
42764 uint32_t __attribute__((export_name("TS_ChannelUsage_clone_ptr"))) TS_ChannelUsage_clone_ptr(uint32_t arg) {
42765 LDKChannelUsage arg_conv;
42766 arg_conv.inner = (void*)(arg & (~1));
42767 arg_conv.is_owned = false;
42768 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42769 uint32_t ret_conv = ChannelUsage_clone_ptr(&arg_conv);
42773 uint32_t __attribute__((export_name("TS_ChannelUsage_clone"))) TS_ChannelUsage_clone(uint32_t orig) {
42774 LDKChannelUsage orig_conv;
42775 orig_conv.inner = (void*)(orig & (~1));
42776 orig_conv.is_owned = false;
42777 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42778 LDKChannelUsage ret_var = ChannelUsage_clone(&orig_conv);
42779 uint32_t ret_ref = 0;
42780 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42781 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42782 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42783 ret_ref = (uintptr_t)ret_var.inner;
42784 if (ret_var.is_owned) {
42790 void __attribute__((export_name("TS_FixedPenaltyScorer_free"))) TS_FixedPenaltyScorer_free(uint32_t this_obj) {
42791 LDKFixedPenaltyScorer this_obj_conv;
42792 this_obj_conv.inner = (void*)(this_obj & (~1));
42793 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42795 FixedPenaltyScorer_free(this_obj_conv);
42798 static inline uintptr_t FixedPenaltyScorer_clone_ptr(LDKFixedPenaltyScorer *NONNULL_PTR arg) {
42799 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(arg);
42800 uint32_t ret_ref = 0;
42801 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42802 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42803 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42804 ret_ref = (uintptr_t)ret_var.inner;
42805 if (ret_var.is_owned) {
42810 uint32_t __attribute__((export_name("TS_FixedPenaltyScorer_clone_ptr"))) TS_FixedPenaltyScorer_clone_ptr(uint32_t arg) {
42811 LDKFixedPenaltyScorer arg_conv;
42812 arg_conv.inner = (void*)(arg & (~1));
42813 arg_conv.is_owned = false;
42814 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
42815 uint32_t ret_conv = FixedPenaltyScorer_clone_ptr(&arg_conv);
42819 uint32_t __attribute__((export_name("TS_FixedPenaltyScorer_clone"))) TS_FixedPenaltyScorer_clone(uint32_t orig) {
42820 LDKFixedPenaltyScorer orig_conv;
42821 orig_conv.inner = (void*)(orig & (~1));
42822 orig_conv.is_owned = false;
42823 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
42824 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_clone(&orig_conv);
42825 uint32_t ret_ref = 0;
42826 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42827 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42828 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42829 ret_ref = (uintptr_t)ret_var.inner;
42830 if (ret_var.is_owned) {
42836 uint32_t __attribute__((export_name("TS_FixedPenaltyScorer_with_penalty"))) TS_FixedPenaltyScorer_with_penalty(int64_t penalty_msat) {
42837 LDKFixedPenaltyScorer ret_var = FixedPenaltyScorer_with_penalty(penalty_msat);
42838 uint32_t ret_ref = 0;
42839 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
42840 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
42841 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
42842 ret_ref = (uintptr_t)ret_var.inner;
42843 if (ret_var.is_owned) {
42849 uint32_t __attribute__((export_name("TS_FixedPenaltyScorer_as_Score"))) TS_FixedPenaltyScorer_as_Score(uint32_t this_arg) {
42850 LDKFixedPenaltyScorer this_arg_conv;
42851 this_arg_conv.inner = (void*)(this_arg & (~1));
42852 this_arg_conv.is_owned = false;
42853 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
42854 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
42855 *ret_ret = FixedPenaltyScorer_as_Score(&this_arg_conv);
42856 return (uint32_t)ret_ret;
42859 int8_tArray __attribute__((export_name("TS_FixedPenaltyScorer_write"))) TS_FixedPenaltyScorer_write(uint32_t obj) {
42860 LDKFixedPenaltyScorer obj_conv;
42861 obj_conv.inner = (void*)(obj & (~1));
42862 obj_conv.is_owned = false;
42863 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
42864 LDKCVec_u8Z ret_var = FixedPenaltyScorer_write(&obj_conv);
42865 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
42866 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
42867 CVec_u8Z_free(ret_var);
42871 uint32_t __attribute__((export_name("TS_FixedPenaltyScorer_read"))) TS_FixedPenaltyScorer_read(int8_tArray ser, int64_t arg) {
42872 LDKu8slice ser_ref;
42873 ser_ref.datalen = ser->arr_len;
42874 ser_ref.data = ser->elems;
42875 LDKCResult_FixedPenaltyScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FixedPenaltyScorerDecodeErrorZ), "LDKCResult_FixedPenaltyScorerDecodeErrorZ");
42876 *ret_conv = FixedPenaltyScorer_read(ser_ref, arg);
42878 return (uint32_t)ret_conv;
42881 void __attribute__((export_name("TS_ProbabilisticScorer_free"))) TS_ProbabilisticScorer_free(uint32_t this_obj) {
42882 LDKProbabilisticScorer this_obj_conv;
42883 this_obj_conv.inner = (void*)(this_obj & (~1));
42884 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42885 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42886 ProbabilisticScorer_free(this_obj_conv);
42889 void __attribute__((export_name("TS_ProbabilisticScoringParameters_free"))) TS_ProbabilisticScoringParameters_free(uint32_t this_obj) {
42890 LDKProbabilisticScoringParameters this_obj_conv;
42891 this_obj_conv.inner = (void*)(this_obj & (~1));
42892 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
42893 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
42894 ProbabilisticScoringParameters_free(this_obj_conv);
42897 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_msat(uint32_t this_ptr) {
42898 LDKProbabilisticScoringParameters this_ptr_conv;
42899 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42900 this_ptr_conv.is_owned = false;
42901 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42902 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_msat(&this_ptr_conv);
42906 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_msat(uint32_t this_ptr, int64_t val) {
42907 LDKProbabilisticScoringParameters this_ptr_conv;
42908 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42909 this_ptr_conv.is_owned = false;
42910 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42911 ProbabilisticScoringParameters_set_base_penalty_msat(&this_ptr_conv, val);
42914 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(uint32_t this_ptr) {
42915 LDKProbabilisticScoringParameters this_ptr_conv;
42916 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42917 this_ptr_conv.is_owned = false;
42918 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42919 int64_t ret_conv = ProbabilisticScoringParameters_get_base_penalty_amount_multiplier_msat(&this_ptr_conv);
42923 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(uint32_t this_ptr, int64_t val) {
42924 LDKProbabilisticScoringParameters this_ptr_conv;
42925 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42926 this_ptr_conv.is_owned = false;
42927 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42928 ProbabilisticScoringParameters_set_base_penalty_amount_multiplier_msat(&this_ptr_conv, val);
42931 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(uint32_t this_ptr) {
42932 LDKProbabilisticScoringParameters this_ptr_conv;
42933 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42934 this_ptr_conv.is_owned = false;
42935 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42936 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_multiplier_msat(&this_ptr_conv);
42940 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(uint32_t this_ptr, int64_t val) {
42941 LDKProbabilisticScoringParameters this_ptr_conv;
42942 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42943 this_ptr_conv.is_owned = false;
42944 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42945 ProbabilisticScoringParameters_set_liquidity_penalty_multiplier_msat(&this_ptr_conv, val);
42948 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_get_liquidity_offset_half_life(uint32_t this_ptr) {
42949 LDKProbabilisticScoringParameters this_ptr_conv;
42950 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42951 this_ptr_conv.is_owned = false;
42952 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42953 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_offset_half_life(&this_ptr_conv);
42957 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life"))) TS_ProbabilisticScoringParameters_set_liquidity_offset_half_life(uint32_t this_ptr, int64_t val) {
42958 LDKProbabilisticScoringParameters this_ptr_conv;
42959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42960 this_ptr_conv.is_owned = false;
42961 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42962 ProbabilisticScoringParameters_set_liquidity_offset_half_life(&this_ptr_conv, val);
42965 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(uint32_t this_ptr) {
42966 LDKProbabilisticScoringParameters this_ptr_conv;
42967 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42968 this_ptr_conv.is_owned = false;
42969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42970 int64_t ret_conv = ProbabilisticScoringParameters_get_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv);
42974 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat"))) TS_ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(uint32_t this_ptr, int64_t val) {
42975 LDKProbabilisticScoringParameters this_ptr_conv;
42976 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42977 this_ptr_conv.is_owned = false;
42978 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42979 ProbabilisticScoringParameters_set_liquidity_penalty_amount_multiplier_msat(&this_ptr_conv, val);
42982 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_get_anti_probing_penalty_msat(uint32_t this_ptr) {
42983 LDKProbabilisticScoringParameters this_ptr_conv;
42984 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42985 this_ptr_conv.is_owned = false;
42986 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42987 int64_t ret_conv = ProbabilisticScoringParameters_get_anti_probing_penalty_msat(&this_ptr_conv);
42991 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat"))) TS_ProbabilisticScoringParameters_set_anti_probing_penalty_msat(uint32_t this_ptr, int64_t val) {
42992 LDKProbabilisticScoringParameters this_ptr_conv;
42993 this_ptr_conv.inner = (void*)(this_ptr & (~1));
42994 this_ptr_conv.is_owned = false;
42995 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
42996 ProbabilisticScoringParameters_set_anti_probing_penalty_msat(&this_ptr_conv, val);
42999 int64_t __attribute__((export_name("TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(uint32_t this_ptr) {
43000 LDKProbabilisticScoringParameters this_ptr_conv;
43001 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43002 this_ptr_conv.is_owned = false;
43003 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43004 int64_t ret_conv = ProbabilisticScoringParameters_get_considered_impossible_penalty_msat(&this_ptr_conv);
43008 void __attribute__((export_name("TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat"))) TS_ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(uint32_t this_ptr, int64_t val) {
43009 LDKProbabilisticScoringParameters this_ptr_conv;
43010 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43011 this_ptr_conv.is_owned = false;
43012 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43013 ProbabilisticScoringParameters_set_considered_impossible_penalty_msat(&this_ptr_conv, val);
43016 static inline uintptr_t ProbabilisticScoringParameters_clone_ptr(LDKProbabilisticScoringParameters *NONNULL_PTR arg) {
43017 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(arg);
43018 uint32_t ret_ref = 0;
43019 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43020 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43021 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43022 ret_ref = (uintptr_t)ret_var.inner;
43023 if (ret_var.is_owned) {
43028 uint32_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone_ptr"))) TS_ProbabilisticScoringParameters_clone_ptr(uint32_t arg) {
43029 LDKProbabilisticScoringParameters arg_conv;
43030 arg_conv.inner = (void*)(arg & (~1));
43031 arg_conv.is_owned = false;
43032 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43033 uint32_t ret_conv = ProbabilisticScoringParameters_clone_ptr(&arg_conv);
43037 uint32_t __attribute__((export_name("TS_ProbabilisticScoringParameters_clone"))) TS_ProbabilisticScoringParameters_clone(uint32_t orig) {
43038 LDKProbabilisticScoringParameters orig_conv;
43039 orig_conv.inner = (void*)(orig & (~1));
43040 orig_conv.is_owned = false;
43041 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43042 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_clone(&orig_conv);
43043 uint32_t ret_ref = 0;
43044 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43045 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43046 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43047 ret_ref = (uintptr_t)ret_var.inner;
43048 if (ret_var.is_owned) {
43054 uint32_t __attribute__((export_name("TS_ProbabilisticScorer_new"))) TS_ProbabilisticScorer_new(uint32_t params, uint32_t network_graph, uint32_t logger) {
43055 LDKProbabilisticScoringParameters params_conv;
43056 params_conv.inner = (void*)(params & (~1));
43057 params_conv.is_owned = (params & 1) || (params == 0);
43058 CHECK_INNER_FIELD_ACCESS_OR_NULL(params_conv);
43059 params_conv = ProbabilisticScoringParameters_clone(¶ms_conv);
43060 LDKNetworkGraph network_graph_conv;
43061 network_graph_conv.inner = (void*)(network_graph & (~1));
43062 network_graph_conv.is_owned = false;
43063 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
43064 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
43065 CHECK_ACCESS(logger_ptr);
43066 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
43067 if (logger_conv.free == LDKLogger_JCalls_free) {
43068 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43069 LDKLogger_JCalls_cloned(&logger_conv);
43071 LDKProbabilisticScorer ret_var = ProbabilisticScorer_new(params_conv, &network_graph_conv, logger_conv);
43072 uint32_t ret_ref = 0;
43073 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43074 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43075 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43076 ret_ref = (uintptr_t)ret_var.inner;
43077 if (ret_var.is_owned) {
43083 void __attribute__((export_name("TS_ProbabilisticScorer_debug_log_liquidity_stats"))) TS_ProbabilisticScorer_debug_log_liquidity_stats(uint32_t this_arg) {
43084 LDKProbabilisticScorer this_arg_conv;
43085 this_arg_conv.inner = (void*)(this_arg & (~1));
43086 this_arg_conv.is_owned = false;
43087 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43088 ProbabilisticScorer_debug_log_liquidity_stats(&this_arg_conv);
43091 uint32_t __attribute__((export_name("TS_ProbabilisticScorer_estimated_channel_liquidity_range"))) TS_ProbabilisticScorer_estimated_channel_liquidity_range(uint32_t this_arg, int64_t scid, uint32_t target) {
43092 LDKProbabilisticScorer this_arg_conv;
43093 this_arg_conv.inner = (void*)(this_arg & (~1));
43094 this_arg_conv.is_owned = false;
43095 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43096 LDKNodeId target_conv;
43097 target_conv.inner = (void*)(target & (~1));
43098 target_conv.is_owned = false;
43099 CHECK_INNER_FIELD_ACCESS_OR_NULL(target_conv);
43100 LDKCOption_C2Tuple_u64u64ZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_u64u64ZZ), "LDKCOption_C2Tuple_u64u64ZZ");
43101 *ret_copy = ProbabilisticScorer_estimated_channel_liquidity_range(&this_arg_conv, scid, &target_conv);
43102 uint32_t ret_ref = (uintptr_t)ret_copy;
43106 void __attribute__((export_name("TS_ProbabilisticScorer_add_banned"))) TS_ProbabilisticScorer_add_banned(uint32_t this_arg, uint32_t node_id) {
43107 LDKProbabilisticScorer this_arg_conv;
43108 this_arg_conv.inner = (void*)(this_arg & (~1));
43109 this_arg_conv.is_owned = false;
43110 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43111 LDKNodeId node_id_conv;
43112 node_id_conv.inner = (void*)(node_id & (~1));
43113 node_id_conv.is_owned = false;
43114 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
43115 ProbabilisticScorer_add_banned(&this_arg_conv, &node_id_conv);
43118 void __attribute__((export_name("TS_ProbabilisticScorer_remove_banned"))) TS_ProbabilisticScorer_remove_banned(uint32_t this_arg, uint32_t node_id) {
43119 LDKProbabilisticScorer this_arg_conv;
43120 this_arg_conv.inner = (void*)(this_arg & (~1));
43121 this_arg_conv.is_owned = false;
43122 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43123 LDKNodeId node_id_conv;
43124 node_id_conv.inner = (void*)(node_id & (~1));
43125 node_id_conv.is_owned = false;
43126 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
43127 ProbabilisticScorer_remove_banned(&this_arg_conv, &node_id_conv);
43130 void __attribute__((export_name("TS_ProbabilisticScorer_set_manual_penalty"))) TS_ProbabilisticScorer_set_manual_penalty(uint32_t this_arg, uint32_t node_id, int64_t penalty) {
43131 LDKProbabilisticScorer this_arg_conv;
43132 this_arg_conv.inner = (void*)(this_arg & (~1));
43133 this_arg_conv.is_owned = false;
43134 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43135 LDKNodeId node_id_conv;
43136 node_id_conv.inner = (void*)(node_id & (~1));
43137 node_id_conv.is_owned = false;
43138 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
43139 ProbabilisticScorer_set_manual_penalty(&this_arg_conv, &node_id_conv, penalty);
43142 void __attribute__((export_name("TS_ProbabilisticScorer_remove_manual_penalty"))) TS_ProbabilisticScorer_remove_manual_penalty(uint32_t this_arg, uint32_t node_id) {
43143 LDKProbabilisticScorer this_arg_conv;
43144 this_arg_conv.inner = (void*)(this_arg & (~1));
43145 this_arg_conv.is_owned = false;
43146 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43147 LDKNodeId node_id_conv;
43148 node_id_conv.inner = (void*)(node_id & (~1));
43149 node_id_conv.is_owned = false;
43150 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_id_conv);
43151 ProbabilisticScorer_remove_manual_penalty(&this_arg_conv, &node_id_conv);
43154 void __attribute__((export_name("TS_ProbabilisticScorer_clear_manual_penalties"))) TS_ProbabilisticScorer_clear_manual_penalties(uint32_t this_arg) {
43155 LDKProbabilisticScorer this_arg_conv;
43156 this_arg_conv.inner = (void*)(this_arg & (~1));
43157 this_arg_conv.is_owned = false;
43158 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43159 ProbabilisticScorer_clear_manual_penalties(&this_arg_conv);
43162 void __attribute__((export_name("TS_ProbabilisticScoringParameters_add_banned_from_list"))) TS_ProbabilisticScoringParameters_add_banned_from_list(uint32_t this_arg, uint32_tArray node_ids) {
43163 LDKProbabilisticScoringParameters this_arg_conv;
43164 this_arg_conv.inner = (void*)(this_arg & (~1));
43165 this_arg_conv.is_owned = false;
43166 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43167 LDKCVec_NodeIdZ node_ids_constr;
43168 node_ids_constr.datalen = node_ids->arr_len;
43169 if (node_ids_constr.datalen > 0)
43170 node_ids_constr.data = MALLOC(node_ids_constr.datalen * sizeof(LDKNodeId), "LDKCVec_NodeIdZ Elements");
43172 node_ids_constr.data = NULL;
43173 uint32_t* node_ids_vals = node_ids->elems;
43174 for (size_t i = 0; i < node_ids_constr.datalen; i++) {
43175 uint32_t node_ids_conv_8 = node_ids_vals[i];
43176 LDKNodeId node_ids_conv_8_conv;
43177 node_ids_conv_8_conv.inner = (void*)(node_ids_conv_8 & (~1));
43178 node_ids_conv_8_conv.is_owned = (node_ids_conv_8 & 1) || (node_ids_conv_8 == 0);
43179 CHECK_INNER_FIELD_ACCESS_OR_NULL(node_ids_conv_8_conv);
43180 node_ids_conv_8_conv = NodeId_clone(&node_ids_conv_8_conv);
43181 node_ids_constr.data[i] = node_ids_conv_8_conv;
43184 ProbabilisticScoringParameters_add_banned_from_list(&this_arg_conv, node_ids_constr);
43187 uint32_t __attribute__((export_name("TS_ProbabilisticScoringParameters_default"))) TS_ProbabilisticScoringParameters_default() {
43188 LDKProbabilisticScoringParameters ret_var = ProbabilisticScoringParameters_default();
43189 uint32_t ret_ref = 0;
43190 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43191 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43192 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43193 ret_ref = (uintptr_t)ret_var.inner;
43194 if (ret_var.is_owned) {
43200 uint32_t __attribute__((export_name("TS_ProbabilisticScorer_as_Score"))) TS_ProbabilisticScorer_as_Score(uint32_t this_arg) {
43201 LDKProbabilisticScorer this_arg_conv;
43202 this_arg_conv.inner = (void*)(this_arg & (~1));
43203 this_arg_conv.is_owned = false;
43204 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
43205 LDKScore* ret_ret = MALLOC(sizeof(LDKScore), "LDKScore");
43206 *ret_ret = ProbabilisticScorer_as_Score(&this_arg_conv);
43207 return (uint32_t)ret_ret;
43210 int8_tArray __attribute__((export_name("TS_ProbabilisticScorer_write"))) TS_ProbabilisticScorer_write(uint32_t obj) {
43211 LDKProbabilisticScorer obj_conv;
43212 obj_conv.inner = (void*)(obj & (~1));
43213 obj_conv.is_owned = false;
43214 CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
43215 LDKCVec_u8Z ret_var = ProbabilisticScorer_write(&obj_conv);
43216 int8_tArray ret_arr = init_int8_tArray(ret_var.datalen, __LINE__);
43217 memcpy(ret_arr->elems, ret_var.data, ret_var.datalen);
43218 CVec_u8Z_free(ret_var);
43222 uint32_t __attribute__((export_name("TS_ProbabilisticScorer_read"))) TS_ProbabilisticScorer_read(int8_tArray ser, uint32_t arg_a, uint32_t arg_b, uint32_t arg_c) {
43223 LDKu8slice ser_ref;
43224 ser_ref.datalen = ser->arr_len;
43225 ser_ref.data = ser->elems;
43226 LDKProbabilisticScoringParameters arg_a_conv;
43227 arg_a_conv.inner = (void*)(arg_a & (~1));
43228 arg_a_conv.is_owned = (arg_a & 1) || (arg_a == 0);
43229 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_a_conv);
43230 arg_a_conv = ProbabilisticScoringParameters_clone(&arg_a_conv);
43231 LDKNetworkGraph arg_b_conv;
43232 arg_b_conv.inner = (void*)(arg_b & (~1));
43233 arg_b_conv.is_owned = false;
43234 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_b_conv);
43235 void* arg_c_ptr = (void*)(((uintptr_t)arg_c) & ~1);
43236 CHECK_ACCESS(arg_c_ptr);
43237 LDKLogger arg_c_conv = *(LDKLogger*)(arg_c_ptr);
43238 if (arg_c_conv.free == LDKLogger_JCalls_free) {
43239 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
43240 LDKLogger_JCalls_cloned(&arg_c_conv);
43242 LDKCResult_ProbabilisticScorerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ProbabilisticScorerDecodeErrorZ), "LDKCResult_ProbabilisticScorerDecodeErrorZ");
43243 *ret_conv = ProbabilisticScorer_read(ser_ref, arg_a_conv, &arg_b_conv, arg_c_conv);
43245 return (uint32_t)ret_conv;
43248 void __attribute__((export_name("TS_ParseError_free"))) TS_ParseError_free(uint32_t this_ptr) {
43249 if ((this_ptr & 1) != 0) return;
43250 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
43251 CHECK_ACCESS(this_ptr_ptr);
43252 LDKParseError this_ptr_conv = *(LDKParseError*)(this_ptr_ptr);
43253 FREE((void*)this_ptr);
43254 ParseError_free(this_ptr_conv);
43257 static inline uintptr_t ParseError_clone_ptr(LDKParseError *NONNULL_PTR arg) {
43258 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43259 *ret_copy = ParseError_clone(arg);
43260 uint32_t ret_ref = (uintptr_t)ret_copy;
43263 uint32_t __attribute__((export_name("TS_ParseError_clone_ptr"))) TS_ParseError_clone_ptr(uint32_t arg) {
43264 LDKParseError* arg_conv = (LDKParseError*)arg;
43265 uint32_t ret_conv = ParseError_clone_ptr(arg_conv);
43269 uint32_t __attribute__((export_name("TS_ParseError_clone"))) TS_ParseError_clone(uint32_t orig) {
43270 LDKParseError* orig_conv = (LDKParseError*)orig;
43271 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43272 *ret_copy = ParseError_clone(orig_conv);
43273 uint32_t ret_ref = (uintptr_t)ret_copy;
43277 uint32_t __attribute__((export_name("TS_ParseError_bech32_error"))) TS_ParseError_bech32_error(uint32_t a) {
43278 void* a_ptr = (void*)(((uintptr_t)a) & ~1);
43279 CHECK_ACCESS(a_ptr);
43280 LDKBech32Error a_conv = *(LDKBech32Error*)(a_ptr);
43281 a_conv = Bech32Error_clone((LDKBech32Error*)(((uintptr_t)a) & ~1));
43282 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43283 *ret_copy = ParseError_bech32_error(a_conv);
43284 uint32_t ret_ref = (uintptr_t)ret_copy;
43288 uint32_t __attribute__((export_name("TS_ParseError_parse_amount_error"))) TS_ParseError_parse_amount_error(int32_t a) {
43290 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43291 *ret_copy = ParseError_parse_amount_error((LDKError){ ._dummy = 0 });
43292 uint32_t ret_ref = (uintptr_t)ret_copy;
43296 uint32_t __attribute__((export_name("TS_ParseError_malformed_signature"))) TS_ParseError_malformed_signature(uint32_t a) {
43297 LDKSecp256k1Error a_conv = LDKSecp256k1Error_from_js(a);
43298 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43299 *ret_copy = ParseError_malformed_signature(a_conv);
43300 uint32_t ret_ref = (uintptr_t)ret_copy;
43304 uint32_t __attribute__((export_name("TS_ParseError_bad_prefix"))) TS_ParseError_bad_prefix() {
43305 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43306 *ret_copy = ParseError_bad_prefix();
43307 uint32_t ret_ref = (uintptr_t)ret_copy;
43311 uint32_t __attribute__((export_name("TS_ParseError_unknown_currency"))) TS_ParseError_unknown_currency() {
43312 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43313 *ret_copy = ParseError_unknown_currency();
43314 uint32_t ret_ref = (uintptr_t)ret_copy;
43318 uint32_t __attribute__((export_name("TS_ParseError_unknown_si_prefix"))) TS_ParseError_unknown_si_prefix() {
43319 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43320 *ret_copy = ParseError_unknown_si_prefix();
43321 uint32_t ret_ref = (uintptr_t)ret_copy;
43325 uint32_t __attribute__((export_name("TS_ParseError_malformed_hrp"))) TS_ParseError_malformed_hrp() {
43326 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43327 *ret_copy = ParseError_malformed_hrp();
43328 uint32_t ret_ref = (uintptr_t)ret_copy;
43332 uint32_t __attribute__((export_name("TS_ParseError_too_short_data_part"))) TS_ParseError_too_short_data_part() {
43333 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43334 *ret_copy = ParseError_too_short_data_part();
43335 uint32_t ret_ref = (uintptr_t)ret_copy;
43339 uint32_t __attribute__((export_name("TS_ParseError_unexpected_end_of_tagged_fields"))) TS_ParseError_unexpected_end_of_tagged_fields() {
43340 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43341 *ret_copy = ParseError_unexpected_end_of_tagged_fields();
43342 uint32_t ret_ref = (uintptr_t)ret_copy;
43346 uint32_t __attribute__((export_name("TS_ParseError_description_decode_error"))) TS_ParseError_description_decode_error(int32_t a) {
43348 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43349 *ret_copy = ParseError_description_decode_error((LDKError){ ._dummy = 0 });
43350 uint32_t ret_ref = (uintptr_t)ret_copy;
43354 uint32_t __attribute__((export_name("TS_ParseError_padding_error"))) TS_ParseError_padding_error() {
43355 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43356 *ret_copy = ParseError_padding_error();
43357 uint32_t ret_ref = (uintptr_t)ret_copy;
43361 uint32_t __attribute__((export_name("TS_ParseError_integer_overflow_error"))) TS_ParseError_integer_overflow_error() {
43362 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43363 *ret_copy = ParseError_integer_overflow_error();
43364 uint32_t ret_ref = (uintptr_t)ret_copy;
43368 uint32_t __attribute__((export_name("TS_ParseError_invalid_seg_wit_program_length"))) TS_ParseError_invalid_seg_wit_program_length() {
43369 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43370 *ret_copy = ParseError_invalid_seg_wit_program_length();
43371 uint32_t ret_ref = (uintptr_t)ret_copy;
43375 uint32_t __attribute__((export_name("TS_ParseError_invalid_pub_key_hash_length"))) TS_ParseError_invalid_pub_key_hash_length() {
43376 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43377 *ret_copy = ParseError_invalid_pub_key_hash_length();
43378 uint32_t ret_ref = (uintptr_t)ret_copy;
43382 uint32_t __attribute__((export_name("TS_ParseError_invalid_script_hash_length"))) TS_ParseError_invalid_script_hash_length() {
43383 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43384 *ret_copy = ParseError_invalid_script_hash_length();
43385 uint32_t ret_ref = (uintptr_t)ret_copy;
43389 uint32_t __attribute__((export_name("TS_ParseError_invalid_recovery_id"))) TS_ParseError_invalid_recovery_id() {
43390 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43391 *ret_copy = ParseError_invalid_recovery_id();
43392 uint32_t ret_ref = (uintptr_t)ret_copy;
43396 uint32_t __attribute__((export_name("TS_ParseError_invalid_slice_length"))) TS_ParseError_invalid_slice_length(jstring a) {
43397 LDKStr a_conv = str_ref_to_owned_c(a);
43398 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43399 *ret_copy = ParseError_invalid_slice_length(a_conv);
43400 uint32_t ret_ref = (uintptr_t)ret_copy;
43404 uint32_t __attribute__((export_name("TS_ParseError_skip"))) TS_ParseError_skip() {
43405 LDKParseError *ret_copy = MALLOC(sizeof(LDKParseError), "LDKParseError");
43406 *ret_copy = ParseError_skip();
43407 uint32_t ret_ref = (uintptr_t)ret_copy;
43411 void __attribute__((export_name("TS_ParseOrSemanticError_free"))) TS_ParseOrSemanticError_free(uint32_t this_ptr) {
43412 if ((this_ptr & 1) != 0) return;
43413 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
43414 CHECK_ACCESS(this_ptr_ptr);
43415 LDKParseOrSemanticError this_ptr_conv = *(LDKParseOrSemanticError*)(this_ptr_ptr);
43416 FREE((void*)this_ptr);
43417 ParseOrSemanticError_free(this_ptr_conv);
43420 static inline uintptr_t ParseOrSemanticError_clone_ptr(LDKParseOrSemanticError *NONNULL_PTR arg) {
43421 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
43422 *ret_copy = ParseOrSemanticError_clone(arg);
43423 uint32_t ret_ref = (uintptr_t)ret_copy;
43426 uint32_t __attribute__((export_name("TS_ParseOrSemanticError_clone_ptr"))) TS_ParseOrSemanticError_clone_ptr(uint32_t arg) {
43427 LDKParseOrSemanticError* arg_conv = (LDKParseOrSemanticError*)arg;
43428 uint32_t ret_conv = ParseOrSemanticError_clone_ptr(arg_conv);
43432 uint32_t __attribute__((export_name("TS_ParseOrSemanticError_clone"))) TS_ParseOrSemanticError_clone(uint32_t orig) {
43433 LDKParseOrSemanticError* orig_conv = (LDKParseOrSemanticError*)orig;
43434 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
43435 *ret_copy = ParseOrSemanticError_clone(orig_conv);
43436 uint32_t ret_ref = (uintptr_t)ret_copy;
43440 uint32_t __attribute__((export_name("TS_ParseOrSemanticError_parse_error"))) TS_ParseOrSemanticError_parse_error(uint32_t a) {
43441 void* a_ptr = (void*)(((uintptr_t)a) & ~1);
43442 CHECK_ACCESS(a_ptr);
43443 LDKParseError a_conv = *(LDKParseError*)(a_ptr);
43444 a_conv = ParseError_clone((LDKParseError*)(((uintptr_t)a) & ~1));
43445 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
43446 *ret_copy = ParseOrSemanticError_parse_error(a_conv);
43447 uint32_t ret_ref = (uintptr_t)ret_copy;
43451 uint32_t __attribute__((export_name("TS_ParseOrSemanticError_semantic_error"))) TS_ParseOrSemanticError_semantic_error(uint32_t a) {
43452 LDKSemanticError a_conv = LDKSemanticError_from_js(a);
43453 LDKParseOrSemanticError *ret_copy = MALLOC(sizeof(LDKParseOrSemanticError), "LDKParseOrSemanticError");
43454 *ret_copy = ParseOrSemanticError_semantic_error(a_conv);
43455 uint32_t ret_ref = (uintptr_t)ret_copy;
43459 void __attribute__((export_name("TS_Invoice_free"))) TS_Invoice_free(uint32_t this_obj) {
43460 LDKInvoice this_obj_conv;
43461 this_obj_conv.inner = (void*)(this_obj & (~1));
43462 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43463 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43464 Invoice_free(this_obj_conv);
43467 jboolean __attribute__((export_name("TS_Invoice_eq"))) TS_Invoice_eq(uint32_t a, uint32_t b) {
43469 a_conv.inner = (void*)(a & (~1));
43470 a_conv.is_owned = false;
43471 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43473 b_conv.inner = (void*)(b & (~1));
43474 b_conv.is_owned = false;
43475 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43476 jboolean ret_conv = Invoice_eq(&a_conv, &b_conv);
43480 static inline uintptr_t Invoice_clone_ptr(LDKInvoice *NONNULL_PTR arg) {
43481 LDKInvoice ret_var = Invoice_clone(arg);
43482 uint32_t ret_ref = 0;
43483 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43484 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43485 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43486 ret_ref = (uintptr_t)ret_var.inner;
43487 if (ret_var.is_owned) {
43492 uint32_t __attribute__((export_name("TS_Invoice_clone_ptr"))) TS_Invoice_clone_ptr(uint32_t arg) {
43493 LDKInvoice arg_conv;
43494 arg_conv.inner = (void*)(arg & (~1));
43495 arg_conv.is_owned = false;
43496 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43497 uint32_t ret_conv = Invoice_clone_ptr(&arg_conv);
43501 uint32_t __attribute__((export_name("TS_Invoice_clone"))) TS_Invoice_clone(uint32_t orig) {
43502 LDKInvoice orig_conv;
43503 orig_conv.inner = (void*)(orig & (~1));
43504 orig_conv.is_owned = false;
43505 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43506 LDKInvoice ret_var = Invoice_clone(&orig_conv);
43507 uint32_t ret_ref = 0;
43508 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43509 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43510 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43511 ret_ref = (uintptr_t)ret_var.inner;
43512 if (ret_var.is_owned) {
43518 void __attribute__((export_name("TS_SignedRawInvoice_free"))) TS_SignedRawInvoice_free(uint32_t this_obj) {
43519 LDKSignedRawInvoice this_obj_conv;
43520 this_obj_conv.inner = (void*)(this_obj & (~1));
43521 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43522 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43523 SignedRawInvoice_free(this_obj_conv);
43526 jboolean __attribute__((export_name("TS_SignedRawInvoice_eq"))) TS_SignedRawInvoice_eq(uint32_t a, uint32_t b) {
43527 LDKSignedRawInvoice a_conv;
43528 a_conv.inner = (void*)(a & (~1));
43529 a_conv.is_owned = false;
43530 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43531 LDKSignedRawInvoice b_conv;
43532 b_conv.inner = (void*)(b & (~1));
43533 b_conv.is_owned = false;
43534 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43535 jboolean ret_conv = SignedRawInvoice_eq(&a_conv, &b_conv);
43539 static inline uintptr_t SignedRawInvoice_clone_ptr(LDKSignedRawInvoice *NONNULL_PTR arg) {
43540 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(arg);
43541 uint32_t ret_ref = 0;
43542 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43543 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43544 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43545 ret_ref = (uintptr_t)ret_var.inner;
43546 if (ret_var.is_owned) {
43551 uint32_t __attribute__((export_name("TS_SignedRawInvoice_clone_ptr"))) TS_SignedRawInvoice_clone_ptr(uint32_t arg) {
43552 LDKSignedRawInvoice arg_conv;
43553 arg_conv.inner = (void*)(arg & (~1));
43554 arg_conv.is_owned = false;
43555 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43556 uint32_t ret_conv = SignedRawInvoice_clone_ptr(&arg_conv);
43560 uint32_t __attribute__((export_name("TS_SignedRawInvoice_clone"))) TS_SignedRawInvoice_clone(uint32_t orig) {
43561 LDKSignedRawInvoice orig_conv;
43562 orig_conv.inner = (void*)(orig & (~1));
43563 orig_conv.is_owned = false;
43564 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43565 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
43566 uint32_t ret_ref = 0;
43567 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43568 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43569 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43570 ret_ref = (uintptr_t)ret_var.inner;
43571 if (ret_var.is_owned) {
43577 void __attribute__((export_name("TS_RawInvoice_free"))) TS_RawInvoice_free(uint32_t this_obj) {
43578 LDKRawInvoice this_obj_conv;
43579 this_obj_conv.inner = (void*)(this_obj & (~1));
43580 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43581 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43582 RawInvoice_free(this_obj_conv);
43585 uint32_t __attribute__((export_name("TS_RawInvoice_get_data"))) TS_RawInvoice_get_data(uint32_t this_ptr) {
43586 LDKRawInvoice this_ptr_conv;
43587 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43588 this_ptr_conv.is_owned = false;
43589 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43590 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
43591 uint32_t ret_ref = 0;
43592 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43593 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43594 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43595 ret_ref = (uintptr_t)ret_var.inner;
43596 if (ret_var.is_owned) {
43602 void __attribute__((export_name("TS_RawInvoice_set_data"))) TS_RawInvoice_set_data(uint32_t this_ptr, uint32_t val) {
43603 LDKRawInvoice this_ptr_conv;
43604 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43605 this_ptr_conv.is_owned = false;
43606 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43607 LDKRawDataPart val_conv;
43608 val_conv.inner = (void*)(val & (~1));
43609 val_conv.is_owned = (val & 1) || (val == 0);
43610 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43611 val_conv = RawDataPart_clone(&val_conv);
43612 RawInvoice_set_data(&this_ptr_conv, val_conv);
43615 jboolean __attribute__((export_name("TS_RawInvoice_eq"))) TS_RawInvoice_eq(uint32_t a, uint32_t b) {
43616 LDKRawInvoice a_conv;
43617 a_conv.inner = (void*)(a & (~1));
43618 a_conv.is_owned = false;
43619 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43620 LDKRawInvoice b_conv;
43621 b_conv.inner = (void*)(b & (~1));
43622 b_conv.is_owned = false;
43623 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43624 jboolean ret_conv = RawInvoice_eq(&a_conv, &b_conv);
43628 static inline uintptr_t RawInvoice_clone_ptr(LDKRawInvoice *NONNULL_PTR arg) {
43629 LDKRawInvoice ret_var = RawInvoice_clone(arg);
43630 uint32_t ret_ref = 0;
43631 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43632 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43633 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43634 ret_ref = (uintptr_t)ret_var.inner;
43635 if (ret_var.is_owned) {
43640 uint32_t __attribute__((export_name("TS_RawInvoice_clone_ptr"))) TS_RawInvoice_clone_ptr(uint32_t arg) {
43641 LDKRawInvoice arg_conv;
43642 arg_conv.inner = (void*)(arg & (~1));
43643 arg_conv.is_owned = false;
43644 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43645 uint32_t ret_conv = RawInvoice_clone_ptr(&arg_conv);
43649 uint32_t __attribute__((export_name("TS_RawInvoice_clone"))) TS_RawInvoice_clone(uint32_t orig) {
43650 LDKRawInvoice orig_conv;
43651 orig_conv.inner = (void*)(orig & (~1));
43652 orig_conv.is_owned = false;
43653 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43654 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
43655 uint32_t ret_ref = 0;
43656 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43657 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43658 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43659 ret_ref = (uintptr_t)ret_var.inner;
43660 if (ret_var.is_owned) {
43666 void __attribute__((export_name("TS_RawDataPart_free"))) TS_RawDataPart_free(uint32_t this_obj) {
43667 LDKRawDataPart this_obj_conv;
43668 this_obj_conv.inner = (void*)(this_obj & (~1));
43669 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43670 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43671 RawDataPart_free(this_obj_conv);
43674 uint32_t __attribute__((export_name("TS_RawDataPart_get_timestamp"))) TS_RawDataPart_get_timestamp(uint32_t this_ptr) {
43675 LDKRawDataPart this_ptr_conv;
43676 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43677 this_ptr_conv.is_owned = false;
43678 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43679 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
43680 uint32_t ret_ref = 0;
43681 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43682 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43683 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43684 ret_ref = (uintptr_t)ret_var.inner;
43685 if (ret_var.is_owned) {
43691 void __attribute__((export_name("TS_RawDataPart_set_timestamp"))) TS_RawDataPart_set_timestamp(uint32_t this_ptr, uint32_t val) {
43692 LDKRawDataPart this_ptr_conv;
43693 this_ptr_conv.inner = (void*)(this_ptr & (~1));
43694 this_ptr_conv.is_owned = false;
43695 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
43696 LDKPositiveTimestamp val_conv;
43697 val_conv.inner = (void*)(val & (~1));
43698 val_conv.is_owned = (val & 1) || (val == 0);
43699 CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
43700 val_conv = PositiveTimestamp_clone(&val_conv);
43701 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
43704 jboolean __attribute__((export_name("TS_RawDataPart_eq"))) TS_RawDataPart_eq(uint32_t a, uint32_t b) {
43705 LDKRawDataPart a_conv;
43706 a_conv.inner = (void*)(a & (~1));
43707 a_conv.is_owned = false;
43708 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43709 LDKRawDataPart b_conv;
43710 b_conv.inner = (void*)(b & (~1));
43711 b_conv.is_owned = false;
43712 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43713 jboolean ret_conv = RawDataPart_eq(&a_conv, &b_conv);
43717 static inline uintptr_t RawDataPart_clone_ptr(LDKRawDataPart *NONNULL_PTR arg) {
43718 LDKRawDataPart ret_var = RawDataPart_clone(arg);
43719 uint32_t ret_ref = 0;
43720 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43721 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43722 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43723 ret_ref = (uintptr_t)ret_var.inner;
43724 if (ret_var.is_owned) {
43729 uint32_t __attribute__((export_name("TS_RawDataPart_clone_ptr"))) TS_RawDataPart_clone_ptr(uint32_t arg) {
43730 LDKRawDataPart arg_conv;
43731 arg_conv.inner = (void*)(arg & (~1));
43732 arg_conv.is_owned = false;
43733 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43734 uint32_t ret_conv = RawDataPart_clone_ptr(&arg_conv);
43738 uint32_t __attribute__((export_name("TS_RawDataPart_clone"))) TS_RawDataPart_clone(uint32_t orig) {
43739 LDKRawDataPart orig_conv;
43740 orig_conv.inner = (void*)(orig & (~1));
43741 orig_conv.is_owned = false;
43742 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43743 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
43744 uint32_t ret_ref = 0;
43745 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43746 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43747 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43748 ret_ref = (uintptr_t)ret_var.inner;
43749 if (ret_var.is_owned) {
43755 void __attribute__((export_name("TS_PositiveTimestamp_free"))) TS_PositiveTimestamp_free(uint32_t this_obj) {
43756 LDKPositiveTimestamp this_obj_conv;
43757 this_obj_conv.inner = (void*)(this_obj & (~1));
43758 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43759 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43760 PositiveTimestamp_free(this_obj_conv);
43763 jboolean __attribute__((export_name("TS_PositiveTimestamp_eq"))) TS_PositiveTimestamp_eq(uint32_t a, uint32_t b) {
43764 LDKPositiveTimestamp a_conv;
43765 a_conv.inner = (void*)(a & (~1));
43766 a_conv.is_owned = false;
43767 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43768 LDKPositiveTimestamp b_conv;
43769 b_conv.inner = (void*)(b & (~1));
43770 b_conv.is_owned = false;
43771 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43772 jboolean ret_conv = PositiveTimestamp_eq(&a_conv, &b_conv);
43776 static inline uintptr_t PositiveTimestamp_clone_ptr(LDKPositiveTimestamp *NONNULL_PTR arg) {
43777 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(arg);
43778 uint32_t ret_ref = 0;
43779 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43780 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43781 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43782 ret_ref = (uintptr_t)ret_var.inner;
43783 if (ret_var.is_owned) {
43788 uint32_t __attribute__((export_name("TS_PositiveTimestamp_clone_ptr"))) TS_PositiveTimestamp_clone_ptr(uint32_t arg) {
43789 LDKPositiveTimestamp arg_conv;
43790 arg_conv.inner = (void*)(arg & (~1));
43791 arg_conv.is_owned = false;
43792 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43793 uint32_t ret_conv = PositiveTimestamp_clone_ptr(&arg_conv);
43797 uint32_t __attribute__((export_name("TS_PositiveTimestamp_clone"))) TS_PositiveTimestamp_clone(uint32_t orig) {
43798 LDKPositiveTimestamp orig_conv;
43799 orig_conv.inner = (void*)(orig & (~1));
43800 orig_conv.is_owned = false;
43801 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43802 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
43803 uint32_t ret_ref = 0;
43804 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43805 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43806 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43807 ret_ref = (uintptr_t)ret_var.inner;
43808 if (ret_var.is_owned) {
43814 uint32_t __attribute__((export_name("TS_SiPrefix_clone"))) TS_SiPrefix_clone(uint32_t orig) {
43815 LDKSiPrefix* orig_conv = (LDKSiPrefix*)(orig & ~1);
43816 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
43820 uint32_t __attribute__((export_name("TS_SiPrefix_milli"))) TS_SiPrefix_milli() {
43821 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_milli());
43825 uint32_t __attribute__((export_name("TS_SiPrefix_micro"))) TS_SiPrefix_micro() {
43826 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_micro());
43830 uint32_t __attribute__((export_name("TS_SiPrefix_nano"))) TS_SiPrefix_nano() {
43831 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_nano());
43835 uint32_t __attribute__((export_name("TS_SiPrefix_pico"))) TS_SiPrefix_pico() {
43836 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_pico());
43840 jboolean __attribute__((export_name("TS_SiPrefix_eq"))) TS_SiPrefix_eq(uint32_t a, uint32_t b) {
43841 LDKSiPrefix* a_conv = (LDKSiPrefix*)(a & ~1);
43842 LDKSiPrefix* b_conv = (LDKSiPrefix*)(b & ~1);
43843 jboolean ret_conv = SiPrefix_eq(a_conv, b_conv);
43847 int64_t __attribute__((export_name("TS_SiPrefix_multiplier"))) TS_SiPrefix_multiplier(uint32_t this_arg) {
43848 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)(this_arg & ~1);
43849 int64_t ret_conv = SiPrefix_multiplier(this_arg_conv);
43853 uint32_t __attribute__((export_name("TS_Currency_clone"))) TS_Currency_clone(uint32_t orig) {
43854 LDKCurrency* orig_conv = (LDKCurrency*)(orig & ~1);
43855 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
43859 uint32_t __attribute__((export_name("TS_Currency_bitcoin"))) TS_Currency_bitcoin() {
43860 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin());
43864 uint32_t __attribute__((export_name("TS_Currency_bitcoin_testnet"))) TS_Currency_bitcoin_testnet() {
43865 uint32_t ret_conv = LDKCurrency_to_js(Currency_bitcoin_testnet());
43869 uint32_t __attribute__((export_name("TS_Currency_regtest"))) TS_Currency_regtest() {
43870 uint32_t ret_conv = LDKCurrency_to_js(Currency_regtest());
43874 uint32_t __attribute__((export_name("TS_Currency_simnet"))) TS_Currency_simnet() {
43875 uint32_t ret_conv = LDKCurrency_to_js(Currency_simnet());
43879 uint32_t __attribute__((export_name("TS_Currency_signet"))) TS_Currency_signet() {
43880 uint32_t ret_conv = LDKCurrency_to_js(Currency_signet());
43884 int64_t __attribute__((export_name("TS_Currency_hash"))) TS_Currency_hash(uint32_t o) {
43885 LDKCurrency* o_conv = (LDKCurrency*)(o & ~1);
43886 int64_t ret_conv = Currency_hash(o_conv);
43890 jboolean __attribute__((export_name("TS_Currency_eq"))) TS_Currency_eq(uint32_t a, uint32_t b) {
43891 LDKCurrency* a_conv = (LDKCurrency*)(a & ~1);
43892 LDKCurrency* b_conv = (LDKCurrency*)(b & ~1);
43893 jboolean ret_conv = Currency_eq(a_conv, b_conv);
43897 void __attribute__((export_name("TS_Sha256_free"))) TS_Sha256_free(uint32_t this_obj) {
43898 LDKSha256 this_obj_conv;
43899 this_obj_conv.inner = (void*)(this_obj & (~1));
43900 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43901 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43902 Sha256_free(this_obj_conv);
43905 static inline uintptr_t Sha256_clone_ptr(LDKSha256 *NONNULL_PTR arg) {
43906 LDKSha256 ret_var = Sha256_clone(arg);
43907 uint32_t ret_ref = 0;
43908 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43909 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43910 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43911 ret_ref = (uintptr_t)ret_var.inner;
43912 if (ret_var.is_owned) {
43917 uint32_t __attribute__((export_name("TS_Sha256_clone_ptr"))) TS_Sha256_clone_ptr(uint32_t arg) {
43918 LDKSha256 arg_conv;
43919 arg_conv.inner = (void*)(arg & (~1));
43920 arg_conv.is_owned = false;
43921 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43922 uint32_t ret_conv = Sha256_clone_ptr(&arg_conv);
43926 uint32_t __attribute__((export_name("TS_Sha256_clone"))) TS_Sha256_clone(uint32_t orig) {
43927 LDKSha256 orig_conv;
43928 orig_conv.inner = (void*)(orig & (~1));
43929 orig_conv.is_owned = false;
43930 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43931 LDKSha256 ret_var = Sha256_clone(&orig_conv);
43932 uint32_t ret_ref = 0;
43933 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43934 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43935 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43936 ret_ref = (uintptr_t)ret_var.inner;
43937 if (ret_var.is_owned) {
43943 int64_t __attribute__((export_name("TS_Sha256_hash"))) TS_Sha256_hash(uint32_t o) {
43945 o_conv.inner = (void*)(o & (~1));
43946 o_conv.is_owned = false;
43947 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
43948 int64_t ret_conv = Sha256_hash(&o_conv);
43952 jboolean __attribute__((export_name("TS_Sha256_eq"))) TS_Sha256_eq(uint32_t a, uint32_t b) {
43954 a_conv.inner = (void*)(a & (~1));
43955 a_conv.is_owned = false;
43956 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
43958 b_conv.inner = (void*)(b & (~1));
43959 b_conv.is_owned = false;
43960 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
43961 jboolean ret_conv = Sha256_eq(&a_conv, &b_conv);
43965 void __attribute__((export_name("TS_Description_free"))) TS_Description_free(uint32_t this_obj) {
43966 LDKDescription this_obj_conv;
43967 this_obj_conv.inner = (void*)(this_obj & (~1));
43968 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
43969 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
43970 Description_free(this_obj_conv);
43973 static inline uintptr_t Description_clone_ptr(LDKDescription *NONNULL_PTR arg) {
43974 LDKDescription ret_var = Description_clone(arg);
43975 uint32_t ret_ref = 0;
43976 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
43977 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
43978 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
43979 ret_ref = (uintptr_t)ret_var.inner;
43980 if (ret_var.is_owned) {
43985 uint32_t __attribute__((export_name("TS_Description_clone_ptr"))) TS_Description_clone_ptr(uint32_t arg) {
43986 LDKDescription arg_conv;
43987 arg_conv.inner = (void*)(arg & (~1));
43988 arg_conv.is_owned = false;
43989 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
43990 uint32_t ret_conv = Description_clone_ptr(&arg_conv);
43994 uint32_t __attribute__((export_name("TS_Description_clone"))) TS_Description_clone(uint32_t orig) {
43995 LDKDescription orig_conv;
43996 orig_conv.inner = (void*)(orig & (~1));
43997 orig_conv.is_owned = false;
43998 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
43999 LDKDescription ret_var = Description_clone(&orig_conv);
44000 uint32_t ret_ref = 0;
44001 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44002 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44003 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44004 ret_ref = (uintptr_t)ret_var.inner;
44005 if (ret_var.is_owned) {
44011 int64_t __attribute__((export_name("TS_Description_hash"))) TS_Description_hash(uint32_t o) {
44012 LDKDescription o_conv;
44013 o_conv.inner = (void*)(o & (~1));
44014 o_conv.is_owned = false;
44015 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44016 int64_t ret_conv = Description_hash(&o_conv);
44020 jboolean __attribute__((export_name("TS_Description_eq"))) TS_Description_eq(uint32_t a, uint32_t b) {
44021 LDKDescription a_conv;
44022 a_conv.inner = (void*)(a & (~1));
44023 a_conv.is_owned = false;
44024 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44025 LDKDescription b_conv;
44026 b_conv.inner = (void*)(b & (~1));
44027 b_conv.is_owned = false;
44028 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44029 jboolean ret_conv = Description_eq(&a_conv, &b_conv);
44033 void __attribute__((export_name("TS_PayeePubKey_free"))) TS_PayeePubKey_free(uint32_t this_obj) {
44034 LDKPayeePubKey this_obj_conv;
44035 this_obj_conv.inner = (void*)(this_obj & (~1));
44036 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
44037 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44038 PayeePubKey_free(this_obj_conv);
44041 int8_tArray __attribute__((export_name("TS_PayeePubKey_get_a"))) TS_PayeePubKey_get_a(uint32_t this_ptr) {
44042 LDKPayeePubKey this_ptr_conv;
44043 this_ptr_conv.inner = (void*)(this_ptr & (~1));
44044 this_ptr_conv.is_owned = false;
44045 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44046 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
44047 memcpy(ret_arr->elems, PayeePubKey_get_a(&this_ptr_conv).compressed_form, 33);
44051 void __attribute__((export_name("TS_PayeePubKey_set_a"))) TS_PayeePubKey_set_a(uint32_t this_ptr, int8_tArray val) {
44052 LDKPayeePubKey this_ptr_conv;
44053 this_ptr_conv.inner = (void*)(this_ptr & (~1));
44054 this_ptr_conv.is_owned = false;
44055 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44056 LDKPublicKey val_ref;
44057 CHECK(val->arr_len == 33);
44058 memcpy(val_ref.compressed_form, val->elems, 33); FREE(val);
44059 PayeePubKey_set_a(&this_ptr_conv, val_ref);
44062 uint32_t __attribute__((export_name("TS_PayeePubKey_new"))) TS_PayeePubKey_new(int8_tArray a_arg) {
44063 LDKPublicKey a_arg_ref;
44064 CHECK(a_arg->arr_len == 33);
44065 memcpy(a_arg_ref.compressed_form, a_arg->elems, 33); FREE(a_arg);
44066 LDKPayeePubKey ret_var = PayeePubKey_new(a_arg_ref);
44067 uint32_t ret_ref = 0;
44068 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44069 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44070 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44071 ret_ref = (uintptr_t)ret_var.inner;
44072 if (ret_var.is_owned) {
44078 static inline uintptr_t PayeePubKey_clone_ptr(LDKPayeePubKey *NONNULL_PTR arg) {
44079 LDKPayeePubKey ret_var = PayeePubKey_clone(arg);
44080 uint32_t ret_ref = 0;
44081 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44082 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44083 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44084 ret_ref = (uintptr_t)ret_var.inner;
44085 if (ret_var.is_owned) {
44090 uint32_t __attribute__((export_name("TS_PayeePubKey_clone_ptr"))) TS_PayeePubKey_clone_ptr(uint32_t arg) {
44091 LDKPayeePubKey arg_conv;
44092 arg_conv.inner = (void*)(arg & (~1));
44093 arg_conv.is_owned = false;
44094 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44095 uint32_t ret_conv = PayeePubKey_clone_ptr(&arg_conv);
44099 uint32_t __attribute__((export_name("TS_PayeePubKey_clone"))) TS_PayeePubKey_clone(uint32_t orig) {
44100 LDKPayeePubKey orig_conv;
44101 orig_conv.inner = (void*)(orig & (~1));
44102 orig_conv.is_owned = false;
44103 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44104 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
44105 uint32_t ret_ref = 0;
44106 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44107 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44108 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44109 ret_ref = (uintptr_t)ret_var.inner;
44110 if (ret_var.is_owned) {
44116 int64_t __attribute__((export_name("TS_PayeePubKey_hash"))) TS_PayeePubKey_hash(uint32_t o) {
44117 LDKPayeePubKey o_conv;
44118 o_conv.inner = (void*)(o & (~1));
44119 o_conv.is_owned = false;
44120 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44121 int64_t ret_conv = PayeePubKey_hash(&o_conv);
44125 jboolean __attribute__((export_name("TS_PayeePubKey_eq"))) TS_PayeePubKey_eq(uint32_t a, uint32_t b) {
44126 LDKPayeePubKey a_conv;
44127 a_conv.inner = (void*)(a & (~1));
44128 a_conv.is_owned = false;
44129 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44130 LDKPayeePubKey b_conv;
44131 b_conv.inner = (void*)(b & (~1));
44132 b_conv.is_owned = false;
44133 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44134 jboolean ret_conv = PayeePubKey_eq(&a_conv, &b_conv);
44138 void __attribute__((export_name("TS_ExpiryTime_free"))) TS_ExpiryTime_free(uint32_t this_obj) {
44139 LDKExpiryTime this_obj_conv;
44140 this_obj_conv.inner = (void*)(this_obj & (~1));
44141 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
44142 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44143 ExpiryTime_free(this_obj_conv);
44146 static inline uintptr_t ExpiryTime_clone_ptr(LDKExpiryTime *NONNULL_PTR arg) {
44147 LDKExpiryTime ret_var = ExpiryTime_clone(arg);
44148 uint32_t ret_ref = 0;
44149 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44150 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44151 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44152 ret_ref = (uintptr_t)ret_var.inner;
44153 if (ret_var.is_owned) {
44158 uint32_t __attribute__((export_name("TS_ExpiryTime_clone_ptr"))) TS_ExpiryTime_clone_ptr(uint32_t arg) {
44159 LDKExpiryTime arg_conv;
44160 arg_conv.inner = (void*)(arg & (~1));
44161 arg_conv.is_owned = false;
44162 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44163 uint32_t ret_conv = ExpiryTime_clone_ptr(&arg_conv);
44167 uint32_t __attribute__((export_name("TS_ExpiryTime_clone"))) TS_ExpiryTime_clone(uint32_t orig) {
44168 LDKExpiryTime orig_conv;
44169 orig_conv.inner = (void*)(orig & (~1));
44170 orig_conv.is_owned = false;
44171 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44172 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
44173 uint32_t ret_ref = 0;
44174 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44175 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44176 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44177 ret_ref = (uintptr_t)ret_var.inner;
44178 if (ret_var.is_owned) {
44184 int64_t __attribute__((export_name("TS_ExpiryTime_hash"))) TS_ExpiryTime_hash(uint32_t o) {
44185 LDKExpiryTime o_conv;
44186 o_conv.inner = (void*)(o & (~1));
44187 o_conv.is_owned = false;
44188 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44189 int64_t ret_conv = ExpiryTime_hash(&o_conv);
44193 jboolean __attribute__((export_name("TS_ExpiryTime_eq"))) TS_ExpiryTime_eq(uint32_t a, uint32_t b) {
44194 LDKExpiryTime a_conv;
44195 a_conv.inner = (void*)(a & (~1));
44196 a_conv.is_owned = false;
44197 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44198 LDKExpiryTime b_conv;
44199 b_conv.inner = (void*)(b & (~1));
44200 b_conv.is_owned = false;
44201 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44202 jboolean ret_conv = ExpiryTime_eq(&a_conv, &b_conv);
44206 void __attribute__((export_name("TS_MinFinalCltvExpiry_free"))) TS_MinFinalCltvExpiry_free(uint32_t this_obj) {
44207 LDKMinFinalCltvExpiry this_obj_conv;
44208 this_obj_conv.inner = (void*)(this_obj & (~1));
44209 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
44210 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44211 MinFinalCltvExpiry_free(this_obj_conv);
44214 int64_t __attribute__((export_name("TS_MinFinalCltvExpiry_get_a"))) TS_MinFinalCltvExpiry_get_a(uint32_t this_ptr) {
44215 LDKMinFinalCltvExpiry this_ptr_conv;
44216 this_ptr_conv.inner = (void*)(this_ptr & (~1));
44217 this_ptr_conv.is_owned = false;
44218 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44219 int64_t ret_conv = MinFinalCltvExpiry_get_a(&this_ptr_conv);
44223 void __attribute__((export_name("TS_MinFinalCltvExpiry_set_a"))) TS_MinFinalCltvExpiry_set_a(uint32_t this_ptr, int64_t val) {
44224 LDKMinFinalCltvExpiry this_ptr_conv;
44225 this_ptr_conv.inner = (void*)(this_ptr & (~1));
44226 this_ptr_conv.is_owned = false;
44227 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
44228 MinFinalCltvExpiry_set_a(&this_ptr_conv, val);
44231 uint32_t __attribute__((export_name("TS_MinFinalCltvExpiry_new"))) TS_MinFinalCltvExpiry_new(int64_t a_arg) {
44232 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_new(a_arg);
44233 uint32_t ret_ref = 0;
44234 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44235 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44236 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44237 ret_ref = (uintptr_t)ret_var.inner;
44238 if (ret_var.is_owned) {
44244 static inline uintptr_t MinFinalCltvExpiry_clone_ptr(LDKMinFinalCltvExpiry *NONNULL_PTR arg) {
44245 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(arg);
44246 uint32_t ret_ref = 0;
44247 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44248 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44249 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44250 ret_ref = (uintptr_t)ret_var.inner;
44251 if (ret_var.is_owned) {
44256 uint32_t __attribute__((export_name("TS_MinFinalCltvExpiry_clone_ptr"))) TS_MinFinalCltvExpiry_clone_ptr(uint32_t arg) {
44257 LDKMinFinalCltvExpiry arg_conv;
44258 arg_conv.inner = (void*)(arg & (~1));
44259 arg_conv.is_owned = false;
44260 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44261 uint32_t ret_conv = MinFinalCltvExpiry_clone_ptr(&arg_conv);
44265 uint32_t __attribute__((export_name("TS_MinFinalCltvExpiry_clone"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) {
44266 LDKMinFinalCltvExpiry orig_conv;
44267 orig_conv.inner = (void*)(orig & (~1));
44268 orig_conv.is_owned = false;
44269 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44270 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
44271 uint32_t ret_ref = 0;
44272 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44273 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44274 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44275 ret_ref = (uintptr_t)ret_var.inner;
44276 if (ret_var.is_owned) {
44282 int64_t __attribute__((export_name("TS_MinFinalCltvExpiry_hash"))) TS_MinFinalCltvExpiry_hash(uint32_t o) {
44283 LDKMinFinalCltvExpiry o_conv;
44284 o_conv.inner = (void*)(o & (~1));
44285 o_conv.is_owned = false;
44286 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44287 int64_t ret_conv = MinFinalCltvExpiry_hash(&o_conv);
44291 jboolean __attribute__((export_name("TS_MinFinalCltvExpiry_eq"))) TS_MinFinalCltvExpiry_eq(uint32_t a, uint32_t b) {
44292 LDKMinFinalCltvExpiry a_conv;
44293 a_conv.inner = (void*)(a & (~1));
44294 a_conv.is_owned = false;
44295 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44296 LDKMinFinalCltvExpiry b_conv;
44297 b_conv.inner = (void*)(b & (~1));
44298 b_conv.is_owned = false;
44299 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44300 jboolean ret_conv = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
44304 void __attribute__((export_name("TS_Fallback_free"))) TS_Fallback_free(uint32_t this_ptr) {
44305 if ((this_ptr & 1) != 0) return;
44306 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
44307 CHECK_ACCESS(this_ptr_ptr);
44308 LDKFallback this_ptr_conv = *(LDKFallback*)(this_ptr_ptr);
44309 FREE((void*)this_ptr);
44310 Fallback_free(this_ptr_conv);
44313 static inline uintptr_t Fallback_clone_ptr(LDKFallback *NONNULL_PTR arg) {
44314 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
44315 *ret_copy = Fallback_clone(arg);
44316 uint32_t ret_ref = (uintptr_t)ret_copy;
44319 uint32_t __attribute__((export_name("TS_Fallback_clone_ptr"))) TS_Fallback_clone_ptr(uint32_t arg) {
44320 LDKFallback* arg_conv = (LDKFallback*)arg;
44321 uint32_t ret_conv = Fallback_clone_ptr(arg_conv);
44325 uint32_t __attribute__((export_name("TS_Fallback_clone"))) TS_Fallback_clone(uint32_t orig) {
44326 LDKFallback* orig_conv = (LDKFallback*)orig;
44327 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
44328 *ret_copy = Fallback_clone(orig_conv);
44329 uint32_t ret_ref = (uintptr_t)ret_copy;
44333 uint32_t __attribute__((export_name("TS_Fallback_seg_wit_program"))) TS_Fallback_seg_wit_program(int8_t version, int8_tArray program) {
44335 LDKCVec_u8Z program_ref;
44336 program_ref.datalen = program->arr_len;
44337 program_ref.data = MALLOC(program_ref.datalen, "LDKCVec_u8Z Bytes");
44338 memcpy(program_ref.data, program->elems, program_ref.datalen); FREE(program);
44339 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
44340 *ret_copy = Fallback_seg_wit_program((LDKu5){ ._0 = version }, program_ref);
44341 uint32_t ret_ref = (uintptr_t)ret_copy;
44345 uint32_t __attribute__((export_name("TS_Fallback_pub_key_hash"))) TS_Fallback_pub_key_hash(int8_tArray a) {
44346 LDKTwentyBytes a_ref;
44347 CHECK(a->arr_len == 20);
44348 memcpy(a_ref.data, a->elems, 20); FREE(a);
44349 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
44350 *ret_copy = Fallback_pub_key_hash(a_ref);
44351 uint32_t ret_ref = (uintptr_t)ret_copy;
44355 uint32_t __attribute__((export_name("TS_Fallback_script_hash"))) TS_Fallback_script_hash(int8_tArray a) {
44356 LDKTwentyBytes a_ref;
44357 CHECK(a->arr_len == 20);
44358 memcpy(a_ref.data, a->elems, 20); FREE(a);
44359 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
44360 *ret_copy = Fallback_script_hash(a_ref);
44361 uint32_t ret_ref = (uintptr_t)ret_copy;
44365 int64_t __attribute__((export_name("TS_Fallback_hash"))) TS_Fallback_hash(uint32_t o) {
44366 LDKFallback* o_conv = (LDKFallback*)o;
44367 int64_t ret_conv = Fallback_hash(o_conv);
44371 jboolean __attribute__((export_name("TS_Fallback_eq"))) TS_Fallback_eq(uint32_t a, uint32_t b) {
44372 LDKFallback* a_conv = (LDKFallback*)a;
44373 LDKFallback* b_conv = (LDKFallback*)b;
44374 jboolean ret_conv = Fallback_eq(a_conv, b_conv);
44378 void __attribute__((export_name("TS_InvoiceSignature_free"))) TS_InvoiceSignature_free(uint32_t this_obj) {
44379 LDKInvoiceSignature this_obj_conv;
44380 this_obj_conv.inner = (void*)(this_obj & (~1));
44381 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
44382 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44383 InvoiceSignature_free(this_obj_conv);
44386 static inline uintptr_t InvoiceSignature_clone_ptr(LDKInvoiceSignature *NONNULL_PTR arg) {
44387 LDKInvoiceSignature ret_var = InvoiceSignature_clone(arg);
44388 uint32_t ret_ref = 0;
44389 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44390 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44391 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44392 ret_ref = (uintptr_t)ret_var.inner;
44393 if (ret_var.is_owned) {
44398 uint32_t __attribute__((export_name("TS_InvoiceSignature_clone_ptr"))) TS_InvoiceSignature_clone_ptr(uint32_t arg) {
44399 LDKInvoiceSignature arg_conv;
44400 arg_conv.inner = (void*)(arg & (~1));
44401 arg_conv.is_owned = false;
44402 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44403 uint32_t ret_conv = InvoiceSignature_clone_ptr(&arg_conv);
44407 uint32_t __attribute__((export_name("TS_InvoiceSignature_clone"))) TS_InvoiceSignature_clone(uint32_t orig) {
44408 LDKInvoiceSignature orig_conv;
44409 orig_conv.inner = (void*)(orig & (~1));
44410 orig_conv.is_owned = false;
44411 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44412 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
44413 uint32_t ret_ref = 0;
44414 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44415 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44416 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44417 ret_ref = (uintptr_t)ret_var.inner;
44418 if (ret_var.is_owned) {
44424 jboolean __attribute__((export_name("TS_InvoiceSignature_eq"))) TS_InvoiceSignature_eq(uint32_t a, uint32_t b) {
44425 LDKInvoiceSignature a_conv;
44426 a_conv.inner = (void*)(a & (~1));
44427 a_conv.is_owned = false;
44428 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44429 LDKInvoiceSignature b_conv;
44430 b_conv.inner = (void*)(b & (~1));
44431 b_conv.is_owned = false;
44432 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44433 jboolean ret_conv = InvoiceSignature_eq(&a_conv, &b_conv);
44437 void __attribute__((export_name("TS_PrivateRoute_free"))) TS_PrivateRoute_free(uint32_t this_obj) {
44438 LDKPrivateRoute this_obj_conv;
44439 this_obj_conv.inner = (void*)(this_obj & (~1));
44440 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
44441 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
44442 PrivateRoute_free(this_obj_conv);
44445 static inline uintptr_t PrivateRoute_clone_ptr(LDKPrivateRoute *NONNULL_PTR arg) {
44446 LDKPrivateRoute ret_var = PrivateRoute_clone(arg);
44447 uint32_t ret_ref = 0;
44448 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44449 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44450 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44451 ret_ref = (uintptr_t)ret_var.inner;
44452 if (ret_var.is_owned) {
44457 uint32_t __attribute__((export_name("TS_PrivateRoute_clone_ptr"))) TS_PrivateRoute_clone_ptr(uint32_t arg) {
44458 LDKPrivateRoute arg_conv;
44459 arg_conv.inner = (void*)(arg & (~1));
44460 arg_conv.is_owned = false;
44461 CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
44462 uint32_t ret_conv = PrivateRoute_clone_ptr(&arg_conv);
44466 uint32_t __attribute__((export_name("TS_PrivateRoute_clone"))) TS_PrivateRoute_clone(uint32_t orig) {
44467 LDKPrivateRoute orig_conv;
44468 orig_conv.inner = (void*)(orig & (~1));
44469 orig_conv.is_owned = false;
44470 CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
44471 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
44472 uint32_t ret_ref = 0;
44473 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44474 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44475 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44476 ret_ref = (uintptr_t)ret_var.inner;
44477 if (ret_var.is_owned) {
44483 int64_t __attribute__((export_name("TS_PrivateRoute_hash"))) TS_PrivateRoute_hash(uint32_t o) {
44484 LDKPrivateRoute o_conv;
44485 o_conv.inner = (void*)(o & (~1));
44486 o_conv.is_owned = false;
44487 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
44488 int64_t ret_conv = PrivateRoute_hash(&o_conv);
44492 jboolean __attribute__((export_name("TS_PrivateRoute_eq"))) TS_PrivateRoute_eq(uint32_t a, uint32_t b) {
44493 LDKPrivateRoute a_conv;
44494 a_conv.inner = (void*)(a & (~1));
44495 a_conv.is_owned = false;
44496 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
44497 LDKPrivateRoute b_conv;
44498 b_conv.inner = (void*)(b & (~1));
44499 b_conv.is_owned = false;
44500 CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
44501 jboolean ret_conv = PrivateRoute_eq(&a_conv, &b_conv);
44505 uint32_t __attribute__((export_name("TS_SignedRawInvoice_into_parts"))) TS_SignedRawInvoice_into_parts(uint32_t this_arg) {
44506 LDKSignedRawInvoice this_arg_conv;
44507 this_arg_conv.inner = (void*)(this_arg & (~1));
44508 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
44509 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44510 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
44511 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
44512 *ret_conv = SignedRawInvoice_into_parts(this_arg_conv);
44513 return ((uint32_t)ret_conv);
44516 uint32_t __attribute__((export_name("TS_SignedRawInvoice_raw_invoice"))) TS_SignedRawInvoice_raw_invoice(uint32_t this_arg) {
44517 LDKSignedRawInvoice this_arg_conv;
44518 this_arg_conv.inner = (void*)(this_arg & (~1));
44519 this_arg_conv.is_owned = false;
44520 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44521 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
44522 uint32_t ret_ref = 0;
44523 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44524 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44525 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44526 ret_ref = (uintptr_t)ret_var.inner;
44527 if (ret_var.is_owned) {
44533 int8_tArray __attribute__((export_name("TS_SignedRawInvoice_hash"))) TS_SignedRawInvoice_hash(uint32_t this_arg) {
44534 LDKSignedRawInvoice this_arg_conv;
44535 this_arg_conv.inner = (void*)(this_arg & (~1));
44536 this_arg_conv.is_owned = false;
44537 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44538 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44539 memcpy(ret_arr->elems, *SignedRawInvoice_hash(&this_arg_conv), 32);
44543 uint32_t __attribute__((export_name("TS_SignedRawInvoice_signature"))) TS_SignedRawInvoice_signature(uint32_t this_arg) {
44544 LDKSignedRawInvoice this_arg_conv;
44545 this_arg_conv.inner = (void*)(this_arg & (~1));
44546 this_arg_conv.is_owned = false;
44547 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44548 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
44549 uint32_t ret_ref = 0;
44550 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44551 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44552 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44553 ret_ref = (uintptr_t)ret_var.inner;
44554 if (ret_var.is_owned) {
44560 uint32_t __attribute__((export_name("TS_SignedRawInvoice_recover_payee_pub_key"))) TS_SignedRawInvoice_recover_payee_pub_key(uint32_t this_arg) {
44561 LDKSignedRawInvoice this_arg_conv;
44562 this_arg_conv.inner = (void*)(this_arg & (~1));
44563 this_arg_conv.is_owned = false;
44564 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44565 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
44566 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
44567 return (uint32_t)ret_conv;
44570 jboolean __attribute__((export_name("TS_SignedRawInvoice_check_signature"))) TS_SignedRawInvoice_check_signature(uint32_t this_arg) {
44571 LDKSignedRawInvoice this_arg_conv;
44572 this_arg_conv.inner = (void*)(this_arg & (~1));
44573 this_arg_conv.is_owned = false;
44574 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44575 jboolean ret_conv = SignedRawInvoice_check_signature(&this_arg_conv);
44579 int8_tArray __attribute__((export_name("TS_RawInvoice_hash"))) TS_RawInvoice_hash(uint32_t this_arg) {
44580 LDKRawInvoice this_arg_conv;
44581 this_arg_conv.inner = (void*)(this_arg & (~1));
44582 this_arg_conv.is_owned = false;
44583 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44584 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44585 memcpy(ret_arr->elems, RawInvoice_hash(&this_arg_conv).data, 32);
44589 uint32_t __attribute__((export_name("TS_RawInvoice_payment_hash"))) TS_RawInvoice_payment_hash(uint32_t this_arg) {
44590 LDKRawInvoice this_arg_conv;
44591 this_arg_conv.inner = (void*)(this_arg & (~1));
44592 this_arg_conv.is_owned = false;
44593 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44594 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
44595 uint32_t ret_ref = 0;
44596 if ((uintptr_t)ret_var.inner > 4096) {
44597 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44598 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44599 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44600 ret_ref = (uintptr_t)ret_var.inner;
44601 if (ret_var.is_owned) {
44608 uint32_t __attribute__((export_name("TS_RawInvoice_description"))) TS_RawInvoice_description(uint32_t this_arg) {
44609 LDKRawInvoice this_arg_conv;
44610 this_arg_conv.inner = (void*)(this_arg & (~1));
44611 this_arg_conv.is_owned = false;
44612 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44613 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
44614 uint32_t ret_ref = 0;
44615 if ((uintptr_t)ret_var.inner > 4096) {
44616 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44617 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44618 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44619 ret_ref = (uintptr_t)ret_var.inner;
44620 if (ret_var.is_owned) {
44627 uint32_t __attribute__((export_name("TS_RawInvoice_payee_pub_key"))) TS_RawInvoice_payee_pub_key(uint32_t this_arg) {
44628 LDKRawInvoice this_arg_conv;
44629 this_arg_conv.inner = (void*)(this_arg & (~1));
44630 this_arg_conv.is_owned = false;
44631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44632 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
44633 uint32_t ret_ref = 0;
44634 if ((uintptr_t)ret_var.inner > 4096) {
44635 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44636 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44637 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44638 ret_ref = (uintptr_t)ret_var.inner;
44639 if (ret_var.is_owned) {
44646 uint32_t __attribute__((export_name("TS_RawInvoice_description_hash"))) TS_RawInvoice_description_hash(uint32_t this_arg) {
44647 LDKRawInvoice this_arg_conv;
44648 this_arg_conv.inner = (void*)(this_arg & (~1));
44649 this_arg_conv.is_owned = false;
44650 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44651 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
44652 uint32_t ret_ref = 0;
44653 if ((uintptr_t)ret_var.inner > 4096) {
44654 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44655 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44656 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44657 ret_ref = (uintptr_t)ret_var.inner;
44658 if (ret_var.is_owned) {
44665 uint32_t __attribute__((export_name("TS_RawInvoice_expiry_time"))) TS_RawInvoice_expiry_time(uint32_t this_arg) {
44666 LDKRawInvoice this_arg_conv;
44667 this_arg_conv.inner = (void*)(this_arg & (~1));
44668 this_arg_conv.is_owned = false;
44669 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44670 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
44671 uint32_t ret_ref = 0;
44672 if ((uintptr_t)ret_var.inner > 4096) {
44673 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44674 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44675 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44676 ret_ref = (uintptr_t)ret_var.inner;
44677 if (ret_var.is_owned) {
44684 uint32_t __attribute__((export_name("TS_RawInvoice_min_final_cltv_expiry"))) TS_RawInvoice_min_final_cltv_expiry(uint32_t this_arg) {
44685 LDKRawInvoice this_arg_conv;
44686 this_arg_conv.inner = (void*)(this_arg & (~1));
44687 this_arg_conv.is_owned = false;
44688 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44689 LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
44690 uint32_t ret_ref = 0;
44691 if ((uintptr_t)ret_var.inner > 4096) {
44692 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44693 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44694 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44695 ret_ref = (uintptr_t)ret_var.inner;
44696 if (ret_var.is_owned) {
44703 int8_tArray __attribute__((export_name("TS_RawInvoice_payment_secret"))) TS_RawInvoice_payment_secret(uint32_t this_arg) {
44704 LDKRawInvoice this_arg_conv;
44705 this_arg_conv.inner = (void*)(this_arg & (~1));
44706 this_arg_conv.is_owned = false;
44707 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44708 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44709 memcpy(ret_arr->elems, RawInvoice_payment_secret(&this_arg_conv).data, 32);
44713 uint32_t __attribute__((export_name("TS_RawInvoice_features"))) TS_RawInvoice_features(uint32_t this_arg) {
44714 LDKRawInvoice this_arg_conv;
44715 this_arg_conv.inner = (void*)(this_arg & (~1));
44716 this_arg_conv.is_owned = false;
44717 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44718 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
44719 uint32_t ret_ref = 0;
44720 if ((uintptr_t)ret_var.inner > 4096) {
44721 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44722 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44723 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44724 ret_ref = (uintptr_t)ret_var.inner;
44725 if (ret_var.is_owned) {
44732 uint32_tArray __attribute__((export_name("TS_RawInvoice_private_routes"))) TS_RawInvoice_private_routes(uint32_t this_arg) {
44733 LDKRawInvoice this_arg_conv;
44734 this_arg_conv.inner = (void*)(this_arg & (~1));
44735 this_arg_conv.is_owned = false;
44736 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44737 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
44738 uint32_tArray ret_arr = NULL;
44739 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
44740 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
44741 for (size_t o = 0; o < ret_var.datalen; o++) {
44742 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
44743 uint32_t ret_conv_14_ref = 0;
44744 CHECK((((uintptr_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44745 CHECK((((uintptr_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44746 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
44747 ret_conv_14_ref = (uintptr_t)ret_conv_14_var.inner;
44748 if (ret_conv_14_var.is_owned) {
44749 ret_conv_14_ref |= 1;
44751 ret_arr_ptr[o] = ret_conv_14_ref;
44754 FREE(ret_var.data);
44758 uint32_t __attribute__((export_name("TS_RawInvoice_amount_pico_btc"))) TS_RawInvoice_amount_pico_btc(uint32_t this_arg) {
44759 LDKRawInvoice this_arg_conv;
44760 this_arg_conv.inner = (void*)(this_arg & (~1));
44761 this_arg_conv.is_owned = false;
44762 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44763 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
44764 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
44765 uint32_t ret_ref = (uintptr_t)ret_copy;
44769 uint32_t __attribute__((export_name("TS_RawInvoice_currency"))) TS_RawInvoice_currency(uint32_t this_arg) {
44770 LDKRawInvoice this_arg_conv;
44771 this_arg_conv.inner = (void*)(this_arg & (~1));
44772 this_arg_conv.is_owned = false;
44773 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44774 uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
44778 uint32_t __attribute__((export_name("TS_PositiveTimestamp_from_unix_timestamp"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
44779 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
44780 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
44781 return (uint32_t)ret_conv;
44784 uint32_t __attribute__((export_name("TS_PositiveTimestamp_from_duration_since_epoch"))) TS_PositiveTimestamp_from_duration_since_epoch(int64_t duration) {
44785 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
44786 *ret_conv = PositiveTimestamp_from_duration_since_epoch(duration);
44787 return (uint32_t)ret_conv;
44790 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_unix_timestamp"))) TS_PositiveTimestamp_as_unix_timestamp(uint32_t this_arg) {
44791 LDKPositiveTimestamp this_arg_conv;
44792 this_arg_conv.inner = (void*)(this_arg & (~1));
44793 this_arg_conv.is_owned = false;
44794 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44795 int64_t ret_conv = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
44799 int64_t __attribute__((export_name("TS_PositiveTimestamp_as_duration_since_epoch"))) TS_PositiveTimestamp_as_duration_since_epoch(uint32_t this_arg) {
44800 LDKPositiveTimestamp this_arg_conv;
44801 this_arg_conv.inner = (void*)(this_arg & (~1));
44802 this_arg_conv.is_owned = false;
44803 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44804 int64_t ret_conv = PositiveTimestamp_as_duration_since_epoch(&this_arg_conv);
44808 uint32_t __attribute__((export_name("TS_Invoice_into_signed_raw"))) TS_Invoice_into_signed_raw(uint32_t this_arg) {
44809 LDKInvoice this_arg_conv;
44810 this_arg_conv.inner = (void*)(this_arg & (~1));
44811 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
44812 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44813 this_arg_conv = Invoice_clone(&this_arg_conv);
44814 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
44815 uint32_t ret_ref = 0;
44816 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44817 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44818 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44819 ret_ref = (uintptr_t)ret_var.inner;
44820 if (ret_var.is_owned) {
44826 uint32_t __attribute__((export_name("TS_Invoice_check_signature"))) TS_Invoice_check_signature(uint32_t this_arg) {
44827 LDKInvoice this_arg_conv;
44828 this_arg_conv.inner = (void*)(this_arg & (~1));
44829 this_arg_conv.is_owned = false;
44830 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44831 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
44832 *ret_conv = Invoice_check_signature(&this_arg_conv);
44833 return (uint32_t)ret_conv;
44836 uint32_t __attribute__((export_name("TS_Invoice_from_signed"))) TS_Invoice_from_signed(uint32_t signed_invoice) {
44837 LDKSignedRawInvoice signed_invoice_conv;
44838 signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
44839 signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
44840 CHECK_INNER_FIELD_ACCESS_OR_NULL(signed_invoice_conv);
44841 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
44842 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
44843 *ret_conv = Invoice_from_signed(signed_invoice_conv);
44844 return (uint32_t)ret_conv;
44847 int64_t __attribute__((export_name("TS_Invoice_duration_since_epoch"))) TS_Invoice_duration_since_epoch(uint32_t this_arg) {
44848 LDKInvoice this_arg_conv;
44849 this_arg_conv.inner = (void*)(this_arg & (~1));
44850 this_arg_conv.is_owned = false;
44851 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44852 int64_t ret_conv = Invoice_duration_since_epoch(&this_arg_conv);
44856 int8_tArray __attribute__((export_name("TS_Invoice_payment_hash"))) TS_Invoice_payment_hash(uint32_t this_arg) {
44857 LDKInvoice this_arg_conv;
44858 this_arg_conv.inner = (void*)(this_arg & (~1));
44859 this_arg_conv.is_owned = false;
44860 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44861 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44862 memcpy(ret_arr->elems, *Invoice_payment_hash(&this_arg_conv), 32);
44866 int8_tArray __attribute__((export_name("TS_Invoice_payee_pub_key"))) TS_Invoice_payee_pub_key(uint32_t this_arg) {
44867 LDKInvoice this_arg_conv;
44868 this_arg_conv.inner = (void*)(this_arg & (~1));
44869 this_arg_conv.is_owned = false;
44870 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44871 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
44872 memcpy(ret_arr->elems, Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
44876 int8_tArray __attribute__((export_name("TS_Invoice_payment_secret"))) TS_Invoice_payment_secret(uint32_t this_arg) {
44877 LDKInvoice this_arg_conv;
44878 this_arg_conv.inner = (void*)(this_arg & (~1));
44879 this_arg_conv.is_owned = false;
44880 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44881 int8_tArray ret_arr = init_int8_tArray(32, __LINE__);
44882 memcpy(ret_arr->elems, *Invoice_payment_secret(&this_arg_conv), 32);
44886 uint32_t __attribute__((export_name("TS_Invoice_features"))) TS_Invoice_features(uint32_t this_arg) {
44887 LDKInvoice this_arg_conv;
44888 this_arg_conv.inner = (void*)(this_arg & (~1));
44889 this_arg_conv.is_owned = false;
44890 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44891 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
44892 uint32_t ret_ref = 0;
44893 if ((uintptr_t)ret_var.inner > 4096) {
44894 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44895 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44896 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
44897 ret_ref = (uintptr_t)ret_var.inner;
44898 if (ret_var.is_owned) {
44905 int8_tArray __attribute__((export_name("TS_Invoice_recover_payee_pub_key"))) TS_Invoice_recover_payee_pub_key(uint32_t this_arg) {
44906 LDKInvoice this_arg_conv;
44907 this_arg_conv.inner = (void*)(this_arg & (~1));
44908 this_arg_conv.is_owned = false;
44909 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44910 int8_tArray ret_arr = init_int8_tArray(33, __LINE__);
44911 memcpy(ret_arr->elems, Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
44915 int64_t __attribute__((export_name("TS_Invoice_expiry_time"))) TS_Invoice_expiry_time(uint32_t this_arg) {
44916 LDKInvoice this_arg_conv;
44917 this_arg_conv.inner = (void*)(this_arg & (~1));
44918 this_arg_conv.is_owned = false;
44919 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44920 int64_t ret_conv = Invoice_expiry_time(&this_arg_conv);
44924 jboolean __attribute__((export_name("TS_Invoice_would_expire"))) TS_Invoice_would_expire(uint32_t this_arg, int64_t at_time) {
44925 LDKInvoice this_arg_conv;
44926 this_arg_conv.inner = (void*)(this_arg & (~1));
44927 this_arg_conv.is_owned = false;
44928 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44929 jboolean ret_conv = Invoice_would_expire(&this_arg_conv, at_time);
44933 int64_t __attribute__((export_name("TS_Invoice_min_final_cltv_expiry"))) TS_Invoice_min_final_cltv_expiry(uint32_t this_arg) {
44934 LDKInvoice this_arg_conv;
44935 this_arg_conv.inner = (void*)(this_arg & (~1));
44936 this_arg_conv.is_owned = false;
44937 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44938 int64_t ret_conv = Invoice_min_final_cltv_expiry(&this_arg_conv);
44942 uint32_tArray __attribute__((export_name("TS_Invoice_private_routes"))) TS_Invoice_private_routes(uint32_t this_arg) {
44943 LDKInvoice this_arg_conv;
44944 this_arg_conv.inner = (void*)(this_arg & (~1));
44945 this_arg_conv.is_owned = false;
44946 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44947 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
44948 uint32_tArray ret_arr = NULL;
44949 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
44950 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
44951 for (size_t o = 0; o < ret_var.datalen; o++) {
44952 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
44953 uint32_t ret_conv_14_ref = 0;
44954 CHECK((((uintptr_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44955 CHECK((((uintptr_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44956 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_14_var);
44957 ret_conv_14_ref = (uintptr_t)ret_conv_14_var.inner;
44958 if (ret_conv_14_var.is_owned) {
44959 ret_conv_14_ref |= 1;
44961 ret_arr_ptr[o] = ret_conv_14_ref;
44964 FREE(ret_var.data);
44968 uint32_tArray __attribute__((export_name("TS_Invoice_route_hints"))) TS_Invoice_route_hints(uint32_t this_arg) {
44969 LDKInvoice this_arg_conv;
44970 this_arg_conv.inner = (void*)(this_arg & (~1));
44971 this_arg_conv.is_owned = false;
44972 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44973 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
44974 uint32_tArray ret_arr = NULL;
44975 ret_arr = init_uint32_tArray(ret_var.datalen, __LINE__);
44976 uint32_t *ret_arr_ptr = (uint32_t*)(((uint8_t*)ret_arr) + 4);
44977 for (size_t l = 0; l < ret_var.datalen; l++) {
44978 LDKRouteHint ret_conv_11_var = ret_var.data[l];
44979 uint32_t ret_conv_11_ref = 0;
44980 CHECK((((uintptr_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
44981 CHECK((((uintptr_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
44982 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
44983 ret_conv_11_ref = (uintptr_t)ret_conv_11_var.inner;
44984 if (ret_conv_11_var.is_owned) {
44985 ret_conv_11_ref |= 1;
44987 ret_arr_ptr[l] = ret_conv_11_ref;
44990 FREE(ret_var.data);
44994 uint32_t __attribute__((export_name("TS_Invoice_currency"))) TS_Invoice_currency(uint32_t this_arg) {
44995 LDKInvoice this_arg_conv;
44996 this_arg_conv.inner = (void*)(this_arg & (~1));
44997 this_arg_conv.is_owned = false;
44998 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
44999 uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
45003 uint32_t __attribute__((export_name("TS_Invoice_amount_milli_satoshis"))) TS_Invoice_amount_milli_satoshis(uint32_t this_arg) {
45004 LDKInvoice this_arg_conv;
45005 this_arg_conv.inner = (void*)(this_arg & (~1));
45006 this_arg_conv.is_owned = false;
45007 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45008 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
45009 *ret_copy = Invoice_amount_milli_satoshis(&this_arg_conv);
45010 uint32_t ret_ref = (uintptr_t)ret_copy;
45014 uint32_t __attribute__((export_name("TS_Description_new"))) TS_Description_new(jstring description) {
45015 LDKStr description_conv = str_ref_to_owned_c(description);
45016 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
45017 *ret_conv = Description_new(description_conv);
45018 return (uint32_t)ret_conv;
45021 jstring __attribute__((export_name("TS_Description_into_inner"))) TS_Description_into_inner(uint32_t this_arg) {
45022 LDKDescription this_arg_conv;
45023 this_arg_conv.inner = (void*)(this_arg & (~1));
45024 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
45025 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45026 this_arg_conv = Description_clone(&this_arg_conv);
45027 LDKStr ret_str = Description_into_inner(this_arg_conv);
45028 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45033 uint32_t __attribute__((export_name("TS_ExpiryTime_from_seconds"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
45034 LDKExpiryTime ret_var = ExpiryTime_from_seconds(seconds);
45035 uint32_t ret_ref = 0;
45036 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
45037 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
45038 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45039 ret_ref = (uintptr_t)ret_var.inner;
45040 if (ret_var.is_owned) {
45046 uint32_t __attribute__((export_name("TS_ExpiryTime_from_duration"))) TS_ExpiryTime_from_duration(int64_t duration) {
45047 LDKExpiryTime ret_var = ExpiryTime_from_duration(duration);
45048 uint32_t ret_ref = 0;
45049 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
45050 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
45051 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45052 ret_ref = (uintptr_t)ret_var.inner;
45053 if (ret_var.is_owned) {
45059 int64_t __attribute__((export_name("TS_ExpiryTime_as_seconds"))) TS_ExpiryTime_as_seconds(uint32_t this_arg) {
45060 LDKExpiryTime this_arg_conv;
45061 this_arg_conv.inner = (void*)(this_arg & (~1));
45062 this_arg_conv.is_owned = false;
45063 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45064 int64_t ret_conv = ExpiryTime_as_seconds(&this_arg_conv);
45068 int64_t __attribute__((export_name("TS_ExpiryTime_as_duration"))) TS_ExpiryTime_as_duration(uint32_t this_arg) {
45069 LDKExpiryTime this_arg_conv;
45070 this_arg_conv.inner = (void*)(this_arg & (~1));
45071 this_arg_conv.is_owned = false;
45072 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45073 int64_t ret_conv = ExpiryTime_as_duration(&this_arg_conv);
45077 uint32_t __attribute__((export_name("TS_PrivateRoute_new"))) TS_PrivateRoute_new(uint32_t hops) {
45078 LDKRouteHint hops_conv;
45079 hops_conv.inner = (void*)(hops & (~1));
45080 hops_conv.is_owned = (hops & 1) || (hops == 0);
45081 CHECK_INNER_FIELD_ACCESS_OR_NULL(hops_conv);
45082 hops_conv = RouteHint_clone(&hops_conv);
45083 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
45084 *ret_conv = PrivateRoute_new(hops_conv);
45085 return (uint32_t)ret_conv;
45088 uint32_t __attribute__((export_name("TS_PrivateRoute_into_inner"))) TS_PrivateRoute_into_inner(uint32_t this_arg) {
45089 LDKPrivateRoute this_arg_conv;
45090 this_arg_conv.inner = (void*)(this_arg & (~1));
45091 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
45092 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45093 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
45094 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
45095 uint32_t ret_ref = 0;
45096 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
45097 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
45098 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45099 ret_ref = (uintptr_t)ret_var.inner;
45100 if (ret_var.is_owned) {
45106 uint32_t __attribute__((export_name("TS_CreationError_clone"))) TS_CreationError_clone(uint32_t orig) {
45107 LDKCreationError* orig_conv = (LDKCreationError*)(orig & ~1);
45108 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
45112 uint32_t __attribute__((export_name("TS_CreationError_description_too_long"))) TS_CreationError_description_too_long() {
45113 uint32_t ret_conv = LDKCreationError_to_js(CreationError_description_too_long());
45117 uint32_t __attribute__((export_name("TS_CreationError_route_too_long"))) TS_CreationError_route_too_long() {
45118 uint32_t ret_conv = LDKCreationError_to_js(CreationError_route_too_long());
45122 uint32_t __attribute__((export_name("TS_CreationError_timestamp_out_of_bounds"))) TS_CreationError_timestamp_out_of_bounds() {
45123 uint32_t ret_conv = LDKCreationError_to_js(CreationError_timestamp_out_of_bounds());
45127 uint32_t __attribute__((export_name("TS_CreationError_invalid_amount"))) TS_CreationError_invalid_amount() {
45128 uint32_t ret_conv = LDKCreationError_to_js(CreationError_invalid_amount());
45132 uint32_t __attribute__((export_name("TS_CreationError_missing_route_hints"))) TS_CreationError_missing_route_hints() {
45133 uint32_t ret_conv = LDKCreationError_to_js(CreationError_missing_route_hints());
45137 jboolean __attribute__((export_name("TS_CreationError_eq"))) TS_CreationError_eq(uint32_t a, uint32_t b) {
45138 LDKCreationError* a_conv = (LDKCreationError*)(a & ~1);
45139 LDKCreationError* b_conv = (LDKCreationError*)(b & ~1);
45140 jboolean ret_conv = CreationError_eq(a_conv, b_conv);
45144 jstring __attribute__((export_name("TS_CreationError_to_str"))) TS_CreationError_to_str(uint32_t o) {
45145 LDKCreationError* o_conv = (LDKCreationError*)(o & ~1);
45146 LDKStr ret_str = CreationError_to_str(o_conv);
45147 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45152 uint32_t __attribute__((export_name("TS_SemanticError_clone"))) TS_SemanticError_clone(uint32_t orig) {
45153 LDKSemanticError* orig_conv = (LDKSemanticError*)(orig & ~1);
45154 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_clone(orig_conv));
45158 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_hash"))) TS_SemanticError_no_payment_hash() {
45159 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_hash());
45163 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_hashes"))) TS_SemanticError_multiple_payment_hashes() {
45164 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_hashes());
45168 uint32_t __attribute__((export_name("TS_SemanticError_no_description"))) TS_SemanticError_no_description() {
45169 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_description());
45173 uint32_t __attribute__((export_name("TS_SemanticError_multiple_descriptions"))) TS_SemanticError_multiple_descriptions() {
45174 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_descriptions());
45178 uint32_t __attribute__((export_name("TS_SemanticError_no_payment_secret"))) TS_SemanticError_no_payment_secret() {
45179 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_secret());
45183 uint32_t __attribute__((export_name("TS_SemanticError_multiple_payment_secrets"))) TS_SemanticError_multiple_payment_secrets() {
45184 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_secrets());
45188 uint32_t __attribute__((export_name("TS_SemanticError_invalid_features"))) TS_SemanticError_invalid_features() {
45189 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_features());
45193 uint32_t __attribute__((export_name("TS_SemanticError_invalid_recovery_id"))) TS_SemanticError_invalid_recovery_id() {
45194 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_recovery_id());
45198 uint32_t __attribute__((export_name("TS_SemanticError_invalid_signature"))) TS_SemanticError_invalid_signature() {
45199 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_invalid_signature());
45203 uint32_t __attribute__((export_name("TS_SemanticError_imprecise_amount"))) TS_SemanticError_imprecise_amount() {
45204 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_imprecise_amount());
45208 jboolean __attribute__((export_name("TS_SemanticError_eq"))) TS_SemanticError_eq(uint32_t a, uint32_t b) {
45209 LDKSemanticError* a_conv = (LDKSemanticError*)(a & ~1);
45210 LDKSemanticError* b_conv = (LDKSemanticError*)(b & ~1);
45211 jboolean ret_conv = SemanticError_eq(a_conv, b_conv);
45215 jstring __attribute__((export_name("TS_SemanticError_to_str"))) TS_SemanticError_to_str(uint32_t o) {
45216 LDKSemanticError* o_conv = (LDKSemanticError*)(o & ~1);
45217 LDKStr ret_str = SemanticError_to_str(o_conv);
45218 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45223 void __attribute__((export_name("TS_SignOrCreationError_free"))) TS_SignOrCreationError_free(uint32_t this_ptr) {
45224 if ((this_ptr & 1) != 0) return;
45225 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
45226 CHECK_ACCESS(this_ptr_ptr);
45227 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(this_ptr_ptr);
45228 FREE((void*)this_ptr);
45229 SignOrCreationError_free(this_ptr_conv);
45232 static inline uintptr_t SignOrCreationError_clone_ptr(LDKSignOrCreationError *NONNULL_PTR arg) {
45233 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
45234 *ret_copy = SignOrCreationError_clone(arg);
45235 uint32_t ret_ref = (uintptr_t)ret_copy;
45238 uint32_t __attribute__((export_name("TS_SignOrCreationError_clone_ptr"))) TS_SignOrCreationError_clone_ptr(uint32_t arg) {
45239 LDKSignOrCreationError* arg_conv = (LDKSignOrCreationError*)arg;
45240 uint32_t ret_conv = SignOrCreationError_clone_ptr(arg_conv);
45244 uint32_t __attribute__((export_name("TS_SignOrCreationError_clone"))) TS_SignOrCreationError_clone(uint32_t orig) {
45245 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
45246 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
45247 *ret_copy = SignOrCreationError_clone(orig_conv);
45248 uint32_t ret_ref = (uintptr_t)ret_copy;
45252 uint32_t __attribute__((export_name("TS_SignOrCreationError_sign_error"))) TS_SignOrCreationError_sign_error() {
45253 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
45254 *ret_copy = SignOrCreationError_sign_error();
45255 uint32_t ret_ref = (uintptr_t)ret_copy;
45259 uint32_t __attribute__((export_name("TS_SignOrCreationError_creation_error"))) TS_SignOrCreationError_creation_error(uint32_t a) {
45260 LDKCreationError a_conv = LDKCreationError_from_js(a);
45261 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
45262 *ret_copy = SignOrCreationError_creation_error(a_conv);
45263 uint32_t ret_ref = (uintptr_t)ret_copy;
45267 jboolean __attribute__((export_name("TS_SignOrCreationError_eq"))) TS_SignOrCreationError_eq(uint32_t a, uint32_t b) {
45268 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)a;
45269 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)b;
45270 jboolean ret_conv = SignOrCreationError_eq(a_conv, b_conv);
45274 jstring __attribute__((export_name("TS_SignOrCreationError_to_str"))) TS_SignOrCreationError_to_str(uint32_t o) {
45275 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)o;
45276 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
45277 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45282 void __attribute__((export_name("TS_InvoicePayer_free"))) TS_InvoicePayer_free(uint32_t this_obj) {
45283 LDKInvoicePayer this_obj_conv;
45284 this_obj_conv.inner = (void*)(this_obj & (~1));
45285 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
45286 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45287 InvoicePayer_free(this_obj_conv);
45290 void __attribute__((export_name("TS_Payer_free"))) TS_Payer_free(uint32_t this_ptr) {
45291 if ((this_ptr & 1) != 0) return;
45292 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
45293 CHECK_ACCESS(this_ptr_ptr);
45294 LDKPayer this_ptr_conv = *(LDKPayer*)(this_ptr_ptr);
45295 FREE((void*)this_ptr);
45296 Payer_free(this_ptr_conv);
45299 void __attribute__((export_name("TS_Router_free"))) TS_Router_free(uint32_t this_ptr) {
45300 if ((this_ptr & 1) != 0) return;
45301 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
45302 CHECK_ACCESS(this_ptr_ptr);
45303 LDKRouter this_ptr_conv = *(LDKRouter*)(this_ptr_ptr);
45304 FREE((void*)this_ptr);
45305 Router_free(this_ptr_conv);
45308 void __attribute__((export_name("TS_Retry_free"))) TS_Retry_free(uint32_t this_ptr) {
45309 if ((this_ptr & 1) != 0) return;
45310 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
45311 CHECK_ACCESS(this_ptr_ptr);
45312 LDKRetry this_ptr_conv = *(LDKRetry*)(this_ptr_ptr);
45313 FREE((void*)this_ptr);
45314 Retry_free(this_ptr_conv);
45317 static inline uintptr_t Retry_clone_ptr(LDKRetry *NONNULL_PTR arg) {
45318 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
45319 *ret_copy = Retry_clone(arg);
45320 uint32_t ret_ref = (uintptr_t)ret_copy;
45323 uint32_t __attribute__((export_name("TS_Retry_clone_ptr"))) TS_Retry_clone_ptr(uint32_t arg) {
45324 LDKRetry* arg_conv = (LDKRetry*)arg;
45325 uint32_t ret_conv = Retry_clone_ptr(arg_conv);
45329 uint32_t __attribute__((export_name("TS_Retry_clone"))) TS_Retry_clone(uint32_t orig) {
45330 LDKRetry* orig_conv = (LDKRetry*)orig;
45331 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
45332 *ret_copy = Retry_clone(orig_conv);
45333 uint32_t ret_ref = (uintptr_t)ret_copy;
45337 uint32_t __attribute__((export_name("TS_Retry_attempts"))) TS_Retry_attempts(uint32_t a) {
45338 LDKRetry *ret_copy = MALLOC(sizeof(LDKRetry), "LDKRetry");
45339 *ret_copy = Retry_attempts(a);
45340 uint32_t ret_ref = (uintptr_t)ret_copy;
45344 jboolean __attribute__((export_name("TS_Retry_eq"))) TS_Retry_eq(uint32_t a, uint32_t b) {
45345 LDKRetry* a_conv = (LDKRetry*)a;
45346 LDKRetry* b_conv = (LDKRetry*)b;
45347 jboolean ret_conv = Retry_eq(a_conv, b_conv);
45351 int64_t __attribute__((export_name("TS_Retry_hash"))) TS_Retry_hash(uint32_t o) {
45352 LDKRetry* o_conv = (LDKRetry*)o;
45353 int64_t ret_conv = Retry_hash(o_conv);
45357 void __attribute__((export_name("TS_PaymentError_free"))) TS_PaymentError_free(uint32_t this_ptr) {
45358 if ((this_ptr & 1) != 0) return;
45359 void* this_ptr_ptr = (void*)(((uintptr_t)this_ptr) & ~1);
45360 CHECK_ACCESS(this_ptr_ptr);
45361 LDKPaymentError this_ptr_conv = *(LDKPaymentError*)(this_ptr_ptr);
45362 FREE((void*)this_ptr);
45363 PaymentError_free(this_ptr_conv);
45366 static inline uintptr_t PaymentError_clone_ptr(LDKPaymentError *NONNULL_PTR arg) {
45367 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
45368 *ret_copy = PaymentError_clone(arg);
45369 uint32_t ret_ref = (uintptr_t)ret_copy;
45372 uint32_t __attribute__((export_name("TS_PaymentError_clone_ptr"))) TS_PaymentError_clone_ptr(uint32_t arg) {
45373 LDKPaymentError* arg_conv = (LDKPaymentError*)arg;
45374 uint32_t ret_conv = PaymentError_clone_ptr(arg_conv);
45378 uint32_t __attribute__((export_name("TS_PaymentError_clone"))) TS_PaymentError_clone(uint32_t orig) {
45379 LDKPaymentError* orig_conv = (LDKPaymentError*)orig;
45380 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
45381 *ret_copy = PaymentError_clone(orig_conv);
45382 uint32_t ret_ref = (uintptr_t)ret_copy;
45386 uint32_t __attribute__((export_name("TS_PaymentError_invoice"))) TS_PaymentError_invoice(jstring a) {
45387 LDKStr a_conv = str_ref_to_owned_c(a);
45388 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
45389 *ret_copy = PaymentError_invoice(a_conv);
45390 uint32_t ret_ref = (uintptr_t)ret_copy;
45394 uint32_t __attribute__((export_name("TS_PaymentError_routing"))) TS_PaymentError_routing(uint32_t a) {
45395 LDKLightningError a_conv;
45396 a_conv.inner = (void*)(a & (~1));
45397 a_conv.is_owned = (a & 1) || (a == 0);
45398 CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
45399 a_conv = LightningError_clone(&a_conv);
45400 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
45401 *ret_copy = PaymentError_routing(a_conv);
45402 uint32_t ret_ref = (uintptr_t)ret_copy;
45406 uint32_t __attribute__((export_name("TS_PaymentError_sending"))) TS_PaymentError_sending(uint32_t a) {
45407 void* a_ptr = (void*)(((uintptr_t)a) & ~1);
45408 CHECK_ACCESS(a_ptr);
45409 LDKPaymentSendFailure a_conv = *(LDKPaymentSendFailure*)(a_ptr);
45410 a_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uintptr_t)a) & ~1));
45411 LDKPaymentError *ret_copy = MALLOC(sizeof(LDKPaymentError), "LDKPaymentError");
45412 *ret_copy = PaymentError_sending(a_conv);
45413 uint32_t ret_ref = (uintptr_t)ret_copy;
45417 uint32_t __attribute__((export_name("TS_InvoicePayer_new"))) TS_InvoicePayer_new(uint32_t payer, uint32_t router, uint32_t scorer, uint32_t logger, uint32_t event_handler, uint32_t retry) {
45418 void* payer_ptr = (void*)(((uintptr_t)payer) & ~1);
45419 CHECK_ACCESS(payer_ptr);
45420 LDKPayer payer_conv = *(LDKPayer*)(payer_ptr);
45421 if (payer_conv.free == LDKPayer_JCalls_free) {
45422 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45423 LDKPayer_JCalls_cloned(&payer_conv);
45425 void* router_ptr = (void*)(((uintptr_t)router) & ~1);
45426 CHECK_ACCESS(router_ptr);
45427 LDKRouter router_conv = *(LDKRouter*)(router_ptr);
45428 if (router_conv.free == LDKRouter_JCalls_free) {
45429 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45430 LDKRouter_JCalls_cloned(&router_conv);
45432 LDKMultiThreadedLockableScore scorer_conv;
45433 scorer_conv.inner = (void*)(scorer & (~1));
45434 scorer_conv.is_owned = false;
45435 CHECK_INNER_FIELD_ACCESS_OR_NULL(scorer_conv);
45436 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
45437 CHECK_ACCESS(logger_ptr);
45438 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45439 if (logger_conv.free == LDKLogger_JCalls_free) {
45440 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45441 LDKLogger_JCalls_cloned(&logger_conv);
45443 void* event_handler_ptr = (void*)(((uintptr_t)event_handler) & ~1);
45444 CHECK_ACCESS(event_handler_ptr);
45445 LDKEventHandler event_handler_conv = *(LDKEventHandler*)(event_handler_ptr);
45446 if (event_handler_conv.free == LDKEventHandler_JCalls_free) {
45447 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45448 LDKEventHandler_JCalls_cloned(&event_handler_conv);
45450 void* retry_ptr = (void*)(((uintptr_t)retry) & ~1);
45451 CHECK_ACCESS(retry_ptr);
45452 LDKRetry retry_conv = *(LDKRetry*)(retry_ptr);
45453 retry_conv = Retry_clone((LDKRetry*)(((uintptr_t)retry) & ~1));
45454 LDKInvoicePayer ret_var = InvoicePayer_new(payer_conv, router_conv, &scorer_conv, logger_conv, event_handler_conv, retry_conv);
45455 uint32_t ret_ref = 0;
45456 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
45457 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
45458 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45459 ret_ref = (uintptr_t)ret_var.inner;
45460 if (ret_var.is_owned) {
45466 uint32_t __attribute__((export_name("TS_InvoicePayer_pay_invoice"))) TS_InvoicePayer_pay_invoice(uint32_t this_arg, uint32_t invoice) {
45467 LDKInvoicePayer this_arg_conv;
45468 this_arg_conv.inner = (void*)(this_arg & (~1));
45469 this_arg_conv.is_owned = false;
45470 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45471 LDKInvoice invoice_conv;
45472 invoice_conv.inner = (void*)(invoice & (~1));
45473 invoice_conv.is_owned = false;
45474 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
45475 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
45476 *ret_conv = InvoicePayer_pay_invoice(&this_arg_conv, &invoice_conv);
45477 return (uint32_t)ret_conv;
45480 uint32_t __attribute__((export_name("TS_InvoicePayer_pay_zero_value_invoice"))) TS_InvoicePayer_pay_zero_value_invoice(uint32_t this_arg, uint32_t invoice, int64_t amount_msats) {
45481 LDKInvoicePayer this_arg_conv;
45482 this_arg_conv.inner = (void*)(this_arg & (~1));
45483 this_arg_conv.is_owned = false;
45484 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45485 LDKInvoice invoice_conv;
45486 invoice_conv.inner = (void*)(invoice & (~1));
45487 invoice_conv.is_owned = false;
45488 CHECK_INNER_FIELD_ACCESS_OR_NULL(invoice_conv);
45489 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
45490 *ret_conv = InvoicePayer_pay_zero_value_invoice(&this_arg_conv, &invoice_conv, amount_msats);
45491 return (uint32_t)ret_conv;
45494 uint32_t __attribute__((export_name("TS_InvoicePayer_pay_pubkey"))) TS_InvoicePayer_pay_pubkey(uint32_t this_arg, int8_tArray pubkey, int8_tArray payment_preimage, int64_t amount_msats, int32_t final_cltv_expiry_delta) {
45495 LDKInvoicePayer this_arg_conv;
45496 this_arg_conv.inner = (void*)(this_arg & (~1));
45497 this_arg_conv.is_owned = false;
45498 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45499 LDKPublicKey pubkey_ref;
45500 CHECK(pubkey->arr_len == 33);
45501 memcpy(pubkey_ref.compressed_form, pubkey->elems, 33); FREE(pubkey);
45502 LDKThirtyTwoBytes payment_preimage_ref;
45503 CHECK(payment_preimage->arr_len == 32);
45504 memcpy(payment_preimage_ref.data, payment_preimage->elems, 32); FREE(payment_preimage);
45505 LDKCResult_PaymentIdPaymentErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentErrorZ), "LDKCResult_PaymentIdPaymentErrorZ");
45506 *ret_conv = InvoicePayer_pay_pubkey(&this_arg_conv, pubkey_ref, payment_preimage_ref, amount_msats, final_cltv_expiry_delta);
45507 return (uint32_t)ret_conv;
45510 void __attribute__((export_name("TS_InvoicePayer_remove_cached_payment"))) TS_InvoicePayer_remove_cached_payment(uint32_t this_arg, int8_tArray payment_hash) {
45511 LDKInvoicePayer this_arg_conv;
45512 this_arg_conv.inner = (void*)(this_arg & (~1));
45513 this_arg_conv.is_owned = false;
45514 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45515 unsigned char payment_hash_arr[32];
45516 CHECK(payment_hash->arr_len == 32);
45517 memcpy(payment_hash_arr, payment_hash->elems, 32); FREE(payment_hash);
45518 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
45519 InvoicePayer_remove_cached_payment(&this_arg_conv, payment_hash_ref);
45522 uint32_t __attribute__((export_name("TS_InvoicePayer_as_EventHandler"))) TS_InvoicePayer_as_EventHandler(uint32_t this_arg) {
45523 LDKInvoicePayer this_arg_conv;
45524 this_arg_conv.inner = (void*)(this_arg & (~1));
45525 this_arg_conv.is_owned = false;
45526 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45527 LDKEventHandler* ret_ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
45528 *ret_ret = InvoicePayer_as_EventHandler(&this_arg_conv);
45529 return (uint32_t)ret_ret;
45532 uint32_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(uint32_t channelmanager, uint32_t keys_manager, uint32_t network, uint32_t amt_msat, uint32_t description_hash, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs) {
45533 LDKChannelManager channelmanager_conv;
45534 channelmanager_conv.inner = (void*)(channelmanager & (~1));
45535 channelmanager_conv.is_owned = false;
45536 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
45537 void* keys_manager_ptr = (void*)(((uintptr_t)keys_manager) & ~1);
45538 CHECK_ACCESS(keys_manager_ptr);
45539 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
45540 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
45541 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45542 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
45544 LDKCurrency network_conv = LDKCurrency_from_js(network);
45545 void* amt_msat_ptr = (void*)(((uintptr_t)amt_msat) & ~1);
45546 CHECK_ACCESS(amt_msat_ptr);
45547 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
45548 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)amt_msat) & ~1));
45549 LDKSha256 description_hash_conv;
45550 description_hash_conv.inner = (void*)(description_hash & (~1));
45551 description_hash_conv.is_owned = (description_hash & 1) || (description_hash == 0);
45552 CHECK_INNER_FIELD_ACCESS_OR_NULL(description_hash_conv);
45553 description_hash_conv = Sha256_clone(&description_hash_conv);
45554 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
45555 *ret_conv = create_invoice_from_channelmanager_with_description_hash_and_duration_since_epoch(&channelmanager_conv, keys_manager_conv, network_conv, amt_msat_conv, description_hash_conv, duration_since_epoch, invoice_expiry_delta_secs);
45556 return (uint32_t)ret_conv;
45559 uint32_t __attribute__((export_name("TS_create_invoice_from_channelmanager_and_duration_since_epoch"))) TS_create_invoice_from_channelmanager_and_duration_since_epoch(uint32_t channelmanager, uint32_t keys_manager, uint32_t network, uint32_t amt_msat, jstring description, int64_t duration_since_epoch, int32_t invoice_expiry_delta_secs) {
45560 LDKChannelManager channelmanager_conv;
45561 channelmanager_conv.inner = (void*)(channelmanager & (~1));
45562 channelmanager_conv.is_owned = false;
45563 CHECK_INNER_FIELD_ACCESS_OR_NULL(channelmanager_conv);
45564 void* keys_manager_ptr = (void*)(((uintptr_t)keys_manager) & ~1);
45565 CHECK_ACCESS(keys_manager_ptr);
45566 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(keys_manager_ptr);
45567 if (keys_manager_conv.free == LDKKeysInterface_JCalls_free) {
45568 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45569 LDKKeysInterface_JCalls_cloned(&keys_manager_conv);
45571 LDKCurrency network_conv = LDKCurrency_from_js(network);
45572 void* amt_msat_ptr = (void*)(((uintptr_t)amt_msat) & ~1);
45573 CHECK_ACCESS(amt_msat_ptr);
45574 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(amt_msat_ptr);
45575 amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uintptr_t)amt_msat) & ~1));
45576 LDKStr description_conv = str_ref_to_owned_c(description);
45577 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
45578 *ret_conv = create_invoice_from_channelmanager_and_duration_since_epoch(&channelmanager_conv, keys_manager_conv, network_conv, amt_msat_conv, description_conv, duration_since_epoch, invoice_expiry_delta_secs);
45579 return (uint32_t)ret_conv;
45582 void __attribute__((export_name("TS_DefaultRouter_free"))) TS_DefaultRouter_free(uint32_t this_obj) {
45583 LDKDefaultRouter this_obj_conv;
45584 this_obj_conv.inner = (void*)(this_obj & (~1));
45585 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
45586 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
45587 DefaultRouter_free(this_obj_conv);
45590 uint32_t __attribute__((export_name("TS_DefaultRouter_new"))) TS_DefaultRouter_new(uint32_t network_graph, uint32_t logger, int8_tArray random_seed_bytes) {
45591 LDKNetworkGraph network_graph_conv;
45592 network_graph_conv.inner = (void*)(network_graph & (~1));
45593 network_graph_conv.is_owned = false;
45594 CHECK_INNER_FIELD_ACCESS_OR_NULL(network_graph_conv);
45595 void* logger_ptr = (void*)(((uintptr_t)logger) & ~1);
45596 CHECK_ACCESS(logger_ptr);
45597 LDKLogger logger_conv = *(LDKLogger*)(logger_ptr);
45598 if (logger_conv.free == LDKLogger_JCalls_free) {
45599 // If this_arg is a JCalls struct, then we need to increment the refcnt in it.
45600 LDKLogger_JCalls_cloned(&logger_conv);
45602 LDKThirtyTwoBytes random_seed_bytes_ref;
45603 CHECK(random_seed_bytes->arr_len == 32);
45604 memcpy(random_seed_bytes_ref.data, random_seed_bytes->elems, 32); FREE(random_seed_bytes);
45605 LDKDefaultRouter ret_var = DefaultRouter_new(&network_graph_conv, logger_conv, random_seed_bytes_ref);
45606 uint32_t ret_ref = 0;
45607 CHECK((((uintptr_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
45608 CHECK((((uintptr_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
45609 CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
45610 ret_ref = (uintptr_t)ret_var.inner;
45611 if (ret_var.is_owned) {
45617 uint32_t __attribute__((export_name("TS_DefaultRouter_as_Router"))) TS_DefaultRouter_as_Router(uint32_t this_arg) {
45618 LDKDefaultRouter this_arg_conv;
45619 this_arg_conv.inner = (void*)(this_arg & (~1));
45620 this_arg_conv.is_owned = false;
45621 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45622 LDKRouter* ret_ret = MALLOC(sizeof(LDKRouter), "LDKRouter");
45623 *ret_ret = DefaultRouter_as_Router(&this_arg_conv);
45624 return (uint32_t)ret_ret;
45627 uint32_t __attribute__((export_name("TS_ChannelManager_as_Payer"))) TS_ChannelManager_as_Payer(uint32_t this_arg) {
45628 LDKChannelManager this_arg_conv;
45629 this_arg_conv.inner = (void*)(this_arg & (~1));
45630 this_arg_conv.is_owned = false;
45631 CHECK_INNER_FIELD_ACCESS_OR_NULL(this_arg_conv);
45632 LDKPayer* ret_ret = MALLOC(sizeof(LDKPayer), "LDKPayer");
45633 *ret_ret = ChannelManager_as_Payer(&this_arg_conv);
45634 return (uint32_t)ret_ret;
45637 uint32_t __attribute__((export_name("TS_SiPrefix_from_str"))) TS_SiPrefix_from_str(jstring s) {
45638 LDKStr s_conv = str_ref_to_owned_c(s);
45639 LDKCResult_SiPrefixParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixParseErrorZ), "LDKCResult_SiPrefixParseErrorZ");
45640 *ret_conv = SiPrefix_from_str(s_conv);
45641 return (uint32_t)ret_conv;
45644 uint32_t __attribute__((export_name("TS_Invoice_from_str"))) TS_Invoice_from_str(jstring s) {
45645 LDKStr s_conv = str_ref_to_owned_c(s);
45646 LDKCResult_InvoiceParseOrSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceParseOrSemanticErrorZ), "LDKCResult_InvoiceParseOrSemanticErrorZ");
45647 *ret_conv = Invoice_from_str(s_conv);
45648 return (uint32_t)ret_conv;
45651 uint32_t __attribute__((export_name("TS_SignedRawInvoice_from_str"))) TS_SignedRawInvoice_from_str(jstring s) {
45652 LDKStr s_conv = str_ref_to_owned_c(s);
45653 LDKCResult_SignedRawInvoiceParseErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceParseErrorZ), "LDKCResult_SignedRawInvoiceParseErrorZ");
45654 *ret_conv = SignedRawInvoice_from_str(s_conv);
45655 return (uint32_t)ret_conv;
45658 jstring __attribute__((export_name("TS_ParseError_to_str"))) TS_ParseError_to_str(uint32_t o) {
45659 LDKParseError* o_conv = (LDKParseError*)o;
45660 LDKStr ret_str = ParseError_to_str(o_conv);
45661 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45666 jstring __attribute__((export_name("TS_ParseOrSemanticError_to_str"))) TS_ParseOrSemanticError_to_str(uint32_t o) {
45667 LDKParseOrSemanticError* o_conv = (LDKParseOrSemanticError*)o;
45668 LDKStr ret_str = ParseOrSemanticError_to_str(o_conv);
45669 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45674 jstring __attribute__((export_name("TS_Invoice_to_str"))) TS_Invoice_to_str(uint32_t o) {
45676 o_conv.inner = (void*)(o & (~1));
45677 o_conv.is_owned = false;
45678 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
45679 LDKStr ret_str = Invoice_to_str(&o_conv);
45680 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45685 jstring __attribute__((export_name("TS_SignedRawInvoice_to_str"))) TS_SignedRawInvoice_to_str(uint32_t o) {
45686 LDKSignedRawInvoice o_conv;
45687 o_conv.inner = (void*)(o & (~1));
45688 o_conv.is_owned = false;
45689 CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
45690 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
45691 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45696 jstring __attribute__((export_name("TS_Currency_to_str"))) TS_Currency_to_str(uint32_t o) {
45697 LDKCurrency* o_conv = (LDKCurrency*)(o & ~1);
45698 LDKStr ret_str = Currency_to_str(o_conv);
45699 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
45704 jstring __attribute__((export_name("TS_SiPrefix_to_str"))) TS_SiPrefix_to_str(uint32_t o) {
45705 LDKSiPrefix* o_conv = (LDKSiPrefix*)(o & ~1);
45706 LDKStr ret_str = SiPrefix_to_str(o_conv);
45707 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);