1 #define LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ LDKCVec_TransactionOutputsZ
2 #define CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free CVec_TransactionOutputsZ_free
7 // These should be provided...somehow...
8 void *memset(void *s, int c, size_t n);
9 void *memcpy(void *dest, const void *src, size_t n);
10 int memcmp(const void *s1, const void *s2, size_t n);
12 void __attribute__((noreturn)) abort(void);
13 static inline void assert(bool expression) {
14 if (!expression) { abort(); }
17 void *malloc(size_t size);
20 #define MALLOC(a, _) malloc(a)
21 #define FREE(p) if ((long)(p) > 1024) { free(p); }
22 #define DO_ASSERT(a) (void)(a)
25 // We assume that CVec_u8Z and u8slice are the same size and layout (and thus pointers to the two can be mixed)
26 _Static_assert(sizeof(LDKCVec_u8Z) == sizeof(LDKu8slice), "Vec<u8> and [u8] need to have been mapped identically");
27 _Static_assert(offsetof(LDKCVec_u8Z, data) == offsetof(LDKu8slice, data), "Vec<u8> and [u8] need to have been mapped identically");
28 _Static_assert(offsetof(LDKCVec_u8Z, datalen) == offsetof(LDKu8slice, datalen), "Vec<u8> and [u8] need to have been mapped identically");
30 _Static_assert(sizeof(void*) == 4, "Pointers mut be 32 bits");
32 typedef uint32_t int64_tArray;
33 typedef uint32_t int8_tArray;
34 typedef uint32_t uint32_tArray;
35 typedef uint32_t ptrArray;
36 typedef uint32_t jstring;
38 static inline uint32_t init_arr(size_t arr_len, size_t elem_size, const char *type_desc) {
39 uint32_t *elems = (uint32_t*)MALLOC(arr_len * elem_size + 4, type_desc);
41 return (uint32_t)elems;
44 static inline jstring str_ref_to_ts(const char* chars, size_t len) {
45 char* err_buf = MALLOC(len + 4, "str conv buf");
46 *((uint32_t*)err_buf) = len;
47 memcpy(err_buf + 4, chars, len);
48 return (uint32_t) err_buf;
50 static inline LDKStr str_ref_to_owned_c(jstring str) {
51 uint32_t *str_len = (uint32_t*)str;
52 char* newchars = MALLOC(*str_len + 1, "String chars");
53 memcpy(newchars, (const char*)(str + 4), *str_len);
54 newchars[*str_len] = 0;
58 .chars_is_owned = true
63 typedef bool jboolean;
65 uint32_t __attribute__((visibility("default"))) TS_malloc(uint32_t size) {
66 return (uint32_t)MALLOC(size, "JS-Called malloc");
68 void __attribute__((visibility("default"))) TS_free(uint32_t ptr) {
71 static inline struct LDKThirtyTwoBytes ThirtyTwoBytes_clone(const struct LDKThirtyTwoBytes *orig) { struct LDKThirtyTwoBytes ret; memcpy(ret.data, orig->data, 32); return ret; }
72 static inline LDKAccessError LDKAccessError_from_js(int32_t ord) {
74 case 0: return LDKAccessError_UnknownChain;
75 case 1: return LDKAccessError_UnknownTx;
79 static inline int32_t LDKAccessError_to_js(LDKAccessError val) {
81 case LDKAccessError_UnknownChain: return 0;
82 case LDKAccessError_UnknownTx: return 1;
86 static inline LDKChannelMonitorUpdateErr LDKChannelMonitorUpdateErr_from_js(int32_t ord) {
88 case 0: return LDKChannelMonitorUpdateErr_TemporaryFailure;
89 case 1: return LDKChannelMonitorUpdateErr_PermanentFailure;
93 static inline int32_t LDKChannelMonitorUpdateErr_to_js(LDKChannelMonitorUpdateErr val) {
95 case LDKChannelMonitorUpdateErr_TemporaryFailure: return 0;
96 case LDKChannelMonitorUpdateErr_PermanentFailure: return 1;
100 static inline LDKConfirmationTarget LDKConfirmationTarget_from_js(int32_t ord) {
102 case 0: return LDKConfirmationTarget_Background;
103 case 1: return LDKConfirmationTarget_Normal;
104 case 2: return LDKConfirmationTarget_HighPriority;
108 static inline int32_t LDKConfirmationTarget_to_js(LDKConfirmationTarget val) {
110 case LDKConfirmationTarget_Background: return 0;
111 case LDKConfirmationTarget_Normal: return 1;
112 case LDKConfirmationTarget_HighPriority: return 2;
116 static inline LDKCreationError LDKCreationError_from_js(int32_t ord) {
118 case 0: return LDKCreationError_DescriptionTooLong;
119 case 1: return LDKCreationError_RouteTooLong;
120 case 2: return LDKCreationError_TimestampOutOfBounds;
121 case 3: return LDKCreationError_ExpiryTimeOutOfBounds;
125 static inline int32_t LDKCreationError_to_js(LDKCreationError val) {
127 case LDKCreationError_DescriptionTooLong: return 0;
128 case LDKCreationError_RouteTooLong: return 1;
129 case LDKCreationError_TimestampOutOfBounds: return 2;
130 case LDKCreationError_ExpiryTimeOutOfBounds: return 3;
134 static inline LDKCurrency LDKCurrency_from_js(int32_t ord) {
136 case 0: return LDKCurrency_Bitcoin;
137 case 1: return LDKCurrency_BitcoinTestnet;
138 case 2: return LDKCurrency_Regtest;
139 case 3: return LDKCurrency_Simnet;
140 case 4: return LDKCurrency_Signet;
144 static inline int32_t LDKCurrency_to_js(LDKCurrency val) {
146 case LDKCurrency_Bitcoin: return 0;
147 case LDKCurrency_BitcoinTestnet: return 1;
148 case LDKCurrency_Regtest: return 2;
149 case LDKCurrency_Simnet: return 3;
150 case LDKCurrency_Signet: return 4;
154 static inline LDKIOError LDKIOError_from_js(int32_t ord) {
156 case 0: return LDKIOError_NotFound;
157 case 1: return LDKIOError_PermissionDenied;
158 case 2: return LDKIOError_ConnectionRefused;
159 case 3: return LDKIOError_ConnectionReset;
160 case 4: return LDKIOError_ConnectionAborted;
161 case 5: return LDKIOError_NotConnected;
162 case 6: return LDKIOError_AddrInUse;
163 case 7: return LDKIOError_AddrNotAvailable;
164 case 8: return LDKIOError_BrokenPipe;
165 case 9: return LDKIOError_AlreadyExists;
166 case 10: return LDKIOError_WouldBlock;
167 case 11: return LDKIOError_InvalidInput;
168 case 12: return LDKIOError_InvalidData;
169 case 13: return LDKIOError_TimedOut;
170 case 14: return LDKIOError_WriteZero;
171 case 15: return LDKIOError_Interrupted;
172 case 16: return LDKIOError_Other;
173 case 17: return LDKIOError_UnexpectedEof;
177 static inline int32_t LDKIOError_to_js(LDKIOError val) {
179 case LDKIOError_NotFound: return 0;
180 case LDKIOError_PermissionDenied: return 1;
181 case LDKIOError_ConnectionRefused: return 2;
182 case LDKIOError_ConnectionReset: return 3;
183 case LDKIOError_ConnectionAborted: return 4;
184 case LDKIOError_NotConnected: return 5;
185 case LDKIOError_AddrInUse: return 6;
186 case LDKIOError_AddrNotAvailable: return 7;
187 case LDKIOError_BrokenPipe: return 8;
188 case LDKIOError_AlreadyExists: return 9;
189 case LDKIOError_WouldBlock: return 10;
190 case LDKIOError_InvalidInput: return 11;
191 case LDKIOError_InvalidData: return 12;
192 case LDKIOError_TimedOut: return 13;
193 case LDKIOError_WriteZero: return 14;
194 case LDKIOError_Interrupted: return 15;
195 case LDKIOError_Other: return 16;
196 case LDKIOError_UnexpectedEof: return 17;
200 static inline LDKLevel LDKLevel_from_js(int32_t ord) {
202 case 0: return LDKLevel_Trace;
203 case 1: return LDKLevel_Debug;
204 case 2: return LDKLevel_Info;
205 case 3: return LDKLevel_Warn;
206 case 4: return LDKLevel_Error;
210 static inline int32_t LDKLevel_to_js(LDKLevel val) {
212 case LDKLevel_Trace: return 0;
213 case LDKLevel_Debug: return 1;
214 case LDKLevel_Info: return 2;
215 case LDKLevel_Warn: return 3;
216 case LDKLevel_Error: return 4;
220 static inline LDKNetwork LDKNetwork_from_js(int32_t ord) {
222 case 0: return LDKNetwork_Bitcoin;
223 case 1: return LDKNetwork_Testnet;
224 case 2: return LDKNetwork_Regtest;
225 case 3: return LDKNetwork_Signet;
229 static inline int32_t LDKNetwork_to_js(LDKNetwork val) {
231 case LDKNetwork_Bitcoin: return 0;
232 case LDKNetwork_Testnet: return 1;
233 case LDKNetwork_Regtest: return 2;
234 case LDKNetwork_Signet: return 3;
238 static inline LDKSecp256k1Error LDKSecp256k1Error_from_js(int32_t ord) {
240 case 0: return LDKSecp256k1Error_IncorrectSignature;
241 case 1: return LDKSecp256k1Error_InvalidMessage;
242 case 2: return LDKSecp256k1Error_InvalidPublicKey;
243 case 3: return LDKSecp256k1Error_InvalidSignature;
244 case 4: return LDKSecp256k1Error_InvalidSecretKey;
245 case 5: return LDKSecp256k1Error_InvalidRecoveryId;
246 case 6: return LDKSecp256k1Error_InvalidTweak;
247 case 7: return LDKSecp256k1Error_TweakCheckFailed;
248 case 8: return LDKSecp256k1Error_NotEnoughMemory;
252 static inline int32_t LDKSecp256k1Error_to_js(LDKSecp256k1Error val) {
254 case LDKSecp256k1Error_IncorrectSignature: return 0;
255 case LDKSecp256k1Error_InvalidMessage: return 1;
256 case LDKSecp256k1Error_InvalidPublicKey: return 2;
257 case LDKSecp256k1Error_InvalidSignature: return 3;
258 case LDKSecp256k1Error_InvalidSecretKey: return 4;
259 case LDKSecp256k1Error_InvalidRecoveryId: return 5;
260 case LDKSecp256k1Error_InvalidTweak: return 6;
261 case LDKSecp256k1Error_TweakCheckFailed: return 7;
262 case LDKSecp256k1Error_NotEnoughMemory: return 8;
266 static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) {
268 case 0: return LDKSemanticError_NoPaymentHash;
269 case 1: return LDKSemanticError_MultiplePaymentHashes;
270 case 2: return LDKSemanticError_NoDescription;
271 case 3: return LDKSemanticError_MultipleDescriptions;
272 case 4: return LDKSemanticError_MultiplePaymentSecrets;
273 case 5: return LDKSemanticError_InvalidFeatures;
274 case 6: return LDKSemanticError_InvalidRecoveryId;
275 case 7: return LDKSemanticError_InvalidSignature;
279 static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) {
281 case LDKSemanticError_NoPaymentHash: return 0;
282 case LDKSemanticError_MultiplePaymentHashes: return 1;
283 case LDKSemanticError_NoDescription: return 2;
284 case LDKSemanticError_MultipleDescriptions: return 3;
285 case LDKSemanticError_MultiplePaymentSecrets: return 4;
286 case LDKSemanticError_InvalidFeatures: return 5;
287 case LDKSemanticError_InvalidRecoveryId: return 6;
288 case LDKSemanticError_InvalidSignature: return 7;
292 static inline LDKSiPrefix LDKSiPrefix_from_js(int32_t ord) {
294 case 0: return LDKSiPrefix_Milli;
295 case 1: return LDKSiPrefix_Micro;
296 case 2: return LDKSiPrefix_Nano;
297 case 3: return LDKSiPrefix_Pico;
301 static inline int32_t LDKSiPrefix_to_js(LDKSiPrefix val) {
303 case LDKSiPrefix_Milli: return 0;
304 case LDKSiPrefix_Micro: return 1;
305 case LDKSiPrefix_Nano: return 2;
306 case LDKSiPrefix_Pico: return 3;
310 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u8Z_new(int8_tArray elems) {
311 LDKCVec_u8Z *ret = MALLOC(sizeof(LDKCVec_u8Z), "LDKCVec_u8Z");
312 ret->datalen = *((uint32_t*)elems);
313 if (ret->datalen == 0) {
316 ret->data = MALLOC(sizeof(uint8_t) * ret->datalen, "LDKCVec_u8Z Data");
317 int8_t *java_elems = (int8_t*)(elems + 4);
318 for (size_t i = 0; i < ret->datalen; i++) {
319 ret->data[i] = java_elems[i];
322 return (uint64_t)ret;
324 static inline LDKCVec_u8Z CVec_u8Z_clone(const LDKCVec_u8Z *orig) {
325 LDKCVec_u8Z ret = { .data = MALLOC(sizeof(int8_t) * orig->datalen, "LDKCVec_u8Z clone bytes"), .datalen = orig->datalen };
326 memcpy(ret.data, orig->data, sizeof(int8_t) * ret.datalen);
329 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_result_ok(uint32_t arg) {
330 return ((LDKCResult_SecretKeyErrorZ*)arg)->result_ok;
332 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_get_ok(uint32_t arg) {
333 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
334 CHECK(val->result_ok);
335 int8_tArray res_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
336 memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).bytes, 32);
339 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SecretKeyErrorZ_get_err(uint32_t arg) {
340 LDKCResult_SecretKeyErrorZ *val = (LDKCResult_SecretKeyErrorZ*)(arg & ~1);
341 CHECK(!val->result_ok);
342 uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
345 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_result_ok(uint32_t arg) {
346 return ((LDKCResult_PublicKeyErrorZ*)arg)->result_ok;
348 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_get_ok(uint32_t arg) {
349 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
350 CHECK(val->result_ok);
351 int8_tArray res_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
352 memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).compressed_form, 33);
355 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PublicKeyErrorZ_get_err(uint32_t arg) {
356 LDKCResult_PublicKeyErrorZ *val = (LDKCResult_PublicKeyErrorZ*)(arg & ~1);
357 CHECK(!val->result_ok);
358 uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
361 jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_result_ok(uint32_t arg) {
362 return ((LDKCResult_TxCreationKeysDecodeErrorZ*)arg)->result_ok;
364 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_get_ok(uint32_t arg) {
365 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
366 CHECK(val->result_ok);
367 LDKTxCreationKeys res_var = (*val->contents.result);
368 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
369 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
370 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
373 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysDecodeErrorZ_get_err(uint32_t arg) {
374 LDKCResult_TxCreationKeysDecodeErrorZ *val = (LDKCResult_TxCreationKeysDecodeErrorZ*)(arg & ~1);
375 CHECK(!val->result_ok);
376 LDKDecodeError err_var = (*val->contents.err);
377 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
378 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
379 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
382 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_result_ok(uint32_t arg) {
383 return ((LDKCResult_ChannelPublicKeysDecodeErrorZ*)arg)->result_ok;
385 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_get_ok(uint32_t arg) {
386 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
387 CHECK(val->result_ok);
388 LDKChannelPublicKeys res_var = (*val->contents.result);
389 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
390 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
391 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
394 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelPublicKeysDecodeErrorZ_get_err(uint32_t arg) {
395 LDKCResult_ChannelPublicKeysDecodeErrorZ *val = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(arg & ~1);
396 CHECK(!val->result_ok);
397 LDKDecodeError err_var = (*val->contents.err);
398 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
399 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
400 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
403 jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_result_ok(uint32_t arg) {
404 return ((LDKCResult_TxCreationKeysErrorZ*)arg)->result_ok;
406 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_get_ok(uint32_t arg) {
407 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
408 CHECK(val->result_ok);
409 LDKTxCreationKeys res_var = (*val->contents.result);
410 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
411 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
412 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
415 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxCreationKeysErrorZ_get_err(uint32_t arg) {
416 LDKCResult_TxCreationKeysErrorZ *val = (LDKCResult_TxCreationKeysErrorZ*)(arg & ~1);
417 CHECK(!val->result_ok);
418 uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
421 uint32_t __attribute__((visibility("default"))) TS_LDKCOption_u32Z_ref_from_ptr(uint32_t ptr) {
422 LDKCOption_u32Z *obj = (LDKCOption_u32Z*)(ptr & ~1);
424 case LDKCOption_u32Z_Some: {
425 return 0 /* LDKCOption_u32Z - Some */; (void) obj->some;
427 case LDKCOption_u32Z_None: {
428 return 0 /* LDKCOption_u32Z - None */;
433 jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_result_ok(uint32_t arg) {
434 return ((LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)arg)->result_ok;
436 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_ok(uint32_t arg) {
437 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
438 CHECK(val->result_ok);
439 LDKHTLCOutputInCommitment res_var = (*val->contents.result);
440 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
441 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
442 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
445 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCOutputInCommitmentDecodeErrorZ_get_err(uint32_t arg) {
446 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ *val = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(arg & ~1);
447 CHECK(!val->result_ok);
448 LDKDecodeError err_var = (*val->contents.err);
449 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
450 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
451 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
454 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
455 return ((LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
457 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
458 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
459 CHECK(val->result_ok);
460 LDKCounterpartyChannelTransactionParameters res_var = (*val->contents.result);
461 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
462 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
463 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
466 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ_get_err(uint32_t arg) {
467 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
468 CHECK(!val->result_ok);
469 LDKDecodeError err_var = (*val->contents.err);
470 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
471 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
472 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
475 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_result_ok(uint32_t arg) {
476 return ((LDKCResult_ChannelTransactionParametersDecodeErrorZ*)arg)->result_ok;
478 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_ok(uint32_t arg) {
479 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
480 CHECK(val->result_ok);
481 LDKChannelTransactionParameters res_var = (*val->contents.result);
482 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
483 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
484 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
487 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelTransactionParametersDecodeErrorZ_get_err(uint32_t arg) {
488 LDKCResult_ChannelTransactionParametersDecodeErrorZ *val = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(arg & ~1);
489 CHECK(!val->result_ok);
490 LDKDecodeError err_var = (*val->contents.err);
491 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
492 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
493 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
496 jboolean __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
497 return ((LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
499 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
500 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
501 CHECK(val->result_ok);
502 LDKHolderCommitmentTransaction res_var = (*val->contents.result);
503 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
504 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
505 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
508 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HolderCommitmentTransactionDecodeErrorZ_get_err(uint32_t arg) {
509 LDKCResult_HolderCommitmentTransactionDecodeErrorZ *val = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(arg & ~1);
510 CHECK(!val->result_ok);
511 LDKDecodeError err_var = (*val->contents.err);
512 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
513 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
514 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
517 jboolean __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
518 return ((LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)arg)->result_ok;
520 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
521 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
522 CHECK(val->result_ok);
523 LDKBuiltCommitmentTransaction res_var = (*val->contents.result);
524 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
525 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
526 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
529 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTransactionDecodeErrorZ_get_err(uint32_t arg) {
530 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ *val = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(arg & ~1);
531 CHECK(!val->result_ok);
532 LDKDecodeError err_var = (*val->contents.err);
533 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
534 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
535 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
538 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) {
539 return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok;
541 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_get_ok(uint32_t arg) {
542 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
543 CHECK(val->result_ok);
544 LDKCommitmentTransaction res_var = (*val->contents.result);
545 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
546 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
547 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
550 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_get_err(uint32_t arg) {
551 LDKCResult_CommitmentTransactionDecodeErrorZ *val = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(arg & ~1);
552 CHECK(!val->result_ok);
553 LDKDecodeError err_var = (*val->contents.err);
554 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
555 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
556 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
559 jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_result_ok(uint32_t arg) {
560 return ((LDKCResult_TrustedCommitmentTransactionNoneZ*)arg)->result_ok;
562 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_get_ok(uint32_t arg) {
563 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
564 CHECK(val->result_ok);
565 LDKTrustedCommitmentTransaction res_var = (*val->contents.result);
566 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
567 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
568 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
571 void __attribute__((visibility("default"))) TS_LDKCResult_TrustedCommitmentTransactionNoneZ_get_err(uint32_t arg) {
572 LDKCResult_TrustedCommitmentTransactionNoneZ *val = (LDKCResult_TrustedCommitmentTransactionNoneZ*)(arg & ~1);
573 CHECK(!val->result_ok);
574 return *val->contents.err;
576 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_result_ok(uint32_t arg) {
577 return ((LDKCResult_CVec_SignatureZNoneZ*)arg)->result_ok;
579 ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_get_ok(uint32_t arg) {
580 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
581 CHECK(val->result_ok);
582 LDKCVec_SignatureZ res_var = (*val->contents.result);
583 ptrArray res_arr = init_arr(res_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
584 int8_tArray *res_arr_ptr = (int8_tArray*)(res_arr + 4);
585 for (size_t m = 0; m < res_var.datalen; m++) {
586 int8_tArray res_conv_12_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
587 memcpy((uint8_t*)(res_conv_12_arr + 4), res_var.data[m].compact_form, 64);
588 res_arr_ptr[m] = res_conv_12_arr;
592 void __attribute__((visibility("default"))) TS_LDKCResult_CVec_SignatureZNoneZ_get_err(uint32_t arg) {
593 LDKCResult_CVec_SignatureZNoneZ *val = (LDKCResult_CVec_SignatureZNoneZ*)(arg & ~1);
594 CHECK(!val->result_ok);
595 return *val->contents.err;
597 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_result_ok(uint32_t arg) {
598 return ((LDKCResult_NoneErrorZ*)arg)->result_ok;
600 void __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_get_ok(uint32_t arg) {
601 LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
602 CHECK(val->result_ok);
603 return *val->contents.result;
605 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneErrorZ_get_err(uint32_t arg) {
606 LDKCResult_NoneErrorZ *val = (LDKCResult_NoneErrorZ*)(arg & ~1);
607 CHECK(!val->result_ok);
608 uint32_t err_conv = LDKIOError_to_js((*val->contents.err));
611 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_result_ok(uint32_t arg) {
612 return ((LDKCResult_RouteHopDecodeErrorZ*)arg)->result_ok;
614 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_get_ok(uint32_t arg) {
615 LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
616 CHECK(val->result_ok);
617 LDKRouteHop res_var = (*val->contents.result);
618 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
619 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
620 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
623 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteHopDecodeErrorZ_get_err(uint32_t arg) {
624 LDKCResult_RouteHopDecodeErrorZ *val = (LDKCResult_RouteHopDecodeErrorZ*)(arg & ~1);
625 CHECK(!val->result_ok);
626 LDKDecodeError err_var = (*val->contents.err);
627 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
628 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
629 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
632 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHopZ_new(uint32_tArray elems) {
633 LDKCVec_RouteHopZ *ret = MALLOC(sizeof(LDKCVec_RouteHopZ), "LDKCVec_RouteHopZ");
634 ret->datalen = *((uint32_t*)elems);
635 if (ret->datalen == 0) {
638 ret->data = MALLOC(sizeof(LDKRouteHop) * ret->datalen, "LDKCVec_RouteHopZ Data");
639 uint32_t *java_elems = (uint32_t*)(elems + 4);
640 for (size_t i = 0; i < ret->datalen; i++) {
641 uint32_t arr_elem = java_elems[i];
642 LDKRouteHop arr_elem_conv;
643 arr_elem_conv.inner = (void*)(arr_elem & (~1));
644 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
645 arr_elem_conv = RouteHop_clone(&arr_elem_conv);
646 ret->data[i] = arr_elem_conv;
649 return (uint64_t)ret;
651 static inline LDKCVec_RouteHopZ CVec_RouteHopZ_clone(const LDKCVec_RouteHopZ *orig) {
652 LDKCVec_RouteHopZ ret = { .data = MALLOC(sizeof(LDKRouteHop) * orig->datalen, "LDKCVec_RouteHopZ clone bytes"), .datalen = orig->datalen };
653 for (size_t i = 0; i < ret.datalen; i++) {
654 ret.data[i] = RouteHop_clone(&orig->data[i]);
658 static inline LDKCVec_CVec_RouteHopZZ CVec_CVec_RouteHopZZ_clone(const LDKCVec_CVec_RouteHopZZ *orig) {
659 LDKCVec_CVec_RouteHopZZ ret = { .data = MALLOC(sizeof(LDKCVec_RouteHopZ) * orig->datalen, "LDKCVec_CVec_RouteHopZZ clone bytes"), .datalen = orig->datalen };
660 for (size_t i = 0; i < ret.datalen; i++) {
661 ret.data[i] = CVec_RouteHopZ_clone(&orig->data[i]);
665 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_result_ok(uint32_t arg) {
666 return ((LDKCResult_RouteDecodeErrorZ*)arg)->result_ok;
668 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_get_ok(uint32_t arg) {
669 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
670 CHECK(val->result_ok);
671 LDKRoute res_var = (*val->contents.result);
672 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
673 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
674 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
677 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteDecodeErrorZ_get_err(uint32_t arg) {
678 LDKCResult_RouteDecodeErrorZ *val = (LDKCResult_RouteDecodeErrorZ*)(arg & ~1);
679 CHECK(!val->result_ok);
680 LDKDecodeError err_var = (*val->contents.err);
681 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
682 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
683 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
686 uint32_t __attribute__((visibility("default"))) TS_LDKCOption_u64Z_ref_from_ptr(uint32_t ptr) {
687 LDKCOption_u64Z *obj = (LDKCOption_u64Z*)(ptr & ~1);
689 case LDKCOption_u64Z_Some: {
690 return 0 /* LDKCOption_u64Z - Some */; (void) obj->some;
692 case LDKCOption_u64Z_None: {
693 return 0 /* LDKCOption_u64Z - None */;
698 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelDetailsZ_new(uint32_tArray elems) {
699 LDKCVec_ChannelDetailsZ *ret = MALLOC(sizeof(LDKCVec_ChannelDetailsZ), "LDKCVec_ChannelDetailsZ");
700 ret->datalen = *((uint32_t*)elems);
701 if (ret->datalen == 0) {
704 ret->data = MALLOC(sizeof(LDKChannelDetails) * ret->datalen, "LDKCVec_ChannelDetailsZ Data");
705 uint32_t *java_elems = (uint32_t*)(elems + 4);
706 for (size_t i = 0; i < ret->datalen; i++) {
707 uint32_t arr_elem = java_elems[i];
708 LDKChannelDetails arr_elem_conv;
709 arr_elem_conv.inner = (void*)(arr_elem & (~1));
710 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
711 arr_elem_conv = ChannelDetails_clone(&arr_elem_conv);
712 ret->data[i] = arr_elem_conv;
715 return (uint64_t)ret;
717 static inline LDKCVec_ChannelDetailsZ CVec_ChannelDetailsZ_clone(const LDKCVec_ChannelDetailsZ *orig) {
718 LDKCVec_ChannelDetailsZ ret = { .data = MALLOC(sizeof(LDKChannelDetails) * orig->datalen, "LDKCVec_ChannelDetailsZ clone bytes"), .datalen = orig->datalen };
719 for (size_t i = 0; i < ret.datalen; i++) {
720 ret.data[i] = ChannelDetails_clone(&orig->data[i]);
724 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_RouteHintZ_new(uint32_tArray elems) {
725 LDKCVec_RouteHintZ *ret = MALLOC(sizeof(LDKCVec_RouteHintZ), "LDKCVec_RouteHintZ");
726 ret->datalen = *((uint32_t*)elems);
727 if (ret->datalen == 0) {
730 ret->data = MALLOC(sizeof(LDKRouteHint) * ret->datalen, "LDKCVec_RouteHintZ Data");
731 uint32_t *java_elems = (uint32_t*)(elems + 4);
732 for (size_t i = 0; i < ret->datalen; i++) {
733 uint32_t arr_elem = java_elems[i];
734 LDKRouteHint arr_elem_conv;
735 arr_elem_conv.inner = (void*)(arr_elem & (~1));
736 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
737 arr_elem_conv = RouteHint_clone(&arr_elem_conv);
738 ret->data[i] = arr_elem_conv;
741 return (uint64_t)ret;
743 static inline LDKCVec_RouteHintZ CVec_RouteHintZ_clone(const LDKCVec_RouteHintZ *orig) {
744 LDKCVec_RouteHintZ ret = { .data = MALLOC(sizeof(LDKRouteHint) * orig->datalen, "LDKCVec_RouteHintZ clone bytes"), .datalen = orig->datalen };
745 for (size_t i = 0; i < ret.datalen; i++) {
746 ret.data[i] = RouteHint_clone(&orig->data[i]);
750 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_result_ok(uint32_t arg) {
751 return ((LDKCResult_RouteLightningErrorZ*)arg)->result_ok;
753 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_get_ok(uint32_t arg) {
754 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
755 CHECK(val->result_ok);
756 LDKRoute res_var = (*val->contents.result);
757 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
758 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
759 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
762 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RouteLightningErrorZ_get_err(uint32_t arg) {
763 LDKCResult_RouteLightningErrorZ *val = (LDKCResult_RouteLightningErrorZ*)(arg & ~1);
764 CHECK(!val->result_ok);
765 LDKLightningError err_var = (*val->contents.err);
766 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
767 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
768 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
771 jboolean __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_result_ok(uint32_t arg) {
772 return ((LDKCResult_TxOutAccessErrorZ*)arg)->result_ok;
774 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_get_ok(uint32_t arg) {
775 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
776 CHECK(val->result_ok);
777 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
778 return (uint64_t)res_ref;
780 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TxOutAccessErrorZ_get_err(uint32_t arg) {
781 LDKCResult_TxOutAccessErrorZ *val = (LDKCResult_TxOutAccessErrorZ*)(arg & ~1);
782 CHECK(!val->result_ok);
783 uint32_t err_conv = LDKAccessError_to_js((*val->contents.err));
786 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ_new(int64_t a, int8_tArray b) {
787 LDKC2Tuple_usizeTransactionZ* ret = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
789 LDKTransaction b_ref;
790 b_ref.datalen = *((uint32_t*)b);
791 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
792 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
793 b_ref.data_is_owned = false;
795 return (uint64_t)ret;
797 int64_t __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ_get_a(uint32_t ptr) {
798 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
801 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ_get_b(uint32_t ptr) {
802 LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1);
803 LDKTransaction b_var = tuple->b;
804 int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
805 memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen);
808 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_usizeTransactionZZ_new(uint32_tArray elems) {
809 LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ");
810 ret->datalen = *((uint32_t*)elems);
811 if (ret->datalen == 0) {
814 ret->data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * ret->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ Data");
815 uint32_t *java_elems = (uint32_t*)(elems + 4);
816 for (size_t i = 0; i < ret->datalen; i++) {
817 uint32_t arr_elem = java_elems[i];
818 LDKC2Tuple_usizeTransactionZ arr_elem_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1);
819 arr_elem_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)arr_elem) & ~1));
820 ret->data[i] = arr_elem_conv;
823 return (uint64_t)ret;
825 static inline LDKCVec_C2Tuple_usizeTransactionZZ CVec_C2Tuple_usizeTransactionZZ_clone(const LDKCVec_C2Tuple_usizeTransactionZZ *orig) {
826 LDKCVec_C2Tuple_usizeTransactionZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ) * orig->datalen, "LDKCVec_C2Tuple_usizeTransactionZZ clone bytes"), .datalen = orig->datalen };
827 for (size_t i = 0; i < ret.datalen; i++) {
828 ret.data[i] = C2Tuple_usizeTransactionZ_clone(&orig->data[i]);
832 static inline LDKCVec_TxidZ CVec_ThirtyTwoBytesZ_clone(const LDKCVec_TxidZ *orig) {
833 LDKCVec_TxidZ ret = { .data = MALLOC(sizeof(LDKThirtyTwoBytes) * orig->datalen, "LDKCVec_TxidZ clone bytes"), .datalen = orig->datalen };
834 for (size_t i = 0; i < ret.datalen; i++) {
835 ret.data[i] = ThirtyTwoBytes_clone(&orig->data[i]);
839 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_result_ok(uint32_t arg) {
840 return ((LDKCResult_NoneChannelMonitorUpdateErrZ*)arg)->result_ok;
842 void __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_get_ok(uint32_t arg) {
843 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
844 CHECK(val->result_ok);
845 return *val->contents.result;
847 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneChannelMonitorUpdateErrZ_get_err(uint32_t arg) {
848 LDKCResult_NoneChannelMonitorUpdateErrZ *val = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(arg & ~1);
849 CHECK(!val->result_ok);
850 uint32_t err_conv = LDKChannelMonitorUpdateErr_to_js((*val->contents.err));
853 uint32_t __attribute__((visibility("default"))) TS_LDKMonitorEvent_ref_from_ptr(uint32_t ptr) {
854 LDKMonitorEvent *obj = (LDKMonitorEvent*)(ptr & ~1);
856 case LDKMonitorEvent_HTLCEvent: {
857 LDKHTLCUpdate htlc_event_var = obj->htlc_event;
858 CHECK((((uint64_t)htlc_event_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
859 CHECK((((uint64_t)&htlc_event_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
860 uint64_t htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1;
861 return 0 /* LDKMonitorEvent - HTLCEvent */; (void) htlc_event_ref;
863 case LDKMonitorEvent_CommitmentTxBroadcasted: {
864 LDKOutPoint commitment_tx_broadcasted_var = obj->commitment_tx_broadcasted;
865 CHECK((((uint64_t)commitment_tx_broadcasted_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
866 CHECK((((uint64_t)&commitment_tx_broadcasted_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
867 uint64_t commitment_tx_broadcasted_ref = (uint64_t)commitment_tx_broadcasted_var.inner & ~1;
868 return 0 /* LDKMonitorEvent - CommitmentTxBroadcasted */; (void) commitment_tx_broadcasted_ref;
873 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MonitorEventZ_new(uint32_tArray elems) {
874 LDKCVec_MonitorEventZ *ret = MALLOC(sizeof(LDKCVec_MonitorEventZ), "LDKCVec_MonitorEventZ");
875 ret->datalen = *((uint32_t*)elems);
876 if (ret->datalen == 0) {
879 ret->data = MALLOC(sizeof(LDKMonitorEvent) * ret->datalen, "LDKCVec_MonitorEventZ Data");
880 uint32_t *java_elems = (uint32_t*)(elems + 4);
881 for (size_t i = 0; i < ret->datalen; i++) {
882 uint32_t arr_elem = java_elems[i];
883 LDKMonitorEvent arr_elem_conv = *(LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1);
884 arr_elem_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)arr_elem) & ~1));
885 ret->data[i] = arr_elem_conv;
888 return (uint64_t)ret;
890 static inline LDKCVec_MonitorEventZ CVec_MonitorEventZ_clone(const LDKCVec_MonitorEventZ *orig) {
891 LDKCVec_MonitorEventZ ret = { .data = MALLOC(sizeof(LDKMonitorEvent) * orig->datalen, "LDKCVec_MonitorEventZ clone bytes"), .datalen = orig->datalen };
892 for (size_t i = 0; i < ret.datalen; i++) {
893 ret.data[i] = MonitorEvent_clone(&orig->data[i]);
897 uint32_t __attribute__((visibility("default"))) TS_LDKCOption_C2Tuple_usizeTransactionZZ_ref_from_ptr(uint32_t ptr) {
898 LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)(ptr & ~1);
900 case LDKCOption_C2Tuple_usizeTransactionZZ_Some: {
901 uint64_t some_ref = (uint64_t)(&obj->some) | 1;
902 return 0 /* LDKCOption_C2Tuple_usizeTransactionZZ - Some */; (void) some_ref;
904 case LDKCOption_C2Tuple_usizeTransactionZZ_None: {
905 return 0 /* LDKCOption_C2Tuple_usizeTransactionZZ - None */;
910 uint32_t __attribute__((visibility("default"))) TS_LDKSpendableOutputDescriptor_ref_from_ptr(uint32_t ptr) {
911 LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1);
913 case LDKSpendableOutputDescriptor_StaticOutput: {
914 LDKOutPoint outpoint_var = obj->static_output.outpoint;
915 CHECK((((uint64_t)outpoint_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
916 CHECK((((uint64_t)&outpoint_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
917 uint64_t outpoint_ref = (uint64_t)outpoint_var.inner & ~1;
918 uint64_t output_ref = ((uint64_t)&obj->static_output.output) | 1;
919 return 0 /* LDKSpendableOutputDescriptor - StaticOutput */; (void) outpoint_ref; (void) (uint64_t)output_ref;
921 case LDKSpendableOutputDescriptor_DelayedPaymentOutput: {
922 LDKDelayedPaymentOutputDescriptor delayed_payment_output_var = obj->delayed_payment_output;
923 CHECK((((uint64_t)delayed_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
924 CHECK((((uint64_t)&delayed_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
925 uint64_t delayed_payment_output_ref = (uint64_t)delayed_payment_output_var.inner & ~1;
926 return 0 /* LDKSpendableOutputDescriptor - DelayedPaymentOutput */; (void) delayed_payment_output_ref;
928 case LDKSpendableOutputDescriptor_StaticPaymentOutput: {
929 LDKStaticPaymentOutputDescriptor static_payment_output_var = obj->static_payment_output;
930 CHECK((((uint64_t)static_payment_output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
931 CHECK((((uint64_t)&static_payment_output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
932 uint64_t static_payment_output_ref = (uint64_t)static_payment_output_var.inner & ~1;
933 return 0 /* LDKSpendableOutputDescriptor - StaticPaymentOutput */; (void) static_payment_output_ref;
938 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_SpendableOutputDescriptorZ_new(uint32_tArray elems) {
939 LDKCVec_SpendableOutputDescriptorZ *ret = MALLOC(sizeof(LDKCVec_SpendableOutputDescriptorZ), "LDKCVec_SpendableOutputDescriptorZ");
940 ret->datalen = *((uint32_t*)elems);
941 if (ret->datalen == 0) {
944 ret->data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * ret->datalen, "LDKCVec_SpendableOutputDescriptorZ Data");
945 uint32_t *java_elems = (uint32_t*)(elems + 4);
946 for (size_t i = 0; i < ret->datalen; i++) {
947 uint32_t arr_elem = java_elems[i];
948 LDKSpendableOutputDescriptor arr_elem_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1);
949 arr_elem_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)arr_elem) & ~1));
950 ret->data[i] = arr_elem_conv;
953 return (uint64_t)ret;
955 static inline LDKCVec_SpendableOutputDescriptorZ CVec_SpendableOutputDescriptorZ_clone(const LDKCVec_SpendableOutputDescriptorZ *orig) {
956 LDKCVec_SpendableOutputDescriptorZ ret = { .data = MALLOC(sizeof(LDKSpendableOutputDescriptor) * orig->datalen, "LDKCVec_SpendableOutputDescriptorZ clone bytes"), .datalen = orig->datalen };
957 for (size_t i = 0; i < ret.datalen; i++) {
958 ret.data[i] = SpendableOutputDescriptor_clone(&orig->data[i]);
962 uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(uint32_t ptr) {
963 LDKErrorAction *obj = (LDKErrorAction*)(ptr & ~1);
965 case LDKErrorAction_DisconnectPeer: {
966 LDKErrorMessage msg_var = obj->disconnect_peer.msg;
967 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
968 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
969 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
970 return 0 /* LDKErrorAction - DisconnectPeer */; (void) msg_ref;
972 case LDKErrorAction_IgnoreError: {
973 return 0 /* LDKErrorAction - IgnoreError */;
975 case LDKErrorAction_IgnoreAndLog: {
976 uint32_t ignore_and_log_conv = LDKLevel_to_js(obj->ignore_and_log);
977 return 0 /* LDKErrorAction - IgnoreAndLog */; (void) ignore_and_log_conv;
979 case LDKErrorAction_SendErrorMessage: {
980 LDKErrorMessage msg_var = obj->send_error_message.msg;
981 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
982 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
983 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
984 return 0 /* LDKErrorAction - SendErrorMessage */; (void) msg_ref;
989 uint32_t __attribute__((visibility("default"))) TS_LDKHTLCFailChannelUpdate_ref_from_ptr(uint32_t ptr) {
990 LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)(ptr & ~1);
992 case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: {
993 LDKChannelUpdate msg_var = obj->channel_update_message.msg;
994 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
995 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
996 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
997 return 0 /* LDKHTLCFailChannelUpdate - ChannelUpdateMessage */; (void) msg_ref;
999 case LDKHTLCFailChannelUpdate_ChannelClosed: {
1000 return 0 /* LDKHTLCFailChannelUpdate - ChannelClosed */; (void) obj->channel_closed.short_channel_id; (void) obj->channel_closed.is_permanent;
1002 case LDKHTLCFailChannelUpdate_NodeFailure: {
1003 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1004 memcpy((uint8_t*)(node_id_arr + 4), obj->node_failure.node_id.compressed_form, 33);
1005 return 0 /* LDKHTLCFailChannelUpdate - NodeFailure */; (void) node_id_arr; (void) obj->node_failure.is_permanent;
1010 uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_ptr(uint32_t ptr) {
1011 LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1);
1013 case LDKMessageSendEvent_SendAcceptChannel: {
1014 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1015 memcpy((uint8_t*)(node_id_arr + 4), obj->send_accept_channel.node_id.compressed_form, 33);
1016 LDKAcceptChannel msg_var = obj->send_accept_channel.msg;
1017 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1018 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1019 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1020 return 0 /* LDKMessageSendEvent - SendAcceptChannel */; (void) node_id_arr; (void) msg_ref;
1022 case LDKMessageSendEvent_SendOpenChannel: {
1023 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1024 memcpy((uint8_t*)(node_id_arr + 4), obj->send_open_channel.node_id.compressed_form, 33);
1025 LDKOpenChannel msg_var = obj->send_open_channel.msg;
1026 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1027 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1028 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1029 return 0 /* LDKMessageSendEvent - SendOpenChannel */; (void) node_id_arr; (void) msg_ref;
1031 case LDKMessageSendEvent_SendFundingCreated: {
1032 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1033 memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_created.node_id.compressed_form, 33);
1034 LDKFundingCreated msg_var = obj->send_funding_created.msg;
1035 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1036 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1037 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1038 return 0 /* LDKMessageSendEvent - SendFundingCreated */; (void) node_id_arr; (void) msg_ref;
1040 case LDKMessageSendEvent_SendFundingSigned: {
1041 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1042 memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_signed.node_id.compressed_form, 33);
1043 LDKFundingSigned msg_var = obj->send_funding_signed.msg;
1044 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1045 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1046 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1047 return 0 /* LDKMessageSendEvent - SendFundingSigned */; (void) node_id_arr; (void) msg_ref;
1049 case LDKMessageSendEvent_SendFundingLocked: {
1050 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1051 memcpy((uint8_t*)(node_id_arr + 4), obj->send_funding_locked.node_id.compressed_form, 33);
1052 LDKFundingLocked msg_var = obj->send_funding_locked.msg;
1053 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1054 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1055 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1056 return 0 /* LDKMessageSendEvent - SendFundingLocked */; (void) node_id_arr; (void) msg_ref;
1058 case LDKMessageSendEvent_SendAnnouncementSignatures: {
1059 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1060 memcpy((uint8_t*)(node_id_arr + 4), obj->send_announcement_signatures.node_id.compressed_form, 33);
1061 LDKAnnouncementSignatures msg_var = obj->send_announcement_signatures.msg;
1062 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1063 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1064 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1065 return 0 /* LDKMessageSendEvent - SendAnnouncementSignatures */; (void) node_id_arr; (void) msg_ref;
1067 case LDKMessageSendEvent_UpdateHTLCs: {
1068 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1069 memcpy((uint8_t*)(node_id_arr + 4), obj->update_htl_cs.node_id.compressed_form, 33);
1070 LDKCommitmentUpdate updates_var = obj->update_htl_cs.updates;
1071 CHECK((((uint64_t)updates_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1072 CHECK((((uint64_t)&updates_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1073 uint64_t updates_ref = (uint64_t)updates_var.inner & ~1;
1074 return 0 /* LDKMessageSendEvent - UpdateHTLCs */; (void) node_id_arr; (void) updates_ref;
1076 case LDKMessageSendEvent_SendRevokeAndACK: {
1077 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1078 memcpy((uint8_t*)(node_id_arr + 4), obj->send_revoke_and_ack.node_id.compressed_form, 33);
1079 LDKRevokeAndACK msg_var = obj->send_revoke_and_ack.msg;
1080 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1081 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1082 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1083 return 0 /* LDKMessageSendEvent - SendRevokeAndACK */; (void) node_id_arr; (void) msg_ref;
1085 case LDKMessageSendEvent_SendClosingSigned: {
1086 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1087 memcpy((uint8_t*)(node_id_arr + 4), obj->send_closing_signed.node_id.compressed_form, 33);
1088 LDKClosingSigned msg_var = obj->send_closing_signed.msg;
1089 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1090 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1091 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1092 return 0 /* LDKMessageSendEvent - SendClosingSigned */; (void) node_id_arr; (void) msg_ref;
1094 case LDKMessageSendEvent_SendShutdown: {
1095 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1096 memcpy((uint8_t*)(node_id_arr + 4), obj->send_shutdown.node_id.compressed_form, 33);
1097 LDKShutdown msg_var = obj->send_shutdown.msg;
1098 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1099 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1100 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1101 return 0 /* LDKMessageSendEvent - SendShutdown */; (void) node_id_arr; (void) msg_ref;
1103 case LDKMessageSendEvent_SendChannelReestablish: {
1104 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1105 memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_reestablish.node_id.compressed_form, 33);
1106 LDKChannelReestablish msg_var = obj->send_channel_reestablish.msg;
1107 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1108 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1109 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1110 return 0 /* LDKMessageSendEvent - SendChannelReestablish */; (void) node_id_arr; (void) msg_ref;
1112 case LDKMessageSendEvent_BroadcastChannelAnnouncement: {
1113 LDKChannelAnnouncement msg_var = obj->broadcast_channel_announcement.msg;
1114 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1115 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1116 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1117 LDKChannelUpdate update_msg_var = obj->broadcast_channel_announcement.update_msg;
1118 CHECK((((uint64_t)update_msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1119 CHECK((((uint64_t)&update_msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1120 uint64_t update_msg_ref = (uint64_t)update_msg_var.inner & ~1;
1121 return 0 /* LDKMessageSendEvent - BroadcastChannelAnnouncement */; (void) msg_ref; (void) update_msg_ref;
1123 case LDKMessageSendEvent_BroadcastNodeAnnouncement: {
1124 LDKNodeAnnouncement msg_var = obj->broadcast_node_announcement.msg;
1125 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1126 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1127 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1128 return 0 /* LDKMessageSendEvent - BroadcastNodeAnnouncement */; (void) msg_ref;
1130 case LDKMessageSendEvent_BroadcastChannelUpdate: {
1131 LDKChannelUpdate msg_var = obj->broadcast_channel_update.msg;
1132 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1133 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1134 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1135 return 0 /* LDKMessageSendEvent - BroadcastChannelUpdate */; (void) msg_ref;
1137 case LDKMessageSendEvent_SendChannelUpdate: {
1138 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1139 memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_update.node_id.compressed_form, 33);
1140 LDKChannelUpdate msg_var = obj->send_channel_update.msg;
1141 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1142 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1143 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1144 return 0 /* LDKMessageSendEvent - SendChannelUpdate */; (void) node_id_arr; (void) msg_ref;
1146 case LDKMessageSendEvent_HandleError: {
1147 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1148 memcpy((uint8_t*)(node_id_arr + 4), obj->handle_error.node_id.compressed_form, 33);
1149 uint64_t action_ref = ((uint64_t)&obj->handle_error.action) | 1;
1150 return 0 /* LDKMessageSendEvent - HandleError */; (void) node_id_arr; (void) action_ref;
1152 case LDKMessageSendEvent_PaymentFailureNetworkUpdate: {
1153 uint64_t update_ref = ((uint64_t)&obj->payment_failure_network_update.update) | 1;
1154 return 0 /* LDKMessageSendEvent - PaymentFailureNetworkUpdate */; (void) update_ref;
1156 case LDKMessageSendEvent_SendChannelRangeQuery: {
1157 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1158 memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_range_query.node_id.compressed_form, 33);
1159 LDKQueryChannelRange msg_var = obj->send_channel_range_query.msg;
1160 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1161 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1162 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1163 return 0 /* LDKMessageSendEvent - SendChannelRangeQuery */; (void) node_id_arr; (void) msg_ref;
1165 case LDKMessageSendEvent_SendShortIdsQuery: {
1166 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1167 memcpy((uint8_t*)(node_id_arr + 4), obj->send_short_ids_query.node_id.compressed_form, 33);
1168 LDKQueryShortChannelIds msg_var = obj->send_short_ids_query.msg;
1169 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1170 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1171 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1172 return 0 /* LDKMessageSendEvent - SendShortIdsQuery */; (void) node_id_arr; (void) msg_ref;
1174 case LDKMessageSendEvent_SendReplyChannelRange: {
1175 int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1176 memcpy((uint8_t*)(node_id_arr + 4), obj->send_reply_channel_range.node_id.compressed_form, 33);
1177 LDKReplyChannelRange msg_var = obj->send_reply_channel_range.msg;
1178 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1179 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1180 uint64_t msg_ref = (uint64_t)msg_var.inner & ~1;
1181 return 0 /* LDKMessageSendEvent - SendReplyChannelRange */; (void) node_id_arr; (void) msg_ref;
1186 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_MessageSendEventZ_new(uint32_tArray elems) {
1187 LDKCVec_MessageSendEventZ *ret = MALLOC(sizeof(LDKCVec_MessageSendEventZ), "LDKCVec_MessageSendEventZ");
1188 ret->datalen = *((uint32_t*)elems);
1189 if (ret->datalen == 0) {
1192 ret->data = MALLOC(sizeof(LDKMessageSendEvent) * ret->datalen, "LDKCVec_MessageSendEventZ Data");
1193 uint32_t *java_elems = (uint32_t*)(elems + 4);
1194 for (size_t i = 0; i < ret->datalen; i++) {
1195 uint32_t arr_elem = java_elems[i];
1196 LDKMessageSendEvent arr_elem_conv = *(LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1);
1197 arr_elem_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)arr_elem) & ~1));
1198 ret->data[i] = arr_elem_conv;
1201 return (uint64_t)ret;
1203 static inline LDKCVec_MessageSendEventZ CVec_MessageSendEventZ_clone(const LDKCVec_MessageSendEventZ *orig) {
1204 LDKCVec_MessageSendEventZ ret = { .data = MALLOC(sizeof(LDKMessageSendEvent) * orig->datalen, "LDKCVec_MessageSendEventZ clone bytes"), .datalen = orig->datalen };
1205 for (size_t i = 0; i < ret.datalen; i++) {
1206 ret.data[i] = MessageSendEvent_clone(&orig->data[i]);
1210 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
1211 return ((LDKCResult_InitFeaturesDecodeErrorZ*)arg)->result_ok;
1213 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
1214 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1215 CHECK(val->result_ok);
1216 LDKInitFeatures res_var = (*val->contents.result);
1217 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1218 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1219 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1222 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitFeaturesDecodeErrorZ_get_err(uint32_t arg) {
1223 LDKCResult_InitFeaturesDecodeErrorZ *val = (LDKCResult_InitFeaturesDecodeErrorZ*)(arg & ~1);
1224 CHECK(!val->result_ok);
1225 LDKDecodeError err_var = (*val->contents.err);
1226 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1227 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1228 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1231 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
1232 return ((LDKCResult_NodeFeaturesDecodeErrorZ*)arg)->result_ok;
1234 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
1235 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1236 CHECK(val->result_ok);
1237 LDKNodeFeatures res_var = (*val->contents.result);
1238 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1239 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1240 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1243 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeFeaturesDecodeErrorZ_get_err(uint32_t arg) {
1244 LDKCResult_NodeFeaturesDecodeErrorZ *val = (LDKCResult_NodeFeaturesDecodeErrorZ*)(arg & ~1);
1245 CHECK(!val->result_ok);
1246 LDKDecodeError err_var = (*val->contents.err);
1247 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1248 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1249 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1252 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
1253 return ((LDKCResult_ChannelFeaturesDecodeErrorZ*)arg)->result_ok;
1255 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
1256 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1257 CHECK(val->result_ok);
1258 LDKChannelFeatures res_var = (*val->contents.result);
1259 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1260 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1261 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1264 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelFeaturesDecodeErrorZ_get_err(uint32_t arg) {
1265 LDKCResult_ChannelFeaturesDecodeErrorZ *val = (LDKCResult_ChannelFeaturesDecodeErrorZ*)(arg & ~1);
1266 CHECK(!val->result_ok);
1267 LDKDecodeError err_var = (*val->contents.err);
1268 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1269 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1270 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1273 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_result_ok(uint32_t arg) {
1274 return ((LDKCResult_InvoiceFeaturesDecodeErrorZ*)arg)->result_ok;
1276 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_get_ok(uint32_t arg) {
1277 LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
1278 CHECK(val->result_ok);
1279 LDKInvoiceFeatures res_var = (*val->contents.result);
1280 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1281 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1282 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1285 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceFeaturesDecodeErrorZ_get_err(uint32_t arg) {
1286 LDKCResult_InvoiceFeaturesDecodeErrorZ *val = (LDKCResult_InvoiceFeaturesDecodeErrorZ*)(arg & ~1);
1287 CHECK(!val->result_ok);
1288 LDKDecodeError err_var = (*val->contents.err);
1289 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1290 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1291 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1294 jboolean __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
1295 return ((LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
1297 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
1298 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
1299 CHECK(val->result_ok);
1300 LDKDelayedPaymentOutputDescriptor res_var = (*val->contents.result);
1301 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1302 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1303 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1306 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ_get_err(uint32_t arg) {
1307 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
1308 CHECK(!val->result_ok);
1309 LDKDecodeError err_var = (*val->contents.err);
1310 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1311 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1312 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1315 jboolean __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
1316 return ((LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)arg)->result_ok;
1318 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
1319 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
1320 CHECK(val->result_ok);
1321 LDKStaticPaymentOutputDescriptor res_var = (*val->contents.result);
1322 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1323 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1324 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1327 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ_get_err(uint32_t arg) {
1328 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ *val = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(arg & ~1);
1329 CHECK(!val->result_ok);
1330 LDKDecodeError err_var = (*val->contents.err);
1331 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1332 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1333 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1336 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_result_ok(uint32_t arg) {
1337 return ((LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)arg)->result_ok;
1339 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_ok(uint32_t arg) {
1340 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
1341 CHECK(val->result_ok);
1342 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
1345 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDescriptorDecodeErrorZ_get_err(uint32_t arg) {
1346 LDKCResult_SpendableOutputDescriptorDecodeErrorZ *val = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(arg & ~1);
1347 CHECK(!val->result_ok);
1348 LDKDecodeError err_var = (*val->contents.err);
1349 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1350 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1351 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1354 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
1355 LDKC2Tuple_SignatureCVec_SignatureZZ* ret = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
1357 CHECK(*((uint32_t*)a) == 64);
1358 memcpy(a_ref.compact_form, (uint8_t*)(a + 4), 64);
1360 LDKCVec_SignatureZ b_constr;
1361 b_constr.datalen = *((uint32_t*)b);
1362 if (b_constr.datalen > 0)
1363 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
1365 b_constr.data = NULL;
1366 int8_tArray* b_vals = (int8_tArray*)(b + 4);
1367 for (size_t m = 0; m < b_constr.datalen; m++) {
1368 int8_tArray b_conv_12 = b_vals[m];
1369 LDKSignature b_conv_12_ref;
1370 CHECK(*((uint32_t*)b_conv_12) == 64);
1371 memcpy(b_conv_12_ref.compact_form, (uint8_t*)(b_conv_12 + 4), 64);
1372 b_constr.data[m] = b_conv_12_ref;
1375 return (uint64_t)ret;
1377 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_get_a(uint32_t ptr) {
1378 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
1379 int8_tArray a_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
1380 memcpy((uint8_t*)(a_arr + 4), tuple->a.compact_form, 64);
1383 ptrArray __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_get_b(uint32_t ptr) {
1384 LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1);
1385 LDKCVec_SignatureZ b_var = tuple->b;
1386 ptrArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
1387 int8_tArray *b_arr_ptr = (int8_tArray*)(b_arr + 4);
1388 for (size_t m = 0; m < b_var.datalen; m++) {
1389 int8_tArray b_conv_12_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
1390 memcpy((uint8_t*)(b_conv_12_arr + 4), b_var.data[m].compact_form, 64);
1391 b_arr_ptr[m] = b_conv_12_arr;
1395 jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(uint32_t arg) {
1396 return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok;
1398 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint32_t arg) {
1399 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
1400 CHECK(val->result_ok);
1401 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
1404 void __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint32_t arg) {
1405 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1);
1406 CHECK(!val->result_ok);
1407 return *val->contents.err;
1409 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_result_ok(uint32_t arg) {
1410 return ((LDKCResult_SignatureNoneZ*)arg)->result_ok;
1412 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_get_ok(uint32_t arg) {
1413 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
1414 CHECK(val->result_ok);
1415 int8_tArray res_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
1416 memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).compact_form, 64);
1419 void __attribute__((visibility("default"))) TS_LDKCResult_SignatureNoneZ_get_err(uint32_t arg) {
1420 LDKCResult_SignatureNoneZ *val = (LDKCResult_SignatureNoneZ*)(arg & ~1);
1421 CHECK(!val->result_ok);
1422 return *val->contents.err;
1424 typedef struct LDKBaseSign_JCalls {
1425 atomic_size_t refcnt;
1426 uint32_t get_per_commitment_point_meth;
1427 uint32_t release_commitment_secret_meth;
1428 uint32_t channel_keys_id_meth;
1429 uint32_t sign_counterparty_commitment_meth;
1430 uint32_t sign_holder_commitment_and_htlcs_meth;
1431 uint32_t sign_justice_revoked_output_meth;
1432 uint32_t sign_justice_revoked_htlc_meth;
1433 uint32_t sign_counterparty_htlc_transaction_meth;
1434 uint32_t sign_closing_transaction_meth;
1435 uint32_t sign_channel_announcement_meth;
1436 uint32_t ready_channel_meth;
1437 } LDKBaseSign_JCalls;
1438 static void LDKBaseSign_JCalls_free(void* this_arg) {
1439 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1440 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1441 js_free(j_calls->get_per_commitment_point_meth);
1442 js_free(j_calls->release_commitment_secret_meth);
1443 js_free(j_calls->channel_keys_id_meth);
1444 js_free(j_calls->sign_counterparty_commitment_meth);
1445 js_free(j_calls->sign_holder_commitment_and_htlcs_meth);
1446 js_free(j_calls->sign_justice_revoked_output_meth);
1447 js_free(j_calls->sign_justice_revoked_htlc_meth);
1448 js_free(j_calls->sign_counterparty_htlc_transaction_meth);
1449 js_free(j_calls->sign_closing_transaction_meth);
1450 js_free(j_calls->sign_channel_announcement_meth);
1451 js_free(j_calls->ready_channel_meth);
1455 LDKPublicKey get_per_commitment_point_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
1456 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1457 int8_tArray ret = js_invoke_function_1(j_calls->get_per_commitment_point_meth, idx);
1458 LDKPublicKey ret_ref;
1459 CHECK(*((uint32_t*)ret) == 33);
1460 memcpy(ret_ref.compressed_form, (uint8_t*)(ret + 4), 33);
1463 LDKThirtyTwoBytes release_commitment_secret_LDKBaseSign_jcall(const void* this_arg, uint64_t idx) {
1464 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1465 int8_tArray ret = js_invoke_function_1(j_calls->release_commitment_secret_meth, idx);
1466 LDKThirtyTwoBytes ret_ref;
1467 CHECK(*((uint32_t*)ret) == 32);
1468 memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
1471 LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) {
1472 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1473 int8_tArray ret = js_invoke_function_0(j_calls->channel_keys_id_meth);
1474 LDKThirtyTwoBytes ret_ref;
1475 CHECK(*((uint32_t*)ret) == 32);
1476 memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
1479 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKCommitmentTransaction * commitment_tx) {
1480 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1481 LDKCommitmentTransaction commitment_tx_var = *commitment_tx;
1482 commitment_tx_var = CommitmentTransaction_clone(commitment_tx);
1483 CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1484 CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1485 uint64_t commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
1486 if (commitment_tx_var.is_owned) {
1487 commitment_tx_ref |= 1;
1489 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)js_invoke_function_1(j_calls->sign_counterparty_commitment_meth, commitment_tx_ref);
1490 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
1491 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
1494 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) {
1495 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1496 LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx;
1497 commitment_tx_var = HolderCommitmentTransaction_clone(commitment_tx);
1498 CHECK((((uint64_t)commitment_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1499 CHECK((((uint64_t)&commitment_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1500 uint64_t commitment_tx_ref = (uint64_t)commitment_tx_var.inner;
1501 if (commitment_tx_var.is_owned) {
1502 commitment_tx_ref |= 1;
1504 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)js_invoke_function_1(j_calls->sign_holder_commitment_and_htlcs_meth, commitment_tx_ref);
1505 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ ret_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1);
1506 ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1));
1509 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]) {
1510 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1511 LDKTransaction justice_tx_var = justice_tx;
1512 int8_tArray justice_tx_arr = init_arr(justice_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1513 memcpy((uint8_t*)(justice_tx_arr + 4), justice_tx_var.data, justice_tx_var.datalen);
1514 Transaction_free(justice_tx_var);
1515 int8_tArray per_commitment_key_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
1516 memcpy((uint8_t*)(per_commitment_key_arr + 4), *per_commitment_key, 32);
1517 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)js_invoke_function_4(j_calls->sign_justice_revoked_output_meth, justice_tx_arr, input, amount, per_commitment_key_arr);
1518 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
1519 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
1522 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) {
1523 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1524 LDKTransaction justice_tx_var = justice_tx;
1525 int8_tArray justice_tx_arr = init_arr(justice_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1526 memcpy((uint8_t*)(justice_tx_arr + 4), justice_tx_var.data, justice_tx_var.datalen);
1527 Transaction_free(justice_tx_var);
1528 int8_tArray per_commitment_key_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
1529 memcpy((uint8_t*)(per_commitment_key_arr + 4), *per_commitment_key, 32);
1530 LDKHTLCOutputInCommitment htlc_var = *htlc;
1531 htlc_var = HTLCOutputInCommitment_clone(htlc);
1532 CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1533 CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1534 uint64_t htlc_ref = (uint64_t)htlc_var.inner;
1535 if (htlc_var.is_owned) {
1538 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)js_invoke_function_5(j_calls->sign_justice_revoked_htlc_meth, justice_tx_arr, input, amount, per_commitment_key_arr, htlc_ref);
1539 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
1540 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
1543 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) {
1544 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1545 LDKTransaction htlc_tx_var = htlc_tx;
1546 int8_tArray htlc_tx_arr = init_arr(htlc_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1547 memcpy((uint8_t*)(htlc_tx_arr + 4), htlc_tx_var.data, htlc_tx_var.datalen);
1548 Transaction_free(htlc_tx_var);
1549 int8_tArray per_commitment_point_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1550 memcpy((uint8_t*)(per_commitment_point_arr + 4), per_commitment_point.compressed_form, 33);
1551 LDKHTLCOutputInCommitment htlc_var = *htlc;
1552 htlc_var = HTLCOutputInCommitment_clone(htlc);
1553 CHECK((((uint64_t)htlc_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1554 CHECK((((uint64_t)&htlc_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1555 uint64_t htlc_ref = (uint64_t)htlc_var.inner;
1556 if (htlc_var.is_owned) {
1559 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)js_invoke_function_5(j_calls->sign_counterparty_htlc_transaction_meth, htlc_tx_arr, input, amount, per_commitment_point_arr, htlc_ref);
1560 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
1561 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
1564 LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction closing_tx) {
1565 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1566 LDKTransaction closing_tx_var = closing_tx;
1567 int8_tArray closing_tx_arr = init_arr(closing_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1568 memcpy((uint8_t*)(closing_tx_arr + 4), closing_tx_var.data, closing_tx_var.datalen);
1569 Transaction_free(closing_tx_var);
1570 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)js_invoke_function_1(j_calls->sign_closing_transaction_meth, closing_tx_arr);
1571 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
1572 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
1575 LDKCResult_SignatureNoneZ sign_channel_announcement_LDKBaseSign_jcall(const void* this_arg, const LDKUnsignedChannelAnnouncement * msg) {
1576 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1577 LDKUnsignedChannelAnnouncement msg_var = *msg;
1578 msg_var = UnsignedChannelAnnouncement_clone(msg);
1579 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1580 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1581 uint64_t msg_ref = (uint64_t)msg_var.inner;
1582 if (msg_var.is_owned) {
1585 LDKCResult_SignatureNoneZ* ret = (LDKCResult_SignatureNoneZ*)js_invoke_function_1(j_calls->sign_channel_announcement_meth, msg_ref);
1586 LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1);
1587 ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1));
1590 void ready_channel_LDKBaseSign_jcall(void* this_arg, const LDKChannelTransactionParameters * channel_parameters) {
1591 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1592 LDKChannelTransactionParameters channel_parameters_var = *channel_parameters;
1593 channel_parameters_var = ChannelTransactionParameters_clone(channel_parameters);
1594 CHECK((((uint64_t)channel_parameters_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1595 CHECK((((uint64_t)&channel_parameters_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1596 uint64_t channel_parameters_ref = (uint64_t)channel_parameters_var.inner;
1597 if (channel_parameters_var.is_owned) {
1598 channel_parameters_ref |= 1;
1600 js_invoke_function_1(j_calls->ready_channel_meth, channel_parameters_ref);
1602 static void* LDKBaseSign_JCalls_clone(const void* this_arg) {
1603 LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg;
1604 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1605 return (void*) this_arg;
1607 static inline LDKBaseSign LDKBaseSign_init (/*TODO: JS Object Reference */void* o, uint32_t pubkeys) {
1608 LDKBaseSign_JCalls *calls = MALLOC(sizeof(LDKBaseSign_JCalls), "LDKBaseSign_JCalls");
1609 atomic_init(&calls->refcnt, 1);
1610 //TODO: Assign calls->o from o
1612 LDKChannelPublicKeys pubkeys_conv;
1613 pubkeys_conv.inner = (void*)(pubkeys & (~1));
1614 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
1615 pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
1618 .this_arg = (void*) calls,
1619 .get_per_commitment_point = get_per_commitment_point_LDKBaseSign_jcall,
1620 .release_commitment_secret = release_commitment_secret_LDKBaseSign_jcall,
1621 .channel_keys_id = channel_keys_id_LDKBaseSign_jcall,
1622 .sign_counterparty_commitment = sign_counterparty_commitment_LDKBaseSign_jcall,
1623 .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKBaseSign_jcall,
1624 .sign_justice_revoked_output = sign_justice_revoked_output_LDKBaseSign_jcall,
1625 .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKBaseSign_jcall,
1626 .sign_counterparty_htlc_transaction = sign_counterparty_htlc_transaction_LDKBaseSign_jcall,
1627 .sign_closing_transaction = sign_closing_transaction_LDKBaseSign_jcall,
1628 .sign_channel_announcement = sign_channel_announcement_LDKBaseSign_jcall,
1629 .ready_channel = ready_channel_LDKBaseSign_jcall,
1630 .free = LDKBaseSign_JCalls_free,
1631 .pubkeys = pubkeys_conv,
1632 .set_pubkeys = NULL,
1636 long __attribute__((visibility("default"))) TS_LDKBaseSign_new(/*TODO: JS Object Reference */void* o, uint32_t pubkeys) {
1637 LDKBaseSign *res_ptr = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
1638 *res_ptr = LDKBaseSign_init(o, pubkeys);
1639 return (long)res_ptr;
1641 int8_tArray __attribute__((visibility("default"))) TS_BaseSign_get_per_commitment_point(uint32_t this_arg, int64_t idx) {
1642 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1643 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
1644 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->get_per_commitment_point)(this_arg_conv->this_arg, idx).compressed_form, 33);
1648 int8_tArray __attribute__((visibility("default"))) TS_BaseSign_release_commitment_secret(uint32_t this_arg, int64_t idx) {
1649 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1650 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
1651 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->release_commitment_secret)(this_arg_conv->this_arg, idx).data, 32);
1655 int8_tArray __attribute__((visibility("default"))) TS_BaseSign_channel_keys_id(uint32_t this_arg) {
1656 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1657 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
1658 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->channel_keys_id)(this_arg_conv->this_arg).data, 32);
1662 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_counterparty_commitment(uint32_t this_arg, uint32_t commitment_tx) {
1663 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1664 LDKCommitmentTransaction commitment_tx_conv;
1665 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
1666 commitment_tx_conv.is_owned = false;
1667 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
1668 *ret_conv = (this_arg_conv->sign_counterparty_commitment)(this_arg_conv->this_arg, &commitment_tx_conv);
1669 return (uint64_t)ret_conv;
1672 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_holder_commitment_and_htlcs(uint32_t this_arg, uint32_t commitment_tx) {
1673 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1674 LDKHolderCommitmentTransaction commitment_tx_conv;
1675 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
1676 commitment_tx_conv.is_owned = false;
1677 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
1678 *ret_conv = (this_arg_conv->sign_holder_commitment_and_htlcs)(this_arg_conv->this_arg, &commitment_tx_conv);
1679 return (uint64_t)ret_conv;
1682 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_justice_revoked_output(uint32_t this_arg, int8_tArray justice_tx, int64_t input, int64_t amount, int8_tArray per_commitment_key) {
1683 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1684 LDKTransaction justice_tx_ref;
1685 justice_tx_ref.datalen = *((uint32_t*)justice_tx);
1686 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
1687 memcpy(justice_tx_ref.data, (uint8_t*)(justice_tx + 4), justice_tx_ref.datalen);
1688 justice_tx_ref.data_is_owned = true;
1689 unsigned char per_commitment_key_arr[32];
1690 CHECK(*((uint32_t*)per_commitment_key) == 32);
1691 memcpy(per_commitment_key_arr, (uint8_t*)(per_commitment_key + 4), 32);
1692 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
1693 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
1694 *ret_conv = (this_arg_conv->sign_justice_revoked_output)(this_arg_conv->this_arg, justice_tx_ref, input, amount, per_commitment_key_ref);
1695 return (uint64_t)ret_conv;
1698 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_justice_revoked_htlc(uint32_t this_arg, int8_tArray justice_tx, int64_t input, int64_t amount, int8_tArray per_commitment_key, uint32_t htlc) {
1699 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1700 LDKTransaction justice_tx_ref;
1701 justice_tx_ref.datalen = *((uint32_t*)justice_tx);
1702 justice_tx_ref.data = MALLOC(justice_tx_ref.datalen, "LDKTransaction Bytes");
1703 memcpy(justice_tx_ref.data, (uint8_t*)(justice_tx + 4), justice_tx_ref.datalen);
1704 justice_tx_ref.data_is_owned = true;
1705 unsigned char per_commitment_key_arr[32];
1706 CHECK(*((uint32_t*)per_commitment_key) == 32);
1707 memcpy(per_commitment_key_arr, (uint8_t*)(per_commitment_key + 4), 32);
1708 unsigned char (*per_commitment_key_ref)[32] = &per_commitment_key_arr;
1709 LDKHTLCOutputInCommitment htlc_conv;
1710 htlc_conv.inner = (void*)(htlc & (~1));
1711 htlc_conv.is_owned = false;
1712 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
1713 *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);
1714 return (uint64_t)ret_conv;
1717 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_counterparty_htlc_transaction(uint32_t this_arg, int8_tArray htlc_tx, int64_t input, int64_t amount, int8_tArray per_commitment_point, uint32_t htlc) {
1718 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1719 LDKTransaction htlc_tx_ref;
1720 htlc_tx_ref.datalen = *((uint32_t*)htlc_tx);
1721 htlc_tx_ref.data = MALLOC(htlc_tx_ref.datalen, "LDKTransaction Bytes");
1722 memcpy(htlc_tx_ref.data, (uint8_t*)(htlc_tx + 4), htlc_tx_ref.datalen);
1723 htlc_tx_ref.data_is_owned = true;
1724 LDKPublicKey per_commitment_point_ref;
1725 CHECK(*((uint32_t*)per_commitment_point) == 33);
1726 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
1727 LDKHTLCOutputInCommitment htlc_conv;
1728 htlc_conv.inner = (void*)(htlc & (~1));
1729 htlc_conv.is_owned = false;
1730 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
1731 *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);
1732 return (uint64_t)ret_conv;
1735 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_closing_transaction(uint32_t this_arg, int8_tArray closing_tx) {
1736 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1737 LDKTransaction closing_tx_ref;
1738 closing_tx_ref.datalen = *((uint32_t*)closing_tx);
1739 closing_tx_ref.data = MALLOC(closing_tx_ref.datalen, "LDKTransaction Bytes");
1740 memcpy(closing_tx_ref.data, (uint8_t*)(closing_tx + 4), closing_tx_ref.datalen);
1741 closing_tx_ref.data_is_owned = true;
1742 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
1743 *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, closing_tx_ref);
1744 return (uint64_t)ret_conv;
1747 uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_channel_announcement(uint32_t this_arg, uint32_t msg) {
1748 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1749 LDKUnsignedChannelAnnouncement msg_conv;
1750 msg_conv.inner = (void*)(msg & (~1));
1751 msg_conv.is_owned = false;
1752 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
1753 *ret_conv = (this_arg_conv->sign_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
1754 return (uint64_t)ret_conv;
1757 void __attribute__((visibility("default"))) TS_BaseSign_ready_channel(uint32_t this_arg, uint32_t channel_parameters) {
1758 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1759 LDKChannelTransactionParameters channel_parameters_conv;
1760 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
1761 channel_parameters_conv.is_owned = false;
1762 (this_arg_conv->ready_channel)(this_arg_conv->this_arg, &channel_parameters_conv);
1765 LDKChannelPublicKeys LDKBaseSign_set_get_pubkeys(LDKBaseSign* this_arg) {
1766 if (this_arg->set_pubkeys != NULL)
1767 this_arg->set_pubkeys(this_arg);
1768 return this_arg->pubkeys;
1770 uint32_t __attribute__((visibility("default"))) TS_BaseSign_get_pubkeys(uint32_t this_arg) {
1771 LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1);
1772 LDKChannelPublicKeys ret_var = LDKBaseSign_set_get_pubkeys(this_arg_conv);
1773 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1774 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1775 uint64_t ret_ref = (uint64_t)ret_var.inner;
1776 if (ret_var.is_owned) {
1782 typedef struct LDKSign_JCalls {
1783 atomic_size_t refcnt;
1784 LDKBaseSign_JCalls* BaseSign;
1785 uint32_t write_meth;
1787 static void LDKSign_JCalls_free(void* this_arg) {
1788 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
1789 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
1790 js_free(j_calls->write_meth);
1794 LDKCVec_u8Z write_LDKSign_jcall(const void* this_arg) {
1795 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
1796 int8_tArray ret = js_invoke_function_0(j_calls->write_meth);
1797 LDKCVec_u8Z ret_ref;
1798 ret_ref.datalen = *((uint32_t*)ret);
1799 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
1800 memcpy(ret_ref.data, (uint8_t*)(ret + 4), ret_ref.datalen);
1803 static void* LDKSign_JCalls_clone(const void* this_arg) {
1804 LDKSign_JCalls *j_calls = (LDKSign_JCalls*) this_arg;
1805 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
1806 atomic_fetch_add_explicit(&j_calls->BaseSign->refcnt, 1, memory_order_release);
1807 return (void*) this_arg;
1809 static inline LDKSign LDKSign_init (/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */void* BaseSign, uint32_t pubkeys) {
1810 LDKSign_JCalls *calls = MALLOC(sizeof(LDKSign_JCalls), "LDKSign_JCalls");
1811 atomic_init(&calls->refcnt, 1);
1812 //TODO: Assign calls->o from o
1814 LDKChannelPublicKeys pubkeys_conv;
1815 pubkeys_conv.inner = (void*)(pubkeys & (~1));
1816 pubkeys_conv.is_owned = (pubkeys & 1) || (pubkeys == 0);
1817 pubkeys_conv = ChannelPublicKeys_clone(&pubkeys_conv);
1820 .this_arg = (void*) calls,
1821 .write = write_LDKSign_jcall,
1822 .clone = LDKSign_JCalls_clone,
1823 .free = LDKSign_JCalls_free,
1824 .BaseSign = LDKBaseSign_init(BaseSign, pubkeys),
1826 calls->BaseSign = ret.BaseSign.this_arg;
1829 long __attribute__((visibility("default"))) TS_LDKSign_new(/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */ void* BaseSign, uint32_t pubkeys) {
1830 LDKSign *res_ptr = MALLOC(sizeof(LDKSign), "LDKSign");
1831 *res_ptr = LDKSign_init(o, BaseSign, pubkeys);
1832 return (long)res_ptr;
1834 int8_tArray __attribute__((visibility("default"))) TS_Sign_write(uint32_t this_arg) {
1835 LDKSign* this_arg_conv = (LDKSign*)(((uint64_t)this_arg) & ~1);
1836 LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg);
1837 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1838 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
1839 CVec_u8Z_free(ret_var);
1843 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_result_ok(uint32_t arg) {
1844 return ((LDKCResult_SignDecodeErrorZ*)arg)->result_ok;
1846 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_ok(uint32_t arg) {
1847 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
1848 CHECK(val->result_ok);
1849 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
1850 *ret = Sign_clone(&(*val->contents.result));
1851 return (uint64_t)ret;
1853 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_err(uint32_t arg) {
1854 LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1);
1855 CHECK(!val->result_ok);
1856 LDKDecodeError err_var = (*val->contents.err);
1857 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1858 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1859 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1862 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_result_ok(uint32_t arg) {
1863 return ((LDKCResult_RecoverableSignatureNoneZ*)arg)->result_ok;
1865 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_get_ok(uint32_t arg) {
1866 LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
1867 CHECK(val->result_ok);
1868 int8_tArray es_arr = init_arr(68, sizeof(uint8_t), "Native int8_tArray Bytes");
1869 memcpy((uint8_t*)(es_arr + 4), (*val->contents.result).serialized_form, 68);
1872 void __attribute__((visibility("default"))) TS_LDKCResult_RecoverableSignatureNoneZ_get_err(uint32_t arg) {
1873 LDKCResult_RecoverableSignatureNoneZ *val = (LDKCResult_RecoverableSignatureNoneZ*)(arg & ~1);
1874 CHECK(!val->result_ok);
1875 return *val->contents.err;
1877 static inline LDKCVec_CVec_u8ZZ CVec_CVec_u8ZZ_clone(const LDKCVec_CVec_u8ZZ *orig) {
1878 LDKCVec_CVec_u8ZZ ret = { .data = MALLOC(sizeof(LDKCVec_u8Z) * orig->datalen, "LDKCVec_CVec_u8ZZ clone bytes"), .datalen = orig->datalen };
1879 for (size_t i = 0; i < ret.datalen; i++) {
1880 ret.data[i] = CVec_u8Z_clone(&orig->data[i]);
1884 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_result_ok(uint32_t arg) {
1885 return ((LDKCResult_CVec_CVec_u8ZZNoneZ*)arg)->result_ok;
1887 ptrArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_get_ok(uint32_t arg) {
1888 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
1889 CHECK(val->result_ok);
1890 LDKCVec_CVec_u8ZZ res_var = (*val->contents.result);
1891 ptrArray res_arr = init_arr(res_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
1892 int8_tArray *res_arr_ptr = (int8_tArray*)(res_arr + 4);
1893 for (size_t m = 0; m < res_var.datalen; m++) {
1894 LDKCVec_u8Z res_conv_12_var = res_var.data[m];
1895 int8_tArray res_conv_12_arr = init_arr(res_conv_12_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1896 memcpy((uint8_t*)(res_conv_12_arr + 4), res_conv_12_var.data, res_conv_12_var.datalen);
1897 res_arr_ptr[m] = res_conv_12_arr;
1901 void __attribute__((visibility("default"))) TS_LDKCResult_CVec_CVec_u8ZZNoneZ_get_err(uint32_t arg) {
1902 LDKCResult_CVec_CVec_u8ZZNoneZ *val = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(arg & ~1);
1903 CHECK(!val->result_ok);
1904 return *val->contents.err;
1906 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_result_ok(uint32_t arg) {
1907 return ((LDKCResult_InMemorySignerDecodeErrorZ*)arg)->result_ok;
1909 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_get_ok(uint32_t arg) {
1910 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
1911 CHECK(val->result_ok);
1912 LDKInMemorySigner res_var = (*val->contents.result);
1913 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1914 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1915 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
1918 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InMemorySignerDecodeErrorZ_get_err(uint32_t arg) {
1919 LDKCResult_InMemorySignerDecodeErrorZ *val = (LDKCResult_InMemorySignerDecodeErrorZ*)(arg & ~1);
1920 CHECK(!val->result_ok);
1921 LDKDecodeError err_var = (*val->contents.err);
1922 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1923 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1924 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
1927 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_TxOutZ_new(uint32_tArray elems) {
1928 LDKCVec_TxOutZ *ret = MALLOC(sizeof(LDKCVec_TxOutZ), "LDKCVec_TxOutZ");
1929 ret->datalen = *((uint32_t*)elems);
1930 if (ret->datalen == 0) {
1933 ret->data = MALLOC(sizeof(LDKTxOut) * ret->datalen, "LDKCVec_TxOutZ Data");
1934 uint32_t *java_elems = (uint32_t*)(elems + 4);
1935 for (size_t i = 0; i < ret->datalen; i++) {
1936 uint32_t arr_elem = java_elems[i];
1937 LDKTxOut arr_elem_conv = *(LDKTxOut*)(((uint64_t)arr_elem) & ~1);
1938 arr_elem_conv = TxOut_clone((LDKTxOut*)(((uint64_t)arr_elem) & ~1));
1939 ret->data[i] = arr_elem_conv;
1942 return (uint64_t)ret;
1944 static inline LDKCVec_TxOutZ CVec_TxOutZ_clone(const LDKCVec_TxOutZ *orig) {
1945 LDKCVec_TxOutZ ret = { .data = MALLOC(sizeof(LDKTxOut) * orig->datalen, "LDKCVec_TxOutZ clone bytes"), .datalen = orig->datalen };
1946 for (size_t i = 0; i < ret.datalen; i++) {
1947 ret.data[i] = TxOut_clone(&orig->data[i]);
1951 jboolean __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_result_ok(uint32_t arg) {
1952 return ((LDKCResult_TransactionNoneZ*)arg)->result_ok;
1954 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_get_ok(uint32_t arg) {
1955 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
1956 CHECK(val->result_ok);
1957 LDKTransaction res_var = (*val->contents.result);
1958 int8_tArray res_arr = init_arr(res_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
1959 memcpy((uint8_t*)(res_arr + 4), res_var.data, res_var.datalen);
1962 void __attribute__((visibility("default"))) TS_LDKCResult_TransactionNoneZ_get_err(uint32_t arg) {
1963 LDKCResult_TransactionNoneZ *val = (LDKCResult_TransactionNoneZ*)(arg & ~1);
1964 CHECK(!val->result_ok);
1965 return *val->contents.err;
1967 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint32_t b) {
1968 LDKC2Tuple_BlockHashChannelMonitorZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
1969 LDKThirtyTwoBytes a_ref;
1970 CHECK(*((uint32_t*)a) == 32);
1971 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
1973 LDKChannelMonitor b_conv;
1974 b_conv.inner = (void*)(b & (~1));
1975 b_conv.is_owned = (b & 1) || (b == 0);
1976 b_conv = ChannelMonitor_clone(&b_conv);
1978 return (uint64_t)ret;
1980 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelMonitorZ_get_a(uint32_t ptr) {
1981 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
1982 int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
1983 memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32);
1986 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelMonitorZ_get_b(uint32_t ptr) {
1987 LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1);
1988 LDKChannelMonitor b_var = tuple->b;
1989 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
1990 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
1991 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
1994 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(uint32_tArray elems) {
1995 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ");
1996 ret->datalen = *((uint32_t*)elems);
1997 if (ret->datalen == 0) {
2000 ret->data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * ret->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Data");
2001 uint32_t *java_elems = (uint32_t*)(elems + 4);
2002 for (size_t i = 0; i < ret->datalen; i++) {
2003 uint32_t arr_elem = java_elems[i];
2004 LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1);
2005 // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ
2006 ret->data[i] = arr_elem_conv;
2009 return (uint64_t)ret;
2011 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(uint32_t arg) {
2012 return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok;
2014 uint32_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_ok(uint32_t arg) {
2015 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
2016 CHECK(val->result_ok);
2017 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res_var = (*val->contents.result);
2018 uint32_tArray res_arr = init_arr(res_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
2019 uint32_t *res_arr_ptr = (uint32_t*)(res_arr + 4);
2020 for (size_t m = 0; m < res_var.datalen; m++) {
2021 uint64_t res_conv_38_ref = (uint64_t)(&res_var.data[m]) | 1;
2022 res_arr_ptr[m] = res_conv_38_ref;
2026 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_get_err(uint32_t arg) {
2027 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ *val = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(arg & ~1);
2028 CHECK(!val->result_ok);
2029 uint32_t err_conv = LDKIOError_to_js((*val->contents.err));
2032 uint32_t __attribute__((visibility("default"))) TS_LDKCOption_u16Z_ref_from_ptr(uint32_t ptr) {
2033 LDKCOption_u16Z *obj = (LDKCOption_u16Z*)(ptr & ~1);
2035 case LDKCOption_u16Z_Some: {
2036 return 0 /* LDKCOption_u16Z - Some */; (void) obj->some;
2038 case LDKCOption_u16Z_None: {
2039 return 0 /* LDKCOption_u16Z - None */;
2044 uint32_t __attribute__((visibility("default"))) TS_LDKAPIError_ref_from_ptr(uint32_t ptr) {
2045 LDKAPIError *obj = (LDKAPIError*)(ptr & ~1);
2047 case LDKAPIError_APIMisuseError: {
2048 LDKStr err_str = obj->api_misuse_error.err;
2049 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2050 return 0 /* LDKAPIError - APIMisuseError */; (void) err_conv;
2052 case LDKAPIError_FeeRateTooHigh: {
2053 LDKStr err_str = obj->fee_rate_too_high.err;
2054 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2055 return 0 /* LDKAPIError - FeeRateTooHigh */; (void) err_conv; (void) obj->fee_rate_too_high.feerate;
2057 case LDKAPIError_RouteError: {
2058 LDKStr err_str = obj->route_error.err;
2059 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2060 return 0 /* LDKAPIError - RouteError */; (void) err_conv;
2062 case LDKAPIError_ChannelUnavailable: {
2063 LDKStr err_str = obj->channel_unavailable.err;
2064 jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len);
2065 return 0 /* LDKAPIError - ChannelUnavailable */; (void) err_conv;
2067 case LDKAPIError_MonitorUpdateFailed: {
2068 return 0 /* LDKAPIError - MonitorUpdateFailed */;
2073 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_result_ok(uint32_t arg) {
2074 return ((LDKCResult_NoneAPIErrorZ*)arg)->result_ok;
2076 void __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_get_ok(uint32_t arg) {
2077 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
2078 CHECK(val->result_ok);
2079 return *val->contents.result;
2081 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneAPIErrorZ_get_err(uint32_t arg) {
2082 LDKCResult_NoneAPIErrorZ *val = (LDKCResult_NoneAPIErrorZ*)(arg & ~1);
2083 CHECK(!val->result_ok);
2084 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
2087 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_CResult_NoneAPIErrorZZ_new(uint32_tArray elems) {
2088 LDKCVec_CResult_NoneAPIErrorZZ *ret = MALLOC(sizeof(LDKCVec_CResult_NoneAPIErrorZZ), "LDKCVec_CResult_NoneAPIErrorZZ");
2089 ret->datalen = *((uint32_t*)elems);
2090 if (ret->datalen == 0) {
2093 ret->data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * ret->datalen, "LDKCVec_CResult_NoneAPIErrorZZ Data");
2094 uint32_t *java_elems = (uint32_t*)(elems + 4);
2095 for (size_t i = 0; i < ret->datalen; i++) {
2096 uint32_t arr_elem = java_elems[i];
2097 LDKCResult_NoneAPIErrorZ arr_elem_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1);
2098 arr_elem_conv = CResult_NoneAPIErrorZ_clone((LDKCResult_NoneAPIErrorZ*)(((uint64_t)arr_elem) & ~1));
2099 ret->data[i] = arr_elem_conv;
2102 return (uint64_t)ret;
2104 static inline LDKCVec_CResult_NoneAPIErrorZZ CVec_CResult_NoneAPIErrorZZ_clone(const LDKCVec_CResult_NoneAPIErrorZZ *orig) {
2105 LDKCVec_CResult_NoneAPIErrorZZ ret = { .data = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ) * orig->datalen, "LDKCVec_CResult_NoneAPIErrorZZ clone bytes"), .datalen = orig->datalen };
2106 for (size_t i = 0; i < ret.datalen; i++) {
2107 ret.data[i] = CResult_NoneAPIErrorZ_clone(&orig->data[i]);
2111 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_APIErrorZ_new(uint32_tArray elems) {
2112 LDKCVec_APIErrorZ *ret = MALLOC(sizeof(LDKCVec_APIErrorZ), "LDKCVec_APIErrorZ");
2113 ret->datalen = *((uint32_t*)elems);
2114 if (ret->datalen == 0) {
2117 ret->data = MALLOC(sizeof(LDKAPIError) * ret->datalen, "LDKCVec_APIErrorZ Data");
2118 uint32_t *java_elems = (uint32_t*)(elems + 4);
2119 for (size_t i = 0; i < ret->datalen; i++) {
2120 uint32_t arr_elem = java_elems[i];
2121 LDKAPIError arr_elem_conv = *(LDKAPIError*)(((uint64_t)arr_elem) & ~1);
2122 arr_elem_conv = APIError_clone((LDKAPIError*)(((uint64_t)arr_elem) & ~1));
2123 ret->data[i] = arr_elem_conv;
2126 return (uint64_t)ret;
2128 static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *orig) {
2129 LDKCVec_APIErrorZ ret = { .data = MALLOC(sizeof(LDKAPIError) * orig->datalen, "LDKCVec_APIErrorZ clone bytes"), .datalen = orig->datalen };
2130 for (size_t i = 0; i < ret.datalen; i++) {
2131 ret.data[i] = APIError_clone(&orig->data[i]);
2135 uint32_t __attribute__((visibility("default"))) TS_LDKPaymentSendFailure_ref_from_ptr(uint32_t ptr) {
2136 LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1);
2138 case LDKPaymentSendFailure_ParameterError: {
2139 uint64_t parameter_error_ref = ((uint64_t)&obj->parameter_error) | 1;
2140 return 0 /* LDKPaymentSendFailure - ParameterError */; (void) parameter_error_ref;
2142 case LDKPaymentSendFailure_PathParameterError: {
2143 LDKCVec_CResult_NoneAPIErrorZZ path_parameter_error_var = obj->path_parameter_error;
2144 uint32_tArray path_parameter_error_arr = init_arr(path_parameter_error_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
2145 uint32_t *path_parameter_error_arr_ptr = (uint32_t*)(path_parameter_error_arr + 4);
2146 for (size_t w = 0; w < path_parameter_error_var.datalen; w++) {
2147 LDKCResult_NoneAPIErrorZ* path_parameter_error_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
2148 *path_parameter_error_conv_22_conv = path_parameter_error_var.data[w];
2149 *path_parameter_error_conv_22_conv = CResult_NoneAPIErrorZ_clone(path_parameter_error_conv_22_conv);
2150 path_parameter_error_arr_ptr[w] = (uint64_t)path_parameter_error_conv_22_conv;
2152 return 0 /* LDKPaymentSendFailure - PathParameterError */; (void) path_parameter_error_arr;
2154 case LDKPaymentSendFailure_AllFailedRetrySafe: {
2155 LDKCVec_APIErrorZ all_failed_retry_safe_var = obj->all_failed_retry_safe;
2156 uint32_tArray all_failed_retry_safe_arr = init_arr(all_failed_retry_safe_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
2157 uint32_t *all_failed_retry_safe_arr_ptr = (uint32_t*)(all_failed_retry_safe_arr + 4);
2158 for (size_t k = 0; k < all_failed_retry_safe_var.datalen; k++) {
2159 uint64_t all_failed_retry_safe_conv_10_ref = ((uint64_t)&all_failed_retry_safe_var.data[k]) | 1;
2160 all_failed_retry_safe_arr_ptr[k] = all_failed_retry_safe_conv_10_ref;
2162 return 0 /* LDKPaymentSendFailure - AllFailedRetrySafe */; (void) all_failed_retry_safe_arr;
2164 case LDKPaymentSendFailure_PartialFailure: {
2165 LDKCVec_CResult_NoneAPIErrorZZ partial_failure_var = obj->partial_failure;
2166 uint32_tArray partial_failure_arr = init_arr(partial_failure_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
2167 uint32_t *partial_failure_arr_ptr = (uint32_t*)(partial_failure_arr + 4);
2168 for (size_t w = 0; w < partial_failure_var.datalen; w++) {
2169 LDKCResult_NoneAPIErrorZ* partial_failure_conv_22_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
2170 *partial_failure_conv_22_conv = partial_failure_var.data[w];
2171 *partial_failure_conv_22_conv = CResult_NoneAPIErrorZ_clone(partial_failure_conv_22_conv);
2172 partial_failure_arr_ptr[w] = (uint64_t)partial_failure_conv_22_conv;
2174 return 0 /* LDKPaymentSendFailure - PartialFailure */; (void) partial_failure_arr;
2179 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_result_ok(uint32_t arg) {
2180 return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok;
2182 void __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_ok(uint32_t arg) {
2183 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
2184 CHECK(val->result_ok);
2185 return *val->contents.result;
2187 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_get_err(uint32_t arg) {
2188 LDKCResult_NonePaymentSendFailureZ *val = (LDKCResult_NonePaymentSendFailureZ*)(arg & ~1);
2189 CHECK(!val->result_ok);
2190 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
2193 uint32_t __attribute__((visibility("default"))) TS_LDKNetAddress_ref_from_ptr(uint32_t ptr) {
2194 LDKNetAddress *obj = (LDKNetAddress*)(ptr & ~1);
2196 case LDKNetAddress_IPv4: {
2197 int8_tArray addr_arr = init_arr(4, sizeof(uint8_t), "Native int8_tArray Bytes");
2198 memcpy((uint8_t*)(addr_arr + 4), obj->i_pv4.addr.data, 4);
2199 return 0 /* LDKNetAddress - IPv4 */; (void) addr_arr; (void) obj->i_pv4.port;
2201 case LDKNetAddress_IPv6: {
2202 int8_tArray addr_arr = init_arr(16, sizeof(uint8_t), "Native int8_tArray Bytes");
2203 memcpy((uint8_t*)(addr_arr + 4), obj->i_pv6.addr.data, 16);
2204 return 0 /* LDKNetAddress - IPv6 */; (void) addr_arr; (void) obj->i_pv6.port;
2206 case LDKNetAddress_OnionV2: {
2207 int8_tArray addr_arr = init_arr(10, sizeof(uint8_t), "Native int8_tArray Bytes");
2208 memcpy((uint8_t*)(addr_arr + 4), obj->onion_v2.addr.data, 10);
2209 return 0 /* LDKNetAddress - OnionV2 */; (void) addr_arr; (void) obj->onion_v2.port;
2211 case LDKNetAddress_OnionV3: {
2212 int8_tArray ed25519_pubkey_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2213 memcpy((uint8_t*)(ed25519_pubkey_arr + 4), obj->onion_v3.ed25519_pubkey.data, 32);
2214 return 0 /* LDKNetAddress - OnionV3 */; (void) ed25519_pubkey_arr; (void) obj->onion_v3.checksum; (void) obj->onion_v3.version; (void) obj->onion_v3.port;
2219 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NetAddressZ_new(uint32_tArray elems) {
2220 LDKCVec_NetAddressZ *ret = MALLOC(sizeof(LDKCVec_NetAddressZ), "LDKCVec_NetAddressZ");
2221 ret->datalen = *((uint32_t*)elems);
2222 if (ret->datalen == 0) {
2225 ret->data = MALLOC(sizeof(LDKNetAddress) * ret->datalen, "LDKCVec_NetAddressZ Data");
2226 uint32_t *java_elems = (uint32_t*)(elems + 4);
2227 for (size_t i = 0; i < ret->datalen; i++) {
2228 uint32_t arr_elem = java_elems[i];
2229 LDKNetAddress arr_elem_conv = *(LDKNetAddress*)(((uint64_t)arr_elem) & ~1);
2230 arr_elem_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)arr_elem) & ~1));
2231 ret->data[i] = arr_elem_conv;
2234 return (uint64_t)ret;
2236 static inline LDKCVec_NetAddressZ CVec_NetAddressZ_clone(const LDKCVec_NetAddressZ *orig) {
2237 LDKCVec_NetAddressZ ret = { .data = MALLOC(sizeof(LDKNetAddress) * orig->datalen, "LDKCVec_NetAddressZ clone bytes"), .datalen = orig->datalen };
2238 for (size_t i = 0; i < ret.datalen; i++) {
2239 ret.data[i] = NetAddress_clone(&orig->data[i]);
2243 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
2244 LDKC2Tuple_PaymentHashPaymentSecretZ* ret = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
2245 LDKThirtyTwoBytes a_ref;
2246 CHECK(*((uint32_t*)a) == 32);
2247 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
2249 LDKThirtyTwoBytes b_ref;
2250 CHECK(*((uint32_t*)b) == 32);
2251 memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
2253 return (uint64_t)ret;
2255 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentSecretZ_get_a(uint32_t ptr) {
2256 LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1);
2257 int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2258 memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32);
2261 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentSecretZ_get_b(uint32_t ptr) {
2262 LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1);
2263 int8_tArray b_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2264 memcpy((uint8_t*)(b_arr + 4), tuple->b.data, 32);
2267 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_result_ok(uint32_t arg) {
2268 return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok;
2270 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_get_ok(uint32_t arg) {
2271 LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
2272 CHECK(val->result_ok);
2273 int8_tArray res_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2274 memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).data, 32);
2277 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_get_err(uint32_t arg) {
2278 LDKCResult_PaymentSecretAPIErrorZ *val = (LDKCResult_PaymentSecretAPIErrorZ*)(arg & ~1);
2279 CHECK(!val->result_ok);
2280 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
2283 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_ChannelMonitorZ_new(uint32_tArray elems) {
2284 LDKCVec_ChannelMonitorZ *ret = MALLOC(sizeof(LDKCVec_ChannelMonitorZ), "LDKCVec_ChannelMonitorZ");
2285 ret->datalen = *((uint32_t*)elems);
2286 if (ret->datalen == 0) {
2289 ret->data = MALLOC(sizeof(LDKChannelMonitor) * ret->datalen, "LDKCVec_ChannelMonitorZ Data");
2290 uint32_t *java_elems = (uint32_t*)(elems + 4);
2291 for (size_t i = 0; i < ret->datalen; i++) {
2292 uint32_t arr_elem = java_elems[i];
2293 LDKChannelMonitor arr_elem_conv;
2294 arr_elem_conv.inner = (void*)(arr_elem & (~1));
2295 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
2296 arr_elem_conv = ChannelMonitor_clone(&arr_elem_conv);
2297 ret->data[i] = arr_elem_conv;
2300 return (uint64_t)ret;
2302 static inline LDKCVec_ChannelMonitorZ CVec_ChannelMonitorZ_clone(const LDKCVec_ChannelMonitorZ *orig) {
2303 LDKCVec_ChannelMonitorZ ret = { .data = MALLOC(sizeof(LDKChannelMonitor) * orig->datalen, "LDKCVec_ChannelMonitorZ clone bytes"), .datalen = orig->datalen };
2304 for (size_t i = 0; i < ret.datalen; i++) {
2305 ret.data[i] = ChannelMonitor_clone(&orig->data[i]);
2309 typedef struct LDKWatch_JCalls {
2310 atomic_size_t refcnt;
2311 uint32_t watch_channel_meth;
2312 uint32_t update_channel_meth;
2313 uint32_t release_pending_monitor_events_meth;
2315 static void LDKWatch_JCalls_free(void* this_arg) {
2316 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2317 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2318 js_free(j_calls->watch_channel_meth);
2319 js_free(j_calls->update_channel_meth);
2320 js_free(j_calls->release_pending_monitor_events_meth);
2324 LDKCResult_NoneChannelMonitorUpdateErrZ watch_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitor monitor) {
2325 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2326 LDKOutPoint funding_txo_var = funding_txo;
2327 CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2328 CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2329 uint64_t funding_txo_ref = (uint64_t)funding_txo_var.inner;
2330 if (funding_txo_var.is_owned) {
2331 funding_txo_ref |= 1;
2333 LDKChannelMonitor monitor_var = monitor;
2334 CHECK((((uint64_t)monitor_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2335 CHECK((((uint64_t)&monitor_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2336 uint64_t monitor_ref = (uint64_t)monitor_var.inner;
2337 if (monitor_var.is_owned) {
2340 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_2(j_calls->watch_channel_meth, funding_txo_ref, monitor_ref);
2341 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
2342 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
2345 LDKCResult_NoneChannelMonitorUpdateErrZ update_channel_LDKWatch_jcall(const void* this_arg, LDKOutPoint funding_txo, LDKChannelMonitorUpdate update) {
2346 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2347 LDKOutPoint funding_txo_var = funding_txo;
2348 CHECK((((uint64_t)funding_txo_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2349 CHECK((((uint64_t)&funding_txo_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2350 uint64_t funding_txo_ref = (uint64_t)funding_txo_var.inner;
2351 if (funding_txo_var.is_owned) {
2352 funding_txo_ref |= 1;
2354 LDKChannelMonitorUpdate update_var = update;
2355 CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2356 CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2357 uint64_t update_ref = (uint64_t)update_var.inner;
2358 if (update_var.is_owned) {
2361 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_2(j_calls->update_channel_meth, funding_txo_ref, update_ref);
2362 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
2363 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
2366 LDKCVec_MonitorEventZ release_pending_monitor_events_LDKWatch_jcall(const void* this_arg) {
2367 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2368 uint32_tArray ret = js_invoke_function_0(j_calls->release_pending_monitor_events_meth);
2369 LDKCVec_MonitorEventZ ret_constr;
2370 ret_constr.datalen = *((uint32_t*)ret);
2371 if (ret_constr.datalen > 0)
2372 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
2374 ret_constr.data = NULL;
2375 uint32_t* ret_vals = (uint32_t*)(ret + 4);
2376 for (size_t o = 0; o < ret_constr.datalen; o++) {
2377 uint32_t ret_conv_14 = ret_vals[o];
2378 LDKMonitorEvent ret_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1);
2379 ret_conv_14_conv = MonitorEvent_clone((LDKMonitorEvent*)(((uint64_t)ret_conv_14) & ~1));
2380 ret_constr.data[o] = ret_conv_14_conv;
2384 static void* LDKWatch_JCalls_clone(const void* this_arg) {
2385 LDKWatch_JCalls *j_calls = (LDKWatch_JCalls*) this_arg;
2386 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2387 return (void*) this_arg;
2389 static inline LDKWatch LDKWatch_init (/*TODO: JS Object Reference */void* o) {
2390 LDKWatch_JCalls *calls = MALLOC(sizeof(LDKWatch_JCalls), "LDKWatch_JCalls");
2391 atomic_init(&calls->refcnt, 1);
2392 //TODO: Assign calls->o from o
2395 .this_arg = (void*) calls,
2396 .watch_channel = watch_channel_LDKWatch_jcall,
2397 .update_channel = update_channel_LDKWatch_jcall,
2398 .release_pending_monitor_events = release_pending_monitor_events_LDKWatch_jcall,
2399 .free = LDKWatch_JCalls_free,
2403 long __attribute__((visibility("default"))) TS_LDKWatch_new(/*TODO: JS Object Reference */void* o) {
2404 LDKWatch *res_ptr = MALLOC(sizeof(LDKWatch), "LDKWatch");
2405 *res_ptr = LDKWatch_init(o);
2406 return (long)res_ptr;
2408 uint32_t __attribute__((visibility("default"))) TS_Watch_watch_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t monitor) {
2409 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
2410 LDKOutPoint funding_txo_conv;
2411 funding_txo_conv.inner = (void*)(funding_txo & (~1));
2412 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
2413 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
2414 LDKChannelMonitor monitor_conv;
2415 monitor_conv.inner = (void*)(monitor & (~1));
2416 monitor_conv.is_owned = (monitor & 1) || (monitor == 0);
2417 monitor_conv = ChannelMonitor_clone(&monitor_conv);
2418 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
2419 *ret_conv = (this_arg_conv->watch_channel)(this_arg_conv->this_arg, funding_txo_conv, monitor_conv);
2420 return (uint64_t)ret_conv;
2423 uint32_t __attribute__((visibility("default"))) TS_Watch_update_channel(uint32_t this_arg, uint32_t funding_txo, uint32_t update) {
2424 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
2425 LDKOutPoint funding_txo_conv;
2426 funding_txo_conv.inner = (void*)(funding_txo & (~1));
2427 funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0);
2428 funding_txo_conv = OutPoint_clone(&funding_txo_conv);
2429 LDKChannelMonitorUpdate update_conv;
2430 update_conv.inner = (void*)(update & (~1));
2431 update_conv.is_owned = (update & 1) || (update == 0);
2432 update_conv = ChannelMonitorUpdate_clone(&update_conv);
2433 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
2434 *ret_conv = (this_arg_conv->update_channel)(this_arg_conv->this_arg, funding_txo_conv, update_conv);
2435 return (uint64_t)ret_conv;
2438 uint32_tArray __attribute__((visibility("default"))) TS_Watch_release_pending_monitor_events(uint32_t this_arg) {
2439 LDKWatch* this_arg_conv = (LDKWatch*)(((uint64_t)this_arg) & ~1);
2440 LDKCVec_MonitorEventZ ret_var = (this_arg_conv->release_pending_monitor_events)(this_arg_conv->this_arg);
2441 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
2442 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
2443 for (size_t o = 0; o < ret_var.datalen; o++) {
2444 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
2445 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
2446 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_copy;
2447 ret_arr_ptr[o] = ret_conv_14_ref;
2453 typedef struct LDKBroadcasterInterface_JCalls {
2454 atomic_size_t refcnt;
2455 uint32_t broadcast_transaction_meth;
2456 } LDKBroadcasterInterface_JCalls;
2457 static void LDKBroadcasterInterface_JCalls_free(void* this_arg) {
2458 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
2459 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2460 js_free(j_calls->broadcast_transaction_meth);
2464 void broadcast_transaction_LDKBroadcasterInterface_jcall(const void* this_arg, LDKTransaction tx) {
2465 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
2466 LDKTransaction tx_var = tx;
2467 int8_tArray tx_arr = init_arr(tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
2468 memcpy((uint8_t*)(tx_arr + 4), tx_var.data, tx_var.datalen);
2469 Transaction_free(tx_var);
2470 js_invoke_function_1(j_calls->broadcast_transaction_meth, tx_arr);
2472 static void* LDKBroadcasterInterface_JCalls_clone(const void* this_arg) {
2473 LDKBroadcasterInterface_JCalls *j_calls = (LDKBroadcasterInterface_JCalls*) this_arg;
2474 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2475 return (void*) this_arg;
2477 static inline LDKBroadcasterInterface LDKBroadcasterInterface_init (/*TODO: JS Object Reference */void* o) {
2478 LDKBroadcasterInterface_JCalls *calls = MALLOC(sizeof(LDKBroadcasterInterface_JCalls), "LDKBroadcasterInterface_JCalls");
2479 atomic_init(&calls->refcnt, 1);
2480 //TODO: Assign calls->o from o
2482 LDKBroadcasterInterface ret = {
2483 .this_arg = (void*) calls,
2484 .broadcast_transaction = broadcast_transaction_LDKBroadcasterInterface_jcall,
2485 .free = LDKBroadcasterInterface_JCalls_free,
2489 long __attribute__((visibility("default"))) TS_LDKBroadcasterInterface_new(/*TODO: JS Object Reference */void* o) {
2490 LDKBroadcasterInterface *res_ptr = MALLOC(sizeof(LDKBroadcasterInterface), "LDKBroadcasterInterface");
2491 *res_ptr = LDKBroadcasterInterface_init(o);
2492 return (long)res_ptr;
2494 void __attribute__((visibility("default"))) TS_BroadcasterInterface_broadcast_transaction(uint32_t this_arg, int8_tArray tx) {
2495 LDKBroadcasterInterface* this_arg_conv = (LDKBroadcasterInterface*)(((uint64_t)this_arg) & ~1);
2496 LDKTransaction tx_ref;
2497 tx_ref.datalen = *((uint32_t*)tx);
2498 tx_ref.data = MALLOC(tx_ref.datalen, "LDKTransaction Bytes");
2499 memcpy(tx_ref.data, (uint8_t*)(tx + 4), tx_ref.datalen);
2500 tx_ref.data_is_owned = true;
2501 (this_arg_conv->broadcast_transaction)(this_arg_conv->this_arg, tx_ref);
2504 typedef struct LDKKeysInterface_JCalls {
2505 atomic_size_t refcnt;
2506 uint32_t get_node_secret_meth;
2507 uint32_t get_destination_script_meth;
2508 uint32_t get_shutdown_pubkey_meth;
2509 uint32_t get_channel_signer_meth;
2510 uint32_t get_secure_random_bytes_meth;
2511 uint32_t read_chan_signer_meth;
2512 uint32_t sign_invoice_meth;
2513 } LDKKeysInterface_JCalls;
2514 static void LDKKeysInterface_JCalls_free(void* this_arg) {
2515 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2516 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2517 js_free(j_calls->get_node_secret_meth);
2518 js_free(j_calls->get_destination_script_meth);
2519 js_free(j_calls->get_shutdown_pubkey_meth);
2520 js_free(j_calls->get_channel_signer_meth);
2521 js_free(j_calls->get_secure_random_bytes_meth);
2522 js_free(j_calls->read_chan_signer_meth);
2523 js_free(j_calls->sign_invoice_meth);
2527 LDKSecretKey get_node_secret_LDKKeysInterface_jcall(const void* this_arg) {
2528 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2529 int8_tArray ret = js_invoke_function_0(j_calls->get_node_secret_meth);
2530 LDKSecretKey ret_ref;
2531 CHECK(*((uint32_t*)ret) == 32);
2532 memcpy(ret_ref.bytes, (uint8_t*)(ret + 4), 32);
2535 LDKCVec_u8Z get_destination_script_LDKKeysInterface_jcall(const void* this_arg) {
2536 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2537 int8_tArray ret = js_invoke_function_0(j_calls->get_destination_script_meth);
2538 LDKCVec_u8Z ret_ref;
2539 ret_ref.datalen = *((uint32_t*)ret);
2540 ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes");
2541 memcpy(ret_ref.data, (uint8_t*)(ret + 4), ret_ref.datalen);
2544 LDKPublicKey get_shutdown_pubkey_LDKKeysInterface_jcall(const void* this_arg) {
2545 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2546 int8_tArray ret = js_invoke_function_0(j_calls->get_shutdown_pubkey_meth);
2547 LDKPublicKey ret_ref;
2548 CHECK(*((uint32_t*)ret) == 33);
2549 memcpy(ret_ref.compressed_form, (uint8_t*)(ret + 4), 33);
2552 LDKSign get_channel_signer_LDKKeysInterface_jcall(const void* this_arg, bool inbound, uint64_t channel_value_satoshis) {
2553 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2554 LDKSign* ret = (LDKSign*)js_invoke_function_2(j_calls->get_channel_signer_meth, inbound, channel_value_satoshis);
2555 LDKSign ret_conv = *(LDKSign*)(((uint64_t)ret) & ~1);
2556 ret_conv = Sign_clone(ret);
2559 LDKThirtyTwoBytes get_secure_random_bytes_LDKKeysInterface_jcall(const void* this_arg) {
2560 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2561 int8_tArray ret = js_invoke_function_0(j_calls->get_secure_random_bytes_meth);
2562 LDKThirtyTwoBytes ret_ref;
2563 CHECK(*((uint32_t*)ret) == 32);
2564 memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32);
2567 LDKCResult_SignDecodeErrorZ read_chan_signer_LDKKeysInterface_jcall(const void* this_arg, LDKu8slice reader) {
2568 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2569 LDKu8slice reader_var = reader;
2570 int8_tArray reader_arr = init_arr(reader_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
2571 memcpy((uint8_t*)(reader_arr + 4), reader_var.data, reader_var.datalen);
2572 LDKCResult_SignDecodeErrorZ* ret = (LDKCResult_SignDecodeErrorZ*)js_invoke_function_1(j_calls->read_chan_signer_meth, reader_arr);
2573 LDKCResult_SignDecodeErrorZ ret_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1);
2574 ret_conv = CResult_SignDecodeErrorZ_clone((LDKCResult_SignDecodeErrorZ*)(((uint64_t)ret) & ~1));
2577 LDKCResult_RecoverableSignatureNoneZ sign_invoice_LDKKeysInterface_jcall(const void* this_arg, LDKCVec_u8Z invoice_preimage) {
2578 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2579 LDKCVec_u8Z invoice_preimage_var = invoice_preimage;
2580 int8_tArray invoice_preimage_arr = init_arr(invoice_preimage_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
2581 memcpy((uint8_t*)(invoice_preimage_arr + 4), invoice_preimage_var.data, invoice_preimage_var.datalen);
2582 CVec_u8Z_free(invoice_preimage_var);
2583 LDKCResult_RecoverableSignatureNoneZ* ret = (LDKCResult_RecoverableSignatureNoneZ*)js_invoke_function_1(j_calls->sign_invoice_meth, invoice_preimage_arr);
2584 LDKCResult_RecoverableSignatureNoneZ ret_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1);
2585 ret_conv = CResult_RecoverableSignatureNoneZ_clone((LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)ret) & ~1));
2588 static void* LDKKeysInterface_JCalls_clone(const void* this_arg) {
2589 LDKKeysInterface_JCalls *j_calls = (LDKKeysInterface_JCalls*) this_arg;
2590 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2591 return (void*) this_arg;
2593 static inline LDKKeysInterface LDKKeysInterface_init (/*TODO: JS Object Reference */void* o) {
2594 LDKKeysInterface_JCalls *calls = MALLOC(sizeof(LDKKeysInterface_JCalls), "LDKKeysInterface_JCalls");
2595 atomic_init(&calls->refcnt, 1);
2596 //TODO: Assign calls->o from o
2598 LDKKeysInterface ret = {
2599 .this_arg = (void*) calls,
2600 .get_node_secret = get_node_secret_LDKKeysInterface_jcall,
2601 .get_destination_script = get_destination_script_LDKKeysInterface_jcall,
2602 .get_shutdown_pubkey = get_shutdown_pubkey_LDKKeysInterface_jcall,
2603 .get_channel_signer = get_channel_signer_LDKKeysInterface_jcall,
2604 .get_secure_random_bytes = get_secure_random_bytes_LDKKeysInterface_jcall,
2605 .read_chan_signer = read_chan_signer_LDKKeysInterface_jcall,
2606 .sign_invoice = sign_invoice_LDKKeysInterface_jcall,
2607 .free = LDKKeysInterface_JCalls_free,
2611 long __attribute__((visibility("default"))) TS_LDKKeysInterface_new(/*TODO: JS Object Reference */void* o) {
2612 LDKKeysInterface *res_ptr = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
2613 *res_ptr = LDKKeysInterface_init(o);
2614 return (long)res_ptr;
2616 int8_tArray __attribute__((visibility("default"))) TS_KeysInterface_get_node_secret(uint32_t this_arg) {
2617 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2618 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2619 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->get_node_secret)(this_arg_conv->this_arg).bytes, 32);
2623 int8_tArray __attribute__((visibility("default"))) TS_KeysInterface_get_destination_script(uint32_t this_arg) {
2624 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2625 LDKCVec_u8Z ret_var = (this_arg_conv->get_destination_script)(this_arg_conv->this_arg);
2626 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
2627 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
2628 CVec_u8Z_free(ret_var);
2632 int8_tArray __attribute__((visibility("default"))) TS_KeysInterface_get_shutdown_pubkey(uint32_t this_arg) {
2633 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2634 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
2635 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->get_shutdown_pubkey)(this_arg_conv->this_arg).compressed_form, 33);
2639 uint32_t __attribute__((visibility("default"))) TS_KeysInterface_get_channel_signer(uint32_t this_arg, jboolean inbound, int64_t channel_value_satoshis) {
2640 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2641 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
2642 *ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis);
2643 return (uint64_t)ret;
2646 int8_tArray __attribute__((visibility("default"))) TS_KeysInterface_get_secure_random_bytes(uint32_t this_arg) {
2647 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2648 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2649 memcpy((uint8_t*)(ret_arr + 4), (this_arg_conv->get_secure_random_bytes)(this_arg_conv->this_arg).data, 32);
2653 uint32_t __attribute__((visibility("default"))) TS_KeysInterface_read_chan_signer(uint32_t this_arg, int8_tArray reader) {
2654 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2655 LDKu8slice reader_ref;
2656 reader_ref.datalen = *((uint32_t*)reader);
2657 reader_ref.data = (int8_t*)(reader + 4);
2658 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
2659 *ret_conv = (this_arg_conv->read_chan_signer)(this_arg_conv->this_arg, reader_ref);
2660 return (uint64_t)ret_conv;
2663 uint32_t __attribute__((visibility("default"))) TS_KeysInterface_sign_invoice(uint32_t this_arg, int8_tArray invoice_preimage) {
2664 LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1);
2665 LDKCVec_u8Z invoice_preimage_ref;
2666 invoice_preimage_ref.datalen = *((uint32_t*)invoice_preimage);
2667 invoice_preimage_ref.data = MALLOC(invoice_preimage_ref.datalen, "LDKCVec_u8Z Bytes");
2668 memcpy(invoice_preimage_ref.data, (uint8_t*)(invoice_preimage + 4), invoice_preimage_ref.datalen);
2669 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
2670 *ret_conv = (this_arg_conv->sign_invoice)(this_arg_conv->this_arg, invoice_preimage_ref);
2671 return (uint64_t)ret_conv;
2674 typedef struct LDKFeeEstimator_JCalls {
2675 atomic_size_t refcnt;
2676 uint32_t get_est_sat_per_1000_weight_meth;
2677 } LDKFeeEstimator_JCalls;
2678 static void LDKFeeEstimator_JCalls_free(void* this_arg) {
2679 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
2680 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2681 js_free(j_calls->get_est_sat_per_1000_weight_meth);
2685 uint32_t get_est_sat_per_1000_weight_LDKFeeEstimator_jcall(const void* this_arg, LDKConfirmationTarget confirmation_target) {
2686 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
2687 uint32_t confirmation_target_conv = LDKConfirmationTarget_to_js(confirmation_target);
2688 return js_invoke_function_1(j_calls->get_est_sat_per_1000_weight_meth, confirmation_target_conv);
2690 static void* LDKFeeEstimator_JCalls_clone(const void* this_arg) {
2691 LDKFeeEstimator_JCalls *j_calls = (LDKFeeEstimator_JCalls*) this_arg;
2692 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2693 return (void*) this_arg;
2695 static inline LDKFeeEstimator LDKFeeEstimator_init (/*TODO: JS Object Reference */void* o) {
2696 LDKFeeEstimator_JCalls *calls = MALLOC(sizeof(LDKFeeEstimator_JCalls), "LDKFeeEstimator_JCalls");
2697 atomic_init(&calls->refcnt, 1);
2698 //TODO: Assign calls->o from o
2700 LDKFeeEstimator ret = {
2701 .this_arg = (void*) calls,
2702 .get_est_sat_per_1000_weight = get_est_sat_per_1000_weight_LDKFeeEstimator_jcall,
2703 .free = LDKFeeEstimator_JCalls_free,
2707 long __attribute__((visibility("default"))) TS_LDKFeeEstimator_new(/*TODO: JS Object Reference */void* o) {
2708 LDKFeeEstimator *res_ptr = MALLOC(sizeof(LDKFeeEstimator), "LDKFeeEstimator");
2709 *res_ptr = LDKFeeEstimator_init(o);
2710 return (long)res_ptr;
2712 int32_t __attribute__((visibility("default"))) TS_FeeEstimator_get_est_sat_per_1000_weight(uint32_t this_arg, uint32_t confirmation_target) {
2713 LDKFeeEstimator* this_arg_conv = (LDKFeeEstimator*)(((uint64_t)this_arg) & ~1);
2714 LDKConfirmationTarget confirmation_target_conv = LDKConfirmationTarget_from_js(confirmation_target);
2715 int32_t ret_val = (this_arg_conv->get_est_sat_per_1000_weight)(this_arg_conv->this_arg, confirmation_target_conv);
2719 typedef struct LDKLogger_JCalls {
2720 atomic_size_t refcnt;
2723 static void LDKLogger_JCalls_free(void* this_arg) {
2724 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2725 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
2726 js_free(j_calls->log_meth);
2730 void log_LDKLogger_jcall(const void* this_arg, const char* record) {
2731 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2732 const char* record_str = record;
2733 jstring record_conv = str_ref_to_ts(record_str, strlen(record_str));
2734 js_invoke_function_1(j_calls->log_meth, record_conv);
2736 static void* LDKLogger_JCalls_clone(const void* this_arg) {
2737 LDKLogger_JCalls *j_calls = (LDKLogger_JCalls*) this_arg;
2738 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
2739 return (void*) this_arg;
2741 static inline LDKLogger LDKLogger_init (/*TODO: JS Object Reference */void* o) {
2742 LDKLogger_JCalls *calls = MALLOC(sizeof(LDKLogger_JCalls), "LDKLogger_JCalls");
2743 atomic_init(&calls->refcnt, 1);
2744 //TODO: Assign calls->o from o
2747 .this_arg = (void*) calls,
2748 .log = log_LDKLogger_jcall,
2749 .free = LDKLogger_JCalls_free,
2753 long __attribute__((visibility("default"))) TS_LDKLogger_new(/*TODO: JS Object Reference */void* o) {
2754 LDKLogger *res_ptr = MALLOC(sizeof(LDKLogger), "LDKLogger");
2755 *res_ptr = LDKLogger_init(o);
2756 return (long)res_ptr;
2758 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint32_t b) {
2759 LDKC2Tuple_BlockHashChannelManagerZ* ret = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
2760 LDKThirtyTwoBytes a_ref;
2761 CHECK(*((uint32_t*)a) == 32);
2762 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
2764 LDKChannelManager b_conv;
2765 b_conv.inner = (void*)(b & (~1));
2766 b_conv.is_owned = (b & 1) || (b == 0);
2767 // Warning: we need a move here but no clone is available for LDKChannelManager
2769 return (uint64_t)ret;
2771 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelManagerZ_get_a(uint32_t ptr) {
2772 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
2773 int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2774 memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32);
2777 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelManagerZ_get_b(uint32_t ptr) {
2778 LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1);
2779 LDKChannelManager b_var = tuple->b;
2780 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2781 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2782 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
2785 jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(uint32_t arg) {
2786 return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok;
2788 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint32_t arg) {
2789 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
2790 CHECK(val->result_ok);
2791 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
2794 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint32_t arg) {
2795 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1);
2796 CHECK(!val->result_ok);
2797 LDKDecodeError err_var = (*val->contents.err);
2798 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2799 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2800 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2803 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_result_ok(uint32_t arg) {
2804 return ((LDKCResult_ChannelConfigDecodeErrorZ*)arg)->result_ok;
2806 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_ok(uint32_t arg) {
2807 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
2808 CHECK(val->result_ok);
2809 LDKChannelConfig res_var = (*val->contents.result);
2810 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2811 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2812 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2815 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelConfigDecodeErrorZ_get_err(uint32_t arg) {
2816 LDKCResult_ChannelConfigDecodeErrorZ *val = (LDKCResult_ChannelConfigDecodeErrorZ*)(arg & ~1);
2817 CHECK(!val->result_ok);
2818 LDKDecodeError err_var = (*val->contents.err);
2819 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2820 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2821 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2824 jboolean __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_result_ok(uint32_t arg) {
2825 return ((LDKCResult_OutPointDecodeErrorZ*)arg)->result_ok;
2827 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_get_ok(uint32_t arg) {
2828 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
2829 CHECK(val->result_ok);
2830 LDKOutPoint res_var = (*val->contents.result);
2831 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2832 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2833 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2836 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErrorZ_get_err(uint32_t arg) {
2837 LDKCResult_OutPointDecodeErrorZ *val = (LDKCResult_OutPointDecodeErrorZ*)(arg & ~1);
2838 CHECK(!val->result_ok);
2839 LDKDecodeError err_var = (*val->contents.err);
2840 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2841 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2842 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
2845 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_result_ok(uint32_t arg) {
2846 return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok;
2848 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_get_ok(uint32_t arg) {
2849 LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
2850 CHECK(val->result_ok);
2851 uint32_t res_conv = LDKSiPrefix_to_js((*val->contents.result));
2854 void __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_get_err(uint32_t arg) {
2855 LDKCResult_SiPrefixNoneZ *val = (LDKCResult_SiPrefixNoneZ*)(arg & ~1);
2856 CHECK(!val->result_ok);
2857 return *val->contents.err;
2859 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_result_ok(uint32_t arg) {
2860 return ((LDKCResult_InvoiceNoneZ*)arg)->result_ok;
2862 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_get_ok(uint32_t arg) {
2863 LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
2864 CHECK(val->result_ok);
2865 LDKInvoice res_var = (*val->contents.result);
2866 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2867 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2868 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2871 void __attribute__((visibility("default"))) TS_LDKCResult_InvoiceNoneZ_get_err(uint32_t arg) {
2872 LDKCResult_InvoiceNoneZ *val = (LDKCResult_InvoiceNoneZ*)(arg & ~1);
2873 CHECK(!val->result_ok);
2874 return *val->contents.err;
2876 jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_result_ok(uint32_t arg) {
2877 return ((LDKCResult_SignedRawInvoiceNoneZ*)arg)->result_ok;
2879 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_get_ok(uint32_t arg) {
2880 LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
2881 CHECK(val->result_ok);
2882 LDKSignedRawInvoice res_var = (*val->contents.result);
2883 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2884 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2885 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2888 void __attribute__((visibility("default"))) TS_LDKCResult_SignedRawInvoiceNoneZ_get_err(uint32_t arg) {
2889 LDKCResult_SignedRawInvoiceNoneZ *val = (LDKCResult_SignedRawInvoiceNoneZ*)(arg & ~1);
2890 CHECK(!val->result_ok);
2891 return *val->contents.err;
2893 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint32_t a, int8_tArray b, uint32_t c) {
2894 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
2895 LDKRawInvoice a_conv;
2896 a_conv.inner = (void*)(a & (~1));
2897 a_conv.is_owned = (a & 1) || (a == 0);
2898 a_conv = RawInvoice_clone(&a_conv);
2900 LDKThirtyTwoBytes b_ref;
2901 CHECK(*((uint32_t*)b) == 32);
2902 memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
2904 LDKInvoiceSignature c_conv;
2905 c_conv.inner = (void*)(c & (~1));
2906 c_conv.is_owned = (c & 1) || (c == 0);
2907 c_conv = InvoiceSignature_clone(&c_conv);
2909 return (uint64_t)ret;
2911 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint32_t ptr) {
2912 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
2913 LDKRawInvoice a_var = tuple->a;
2914 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2915 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2916 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
2919 int8_tArray __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint32_t ptr) {
2920 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
2921 int8_tArray b_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
2922 memcpy((uint8_t*)(b_arr + 4), tuple->b.data, 32);
2925 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint32_t ptr) {
2926 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1);
2927 LDKInvoiceSignature c_var = tuple->c;
2928 CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2929 CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2930 uint64_t c_ref = (uint64_t)c_var.inner & ~1;
2933 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_result_ok(uint32_t arg) {
2934 return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok;
2936 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_get_ok(uint32_t arg) {
2937 LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
2938 CHECK(val->result_ok);
2939 LDKPayeePubKey res_var = (*val->contents.result);
2940 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2941 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2942 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2945 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_get_err(uint32_t arg) {
2946 LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1);
2947 CHECK(!val->result_ok);
2948 uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
2951 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_PrivateRouteZ_new(uint32_tArray elems) {
2952 LDKCVec_PrivateRouteZ *ret = MALLOC(sizeof(LDKCVec_PrivateRouteZ), "LDKCVec_PrivateRouteZ");
2953 ret->datalen = *((uint32_t*)elems);
2954 if (ret->datalen == 0) {
2957 ret->data = MALLOC(sizeof(LDKPrivateRoute) * ret->datalen, "LDKCVec_PrivateRouteZ Data");
2958 uint32_t *java_elems = (uint32_t*)(elems + 4);
2959 for (size_t i = 0; i < ret->datalen; i++) {
2960 uint32_t arr_elem = java_elems[i];
2961 LDKPrivateRoute arr_elem_conv;
2962 arr_elem_conv.inner = (void*)(arr_elem & (~1));
2963 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
2964 arr_elem_conv = PrivateRoute_clone(&arr_elem_conv);
2965 ret->data[i] = arr_elem_conv;
2968 return (uint64_t)ret;
2970 static inline LDKCVec_PrivateRouteZ CVec_PrivateRouteZ_clone(const LDKCVec_PrivateRouteZ *orig) {
2971 LDKCVec_PrivateRouteZ ret = { .data = MALLOC(sizeof(LDKPrivateRoute) * orig->datalen, "LDKCVec_PrivateRouteZ clone bytes"), .datalen = orig->datalen };
2972 for (size_t i = 0; i < ret.datalen; i++) {
2973 ret.data[i] = PrivateRoute_clone(&orig->data[i]);
2977 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_result_ok(uint32_t arg) {
2978 return ((LDKCResult_PositiveTimestampCreationErrorZ*)arg)->result_ok;
2980 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_get_ok(uint32_t arg) {
2981 LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
2982 CHECK(val->result_ok);
2983 LDKPositiveTimestamp res_var = (*val->contents.result);
2984 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
2985 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
2986 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
2989 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PositiveTimestampCreationErrorZ_get_err(uint32_t arg) {
2990 LDKCResult_PositiveTimestampCreationErrorZ *val = (LDKCResult_PositiveTimestampCreationErrorZ*)(arg & ~1);
2991 CHECK(!val->result_ok);
2992 uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
2995 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_result_ok(uint32_t arg) {
2996 return ((LDKCResult_NoneSemanticErrorZ*)arg)->result_ok;
2998 void __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_get_ok(uint32_t arg) {
2999 LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
3000 CHECK(val->result_ok);
3001 return *val->contents.result;
3003 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneSemanticErrorZ_get_err(uint32_t arg) {
3004 LDKCResult_NoneSemanticErrorZ *val = (LDKCResult_NoneSemanticErrorZ*)(arg & ~1);
3005 CHECK(!val->result_ok);
3006 uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
3009 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_result_ok(uint32_t arg) {
3010 return ((LDKCResult_InvoiceSemanticErrorZ*)arg)->result_ok;
3012 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_get_ok(uint32_t arg) {
3013 LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
3014 CHECK(val->result_ok);
3015 LDKInvoice res_var = (*val->contents.result);
3016 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3017 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3018 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3021 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSemanticErrorZ_get_err(uint32_t arg) {
3022 LDKCResult_InvoiceSemanticErrorZ *val = (LDKCResult_InvoiceSemanticErrorZ*)(arg & ~1);
3023 CHECK(!val->result_ok);
3024 uint32_t err_conv = LDKSemanticError_to_js((*val->contents.err));
3027 jboolean __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_result_ok(uint32_t arg) {
3028 return ((LDKCResult_DescriptionCreationErrorZ*)arg)->result_ok;
3030 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_get_ok(uint32_t arg) {
3031 LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
3032 CHECK(val->result_ok);
3033 LDKDescription res_var = (*val->contents.result);
3034 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3035 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3036 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3039 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DescriptionCreationErrorZ_get_err(uint32_t arg) {
3040 LDKCResult_DescriptionCreationErrorZ *val = (LDKCResult_DescriptionCreationErrorZ*)(arg & ~1);
3041 CHECK(!val->result_ok);
3042 uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
3045 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_result_ok(uint32_t arg) {
3046 return ((LDKCResult_ExpiryTimeCreationErrorZ*)arg)->result_ok;
3048 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_get_ok(uint32_t arg) {
3049 LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
3050 CHECK(val->result_ok);
3051 LDKExpiryTime res_var = (*val->contents.result);
3052 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3053 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3054 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3057 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ExpiryTimeCreationErrorZ_get_err(uint32_t arg) {
3058 LDKCResult_ExpiryTimeCreationErrorZ *val = (LDKCResult_ExpiryTimeCreationErrorZ*)(arg & ~1);
3059 CHECK(!val->result_ok);
3060 uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
3063 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_result_ok(uint32_t arg) {
3064 return ((LDKCResult_PrivateRouteCreationErrorZ*)arg)->result_ok;
3066 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_get_ok(uint32_t arg) {
3067 LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
3068 CHECK(val->result_ok);
3069 LDKPrivateRoute res_var = (*val->contents.result);
3070 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3071 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3072 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3075 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PrivateRouteCreationErrorZ_get_err(uint32_t arg) {
3076 LDKCResult_PrivateRouteCreationErrorZ *val = (LDKCResult_PrivateRouteCreationErrorZ*)(arg & ~1);
3077 CHECK(!val->result_ok);
3078 uint32_t err_conv = LDKCreationError_to_js((*val->contents.err));
3081 jboolean __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_result_ok(uint32_t arg) {
3082 return ((LDKCResult_StringErrorZ*)arg)->result_ok;
3084 jstring __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_get_ok(uint32_t arg) {
3085 LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
3086 CHECK(val->result_ok);
3087 LDKStr res_str = (*val->contents.result);
3088 jstring res_conv = str_ref_to_ts(res_str.chars, res_str.len);
3091 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_StringErrorZ_get_err(uint32_t arg) {
3092 LDKCResult_StringErrorZ *val = (LDKCResult_StringErrorZ*)(arg & ~1);
3093 CHECK(!val->result_ok);
3094 uint32_t err_conv = LDKSecp256k1Error_to_js((*val->contents.err));
3097 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_result_ok(uint32_t arg) {
3098 return ((LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)arg)->result_ok;
3100 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_ok(uint32_t arg) {
3101 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
3102 CHECK(val->result_ok);
3103 LDKChannelMonitorUpdate res_var = (*val->contents.result);
3104 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3105 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3106 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3109 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelMonitorUpdateDecodeErrorZ_get_err(uint32_t arg) {
3110 LDKCResult_ChannelMonitorUpdateDecodeErrorZ *val = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(arg & ~1);
3111 CHECK(!val->result_ok);
3112 LDKDecodeError err_var = (*val->contents.err);
3113 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3114 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3115 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3118 jboolean __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_result_ok(uint32_t arg) {
3119 return ((LDKCResult_HTLCUpdateDecodeErrorZ*)arg)->result_ok;
3121 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_get_ok(uint32_t arg) {
3122 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
3123 CHECK(val->result_ok);
3124 LDKHTLCUpdate res_var = (*val->contents.result);
3125 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3126 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3127 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3130 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_HTLCUpdateDecodeErrorZ_get_err(uint32_t arg) {
3131 LDKCResult_HTLCUpdateDecodeErrorZ *val = (LDKCResult_HTLCUpdateDecodeErrorZ*)(arg & ~1);
3132 CHECK(!val->result_ok);
3133 LDKDecodeError err_var = (*val->contents.err);
3134 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3135 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3136 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3139 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_result_ok(uint32_t arg) {
3140 return ((LDKCResult_NoneMonitorUpdateErrorZ*)arg)->result_ok;
3142 void __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_get_ok(uint32_t arg) {
3143 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
3144 CHECK(val->result_ok);
3145 return *val->contents.result;
3147 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneMonitorUpdateErrorZ_get_err(uint32_t arg) {
3148 LDKCResult_NoneMonitorUpdateErrorZ *val = (LDKCResult_NoneMonitorUpdateErrorZ*)(arg & ~1);
3149 CHECK(!val->result_ok);
3150 LDKMonitorUpdateError err_var = (*val->contents.err);
3151 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3152 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3153 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3156 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_new(uint32_t a, int8_tArray b) {
3157 LDKC2Tuple_OutPointScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
3159 a_conv.inner = (void*)(a & (~1));
3160 a_conv.is_owned = (a & 1) || (a == 0);
3161 a_conv = OutPoint_clone(&a_conv);
3164 b_ref.datalen = *((uint32_t*)b);
3165 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
3166 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
3168 return (uint64_t)ret;
3170 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_get_a(uint32_t ptr) {
3171 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
3172 LDKOutPoint a_var = tuple->a;
3173 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3174 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3175 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
3178 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_get_b(uint32_t ptr) {
3179 LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1);
3180 LDKCVec_u8Z b_var = tuple->b;
3181 int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
3182 memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen);
3185 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
3186 LDKC2Tuple_u32ScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
3189 b_ref.datalen = *((uint32_t*)b);
3190 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
3191 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
3193 return (uint64_t)ret;
3195 int32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_get_a(uint32_t ptr) {
3196 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
3199 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_get_b(uint32_t ptr) {
3200 LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1);
3201 LDKCVec_u8Z b_var = tuple->b;
3202 int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
3203 memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen);
3206 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32ScriptZZ_new(uint32_tArray elems) {
3207 LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ");
3208 ret->datalen = *((uint32_t*)elems);
3209 if (ret->datalen == 0) {
3212 ret->data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * ret->datalen, "LDKCVec_C2Tuple_u32ScriptZZ Data");
3213 uint32_t *java_elems = (uint32_t*)(elems + 4);
3214 for (size_t i = 0; i < ret->datalen; i++) {
3215 uint32_t arr_elem = java_elems[i];
3216 LDKC2Tuple_u32ScriptZ arr_elem_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1);
3217 arr_elem_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)arr_elem) & ~1));
3218 ret->data[i] = arr_elem_conv;
3221 return (uint64_t)ret;
3223 static inline LDKCVec_C2Tuple_u32ScriptZZ CVec_C2Tuple_u32ScriptZZ_clone(const LDKCVec_C2Tuple_u32ScriptZZ *orig) {
3224 LDKCVec_C2Tuple_u32ScriptZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ) * orig->datalen, "LDKCVec_C2Tuple_u32ScriptZZ clone bytes"), .datalen = orig->datalen };
3225 for (size_t i = 0; i < ret.datalen; i++) {
3226 ret.data[i] = C2Tuple_u32ScriptZ_clone(&orig->data[i]);
3230 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint32_tArray b) {
3231 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
3232 LDKThirtyTwoBytes a_ref;
3233 CHECK(*((uint32_t*)a) == 32);
3234 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
3236 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
3237 b_constr.datalen = *((uint32_t*)b);
3238 if (b_constr.datalen > 0)
3239 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
3241 b_constr.data = NULL;
3242 uint32_t* b_vals = (uint32_t*)(b + 4);
3243 for (size_t e = 0; e < b_constr.datalen; e++) {
3244 uint32_t b_conv_30 = b_vals[e];
3245 LDKC2Tuple_u32ScriptZ b_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1);
3246 b_conv_30_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1));
3247 b_constr.data[e] = b_conv_30_conv;
3250 return (uint64_t)ret;
3252 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint32_t ptr) {
3253 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
3254 int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3255 memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32);
3258 uint32_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint32_t ptr) {
3259 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1);
3260 LDKCVec_C2Tuple_u32ScriptZZ b_var = tuple->b;
3261 uint32_tArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
3262 uint32_t *b_arr_ptr = (uint32_t*)(b_arr + 4);
3263 for (size_t e = 0; e < b_var.datalen; e++) {
3264 uint64_t b_conv_30_ref = (uint64_t)(&b_var.data[e]) | 1;
3265 b_arr_ptr[e] = b_conv_30_ref;
3269 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(uint32_tArray elems) {
3270 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ");
3271 ret->datalen = *((uint32_t*)elems);
3272 if (ret->datalen == 0) {
3275 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Data");
3276 uint32_t *java_elems = (uint32_t*)(elems + 4);
3277 for (size_t i = 0; i < ret->datalen; i++) {
3278 uint32_t arr_elem = java_elems[i];
3279 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1);
3280 arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)arr_elem) & ~1));
3281 ret->data[i] = arr_elem_conv;
3284 return (uint64_t)ret;
3286 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *orig) {
3287 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 };
3288 for (size_t i = 0; i < ret.datalen; i++) {
3289 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(&orig->data[i]);
3293 uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) {
3294 LDKEvent *obj = (LDKEvent*)(ptr & ~1);
3296 case LDKEvent_FundingGenerationReady: {
3297 int8_tArray temporary_channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3298 memcpy((uint8_t*)(temporary_channel_id_arr + 4), obj->funding_generation_ready.temporary_channel_id.data, 32);
3299 LDKCVec_u8Z output_script_var = obj->funding_generation_ready.output_script;
3300 int8_tArray output_script_arr = init_arr(output_script_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
3301 memcpy((uint8_t*)(output_script_arr + 4), output_script_var.data, output_script_var.datalen);
3302 return 0 /* LDKEvent - FundingGenerationReady */; (void) temporary_channel_id_arr; (void) obj->funding_generation_ready.channel_value_satoshis; (void) output_script_arr; (void) obj->funding_generation_ready.user_channel_id;
3304 case LDKEvent_PaymentReceived: {
3305 int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3306 memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_received.payment_hash.data, 32);
3307 int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3308 memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_received.payment_preimage.data, 32);
3309 int8_tArray payment_secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3310 memcpy((uint8_t*)(payment_secret_arr + 4), obj->payment_received.payment_secret.data, 32);
3311 return 0 /* LDKEvent - PaymentReceived */; (void) payment_hash_arr; (void) payment_preimage_arr; (void) payment_secret_arr; (void) obj->payment_received.amt; (void) obj->payment_received.user_payment_id;
3313 case LDKEvent_PaymentSent: {
3314 int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3315 memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32);
3316 return 0 /* LDKEvent - PaymentSent */; (void) payment_preimage_arr;
3318 case LDKEvent_PaymentFailed: {
3319 int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3320 memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_failed.payment_hash.data, 32);
3321 return 0 /* LDKEvent - PaymentFailed */; (void) payment_hash_arr; (void) obj->payment_failed.rejected_by_dest;
3323 case LDKEvent_PendingHTLCsForwardable: {
3324 return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable;
3326 case LDKEvent_SpendableOutputs: {
3327 LDKCVec_SpendableOutputDescriptorZ outputs_var = obj->spendable_outputs.outputs;
3328 uint32_tArray outputs_arr = init_arr(outputs_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
3329 uint32_t *outputs_arr_ptr = (uint32_t*)(outputs_arr + 4);
3330 for (size_t b = 0; b < outputs_var.datalen; b++) {
3331 uint64_t outputs_conv_27_ref = ((uint64_t)&outputs_var.data[b]) | 1;
3332 outputs_arr_ptr[b] = outputs_conv_27_ref;
3334 return 0 /* LDKEvent - SpendableOutputs */; (void) outputs_arr;
3339 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_EventZ_new(uint32_tArray elems) {
3340 LDKCVec_EventZ *ret = MALLOC(sizeof(LDKCVec_EventZ), "LDKCVec_EventZ");
3341 ret->datalen = *((uint32_t*)elems);
3342 if (ret->datalen == 0) {
3345 ret->data = MALLOC(sizeof(LDKEvent) * ret->datalen, "LDKCVec_EventZ Data");
3346 uint32_t *java_elems = (uint32_t*)(elems + 4);
3347 for (size_t i = 0; i < ret->datalen; i++) {
3348 uint32_t arr_elem = java_elems[i];
3349 LDKEvent arr_elem_conv = *(LDKEvent*)(((uint64_t)arr_elem) & ~1);
3350 arr_elem_conv = Event_clone((LDKEvent*)(((uint64_t)arr_elem) & ~1));
3351 ret->data[i] = arr_elem_conv;
3354 return (uint64_t)ret;
3356 static inline LDKCVec_EventZ CVec_EventZ_clone(const LDKCVec_EventZ *orig) {
3357 LDKCVec_EventZ ret = { .data = MALLOC(sizeof(LDKEvent) * orig->datalen, "LDKCVec_EventZ clone bytes"), .datalen = orig->datalen };
3358 for (size_t i = 0; i < ret.datalen; i++) {
3359 ret.data[i] = Event_clone(&orig->data[i]);
3363 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_new(int32_t a, uint32_t b) {
3364 LDKC2Tuple_u32TxOutZ* ret = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
3366 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
3367 b_conv = TxOut_clone((LDKTxOut*)(((uint64_t)b) & ~1));
3369 return (uint64_t)ret;
3371 int32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_get_a(uint32_t ptr) {
3372 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
3375 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_get_b(uint32_t ptr) {
3376 LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1);
3377 uint64_t b_ref = ((uint64_t)&tuple->b) | 1;
3378 return (uint64_t)b_ref;
3380 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32TxOutZZ_new(uint32_tArray elems) {
3381 LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ");
3382 ret->datalen = *((uint32_t*)elems);
3383 if (ret->datalen == 0) {
3386 ret->data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * ret->datalen, "LDKCVec_C2Tuple_u32TxOutZZ Data");
3387 uint32_t *java_elems = (uint32_t*)(elems + 4);
3388 for (size_t i = 0; i < ret->datalen; i++) {
3389 uint32_t arr_elem = java_elems[i];
3390 LDKC2Tuple_u32TxOutZ arr_elem_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1);
3391 arr_elem_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)arr_elem) & ~1));
3392 ret->data[i] = arr_elem_conv;
3395 return (uint64_t)ret;
3397 static inline LDKCVec_C2Tuple_u32TxOutZZ CVec_C2Tuple_u32TxOutZZ_clone(const LDKCVec_C2Tuple_u32TxOutZZ *orig) {
3398 LDKCVec_C2Tuple_u32TxOutZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ) * orig->datalen, "LDKCVec_C2Tuple_u32TxOutZZ clone bytes"), .datalen = orig->datalen };
3399 for (size_t i = 0; i < ret.datalen; i++) {
3400 ret.data[i] = C2Tuple_u32TxOutZ_clone(&orig->data[i]);
3404 uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint32_tArray b) {
3405 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
3406 LDKThirtyTwoBytes a_ref;
3407 CHECK(*((uint32_t*)a) == 32);
3408 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
3410 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
3411 b_constr.datalen = *((uint32_t*)b);
3412 if (b_constr.datalen > 0)
3413 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
3415 b_constr.data = NULL;
3416 uint32_t* b_vals = (uint32_t*)(b + 4);
3417 for (size_t z = 0; z < b_constr.datalen; z++) {
3418 uint32_t b_conv_25 = b_vals[z];
3419 LDKC2Tuple_u32TxOutZ b_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1);
3420 b_conv_25_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1));
3421 b_constr.data[z] = b_conv_25_conv;
3424 return (uint64_t)ret;
3426 int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint32_t ptr) {
3427 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
3428 int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
3429 memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32);
3432 uint32_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint32_t ptr) {
3433 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1);
3434 LDKCVec_C2Tuple_u32TxOutZZ b_var = tuple->b;
3435 uint32_tArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
3436 uint32_t *b_arr_ptr = (uint32_t*)(b_arr + 4);
3437 for (size_t z = 0; z < b_var.datalen; z++) {
3438 uint64_t b_conv_25_ref = (uint64_t)(&b_var.data[z]) | 1;
3439 b_arr_ptr[z] = b_conv_25_ref;
3443 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(uint32_tArray elems) {
3444 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ");
3445 ret->datalen = *((uint32_t*)elems);
3446 if (ret->datalen == 0) {
3449 ret->data = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ) * ret->datalen, "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Data");
3450 uint32_t *java_elems = (uint32_t*)(elems + 4);
3451 for (size_t i = 0; i < ret->datalen; i++) {
3452 uint32_t arr_elem = java_elems[i];
3453 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ arr_elem_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1);
3454 arr_elem_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone((LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)arr_elem) & ~1));
3455 ret->data[i] = arr_elem_conv;
3458 return (uint64_t)ret;
3460 static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_clone(const LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *orig) {
3461 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 };
3462 for (size_t i = 0; i < ret.datalen; i++) {
3463 ret.data[i] = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(&orig->data[i]);
3467 jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(uint32_t arg) {
3468 return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok;
3470 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint32_t arg) {
3471 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
3472 CHECK(val->result_ok);
3473 uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1;
3476 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint32_t arg) {
3477 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1);
3478 CHECK(!val->result_ok);
3479 LDKDecodeError err_var = (*val->contents.err);
3480 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3481 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3482 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3485 jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_result_ok(uint32_t arg) {
3486 return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok;
3488 jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_get_ok(uint32_t arg) {
3489 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
3490 CHECK(val->result_ok);
3491 return *val->contents.result;
3493 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_get_err(uint32_t arg) {
3494 LDKCResult_boolLightningErrorZ *val = (LDKCResult_boolLightningErrorZ*)(arg & ~1);
3495 CHECK(!val->result_ok);
3496 LDKLightningError err_var = (*val->contents.err);
3497 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3498 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3499 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3502 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
3503 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
3504 LDKChannelAnnouncement a_conv;
3505 a_conv.inner = (void*)(a & (~1));
3506 a_conv.is_owned = (a & 1) || (a == 0);
3507 a_conv = ChannelAnnouncement_clone(&a_conv);
3509 LDKChannelUpdate b_conv;
3510 b_conv.inner = (void*)(b & (~1));
3511 b_conv.is_owned = (b & 1) || (b == 0);
3512 b_conv = ChannelUpdate_clone(&b_conv);
3514 LDKChannelUpdate c_conv;
3515 c_conv.inner = (void*)(c & (~1));
3516 c_conv.is_owned = (c & 1) || (c == 0);
3517 c_conv = ChannelUpdate_clone(&c_conv);
3519 return (uint64_t)ret;
3521 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint32_t ptr) {
3522 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
3523 LDKChannelAnnouncement a_var = tuple->a;
3524 CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3525 CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3526 uint64_t a_ref = (uint64_t)a_var.inner & ~1;
3529 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint32_t ptr) {
3530 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
3531 LDKChannelUpdate b_var = tuple->b;
3532 CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3533 CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3534 uint64_t b_ref = (uint64_t)b_var.inner & ~1;
3537 uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint32_t ptr) {
3538 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1);
3539 LDKChannelUpdate c_var = tuple->c;
3540 CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3541 CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3542 uint64_t c_ref = (uint64_t)c_var.inner & ~1;
3545 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(uint32_tArray elems) {
3546 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ");
3547 ret->datalen = *((uint32_t*)elems);
3548 if (ret->datalen == 0) {
3551 ret->data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * ret->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Data");
3552 uint32_t *java_elems = (uint32_t*)(elems + 4);
3553 for (size_t i = 0; i < ret->datalen; i++) {
3554 uint32_t arr_elem = java_elems[i];
3555 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ arr_elem_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1);
3556 arr_elem_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)arr_elem) & ~1));
3557 ret->data[i] = arr_elem_conv;
3560 return (uint64_t)ret;
3562 static inline LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_clone(const LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *orig) {
3563 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret = { .data = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ) * orig->datalen, "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ clone bytes"), .datalen = orig->datalen };
3564 for (size_t i = 0; i < ret.datalen; i++) {
3565 ret.data[i] = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(&orig->data[i]);
3569 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_NodeAnnouncementZ_new(uint32_tArray elems) {
3570 LDKCVec_NodeAnnouncementZ *ret = MALLOC(sizeof(LDKCVec_NodeAnnouncementZ), "LDKCVec_NodeAnnouncementZ");
3571 ret->datalen = *((uint32_t*)elems);
3572 if (ret->datalen == 0) {
3575 ret->data = MALLOC(sizeof(LDKNodeAnnouncement) * ret->datalen, "LDKCVec_NodeAnnouncementZ Data");
3576 uint32_t *java_elems = (uint32_t*)(elems + 4);
3577 for (size_t i = 0; i < ret->datalen; i++) {
3578 uint32_t arr_elem = java_elems[i];
3579 LDKNodeAnnouncement arr_elem_conv;
3580 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3581 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3582 arr_elem_conv = NodeAnnouncement_clone(&arr_elem_conv);
3583 ret->data[i] = arr_elem_conv;
3586 return (uint64_t)ret;
3588 static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCVec_NodeAnnouncementZ *orig) {
3589 LDKCVec_NodeAnnouncementZ ret = { .data = MALLOC(sizeof(LDKNodeAnnouncement) * orig->datalen, "LDKCVec_NodeAnnouncementZ clone bytes"), .datalen = orig->datalen };
3590 for (size_t i = 0; i < ret.datalen; i++) {
3591 ret.data[i] = NodeAnnouncement_clone(&orig->data[i]);
3595 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_result_ok(uint32_t arg) {
3596 return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok;
3598 void __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_ok(uint32_t arg) {
3599 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
3600 CHECK(val->result_ok);
3601 return *val->contents.result;
3603 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_err(uint32_t arg) {
3604 LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1);
3605 CHECK(!val->result_ok);
3606 LDKLightningError err_var = (*val->contents.err);
3607 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3608 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3609 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3612 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) {
3613 return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok;
3615 int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_ok(uint32_t arg) {
3616 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
3617 CHECK(val->result_ok);
3618 LDKCVec_u8Z res_var = (*val->contents.result);
3619 int8_tArray res_arr = init_arr(res_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
3620 memcpy((uint8_t*)(res_arr + 4), res_var.data, res_var.datalen);
3623 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_get_err(uint32_t arg) {
3624 LDKCResult_CVec_u8ZPeerHandleErrorZ *val = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(arg & ~1);
3625 CHECK(!val->result_ok);
3626 LDKPeerHandleError err_var = (*val->contents.err);
3627 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3628 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3629 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3632 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_result_ok(uint32_t arg) {
3633 return ((LDKCResult_NonePeerHandleErrorZ*)arg)->result_ok;
3635 void __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_ok(uint32_t arg) {
3636 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
3637 CHECK(val->result_ok);
3638 return *val->contents.result;
3640 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NonePeerHandleErrorZ_get_err(uint32_t arg) {
3641 LDKCResult_NonePeerHandleErrorZ *val = (LDKCResult_NonePeerHandleErrorZ*)(arg & ~1);
3642 CHECK(!val->result_ok);
3643 LDKPeerHandleError err_var = (*val->contents.err);
3644 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3645 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3646 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3649 jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_result_ok(uint32_t arg) {
3650 return ((LDKCResult_boolPeerHandleErrorZ*)arg)->result_ok;
3652 jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_ok(uint32_t arg) {
3653 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
3654 CHECK(val->result_ok);
3655 return *val->contents.result;
3657 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErrorZ_get_err(uint32_t arg) {
3658 LDKCResult_boolPeerHandleErrorZ *val = (LDKCResult_boolPeerHandleErrorZ*)(arg & ~1);
3659 CHECK(!val->result_ok);
3660 LDKPeerHandleError err_var = (*val->contents.err);
3661 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3662 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3663 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3666 jboolean __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
3667 return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok;
3669 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
3670 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
3671 CHECK(val->result_ok);
3672 LDKDirectionalChannelInfo res_var = (*val->contents.result);
3673 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3674 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3675 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3678 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(uint32_t arg) {
3679 LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1);
3680 CHECK(!val->result_ok);
3681 LDKDecodeError err_var = (*val->contents.err);
3682 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3683 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3684 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3687 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_result_ok(uint32_t arg) {
3688 return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok;
3690 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t arg) {
3691 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
3692 CHECK(val->result_ok);
3693 LDKChannelInfo res_var = (*val->contents.result);
3694 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3695 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3696 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3699 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_err(uint32_t arg) {
3700 LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1);
3701 CHECK(!val->result_ok);
3702 LDKDecodeError err_var = (*val->contents.err);
3703 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3704 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3705 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3708 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_result_ok(uint32_t arg) {
3709 return ((LDKCResult_RoutingFeesDecodeErrorZ*)arg)->result_ok;
3711 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_get_ok(uint32_t arg) {
3712 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
3713 CHECK(val->result_ok);
3714 LDKRoutingFees res_var = (*val->contents.result);
3715 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3716 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3717 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3720 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RoutingFeesDecodeErrorZ_get_err(uint32_t arg) {
3721 LDKCResult_RoutingFeesDecodeErrorZ *val = (LDKCResult_RoutingFeesDecodeErrorZ*)(arg & ~1);
3722 CHECK(!val->result_ok);
3723 LDKDecodeError err_var = (*val->contents.err);
3724 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3725 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3726 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3729 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_result_ok(uint32_t arg) {
3730 return ((LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)arg)->result_ok;
3732 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_ok(uint32_t arg) {
3733 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
3734 CHECK(val->result_ok);
3735 LDKNodeAnnouncementInfo res_var = (*val->contents.result);
3736 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3737 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3738 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3741 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementInfoDecodeErrorZ_get_err(uint32_t arg) {
3742 LDKCResult_NodeAnnouncementInfoDecodeErrorZ *val = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(arg & ~1);
3743 CHECK(!val->result_ok);
3744 LDKDecodeError err_var = (*val->contents.err);
3745 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3746 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3747 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3750 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_u64Z_new(int64_tArray elems) {
3751 LDKCVec_u64Z *ret = MALLOC(sizeof(LDKCVec_u64Z), "LDKCVec_u64Z");
3752 ret->datalen = *((uint32_t*)elems);
3753 if (ret->datalen == 0) {
3756 ret->data = MALLOC(sizeof(uint64_t) * ret->datalen, "LDKCVec_u64Z Data");
3757 int64_t *java_elems = (int64_t*)(elems + 4);
3758 for (size_t i = 0; i < ret->datalen; i++) {
3759 ret->data[i] = java_elems[i];
3762 return (uint64_t)ret;
3764 static inline LDKCVec_u64Z CVec_u64Z_clone(const LDKCVec_u64Z *orig) {
3765 LDKCVec_u64Z ret = { .data = MALLOC(sizeof(int64_t) * orig->datalen, "LDKCVec_u64Z clone bytes"), .datalen = orig->datalen };
3766 memcpy(ret.data, orig->data, sizeof(int64_t) * ret.datalen);
3769 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_result_ok(uint32_t arg) {
3770 return ((LDKCResult_NodeInfoDecodeErrorZ*)arg)->result_ok;
3772 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_get_ok(uint32_t arg) {
3773 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
3774 CHECK(val->result_ok);
3775 LDKNodeInfo res_var = (*val->contents.result);
3776 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3777 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3778 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3781 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeInfoDecodeErrorZ_get_err(uint32_t arg) {
3782 LDKCResult_NodeInfoDecodeErrorZ *val = (LDKCResult_NodeInfoDecodeErrorZ*)(arg & ~1);
3783 CHECK(!val->result_ok);
3784 LDKDecodeError err_var = (*val->contents.err);
3785 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3786 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3787 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3790 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_result_ok(uint32_t arg) {
3791 return ((LDKCResult_NetworkGraphDecodeErrorZ*)arg)->result_ok;
3793 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_get_ok(uint32_t arg) {
3794 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
3795 CHECK(val->result_ok);
3796 LDKNetworkGraph res_var = (*val->contents.result);
3797 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3798 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3799 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3802 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecodeErrorZ_get_err(uint32_t arg) {
3803 LDKCResult_NetworkGraphDecodeErrorZ *val = (LDKCResult_NetworkGraphDecodeErrorZ*)(arg & ~1);
3804 CHECK(!val->result_ok);
3805 LDKDecodeError err_var = (*val->contents.err);
3806 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3807 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3808 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3811 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetAddressu8Z_result_ok(uint32_t arg) {
3812 return ((LDKCResult_NetAddressu8Z*)arg)->result_ok;
3814 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressu8Z_get_ok(uint32_t arg) {
3815 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
3816 CHECK(val->result_ok);
3817 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
3820 int8_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressu8Z_get_err(uint32_t arg) {
3821 LDKCResult_NetAddressu8Z *val = (LDKCResult_NetAddressu8Z*)(arg & ~1);
3822 CHECK(!val->result_ok);
3823 return *val->contents.err;
3825 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_result_ok(uint32_t arg) {
3826 return ((LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)arg)->result_ok;
3828 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_ok(uint32_t arg) {
3829 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
3830 CHECK(val->result_ok);
3831 LDKCResult_NetAddressu8Z* res_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
3832 *res_conv = (*val->contents.result);
3833 *res_conv = CResult_NetAddressu8Z_clone(res_conv);
3834 return (uint64_t)res_conv;
3836 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CResult_NetAddressu8ZDecodeErrorZ_get_err(uint32_t arg) {
3837 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ *val = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(arg & ~1);
3838 CHECK(!val->result_ok);
3839 LDKDecodeError err_var = (*val->contents.err);
3840 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3841 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3842 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3845 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_result_ok(uint32_t arg) {
3846 return ((LDKCResult_NetAddressDecodeErrorZ*)arg)->result_ok;
3848 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_get_ok(uint32_t arg) {
3849 LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
3850 CHECK(val->result_ok);
3851 uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1;
3854 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetAddressDecodeErrorZ_get_err(uint32_t arg) {
3855 LDKCResult_NetAddressDecodeErrorZ *val = (LDKCResult_NetAddressDecodeErrorZ*)(arg & ~1);
3856 CHECK(!val->result_ok);
3857 LDKDecodeError err_var = (*val->contents.err);
3858 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3859 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3860 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3863 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateAddHTLCZ_new(uint32_tArray elems) {
3864 LDKCVec_UpdateAddHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateAddHTLCZ), "LDKCVec_UpdateAddHTLCZ");
3865 ret->datalen = *((uint32_t*)elems);
3866 if (ret->datalen == 0) {
3869 ret->data = MALLOC(sizeof(LDKUpdateAddHTLC) * ret->datalen, "LDKCVec_UpdateAddHTLCZ Data");
3870 uint32_t *java_elems = (uint32_t*)(elems + 4);
3871 for (size_t i = 0; i < ret->datalen; i++) {
3872 uint32_t arr_elem = java_elems[i];
3873 LDKUpdateAddHTLC arr_elem_conv;
3874 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3875 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3876 arr_elem_conv = UpdateAddHTLC_clone(&arr_elem_conv);
3877 ret->data[i] = arr_elem_conv;
3880 return (uint64_t)ret;
3882 static inline LDKCVec_UpdateAddHTLCZ CVec_UpdateAddHTLCZ_clone(const LDKCVec_UpdateAddHTLCZ *orig) {
3883 LDKCVec_UpdateAddHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateAddHTLC) * orig->datalen, "LDKCVec_UpdateAddHTLCZ clone bytes"), .datalen = orig->datalen };
3884 for (size_t i = 0; i < ret.datalen; i++) {
3885 ret.data[i] = UpdateAddHTLC_clone(&orig->data[i]);
3889 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFulfillHTLCZ_new(uint32_tArray elems) {
3890 LDKCVec_UpdateFulfillHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFulfillHTLCZ), "LDKCVec_UpdateFulfillHTLCZ");
3891 ret->datalen = *((uint32_t*)elems);
3892 if (ret->datalen == 0) {
3895 ret->data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * ret->datalen, "LDKCVec_UpdateFulfillHTLCZ Data");
3896 uint32_t *java_elems = (uint32_t*)(elems + 4);
3897 for (size_t i = 0; i < ret->datalen; i++) {
3898 uint32_t arr_elem = java_elems[i];
3899 LDKUpdateFulfillHTLC arr_elem_conv;
3900 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3901 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3902 arr_elem_conv = UpdateFulfillHTLC_clone(&arr_elem_conv);
3903 ret->data[i] = arr_elem_conv;
3906 return (uint64_t)ret;
3908 static inline LDKCVec_UpdateFulfillHTLCZ CVec_UpdateFulfillHTLCZ_clone(const LDKCVec_UpdateFulfillHTLCZ *orig) {
3909 LDKCVec_UpdateFulfillHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFulfillHTLC) * orig->datalen, "LDKCVec_UpdateFulfillHTLCZ clone bytes"), .datalen = orig->datalen };
3910 for (size_t i = 0; i < ret.datalen; i++) {
3911 ret.data[i] = UpdateFulfillHTLC_clone(&orig->data[i]);
3915 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailHTLCZ_new(uint32_tArray elems) {
3916 LDKCVec_UpdateFailHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailHTLCZ), "LDKCVec_UpdateFailHTLCZ");
3917 ret->datalen = *((uint32_t*)elems);
3918 if (ret->datalen == 0) {
3921 ret->data = MALLOC(sizeof(LDKUpdateFailHTLC) * ret->datalen, "LDKCVec_UpdateFailHTLCZ Data");
3922 uint32_t *java_elems = (uint32_t*)(elems + 4);
3923 for (size_t i = 0; i < ret->datalen; i++) {
3924 uint32_t arr_elem = java_elems[i];
3925 LDKUpdateFailHTLC arr_elem_conv;
3926 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3927 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3928 arr_elem_conv = UpdateFailHTLC_clone(&arr_elem_conv);
3929 ret->data[i] = arr_elem_conv;
3932 return (uint64_t)ret;
3934 static inline LDKCVec_UpdateFailHTLCZ CVec_UpdateFailHTLCZ_clone(const LDKCVec_UpdateFailHTLCZ *orig) {
3935 LDKCVec_UpdateFailHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailHTLC) * orig->datalen, "LDKCVec_UpdateFailHTLCZ clone bytes"), .datalen = orig->datalen };
3936 for (size_t i = 0; i < ret.datalen; i++) {
3937 ret.data[i] = UpdateFailHTLC_clone(&orig->data[i]);
3941 uint32_t __attribute__((visibility("default"))) TS_LDKCVec_UpdateFailMalformedHTLCZ_new(uint32_tArray elems) {
3942 LDKCVec_UpdateFailMalformedHTLCZ *ret = MALLOC(sizeof(LDKCVec_UpdateFailMalformedHTLCZ), "LDKCVec_UpdateFailMalformedHTLCZ");
3943 ret->datalen = *((uint32_t*)elems);
3944 if (ret->datalen == 0) {
3947 ret->data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * ret->datalen, "LDKCVec_UpdateFailMalformedHTLCZ Data");
3948 uint32_t *java_elems = (uint32_t*)(elems + 4);
3949 for (size_t i = 0; i < ret->datalen; i++) {
3950 uint32_t arr_elem = java_elems[i];
3951 LDKUpdateFailMalformedHTLC arr_elem_conv;
3952 arr_elem_conv.inner = (void*)(arr_elem & (~1));
3953 arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0);
3954 arr_elem_conv = UpdateFailMalformedHTLC_clone(&arr_elem_conv);
3955 ret->data[i] = arr_elem_conv;
3958 return (uint64_t)ret;
3960 static inline LDKCVec_UpdateFailMalformedHTLCZ CVec_UpdateFailMalformedHTLCZ_clone(const LDKCVec_UpdateFailMalformedHTLCZ *orig) {
3961 LDKCVec_UpdateFailMalformedHTLCZ ret = { .data = MALLOC(sizeof(LDKUpdateFailMalformedHTLC) * orig->datalen, "LDKCVec_UpdateFailMalformedHTLCZ clone bytes"), .datalen = orig->datalen };
3962 for (size_t i = 0; i < ret.datalen; i++) {
3963 ret.data[i] = UpdateFailMalformedHTLC_clone(&orig->data[i]);
3967 jboolean __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_result_ok(uint32_t arg) {
3968 return ((LDKCResult_AcceptChannelDecodeErrorZ*)arg)->result_ok;
3970 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_get_ok(uint32_t arg) {
3971 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
3972 CHECK(val->result_ok);
3973 LDKAcceptChannel res_var = (*val->contents.result);
3974 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3975 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3976 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
3979 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AcceptChannelDecodeErrorZ_get_err(uint32_t arg) {
3980 LDKCResult_AcceptChannelDecodeErrorZ *val = (LDKCResult_AcceptChannelDecodeErrorZ*)(arg & ~1);
3981 CHECK(!val->result_ok);
3982 LDKDecodeError err_var = (*val->contents.err);
3983 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3984 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3985 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
3988 jboolean __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_result_ok(uint32_t arg) {
3989 return ((LDKCResult_AnnouncementSignaturesDecodeErrorZ*)arg)->result_ok;
3991 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_ok(uint32_t arg) {
3992 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
3993 CHECK(val->result_ok);
3994 LDKAnnouncementSignatures res_var = (*val->contents.result);
3995 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
3996 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
3997 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4000 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_AnnouncementSignaturesDecodeErrorZ_get_err(uint32_t arg) {
4001 LDKCResult_AnnouncementSignaturesDecodeErrorZ *val = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(arg & ~1);
4002 CHECK(!val->result_ok);
4003 LDKDecodeError err_var = (*val->contents.err);
4004 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4005 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4006 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4009 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_result_ok(uint32_t arg) {
4010 return ((LDKCResult_ChannelReestablishDecodeErrorZ*)arg)->result_ok;
4012 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_get_ok(uint32_t arg) {
4013 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
4014 CHECK(val->result_ok);
4015 LDKChannelReestablish res_var = (*val->contents.result);
4016 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4017 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4018 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4021 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelReestablishDecodeErrorZ_get_err(uint32_t arg) {
4022 LDKCResult_ChannelReestablishDecodeErrorZ *val = (LDKCResult_ChannelReestablishDecodeErrorZ*)(arg & ~1);
4023 CHECK(!val->result_ok);
4024 LDKDecodeError err_var = (*val->contents.err);
4025 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4026 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4027 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4030 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_result_ok(uint32_t arg) {
4031 return ((LDKCResult_ClosingSignedDecodeErrorZ*)arg)->result_ok;
4033 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_get_ok(uint32_t arg) {
4034 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
4035 CHECK(val->result_ok);
4036 LDKClosingSigned res_var = (*val->contents.result);
4037 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4038 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4039 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4042 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ClosingSignedDecodeErrorZ_get_err(uint32_t arg) {
4043 LDKCResult_ClosingSignedDecodeErrorZ *val = (LDKCResult_ClosingSignedDecodeErrorZ*)(arg & ~1);
4044 CHECK(!val->result_ok);
4045 LDKDecodeError err_var = (*val->contents.err);
4046 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4047 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4048 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4051 jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_result_ok(uint32_t arg) {
4052 return ((LDKCResult_CommitmentSignedDecodeErrorZ*)arg)->result_ok;
4054 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_get_ok(uint32_t arg) {
4055 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
4056 CHECK(val->result_ok);
4057 LDKCommitmentSigned res_var = (*val->contents.result);
4058 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4059 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4060 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4063 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CommitmentSignedDecodeErrorZ_get_err(uint32_t arg) {
4064 LDKCResult_CommitmentSignedDecodeErrorZ *val = (LDKCResult_CommitmentSignedDecodeErrorZ*)(arg & ~1);
4065 CHECK(!val->result_ok);
4066 LDKDecodeError err_var = (*val->contents.err);
4067 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4068 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4069 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4072 jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_result_ok(uint32_t arg) {
4073 return ((LDKCResult_FundingCreatedDecodeErrorZ*)arg)->result_ok;
4075 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_get_ok(uint32_t arg) {
4076 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
4077 CHECK(val->result_ok);
4078 LDKFundingCreated res_var = (*val->contents.result);
4079 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4080 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4081 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4084 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingCreatedDecodeErrorZ_get_err(uint32_t arg) {
4085 LDKCResult_FundingCreatedDecodeErrorZ *val = (LDKCResult_FundingCreatedDecodeErrorZ*)(arg & ~1);
4086 CHECK(!val->result_ok);
4087 LDKDecodeError err_var = (*val->contents.err);
4088 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4089 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4090 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4093 jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_result_ok(uint32_t arg) {
4094 return ((LDKCResult_FundingSignedDecodeErrorZ*)arg)->result_ok;
4096 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_get_ok(uint32_t arg) {
4097 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
4098 CHECK(val->result_ok);
4099 LDKFundingSigned res_var = (*val->contents.result);
4100 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4101 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4102 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4105 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingSignedDecodeErrorZ_get_err(uint32_t arg) {
4106 LDKCResult_FundingSignedDecodeErrorZ *val = (LDKCResult_FundingSignedDecodeErrorZ*)(arg & ~1);
4107 CHECK(!val->result_ok);
4108 LDKDecodeError err_var = (*val->contents.err);
4109 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4110 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4111 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4114 jboolean __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_result_ok(uint32_t arg) {
4115 return ((LDKCResult_FundingLockedDecodeErrorZ*)arg)->result_ok;
4117 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_get_ok(uint32_t arg) {
4118 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
4119 CHECK(val->result_ok);
4120 LDKFundingLocked res_var = (*val->contents.result);
4121 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4122 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4123 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4126 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_FundingLockedDecodeErrorZ_get_err(uint32_t arg) {
4127 LDKCResult_FundingLockedDecodeErrorZ *val = (LDKCResult_FundingLockedDecodeErrorZ*)(arg & ~1);
4128 CHECK(!val->result_ok);
4129 LDKDecodeError err_var = (*val->contents.err);
4130 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4131 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4132 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4135 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_result_ok(uint32_t arg) {
4136 return ((LDKCResult_InitDecodeErrorZ*)arg)->result_ok;
4138 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_get_ok(uint32_t arg) {
4139 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
4140 CHECK(val->result_ok);
4141 LDKInit res_var = (*val->contents.result);
4142 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4143 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4144 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4147 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InitDecodeErrorZ_get_err(uint32_t arg) {
4148 LDKCResult_InitDecodeErrorZ *val = (LDKCResult_InitDecodeErrorZ*)(arg & ~1);
4149 CHECK(!val->result_ok);
4150 LDKDecodeError err_var = (*val->contents.err);
4151 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4152 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4153 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4156 jboolean __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_result_ok(uint32_t arg) {
4157 return ((LDKCResult_OpenChannelDecodeErrorZ*)arg)->result_ok;
4159 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_get_ok(uint32_t arg) {
4160 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
4161 CHECK(val->result_ok);
4162 LDKOpenChannel res_var = (*val->contents.result);
4163 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4164 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4165 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4168 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OpenChannelDecodeErrorZ_get_err(uint32_t arg) {
4169 LDKCResult_OpenChannelDecodeErrorZ *val = (LDKCResult_OpenChannelDecodeErrorZ*)(arg & ~1);
4170 CHECK(!val->result_ok);
4171 LDKDecodeError err_var = (*val->contents.err);
4172 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4173 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4174 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4177 jboolean __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_result_ok(uint32_t arg) {
4178 return ((LDKCResult_RevokeAndACKDecodeErrorZ*)arg)->result_ok;
4180 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_get_ok(uint32_t arg) {
4181 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
4182 CHECK(val->result_ok);
4183 LDKRevokeAndACK res_var = (*val->contents.result);
4184 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4185 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4186 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4189 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_RevokeAndACKDecodeErrorZ_get_err(uint32_t arg) {
4190 LDKCResult_RevokeAndACKDecodeErrorZ *val = (LDKCResult_RevokeAndACKDecodeErrorZ*)(arg & ~1);
4191 CHECK(!val->result_ok);
4192 LDKDecodeError err_var = (*val->contents.err);
4193 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4194 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4195 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4198 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_result_ok(uint32_t arg) {
4199 return ((LDKCResult_ShutdownDecodeErrorZ*)arg)->result_ok;
4201 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_get_ok(uint32_t arg) {
4202 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
4203 CHECK(val->result_ok);
4204 LDKShutdown res_var = (*val->contents.result);
4205 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4206 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4207 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4210 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ShutdownDecodeErrorZ_get_err(uint32_t arg) {
4211 LDKCResult_ShutdownDecodeErrorZ *val = (LDKCResult_ShutdownDecodeErrorZ*)(arg & ~1);
4212 CHECK(!val->result_ok);
4213 LDKDecodeError err_var = (*val->contents.err);
4214 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4215 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4216 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4219 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_result_ok(uint32_t arg) {
4220 return ((LDKCResult_UpdateFailHTLCDecodeErrorZ*)arg)->result_ok;
4222 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_get_ok(uint32_t arg) {
4223 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
4224 CHECK(val->result_ok);
4225 LDKUpdateFailHTLC res_var = (*val->contents.result);
4226 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4227 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4228 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4231 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailHTLCDecodeErrorZ_get_err(uint32_t arg) {
4232 LDKCResult_UpdateFailHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(arg & ~1);
4233 CHECK(!val->result_ok);
4234 LDKDecodeError err_var = (*val->contents.err);
4235 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4236 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4237 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4240 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_result_ok(uint32_t arg) {
4241 return ((LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)arg)->result_ok;
4243 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_ok(uint32_t arg) {
4244 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
4245 CHECK(val->result_ok);
4246 LDKUpdateFailMalformedHTLC res_var = (*val->contents.result);
4247 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4248 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4249 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4252 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ_get_err(uint32_t arg) {
4253 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ *val = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(arg & ~1);
4254 CHECK(!val->result_ok);
4255 LDKDecodeError err_var = (*val->contents.err);
4256 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4257 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4258 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4261 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_result_ok(uint32_t arg) {
4262 return ((LDKCResult_UpdateFeeDecodeErrorZ*)arg)->result_ok;
4264 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_get_ok(uint32_t arg) {
4265 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
4266 CHECK(val->result_ok);
4267 LDKUpdateFee res_var = (*val->contents.result);
4268 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4269 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4270 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4273 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFeeDecodeErrorZ_get_err(uint32_t arg) {
4274 LDKCResult_UpdateFeeDecodeErrorZ *val = (LDKCResult_UpdateFeeDecodeErrorZ*)(arg & ~1);
4275 CHECK(!val->result_ok);
4276 LDKDecodeError err_var = (*val->contents.err);
4277 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4278 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4279 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4282 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_result_ok(uint32_t arg) {
4283 return ((LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)arg)->result_ok;
4285 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_ok(uint32_t arg) {
4286 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
4287 CHECK(val->result_ok);
4288 LDKUpdateFulfillHTLC res_var = (*val->contents.result);
4289 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4290 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4291 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4294 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateFulfillHTLCDecodeErrorZ_get_err(uint32_t arg) {
4295 LDKCResult_UpdateFulfillHTLCDecodeErrorZ *val = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(arg & ~1);
4296 CHECK(!val->result_ok);
4297 LDKDecodeError err_var = (*val->contents.err);
4298 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4299 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4300 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4303 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_result_ok(uint32_t arg) {
4304 return ((LDKCResult_UpdateAddHTLCDecodeErrorZ*)arg)->result_ok;
4306 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_get_ok(uint32_t arg) {
4307 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
4308 CHECK(val->result_ok);
4309 LDKUpdateAddHTLC res_var = (*val->contents.result);
4310 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4311 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4312 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4315 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UpdateAddHTLCDecodeErrorZ_get_err(uint32_t arg) {
4316 LDKCResult_UpdateAddHTLCDecodeErrorZ *val = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(arg & ~1);
4317 CHECK(!val->result_ok);
4318 LDKDecodeError err_var = (*val->contents.err);
4319 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4320 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4321 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4324 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_result_ok(uint32_t arg) {
4325 return ((LDKCResult_PingDecodeErrorZ*)arg)->result_ok;
4327 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_get_ok(uint32_t arg) {
4328 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
4329 CHECK(val->result_ok);
4330 LDKPing res_var = (*val->contents.result);
4331 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4332 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4333 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4336 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PingDecodeErrorZ_get_err(uint32_t arg) {
4337 LDKCResult_PingDecodeErrorZ *val = (LDKCResult_PingDecodeErrorZ*)(arg & ~1);
4338 CHECK(!val->result_ok);
4339 LDKDecodeError err_var = (*val->contents.err);
4340 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4341 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4342 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4345 jboolean __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_result_ok(uint32_t arg) {
4346 return ((LDKCResult_PongDecodeErrorZ*)arg)->result_ok;
4348 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_get_ok(uint32_t arg) {
4349 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
4350 CHECK(val->result_ok);
4351 LDKPong res_var = (*val->contents.result);
4352 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4353 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4354 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4357 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PongDecodeErrorZ_get_err(uint32_t arg) {
4358 LDKCResult_PongDecodeErrorZ *val = (LDKCResult_PongDecodeErrorZ*)(arg & ~1);
4359 CHECK(!val->result_ok);
4360 LDKDecodeError err_var = (*val->contents.err);
4361 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4362 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4363 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4366 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
4367 return ((LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
4369 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
4370 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4371 CHECK(val->result_ok);
4372 LDKUnsignedChannelAnnouncement res_var = (*val->contents.result);
4373 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4374 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4375 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4378 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ_get_err(uint32_t arg) {
4379 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4380 CHECK(!val->result_ok);
4381 LDKDecodeError err_var = (*val->contents.err);
4382 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4383 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4384 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4387 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
4388 return ((LDKCResult_ChannelAnnouncementDecodeErrorZ*)arg)->result_ok;
4390 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
4391 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4392 CHECK(val->result_ok);
4393 LDKChannelAnnouncement res_var = (*val->contents.result);
4394 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4395 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4396 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4399 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelAnnouncementDecodeErrorZ_get_err(uint32_t arg) {
4400 LDKCResult_ChannelAnnouncementDecodeErrorZ *val = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(arg & ~1);
4401 CHECK(!val->result_ok);
4402 LDKDecodeError err_var = (*val->contents.err);
4403 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4404 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4405 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4408 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
4409 return ((LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)arg)->result_ok;
4411 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
4412 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
4413 CHECK(val->result_ok);
4414 LDKUnsignedChannelUpdate res_var = (*val->contents.result);
4415 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4416 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4417 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4420 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedChannelUpdateDecodeErrorZ_get_err(uint32_t arg) {
4421 LDKCResult_UnsignedChannelUpdateDecodeErrorZ *val = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(arg & ~1);
4422 CHECK(!val->result_ok);
4423 LDKDecodeError err_var = (*val->contents.err);
4424 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4425 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4426 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4429 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_result_ok(uint32_t arg) {
4430 return ((LDKCResult_ChannelUpdateDecodeErrorZ*)arg)->result_ok;
4432 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_get_ok(uint32_t arg) {
4433 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
4434 CHECK(val->result_ok);
4435 LDKChannelUpdate res_var = (*val->contents.result);
4436 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4437 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4438 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4441 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelUpdateDecodeErrorZ_get_err(uint32_t arg) {
4442 LDKCResult_ChannelUpdateDecodeErrorZ *val = (LDKCResult_ChannelUpdateDecodeErrorZ*)(arg & ~1);
4443 CHECK(!val->result_ok);
4444 LDKDecodeError err_var = (*val->contents.err);
4445 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4446 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4447 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4450 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_result_ok(uint32_t arg) {
4451 return ((LDKCResult_ErrorMessageDecodeErrorZ*)arg)->result_ok;
4453 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_get_ok(uint32_t arg) {
4454 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
4455 CHECK(val->result_ok);
4456 LDKErrorMessage res_var = (*val->contents.result);
4457 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4458 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4459 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4462 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ErrorMessageDecodeErrorZ_get_err(uint32_t arg) {
4463 LDKCResult_ErrorMessageDecodeErrorZ *val = (LDKCResult_ErrorMessageDecodeErrorZ*)(arg & ~1);
4464 CHECK(!val->result_ok);
4465 LDKDecodeError err_var = (*val->contents.err);
4466 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4467 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4468 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4471 jboolean __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
4472 return ((LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)arg)->result_ok;
4474 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
4475 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
4476 CHECK(val->result_ok);
4477 LDKUnsignedNodeAnnouncement res_var = (*val->contents.result);
4478 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4479 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4480 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4483 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ_get_err(uint32_t arg) {
4484 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ *val = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(arg & ~1);
4485 CHECK(!val->result_ok);
4486 LDKDecodeError err_var = (*val->contents.err);
4487 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4488 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4489 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4492 jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_result_ok(uint32_t arg) {
4493 return ((LDKCResult_NodeAnnouncementDecodeErrorZ*)arg)->result_ok;
4495 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_get_ok(uint32_t arg) {
4496 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
4497 CHECK(val->result_ok);
4498 LDKNodeAnnouncement res_var = (*val->contents.result);
4499 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4500 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4501 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4504 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeAnnouncementDecodeErrorZ_get_err(uint32_t arg) {
4505 LDKCResult_NodeAnnouncementDecodeErrorZ *val = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(arg & ~1);
4506 CHECK(!val->result_ok);
4507 LDKDecodeError err_var = (*val->contents.err);
4508 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4509 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4510 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4513 jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_result_ok(uint32_t arg) {
4514 return ((LDKCResult_QueryShortChannelIdsDecodeErrorZ*)arg)->result_ok;
4516 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_ok(uint32_t arg) {
4517 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
4518 CHECK(val->result_ok);
4519 LDKQueryShortChannelIds res_var = (*val->contents.result);
4520 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4521 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4522 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4525 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryShortChannelIdsDecodeErrorZ_get_err(uint32_t arg) {
4526 LDKCResult_QueryShortChannelIdsDecodeErrorZ *val = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(arg & ~1);
4527 CHECK(!val->result_ok);
4528 LDKDecodeError err_var = (*val->contents.err);
4529 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4530 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4531 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4534 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_result_ok(uint32_t arg) {
4535 return ((LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)arg)->result_ok;
4537 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_ok(uint32_t arg) {
4538 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
4539 CHECK(val->result_ok);
4540 LDKReplyShortChannelIdsEnd res_var = (*val->contents.result);
4541 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4542 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4543 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4546 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ_get_err(uint32_t arg) {
4547 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ *val = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(arg & ~1);
4548 CHECK(!val->result_ok);
4549 LDKDecodeError err_var = (*val->contents.err);
4550 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4551 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4552 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4555 jboolean __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
4556 return ((LDKCResult_QueryChannelRangeDecodeErrorZ*)arg)->result_ok;
4558 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
4559 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
4560 CHECK(val->result_ok);
4561 LDKQueryChannelRange res_var = (*val->contents.result);
4562 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4563 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4564 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4567 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_QueryChannelRangeDecodeErrorZ_get_err(uint32_t arg) {
4568 LDKCResult_QueryChannelRangeDecodeErrorZ *val = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(arg & ~1);
4569 CHECK(!val->result_ok);
4570 LDKDecodeError err_var = (*val->contents.err);
4571 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4572 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4573 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4576 jboolean __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_result_ok(uint32_t arg) {
4577 return ((LDKCResult_ReplyChannelRangeDecodeErrorZ*)arg)->result_ok;
4579 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_get_ok(uint32_t arg) {
4580 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
4581 CHECK(val->result_ok);
4582 LDKReplyChannelRange res_var = (*val->contents.result);
4583 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4584 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4585 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4588 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ReplyChannelRangeDecodeErrorZ_get_err(uint32_t arg) {
4589 LDKCResult_ReplyChannelRangeDecodeErrorZ *val = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(arg & ~1);
4590 CHECK(!val->result_ok);
4591 LDKDecodeError err_var = (*val->contents.err);
4592 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4593 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4594 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4597 jboolean __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_result_ok(uint32_t arg) {
4598 return ((LDKCResult_GossipTimestampFilterDecodeErrorZ*)arg)->result_ok;
4600 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_get_ok(uint32_t arg) {
4601 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
4602 CHECK(val->result_ok);
4603 LDKGossipTimestampFilter res_var = (*val->contents.result);
4604 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4605 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4606 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4609 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_GossipTimestampFilterDecodeErrorZ_get_err(uint32_t arg) {
4610 LDKCResult_GossipTimestampFilterDecodeErrorZ *val = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(arg & ~1);
4611 CHECK(!val->result_ok);
4612 LDKDecodeError err_var = (*val->contents.err);
4613 CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4614 CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4615 uint64_t err_ref = (uint64_t)err_var.inner & ~1;
4618 uint32_t __attribute__((visibility("default"))) TS_LDKSignOrCreationError_ref_from_ptr(uint32_t ptr) {
4619 LDKSignOrCreationError *obj = (LDKSignOrCreationError*)(ptr & ~1);
4621 case LDKSignOrCreationError_SignError: {
4622 return 0 /* LDKSignOrCreationError - SignError */;
4624 case LDKSignOrCreationError_CreationError: {
4625 uint32_t creation_error_conv = LDKCreationError_to_js(obj->creation_error);
4626 return 0 /* LDKSignOrCreationError - CreationError */; (void) creation_error_conv;
4631 jboolean __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_result_ok(uint32_t arg) {
4632 return ((LDKCResult_InvoiceSignOrCreationErrorZ*)arg)->result_ok;
4634 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_get_ok(uint32_t arg) {
4635 LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
4636 CHECK(val->result_ok);
4637 LDKInvoice res_var = (*val->contents.result);
4638 CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
4639 CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
4640 uint64_t res_ref = (uint64_t)res_var.inner & ~1;
4643 uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCreationErrorZ_get_err(uint32_t arg) {
4644 LDKCResult_InvoiceSignOrCreationErrorZ *val = (LDKCResult_InvoiceSignOrCreationErrorZ*)(arg & ~1);
4645 CHECK(!val->result_ok);
4646 uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1;
4649 typedef struct LDKMessageSendEventsProvider_JCalls {
4650 atomic_size_t refcnt;
4651 uint32_t get_and_clear_pending_msg_events_meth;
4652 } LDKMessageSendEventsProvider_JCalls;
4653 static void LDKMessageSendEventsProvider_JCalls_free(void* this_arg) {
4654 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4655 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4656 js_free(j_calls->get_and_clear_pending_msg_events_meth);
4660 LDKCVec_MessageSendEventZ get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall(const void* this_arg) {
4661 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4662 uint32_tArray ret = js_invoke_function_0(j_calls->get_and_clear_pending_msg_events_meth);
4663 LDKCVec_MessageSendEventZ ret_constr;
4664 ret_constr.datalen = *((uint32_t*)ret);
4665 if (ret_constr.datalen > 0)
4666 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
4668 ret_constr.data = NULL;
4669 uint32_t* ret_vals = (uint32_t*)(ret + 4);
4670 for (size_t s = 0; s < ret_constr.datalen; s++) {
4671 uint32_t ret_conv_18 = ret_vals[s];
4672 LDKMessageSendEvent ret_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1);
4673 ret_conv_18_conv = MessageSendEvent_clone((LDKMessageSendEvent*)(((uint64_t)ret_conv_18) & ~1));
4674 ret_constr.data[s] = ret_conv_18_conv;
4678 static void* LDKMessageSendEventsProvider_JCalls_clone(const void* this_arg) {
4679 LDKMessageSendEventsProvider_JCalls *j_calls = (LDKMessageSendEventsProvider_JCalls*) this_arg;
4680 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4681 return (void*) this_arg;
4683 static inline LDKMessageSendEventsProvider LDKMessageSendEventsProvider_init (/*TODO: JS Object Reference */void* o) {
4684 LDKMessageSendEventsProvider_JCalls *calls = MALLOC(sizeof(LDKMessageSendEventsProvider_JCalls), "LDKMessageSendEventsProvider_JCalls");
4685 atomic_init(&calls->refcnt, 1);
4686 //TODO: Assign calls->o from o
4688 LDKMessageSendEventsProvider ret = {
4689 .this_arg = (void*) calls,
4690 .get_and_clear_pending_msg_events = get_and_clear_pending_msg_events_LDKMessageSendEventsProvider_jcall,
4691 .free = LDKMessageSendEventsProvider_JCalls_free,
4695 long __attribute__((visibility("default"))) TS_LDKMessageSendEventsProvider_new(/*TODO: JS Object Reference */void* o) {
4696 LDKMessageSendEventsProvider *res_ptr = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
4697 *res_ptr = LDKMessageSendEventsProvider_init(o);
4698 return (long)res_ptr;
4700 uint32_tArray __attribute__((visibility("default"))) TS_MessageSendEventsProvider_get_and_clear_pending_msg_events(uint32_t this_arg) {
4701 LDKMessageSendEventsProvider* this_arg_conv = (LDKMessageSendEventsProvider*)(((uint64_t)this_arg) & ~1);
4702 LDKCVec_MessageSendEventZ ret_var = (this_arg_conv->get_and_clear_pending_msg_events)(this_arg_conv->this_arg);
4703 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
4704 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
4705 for (size_t s = 0; s < ret_var.datalen; s++) {
4706 LDKMessageSendEvent *ret_conv_18_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
4707 *ret_conv_18_copy = MessageSendEvent_clone(&ret_var.data[s]);
4708 uint64_t ret_conv_18_ref = (uint64_t)ret_conv_18_copy;
4709 ret_arr_ptr[s] = ret_conv_18_ref;
4715 typedef struct LDKEventHandler_JCalls {
4716 atomic_size_t refcnt;
4717 uint32_t handle_event_meth;
4718 } LDKEventHandler_JCalls;
4719 static void LDKEventHandler_JCalls_free(void* this_arg) {
4720 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
4721 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4722 js_free(j_calls->handle_event_meth);
4726 void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) {
4727 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
4728 LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
4729 *event_copy = event;
4730 uint64_t event_ref = (uint64_t)event_copy;
4731 js_invoke_function_1(j_calls->handle_event_meth, event_ref);
4733 static void* LDKEventHandler_JCalls_clone(const void* this_arg) {
4734 LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg;
4735 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4736 return (void*) this_arg;
4738 static inline LDKEventHandler LDKEventHandler_init (/*TODO: JS Object Reference */void* o) {
4739 LDKEventHandler_JCalls *calls = MALLOC(sizeof(LDKEventHandler_JCalls), "LDKEventHandler_JCalls");
4740 atomic_init(&calls->refcnt, 1);
4741 //TODO: Assign calls->o from o
4743 LDKEventHandler ret = {
4744 .this_arg = (void*) calls,
4745 .handle_event = handle_event_LDKEventHandler_jcall,
4746 .free = LDKEventHandler_JCalls_free,
4750 long __attribute__((visibility("default"))) TS_LDKEventHandler_new(/*TODO: JS Object Reference */void* o) {
4751 LDKEventHandler *res_ptr = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
4752 *res_ptr = LDKEventHandler_init(o);
4753 return (long)res_ptr;
4755 void __attribute__((visibility("default"))) TS_EventHandler_handle_event(uint32_t this_arg, uint32_t event) {
4756 LDKEventHandler* this_arg_conv = (LDKEventHandler*)(((uint64_t)this_arg) & ~1);
4757 LDKEvent event_conv = *(LDKEvent*)(((uint64_t)event) & ~1);
4758 (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv);
4761 typedef struct LDKEventsProvider_JCalls {
4762 atomic_size_t refcnt;
4763 uint32_t process_pending_events_meth;
4764 } LDKEventsProvider_JCalls;
4765 static void LDKEventsProvider_JCalls_free(void* this_arg) {
4766 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4767 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4768 js_free(j_calls->process_pending_events_meth);
4772 void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) {
4773 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4774 LDKEventHandler* ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler");
4776 js_invoke_function_1(j_calls->process_pending_events_meth, (uint64_t)ret);
4778 static void* LDKEventsProvider_JCalls_clone(const void* this_arg) {
4779 LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg;
4780 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4781 return (void*) this_arg;
4783 static inline LDKEventsProvider LDKEventsProvider_init (/*TODO: JS Object Reference */void* o) {
4784 LDKEventsProvider_JCalls *calls = MALLOC(sizeof(LDKEventsProvider_JCalls), "LDKEventsProvider_JCalls");
4785 atomic_init(&calls->refcnt, 1);
4786 //TODO: Assign calls->o from o
4788 LDKEventsProvider ret = {
4789 .this_arg = (void*) calls,
4790 .process_pending_events = process_pending_events_LDKEventsProvider_jcall,
4791 .free = LDKEventsProvider_JCalls_free,
4795 long __attribute__((visibility("default"))) TS_LDKEventsProvider_new(/*TODO: JS Object Reference */void* o) {
4796 LDKEventsProvider *res_ptr = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
4797 *res_ptr = LDKEventsProvider_init(o);
4798 return (long)res_ptr;
4800 void __attribute__((visibility("default"))) TS_EventsProvider_process_pending_events(uint32_t this_arg, uint32_t handler) {
4801 LDKEventsProvider* this_arg_conv = (LDKEventsProvider*)(((uint64_t)this_arg) & ~1);
4802 LDKEventHandler handler_conv = *(LDKEventHandler*)(((uint64_t)handler) & ~1);
4803 (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv);
4806 typedef struct LDKAccess_JCalls {
4807 atomic_size_t refcnt;
4808 uint32_t get_utxo_meth;
4810 static void LDKAccess_JCalls_free(void* this_arg) {
4811 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4812 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4813 js_free(j_calls->get_utxo_meth);
4817 LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) {
4818 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4819 int8_tArray genesis_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
4820 memcpy((uint8_t*)(genesis_hash_arr + 4), *genesis_hash, 32);
4821 LDKCResult_TxOutAccessErrorZ* ret = (LDKCResult_TxOutAccessErrorZ*)js_invoke_function_2(j_calls->get_utxo_meth, genesis_hash_arr, short_channel_id);
4822 LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1);
4823 ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1));
4826 static void* LDKAccess_JCalls_clone(const void* this_arg) {
4827 LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg;
4828 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4829 return (void*) this_arg;
4831 static inline LDKAccess LDKAccess_init (/*TODO: JS Object Reference */void* o) {
4832 LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls");
4833 atomic_init(&calls->refcnt, 1);
4834 //TODO: Assign calls->o from o
4837 .this_arg = (void*) calls,
4838 .get_utxo = get_utxo_LDKAccess_jcall,
4839 .free = LDKAccess_JCalls_free,
4843 long __attribute__((visibility("default"))) TS_LDKAccess_new(/*TODO: JS Object Reference */void* o) {
4844 LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
4845 *res_ptr = LDKAccess_init(o);
4846 return (long)res_ptr;
4848 uint32_t __attribute__((visibility("default"))) TS_Access_get_utxo(uint32_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) {
4849 LDKAccess* this_arg_conv = (LDKAccess*)(((uint64_t)this_arg) & ~1);
4850 unsigned char genesis_hash_arr[32];
4851 CHECK(*((uint32_t*)genesis_hash) == 32);
4852 memcpy(genesis_hash_arr, (uint8_t*)(genesis_hash + 4), 32);
4853 unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr;
4854 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
4855 *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id);
4856 return (uint64_t)ret_conv;
4859 typedef struct LDKListen_JCalls {
4860 atomic_size_t refcnt;
4861 uint32_t block_connected_meth;
4862 uint32_t block_disconnected_meth;
4864 static void LDKListen_JCalls_free(void* this_arg) {
4865 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4866 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4867 js_free(j_calls->block_connected_meth);
4868 js_free(j_calls->block_disconnected_meth);
4872 void block_connected_LDKListen_jcall(const void* this_arg, LDKu8slice block, uint32_t height) {
4873 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4874 LDKu8slice block_var = block;
4875 int8_tArray block_arr = init_arr(block_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
4876 memcpy((uint8_t*)(block_arr + 4), block_var.data, block_var.datalen);
4877 js_invoke_function_2(j_calls->block_connected_meth, block_arr, height);
4879 void block_disconnected_LDKListen_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
4880 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4881 int8_tArray header_arr = init_arr(80, sizeof(uint8_t), "Native int8_tArray Bytes");
4882 memcpy((uint8_t*)(header_arr + 4), *header, 80);
4883 js_invoke_function_2(j_calls->block_disconnected_meth, header_arr, height);
4885 static void* LDKListen_JCalls_clone(const void* this_arg) {
4886 LDKListen_JCalls *j_calls = (LDKListen_JCalls*) this_arg;
4887 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4888 return (void*) this_arg;
4890 static inline LDKListen LDKListen_init (/*TODO: JS Object Reference */void* o) {
4891 LDKListen_JCalls *calls = MALLOC(sizeof(LDKListen_JCalls), "LDKListen_JCalls");
4892 atomic_init(&calls->refcnt, 1);
4893 //TODO: Assign calls->o from o
4896 .this_arg = (void*) calls,
4897 .block_connected = block_connected_LDKListen_jcall,
4898 .block_disconnected = block_disconnected_LDKListen_jcall,
4899 .free = LDKListen_JCalls_free,
4903 long __attribute__((visibility("default"))) TS_LDKListen_new(/*TODO: JS Object Reference */void* o) {
4904 LDKListen *res_ptr = MALLOC(sizeof(LDKListen), "LDKListen");
4905 *res_ptr = LDKListen_init(o);
4906 return (long)res_ptr;
4908 void __attribute__((visibility("default"))) TS_Listen_block_connected(uint32_t this_arg, int8_tArray block, int32_t height) {
4909 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
4910 LDKu8slice block_ref;
4911 block_ref.datalen = *((uint32_t*)block);
4912 block_ref.data = (int8_t*)(block + 4);
4913 (this_arg_conv->block_connected)(this_arg_conv->this_arg, block_ref, height);
4916 void __attribute__((visibility("default"))) TS_Listen_block_disconnected(uint32_t this_arg, int8_tArray header, int32_t height) {
4917 LDKListen* this_arg_conv = (LDKListen*)(((uint64_t)this_arg) & ~1);
4918 unsigned char header_arr[80];
4919 CHECK(*((uint32_t*)header) == 80);
4920 memcpy(header_arr, (uint8_t*)(header + 4), 80);
4921 unsigned char (*header_ref)[80] = &header_arr;
4922 (this_arg_conv->block_disconnected)(this_arg_conv->this_arg, header_ref, height);
4925 typedef struct LDKConfirm_JCalls {
4926 atomic_size_t refcnt;
4927 uint32_t transactions_confirmed_meth;
4928 uint32_t transaction_unconfirmed_meth;
4929 uint32_t best_block_updated_meth;
4930 uint32_t get_relevant_txids_meth;
4931 } LDKConfirm_JCalls;
4932 static void LDKConfirm_JCalls_free(void* this_arg) {
4933 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4934 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
4935 js_free(j_calls->transactions_confirmed_meth);
4936 js_free(j_calls->transaction_unconfirmed_meth);
4937 js_free(j_calls->best_block_updated_meth);
4938 js_free(j_calls->get_relevant_txids_meth);
4942 void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], LDKCVec_C2Tuple_usizeTransactionZZ txdata, uint32_t height) {
4943 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4944 int8_tArray header_arr = init_arr(80, sizeof(uint8_t), "Native int8_tArray Bytes");
4945 memcpy((uint8_t*)(header_arr + 4), *header, 80);
4946 LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata;
4947 uint32_tArray txdata_arr = init_arr(txdata_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
4948 uint32_t *txdata_arr_ptr = (uint32_t*)(txdata_arr + 4);
4949 for (size_t e = 0; e < txdata_var.datalen; e++) {
4950 LDKC2Tuple_usizeTransactionZ* txdata_conv_30_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
4951 *txdata_conv_30_ref = txdata_var.data[e];
4952 txdata_arr_ptr[e] = (uint64_t)txdata_conv_30_ref;
4954 FREE(txdata_var.data);
4955 js_invoke_function_3(j_calls->transactions_confirmed_meth, header_arr, txdata_arr, height);
4957 void transaction_unconfirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t (* txid)[32]) {
4958 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4959 int8_tArray txid_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
4960 memcpy((uint8_t*)(txid_arr + 4), *txid, 32);
4961 js_invoke_function_1(j_calls->transaction_unconfirmed_meth, txid_arr);
4963 void best_block_updated_LDKConfirm_jcall(const void* this_arg, const uint8_t (* header)[80], uint32_t height) {
4964 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4965 int8_tArray header_arr = init_arr(80, sizeof(uint8_t), "Native int8_tArray Bytes");
4966 memcpy((uint8_t*)(header_arr + 4), *header, 80);
4967 js_invoke_function_2(j_calls->best_block_updated_meth, header_arr, height);
4969 LDKCVec_TxidZ get_relevant_txids_LDKConfirm_jcall(const void* this_arg) {
4970 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4971 ptrArray ret = js_invoke_function_0(j_calls->get_relevant_txids_meth);
4972 LDKCVec_TxidZ ret_constr;
4973 ret_constr.datalen = *((uint32_t*)ret);
4974 if (ret_constr.datalen > 0)
4975 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
4977 ret_constr.data = NULL;
4978 int8_tArray* ret_vals = (int8_tArray*)(ret + 4);
4979 for (size_t m = 0; m < ret_constr.datalen; m++) {
4980 int8_tArray ret_conv_12 = ret_vals[m];
4981 LDKThirtyTwoBytes ret_conv_12_ref;
4982 CHECK(*((uint32_t*)ret_conv_12) == 32);
4983 memcpy(ret_conv_12_ref.data, (uint8_t*)(ret_conv_12 + 4), 32);
4984 ret_constr.data[m] = ret_conv_12_ref;
4988 static void* LDKConfirm_JCalls_clone(const void* this_arg) {
4989 LDKConfirm_JCalls *j_calls = (LDKConfirm_JCalls*) this_arg;
4990 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
4991 return (void*) this_arg;
4993 static inline LDKConfirm LDKConfirm_init (/*TODO: JS Object Reference */void* o) {
4994 LDKConfirm_JCalls *calls = MALLOC(sizeof(LDKConfirm_JCalls), "LDKConfirm_JCalls");
4995 atomic_init(&calls->refcnt, 1);
4996 //TODO: Assign calls->o from o
4999 .this_arg = (void*) calls,
5000 .transactions_confirmed = transactions_confirmed_LDKConfirm_jcall,
5001 .transaction_unconfirmed = transaction_unconfirmed_LDKConfirm_jcall,
5002 .best_block_updated = best_block_updated_LDKConfirm_jcall,
5003 .get_relevant_txids = get_relevant_txids_LDKConfirm_jcall,
5004 .free = LDKConfirm_JCalls_free,
5008 long __attribute__((visibility("default"))) TS_LDKConfirm_new(/*TODO: JS Object Reference */void* o) {
5009 LDKConfirm *res_ptr = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
5010 *res_ptr = LDKConfirm_init(o);
5011 return (long)res_ptr;
5013 void __attribute__((visibility("default"))) TS_Confirm_transactions_confirmed(uint32_t this_arg, int8_tArray header, uint32_tArray txdata, int32_t height) {
5014 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
5015 unsigned char header_arr[80];
5016 CHECK(*((uint32_t*)header) == 80);
5017 memcpy(header_arr, (uint8_t*)(header + 4), 80);
5018 unsigned char (*header_ref)[80] = &header_arr;
5019 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
5020 txdata_constr.datalen = *((uint32_t*)txdata);
5021 if (txdata_constr.datalen > 0)
5022 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
5024 txdata_constr.data = NULL;
5025 uint32_t* txdata_vals = (uint32_t*)(txdata + 4);
5026 for (size_t e = 0; e < txdata_constr.datalen; e++) {
5027 uint32_t txdata_conv_30 = txdata_vals[e];
5028 LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1);
5029 txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1));
5030 txdata_constr.data[e] = txdata_conv_30_conv;
5032 (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height);
5035 void __attribute__((visibility("default"))) TS_Confirm_transaction_unconfirmed(uint32_t this_arg, int8_tArray txid) {
5036 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
5037 unsigned char txid_arr[32];
5038 CHECK(*((uint32_t*)txid) == 32);
5039 memcpy(txid_arr, (uint8_t*)(txid + 4), 32);
5040 unsigned char (*txid_ref)[32] = &txid_arr;
5041 (this_arg_conv->transaction_unconfirmed)(this_arg_conv->this_arg, txid_ref);
5044 void __attribute__((visibility("default"))) TS_Confirm_best_block_updated(uint32_t this_arg, int8_tArray header, int32_t height) {
5045 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
5046 unsigned char header_arr[80];
5047 CHECK(*((uint32_t*)header) == 80);
5048 memcpy(header_arr, (uint8_t*)(header + 4), 80);
5049 unsigned char (*header_ref)[80] = &header_arr;
5050 (this_arg_conv->best_block_updated)(this_arg_conv->this_arg, header_ref, height);
5053 ptrArray __attribute__((visibility("default"))) TS_Confirm_get_relevant_txids(uint32_t this_arg) {
5054 LDKConfirm* this_arg_conv = (LDKConfirm*)(((uint64_t)this_arg) & ~1);
5055 LDKCVec_TxidZ ret_var = (this_arg_conv->get_relevant_txids)(this_arg_conv->this_arg);
5056 ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
5057 int8_tArray *ret_arr_ptr = (int8_tArray*)(ret_arr + 4);
5058 for (size_t m = 0; m < ret_var.datalen; m++) {
5059 int8_tArray ret_conv_12_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
5060 memcpy((uint8_t*)(ret_conv_12_arr + 4), ret_var.data[m].data, 32);
5061 ret_arr_ptr[m] = ret_conv_12_arr;
5067 typedef struct LDKFilter_JCalls {
5068 atomic_size_t refcnt;
5069 uint32_t register_tx_meth;
5070 uint32_t register_output_meth;
5072 static void LDKFilter_JCalls_free(void* this_arg) {
5073 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
5074 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5075 js_free(j_calls->register_tx_meth);
5076 js_free(j_calls->register_output_meth);
5080 void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) {
5081 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
5082 int8_tArray txid_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
5083 memcpy((uint8_t*)(txid_arr + 4), *txid, 32);
5084 LDKu8slice script_pubkey_var = script_pubkey;
5085 int8_tArray script_pubkey_arr = init_arr(script_pubkey_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
5086 memcpy((uint8_t*)(script_pubkey_arr + 4), script_pubkey_var.data, script_pubkey_var.datalen);
5087 js_invoke_function_2(j_calls->register_tx_meth, txid_arr, script_pubkey_arr);
5089 LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) {
5090 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
5091 LDKWatchedOutput output_var = output;
5092 CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5093 CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5094 uint64_t output_ref = (uint64_t)output_var.inner;
5095 if (output_var.is_owned) {
5098 LDKCOption_C2Tuple_usizeTransactionZZ* ret = (LDKCOption_C2Tuple_usizeTransactionZZ*)js_invoke_function_1(j_calls->register_output_meth, output_ref);
5099 LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1);
5100 ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1));
5103 static void* LDKFilter_JCalls_clone(const void* this_arg) {
5104 LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg;
5105 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5106 return (void*) this_arg;
5108 static inline LDKFilter LDKFilter_init (/*TODO: JS Object Reference */void* o) {
5109 LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls");
5110 atomic_init(&calls->refcnt, 1);
5111 //TODO: Assign calls->o from o
5114 .this_arg = (void*) calls,
5115 .register_tx = register_tx_LDKFilter_jcall,
5116 .register_output = register_output_LDKFilter_jcall,
5117 .free = LDKFilter_JCalls_free,
5121 long __attribute__((visibility("default"))) TS_LDKFilter_new(/*TODO: JS Object Reference */void* o) {
5122 LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
5123 *res_ptr = LDKFilter_init(o);
5124 return (long)res_ptr;
5126 void __attribute__((visibility("default"))) TS_Filter_register_tx(uint32_t this_arg, int8_tArray txid, int8_tArray script_pubkey) {
5127 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
5128 unsigned char txid_arr[32];
5129 CHECK(*((uint32_t*)txid) == 32);
5130 memcpy(txid_arr, (uint8_t*)(txid + 4), 32);
5131 unsigned char (*txid_ref)[32] = &txid_arr;
5132 LDKu8slice script_pubkey_ref;
5133 script_pubkey_ref.datalen = *((uint32_t*)script_pubkey);
5134 script_pubkey_ref.data = (int8_t*)(script_pubkey + 4);
5135 (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref);
5138 uint32_t __attribute__((visibility("default"))) TS_Filter_register_output(uint32_t this_arg, uint32_t output) {
5139 LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1);
5140 LDKWatchedOutput output_conv;
5141 output_conv.inner = (void*)(output & (~1));
5142 output_conv.is_owned = (output & 1) || (output == 0);
5143 output_conv = WatchedOutput_clone(&output_conv);
5144 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
5145 *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv);
5146 uint64_t ret_ref = (uint64_t)ret_copy;
5150 typedef struct LDKPersist_JCalls {
5151 atomic_size_t refcnt;
5152 uint32_t persist_new_channel_meth;
5153 uint32_t update_persisted_channel_meth;
5154 } LDKPersist_JCalls;
5155 static void LDKPersist_JCalls_free(void* this_arg) {
5156 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5157 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5158 js_free(j_calls->persist_new_channel_meth);
5159 js_free(j_calls->update_persisted_channel_meth);
5163 LDKCResult_NoneChannelMonitorUpdateErrZ persist_new_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitor * data) {
5164 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5165 LDKOutPoint id_var = id;
5166 CHECK((((uint64_t)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5167 CHECK((((uint64_t)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5168 uint64_t id_ref = (uint64_t)id_var.inner;
5169 if (id_var.is_owned) {
5172 LDKChannelMonitor data_var = *data;
5173 data_var = ChannelMonitor_clone(data);
5174 CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5175 CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5176 uint64_t data_ref = (uint64_t)data_var.inner;
5177 if (data_var.is_owned) {
5180 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_2(j_calls->persist_new_channel_meth, id_ref, data_ref);
5181 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
5182 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
5185 LDKCResult_NoneChannelMonitorUpdateErrZ update_persisted_channel_LDKPersist_jcall(const void* this_arg, LDKOutPoint id, const LDKChannelMonitorUpdate * update, const LDKChannelMonitor * data) {
5186 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5187 LDKOutPoint id_var = id;
5188 CHECK((((uint64_t)id_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5189 CHECK((((uint64_t)&id_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5190 uint64_t id_ref = (uint64_t)id_var.inner;
5191 if (id_var.is_owned) {
5194 LDKChannelMonitorUpdate update_var = *update;
5195 update_var = ChannelMonitorUpdate_clone(update);
5196 CHECK((((uint64_t)update_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5197 CHECK((((uint64_t)&update_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5198 uint64_t update_ref = (uint64_t)update_var.inner;
5199 if (update_var.is_owned) {
5202 LDKChannelMonitor data_var = *data;
5203 data_var = ChannelMonitor_clone(data);
5204 CHECK((((uint64_t)data_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5205 CHECK((((uint64_t)&data_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5206 uint64_t data_ref = (uint64_t)data_var.inner;
5207 if (data_var.is_owned) {
5210 LDKCResult_NoneChannelMonitorUpdateErrZ* ret = (LDKCResult_NoneChannelMonitorUpdateErrZ*)js_invoke_function_3(j_calls->update_persisted_channel_meth, id_ref, update_ref, data_ref);
5211 LDKCResult_NoneChannelMonitorUpdateErrZ ret_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1);
5212 ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone((LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)ret) & ~1));
5215 static void* LDKPersist_JCalls_clone(const void* this_arg) {
5216 LDKPersist_JCalls *j_calls = (LDKPersist_JCalls*) this_arg;
5217 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5218 return (void*) this_arg;
5220 static inline LDKPersist LDKPersist_init (/*TODO: JS Object Reference */void* o) {
5221 LDKPersist_JCalls *calls = MALLOC(sizeof(LDKPersist_JCalls), "LDKPersist_JCalls");
5222 atomic_init(&calls->refcnt, 1);
5223 //TODO: Assign calls->o from o
5226 .this_arg = (void*) calls,
5227 .persist_new_channel = persist_new_channel_LDKPersist_jcall,
5228 .update_persisted_channel = update_persisted_channel_LDKPersist_jcall,
5229 .free = LDKPersist_JCalls_free,
5233 long __attribute__((visibility("default"))) TS_LDKPersist_new(/*TODO: JS Object Reference */void* o) {
5234 LDKPersist *res_ptr = MALLOC(sizeof(LDKPersist), "LDKPersist");
5235 *res_ptr = LDKPersist_init(o);
5236 return (long)res_ptr;
5238 uint32_t __attribute__((visibility("default"))) TS_Persist_persist_new_channel(uint32_t this_arg, uint32_t id, uint32_t data) {
5239 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
5240 LDKOutPoint id_conv;
5241 id_conv.inner = (void*)(id & (~1));
5242 id_conv.is_owned = (id & 1) || (id == 0);
5243 id_conv = OutPoint_clone(&id_conv);
5244 LDKChannelMonitor data_conv;
5245 data_conv.inner = (void*)(data & (~1));
5246 data_conv.is_owned = false;
5247 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5248 *ret_conv = (this_arg_conv->persist_new_channel)(this_arg_conv->this_arg, id_conv, &data_conv);
5249 return (uint64_t)ret_conv;
5252 uint32_t __attribute__((visibility("default"))) TS_Persist_update_persisted_channel(uint32_t this_arg, uint32_t id, uint32_t update, uint32_t data) {
5253 LDKPersist* this_arg_conv = (LDKPersist*)(((uint64_t)this_arg) & ~1);
5254 LDKOutPoint id_conv;
5255 id_conv.inner = (void*)(id & (~1));
5256 id_conv.is_owned = (id & 1) || (id == 0);
5257 id_conv = OutPoint_clone(&id_conv);
5258 LDKChannelMonitorUpdate update_conv;
5259 update_conv.inner = (void*)(update & (~1));
5260 update_conv.is_owned = false;
5261 LDKChannelMonitor data_conv;
5262 data_conv.inner = (void*)(data & (~1));
5263 data_conv.is_owned = false;
5264 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
5265 *ret_conv = (this_arg_conv->update_persisted_channel)(this_arg_conv->this_arg, id_conv, &update_conv, &data_conv);
5266 return (uint64_t)ret_conv;
5269 typedef struct LDKChannelMessageHandler_JCalls {
5270 atomic_size_t refcnt;
5271 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
5272 uint32_t handle_open_channel_meth;
5273 uint32_t handle_accept_channel_meth;
5274 uint32_t handle_funding_created_meth;
5275 uint32_t handle_funding_signed_meth;
5276 uint32_t handle_funding_locked_meth;
5277 uint32_t handle_shutdown_meth;
5278 uint32_t handle_closing_signed_meth;
5279 uint32_t handle_update_add_htlc_meth;
5280 uint32_t handle_update_fulfill_htlc_meth;
5281 uint32_t handle_update_fail_htlc_meth;
5282 uint32_t handle_update_fail_malformed_htlc_meth;
5283 uint32_t handle_commitment_signed_meth;
5284 uint32_t handle_revoke_and_ack_meth;
5285 uint32_t handle_update_fee_meth;
5286 uint32_t handle_announcement_signatures_meth;
5287 uint32_t peer_disconnected_meth;
5288 uint32_t peer_connected_meth;
5289 uint32_t handle_channel_reestablish_meth;
5290 uint32_t handle_channel_update_meth;
5291 uint32_t handle_error_meth;
5292 } LDKChannelMessageHandler_JCalls;
5293 static void LDKChannelMessageHandler_JCalls_free(void* this_arg) {
5294 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5295 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5296 js_free(j_calls->handle_open_channel_meth);
5297 js_free(j_calls->handle_accept_channel_meth);
5298 js_free(j_calls->handle_funding_created_meth);
5299 js_free(j_calls->handle_funding_signed_meth);
5300 js_free(j_calls->handle_funding_locked_meth);
5301 js_free(j_calls->handle_shutdown_meth);
5302 js_free(j_calls->handle_closing_signed_meth);
5303 js_free(j_calls->handle_update_add_htlc_meth);
5304 js_free(j_calls->handle_update_fulfill_htlc_meth);
5305 js_free(j_calls->handle_update_fail_htlc_meth);
5306 js_free(j_calls->handle_update_fail_malformed_htlc_meth);
5307 js_free(j_calls->handle_commitment_signed_meth);
5308 js_free(j_calls->handle_revoke_and_ack_meth);
5309 js_free(j_calls->handle_update_fee_meth);
5310 js_free(j_calls->handle_announcement_signatures_meth);
5311 js_free(j_calls->peer_disconnected_meth);
5312 js_free(j_calls->peer_connected_meth);
5313 js_free(j_calls->handle_channel_reestablish_meth);
5314 js_free(j_calls->handle_channel_update_meth);
5315 js_free(j_calls->handle_error_meth);
5319 void handle_open_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKOpenChannel * msg) {
5320 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5321 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5322 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5323 LDKInitFeatures their_features_var = their_features;
5324 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5325 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5326 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
5327 if (their_features_var.is_owned) {
5328 their_features_ref |= 1;
5330 LDKOpenChannel msg_var = *msg;
5331 msg_var = OpenChannel_clone(msg);
5332 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5333 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5334 uint64_t msg_ref = (uint64_t)msg_var.inner;
5335 if (msg_var.is_owned) {
5338 js_invoke_function_3(j_calls->handle_open_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
5340 void handle_accept_channel_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKInitFeatures their_features, const LDKAcceptChannel * msg) {
5341 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5342 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5343 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5344 LDKInitFeatures their_features_var = their_features;
5345 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5346 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5347 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
5348 if (their_features_var.is_owned) {
5349 their_features_ref |= 1;
5351 LDKAcceptChannel msg_var = *msg;
5352 msg_var = AcceptChannel_clone(msg);
5353 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5354 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5355 uint64_t msg_ref = (uint64_t)msg_var.inner;
5356 if (msg_var.is_owned) {
5359 js_invoke_function_3(j_calls->handle_accept_channel_meth, their_node_id_arr, their_features_ref, msg_ref);
5361 void handle_funding_created_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingCreated * msg) {
5362 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5363 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5364 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5365 LDKFundingCreated msg_var = *msg;
5366 msg_var = FundingCreated_clone(msg);
5367 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5368 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5369 uint64_t msg_ref = (uint64_t)msg_var.inner;
5370 if (msg_var.is_owned) {
5373 js_invoke_function_2(j_calls->handle_funding_created_meth, their_node_id_arr, msg_ref);
5375 void handle_funding_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingSigned * msg) {
5376 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5377 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5378 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5379 LDKFundingSigned msg_var = *msg;
5380 msg_var = FundingSigned_clone(msg);
5381 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5382 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5383 uint64_t msg_ref = (uint64_t)msg_var.inner;
5384 if (msg_var.is_owned) {
5387 js_invoke_function_2(j_calls->handle_funding_signed_meth, their_node_id_arr, msg_ref);
5389 void handle_funding_locked_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKFundingLocked * msg) {
5390 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5391 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5392 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5393 LDKFundingLocked msg_var = *msg;
5394 msg_var = FundingLocked_clone(msg);
5395 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5396 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5397 uint64_t msg_ref = (uint64_t)msg_var.inner;
5398 if (msg_var.is_owned) {
5401 js_invoke_function_2(j_calls->handle_funding_locked_meth, their_node_id_arr, msg_ref);
5403 void handle_shutdown_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInitFeatures * their_features, const LDKShutdown * msg) {
5404 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5405 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5406 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5407 LDKInitFeatures their_features_var = *their_features;
5408 their_features_var = InitFeatures_clone(their_features);
5409 CHECK((((uint64_t)their_features_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5410 CHECK((((uint64_t)&their_features_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5411 uint64_t their_features_ref = (uint64_t)their_features_var.inner;
5412 if (their_features_var.is_owned) {
5413 their_features_ref |= 1;
5415 LDKShutdown msg_var = *msg;
5416 msg_var = Shutdown_clone(msg);
5417 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5418 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5419 uint64_t msg_ref = (uint64_t)msg_var.inner;
5420 if (msg_var.is_owned) {
5423 js_invoke_function_3(j_calls->handle_shutdown_meth, their_node_id_arr, their_features_ref, msg_ref);
5425 void handle_closing_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKClosingSigned * msg) {
5426 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5427 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5428 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5429 LDKClosingSigned msg_var = *msg;
5430 msg_var = ClosingSigned_clone(msg);
5431 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5432 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5433 uint64_t msg_ref = (uint64_t)msg_var.inner;
5434 if (msg_var.is_owned) {
5437 js_invoke_function_2(j_calls->handle_closing_signed_meth, their_node_id_arr, msg_ref);
5439 void handle_update_add_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateAddHTLC * msg) {
5440 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5441 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5442 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5443 LDKUpdateAddHTLC msg_var = *msg;
5444 msg_var = UpdateAddHTLC_clone(msg);
5445 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5446 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5447 uint64_t msg_ref = (uint64_t)msg_var.inner;
5448 if (msg_var.is_owned) {
5451 js_invoke_function_2(j_calls->handle_update_add_htlc_meth, their_node_id_arr, msg_ref);
5453 void handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFulfillHTLC * msg) {
5454 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5455 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5456 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5457 LDKUpdateFulfillHTLC msg_var = *msg;
5458 msg_var = UpdateFulfillHTLC_clone(msg);
5459 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5460 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5461 uint64_t msg_ref = (uint64_t)msg_var.inner;
5462 if (msg_var.is_owned) {
5465 js_invoke_function_2(j_calls->handle_update_fulfill_htlc_meth, their_node_id_arr, msg_ref);
5467 void handle_update_fail_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailHTLC * msg) {
5468 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5469 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5470 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5471 LDKUpdateFailHTLC msg_var = *msg;
5472 msg_var = UpdateFailHTLC_clone(msg);
5473 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5474 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5475 uint64_t msg_ref = (uint64_t)msg_var.inner;
5476 if (msg_var.is_owned) {
5479 js_invoke_function_2(j_calls->handle_update_fail_htlc_meth, their_node_id_arr, msg_ref);
5481 void handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFailMalformedHTLC * msg) {
5482 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5483 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5484 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5485 LDKUpdateFailMalformedHTLC msg_var = *msg;
5486 msg_var = UpdateFailMalformedHTLC_clone(msg);
5487 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5488 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5489 uint64_t msg_ref = (uint64_t)msg_var.inner;
5490 if (msg_var.is_owned) {
5493 js_invoke_function_2(j_calls->handle_update_fail_malformed_htlc_meth, their_node_id_arr, msg_ref);
5495 void handle_commitment_signed_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKCommitmentSigned * msg) {
5496 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5497 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5498 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5499 LDKCommitmentSigned msg_var = *msg;
5500 msg_var = CommitmentSigned_clone(msg);
5501 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5502 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5503 uint64_t msg_ref = (uint64_t)msg_var.inner;
5504 if (msg_var.is_owned) {
5507 js_invoke_function_2(j_calls->handle_commitment_signed_meth, their_node_id_arr, msg_ref);
5509 void handle_revoke_and_ack_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKRevokeAndACK * msg) {
5510 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5511 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5512 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5513 LDKRevokeAndACK msg_var = *msg;
5514 msg_var = RevokeAndACK_clone(msg);
5515 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5516 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5517 uint64_t msg_ref = (uint64_t)msg_var.inner;
5518 if (msg_var.is_owned) {
5521 js_invoke_function_2(j_calls->handle_revoke_and_ack_meth, their_node_id_arr, msg_ref);
5523 void handle_update_fee_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKUpdateFee * msg) {
5524 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5525 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5526 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5527 LDKUpdateFee msg_var = *msg;
5528 msg_var = UpdateFee_clone(msg);
5529 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5530 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5531 uint64_t msg_ref = (uint64_t)msg_var.inner;
5532 if (msg_var.is_owned) {
5535 js_invoke_function_2(j_calls->handle_update_fee_meth, their_node_id_arr, msg_ref);
5537 void handle_announcement_signatures_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKAnnouncementSignatures * msg) {
5538 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5539 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5540 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5541 LDKAnnouncementSignatures msg_var = *msg;
5542 msg_var = AnnouncementSignatures_clone(msg);
5543 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5544 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5545 uint64_t msg_ref = (uint64_t)msg_var.inner;
5546 if (msg_var.is_owned) {
5549 js_invoke_function_2(j_calls->handle_announcement_signatures_meth, their_node_id_arr, msg_ref);
5551 void peer_disconnected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, bool no_connection_possible) {
5552 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5553 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5554 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5555 js_invoke_function_2(j_calls->peer_disconnected_meth, their_node_id_arr, no_connection_possible);
5557 void peer_connected_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * msg) {
5558 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5559 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5560 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5561 LDKInit msg_var = *msg;
5562 msg_var = Init_clone(msg);
5563 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5564 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5565 uint64_t msg_ref = (uint64_t)msg_var.inner;
5566 if (msg_var.is_owned) {
5569 js_invoke_function_2(j_calls->peer_connected_meth, their_node_id_arr, msg_ref);
5571 void handle_channel_reestablish_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelReestablish * msg) {
5572 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5573 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5574 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5575 LDKChannelReestablish msg_var = *msg;
5576 msg_var = ChannelReestablish_clone(msg);
5577 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5578 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5579 uint64_t msg_ref = (uint64_t)msg_var.inner;
5580 if (msg_var.is_owned) {
5583 js_invoke_function_2(j_calls->handle_channel_reestablish_meth, their_node_id_arr, msg_ref);
5585 void handle_channel_update_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKChannelUpdate * msg) {
5586 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5587 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5588 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5589 LDKChannelUpdate msg_var = *msg;
5590 msg_var = ChannelUpdate_clone(msg);
5591 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5592 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5593 uint64_t msg_ref = (uint64_t)msg_var.inner;
5594 if (msg_var.is_owned) {
5597 js_invoke_function_2(j_calls->handle_channel_update_meth, their_node_id_arr, msg_ref);
5599 void handle_error_LDKChannelMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKErrorMessage * msg) {
5600 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5601 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5602 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
5603 LDKErrorMessage msg_var = *msg;
5604 msg_var = ErrorMessage_clone(msg);
5605 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5606 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5607 uint64_t msg_ref = (uint64_t)msg_var.inner;
5608 if (msg_var.is_owned) {
5611 js_invoke_function_2(j_calls->handle_error_meth, their_node_id_arr, msg_ref);
5613 static void* LDKChannelMessageHandler_JCalls_clone(const void* this_arg) {
5614 LDKChannelMessageHandler_JCalls *j_calls = (LDKChannelMessageHandler_JCalls*) this_arg;
5615 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
5616 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
5617 return (void*) this_arg;
5619 static inline LDKChannelMessageHandler LDKChannelMessageHandler_init (/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */void* MessageSendEventsProvider) {
5620 LDKChannelMessageHandler_JCalls *calls = MALLOC(sizeof(LDKChannelMessageHandler_JCalls), "LDKChannelMessageHandler_JCalls");
5621 atomic_init(&calls->refcnt, 1);
5622 //TODO: Assign calls->o from o
5624 LDKChannelMessageHandler ret = {
5625 .this_arg = (void*) calls,
5626 .handle_open_channel = handle_open_channel_LDKChannelMessageHandler_jcall,
5627 .handle_accept_channel = handle_accept_channel_LDKChannelMessageHandler_jcall,
5628 .handle_funding_created = handle_funding_created_LDKChannelMessageHandler_jcall,
5629 .handle_funding_signed = handle_funding_signed_LDKChannelMessageHandler_jcall,
5630 .handle_funding_locked = handle_funding_locked_LDKChannelMessageHandler_jcall,
5631 .handle_shutdown = handle_shutdown_LDKChannelMessageHandler_jcall,
5632 .handle_closing_signed = handle_closing_signed_LDKChannelMessageHandler_jcall,
5633 .handle_update_add_htlc = handle_update_add_htlc_LDKChannelMessageHandler_jcall,
5634 .handle_update_fulfill_htlc = handle_update_fulfill_htlc_LDKChannelMessageHandler_jcall,
5635 .handle_update_fail_htlc = handle_update_fail_htlc_LDKChannelMessageHandler_jcall,
5636 .handle_update_fail_malformed_htlc = handle_update_fail_malformed_htlc_LDKChannelMessageHandler_jcall,
5637 .handle_commitment_signed = handle_commitment_signed_LDKChannelMessageHandler_jcall,
5638 .handle_revoke_and_ack = handle_revoke_and_ack_LDKChannelMessageHandler_jcall,
5639 .handle_update_fee = handle_update_fee_LDKChannelMessageHandler_jcall,
5640 .handle_announcement_signatures = handle_announcement_signatures_LDKChannelMessageHandler_jcall,
5641 .peer_disconnected = peer_disconnected_LDKChannelMessageHandler_jcall,
5642 .peer_connected = peer_connected_LDKChannelMessageHandler_jcall,
5643 .handle_channel_reestablish = handle_channel_reestablish_LDKChannelMessageHandler_jcall,
5644 .handle_channel_update = handle_channel_update_LDKChannelMessageHandler_jcall,
5645 .handle_error = handle_error_LDKChannelMessageHandler_jcall,
5646 .free = LDKChannelMessageHandler_JCalls_free,
5647 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
5649 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
5652 long __attribute__((visibility("default"))) TS_LDKChannelMessageHandler_new(/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */ void* MessageSendEventsProvider) {
5653 LDKChannelMessageHandler *res_ptr = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
5654 *res_ptr = LDKChannelMessageHandler_init(o, MessageSendEventsProvider);
5655 return (long)res_ptr;
5657 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_open_channel(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
5658 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5659 LDKPublicKey their_node_id_ref;
5660 CHECK(*((uint32_t*)their_node_id) == 33);
5661 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5662 LDKInitFeatures their_features_conv;
5663 their_features_conv.inner = (void*)(their_features & (~1));
5664 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
5665 their_features_conv = InitFeatures_clone(&their_features_conv);
5666 LDKOpenChannel msg_conv;
5667 msg_conv.inner = (void*)(msg & (~1));
5668 msg_conv.is_owned = false;
5669 (this_arg_conv->handle_open_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
5672 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_accept_channel(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
5673 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5674 LDKPublicKey their_node_id_ref;
5675 CHECK(*((uint32_t*)their_node_id) == 33);
5676 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5677 LDKInitFeatures their_features_conv;
5678 their_features_conv.inner = (void*)(their_features & (~1));
5679 their_features_conv.is_owned = (their_features & 1) || (their_features == 0);
5680 their_features_conv = InitFeatures_clone(&their_features_conv);
5681 LDKAcceptChannel msg_conv;
5682 msg_conv.inner = (void*)(msg & (~1));
5683 msg_conv.is_owned = false;
5684 (this_arg_conv->handle_accept_channel)(this_arg_conv->this_arg, their_node_id_ref, their_features_conv, &msg_conv);
5687 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_funding_created(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5688 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5689 LDKPublicKey their_node_id_ref;
5690 CHECK(*((uint32_t*)their_node_id) == 33);
5691 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5692 LDKFundingCreated msg_conv;
5693 msg_conv.inner = (void*)(msg & (~1));
5694 msg_conv.is_owned = false;
5695 (this_arg_conv->handle_funding_created)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5698 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_funding_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5699 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5700 LDKPublicKey their_node_id_ref;
5701 CHECK(*((uint32_t*)their_node_id) == 33);
5702 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5703 LDKFundingSigned msg_conv;
5704 msg_conv.inner = (void*)(msg & (~1));
5705 msg_conv.is_owned = false;
5706 (this_arg_conv->handle_funding_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5709 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_funding_locked(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5710 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5711 LDKPublicKey their_node_id_ref;
5712 CHECK(*((uint32_t*)their_node_id) == 33);
5713 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5714 LDKFundingLocked msg_conv;
5715 msg_conv.inner = (void*)(msg & (~1));
5716 msg_conv.is_owned = false;
5717 (this_arg_conv->handle_funding_locked)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5720 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_shutdown(uint32_t this_arg, int8_tArray their_node_id, uint32_t their_features, uint32_t msg) {
5721 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5722 LDKPublicKey their_node_id_ref;
5723 CHECK(*((uint32_t*)their_node_id) == 33);
5724 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5725 LDKInitFeatures their_features_conv;
5726 their_features_conv.inner = (void*)(their_features & (~1));
5727 their_features_conv.is_owned = false;
5728 LDKShutdown msg_conv;
5729 msg_conv.inner = (void*)(msg & (~1));
5730 msg_conv.is_owned = false;
5731 (this_arg_conv->handle_shutdown)(this_arg_conv->this_arg, their_node_id_ref, &their_features_conv, &msg_conv);
5734 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_closing_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5735 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5736 LDKPublicKey their_node_id_ref;
5737 CHECK(*((uint32_t*)their_node_id) == 33);
5738 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5739 LDKClosingSigned msg_conv;
5740 msg_conv.inner = (void*)(msg & (~1));
5741 msg_conv.is_owned = false;
5742 (this_arg_conv->handle_closing_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5745 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_update_add_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5746 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5747 LDKPublicKey their_node_id_ref;
5748 CHECK(*((uint32_t*)their_node_id) == 33);
5749 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5750 LDKUpdateAddHTLC msg_conv;
5751 msg_conv.inner = (void*)(msg & (~1));
5752 msg_conv.is_owned = false;
5753 (this_arg_conv->handle_update_add_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5756 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_update_fulfill_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5757 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5758 LDKPublicKey their_node_id_ref;
5759 CHECK(*((uint32_t*)their_node_id) == 33);
5760 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5761 LDKUpdateFulfillHTLC msg_conv;
5762 msg_conv.inner = (void*)(msg & (~1));
5763 msg_conv.is_owned = false;
5764 (this_arg_conv->handle_update_fulfill_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5767 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_update_fail_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5768 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5769 LDKPublicKey their_node_id_ref;
5770 CHECK(*((uint32_t*)their_node_id) == 33);
5771 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5772 LDKUpdateFailHTLC msg_conv;
5773 msg_conv.inner = (void*)(msg & (~1));
5774 msg_conv.is_owned = false;
5775 (this_arg_conv->handle_update_fail_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5778 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_update_fail_malformed_htlc(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5779 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5780 LDKPublicKey their_node_id_ref;
5781 CHECK(*((uint32_t*)their_node_id) == 33);
5782 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5783 LDKUpdateFailMalformedHTLC msg_conv;
5784 msg_conv.inner = (void*)(msg & (~1));
5785 msg_conv.is_owned = false;
5786 (this_arg_conv->handle_update_fail_malformed_htlc)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5789 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_commitment_signed(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5790 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5791 LDKPublicKey their_node_id_ref;
5792 CHECK(*((uint32_t*)their_node_id) == 33);
5793 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5794 LDKCommitmentSigned msg_conv;
5795 msg_conv.inner = (void*)(msg & (~1));
5796 msg_conv.is_owned = false;
5797 (this_arg_conv->handle_commitment_signed)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5800 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_revoke_and_ack(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5801 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5802 LDKPublicKey their_node_id_ref;
5803 CHECK(*((uint32_t*)their_node_id) == 33);
5804 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5805 LDKRevokeAndACK msg_conv;
5806 msg_conv.inner = (void*)(msg & (~1));
5807 msg_conv.is_owned = false;
5808 (this_arg_conv->handle_revoke_and_ack)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5811 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_update_fee(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5812 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5813 LDKPublicKey their_node_id_ref;
5814 CHECK(*((uint32_t*)their_node_id) == 33);
5815 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5816 LDKUpdateFee msg_conv;
5817 msg_conv.inner = (void*)(msg & (~1));
5818 msg_conv.is_owned = false;
5819 (this_arg_conv->handle_update_fee)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5822 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_announcement_signatures(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5823 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5824 LDKPublicKey their_node_id_ref;
5825 CHECK(*((uint32_t*)their_node_id) == 33);
5826 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5827 LDKAnnouncementSignatures msg_conv;
5828 msg_conv.inner = (void*)(msg & (~1));
5829 msg_conv.is_owned = false;
5830 (this_arg_conv->handle_announcement_signatures)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5833 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_peer_disconnected(uint32_t this_arg, int8_tArray their_node_id, jboolean no_connection_possible) {
5834 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5835 LDKPublicKey their_node_id_ref;
5836 CHECK(*((uint32_t*)their_node_id) == 33);
5837 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5838 (this_arg_conv->peer_disconnected)(this_arg_conv->this_arg, their_node_id_ref, no_connection_possible);
5841 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_peer_connected(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5842 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5843 LDKPublicKey their_node_id_ref;
5844 CHECK(*((uint32_t*)their_node_id) == 33);
5845 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5847 msg_conv.inner = (void*)(msg & (~1));
5848 msg_conv.is_owned = false;
5849 (this_arg_conv->peer_connected)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5852 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_channel_reestablish(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5853 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5854 LDKPublicKey their_node_id_ref;
5855 CHECK(*((uint32_t*)their_node_id) == 33);
5856 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5857 LDKChannelReestablish msg_conv;
5858 msg_conv.inner = (void*)(msg & (~1));
5859 msg_conv.is_owned = false;
5860 (this_arg_conv->handle_channel_reestablish)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5863 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_channel_update(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5864 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5865 LDKPublicKey their_node_id_ref;
5866 CHECK(*((uint32_t*)their_node_id) == 33);
5867 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5868 LDKChannelUpdate msg_conv;
5869 msg_conv.inner = (void*)(msg & (~1));
5870 msg_conv.is_owned = false;
5871 (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5874 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_handle_error(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
5875 LDKChannelMessageHandler* this_arg_conv = (LDKChannelMessageHandler*)(((uint64_t)this_arg) & ~1);
5876 LDKPublicKey their_node_id_ref;
5877 CHECK(*((uint32_t*)their_node_id) == 33);
5878 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
5879 LDKErrorMessage msg_conv;
5880 msg_conv.inner = (void*)(msg & (~1));
5881 msg_conv.is_owned = false;
5882 (this_arg_conv->handle_error)(this_arg_conv->this_arg, their_node_id_ref, &msg_conv);
5885 typedef struct LDKRoutingMessageHandler_JCalls {
5886 atomic_size_t refcnt;
5887 LDKMessageSendEventsProvider_JCalls* MessageSendEventsProvider;
5888 uint32_t handle_node_announcement_meth;
5889 uint32_t handle_channel_announcement_meth;
5890 uint32_t handle_channel_update_meth;
5891 uint32_t handle_htlc_fail_channel_update_meth;
5892 uint32_t get_next_channel_announcements_meth;
5893 uint32_t get_next_node_announcements_meth;
5894 uint32_t sync_routing_table_meth;
5895 uint32_t handle_reply_channel_range_meth;
5896 uint32_t handle_reply_short_channel_ids_end_meth;
5897 uint32_t handle_query_channel_range_meth;
5898 uint32_t handle_query_short_channel_ids_meth;
5899 } LDKRoutingMessageHandler_JCalls;
5900 static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) {
5901 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5902 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
5903 js_free(j_calls->handle_node_announcement_meth);
5904 js_free(j_calls->handle_channel_announcement_meth);
5905 js_free(j_calls->handle_channel_update_meth);
5906 js_free(j_calls->handle_htlc_fail_channel_update_meth);
5907 js_free(j_calls->get_next_channel_announcements_meth);
5908 js_free(j_calls->get_next_node_announcements_meth);
5909 js_free(j_calls->sync_routing_table_meth);
5910 js_free(j_calls->handle_reply_channel_range_meth);
5911 js_free(j_calls->handle_reply_short_channel_ids_end_meth);
5912 js_free(j_calls->handle_query_channel_range_meth);
5913 js_free(j_calls->handle_query_short_channel_ids_meth);
5917 LDKCResult_boolLightningErrorZ handle_node_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKNodeAnnouncement * msg) {
5918 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5919 LDKNodeAnnouncement msg_var = *msg;
5920 msg_var = NodeAnnouncement_clone(msg);
5921 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5922 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5923 uint64_t msg_ref = (uint64_t)msg_var.inner;
5924 if (msg_var.is_owned) {
5927 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)js_invoke_function_1(j_calls->handle_node_announcement_meth, msg_ref);
5928 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5929 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
5932 LDKCResult_boolLightningErrorZ handle_channel_announcement_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelAnnouncement * msg) {
5933 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5934 LDKChannelAnnouncement msg_var = *msg;
5935 msg_var = ChannelAnnouncement_clone(msg);
5936 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5937 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5938 uint64_t msg_ref = (uint64_t)msg_var.inner;
5939 if (msg_var.is_owned) {
5942 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)js_invoke_function_1(j_calls->handle_channel_announcement_meth, msg_ref);
5943 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5944 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
5947 LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKChannelUpdate * msg) {
5948 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5949 LDKChannelUpdate msg_var = *msg;
5950 msg_var = ChannelUpdate_clone(msg);
5951 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
5952 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
5953 uint64_t msg_ref = (uint64_t)msg_var.inner;
5954 if (msg_var.is_owned) {
5957 LDKCResult_boolLightningErrorZ* ret = (LDKCResult_boolLightningErrorZ*)js_invoke_function_1(j_calls->handle_channel_update_meth, msg_ref);
5958 LDKCResult_boolLightningErrorZ ret_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1);
5959 ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1));
5962 void handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) {
5963 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5964 uint64_t ret_update = (uint64_t)update;
5965 js_invoke_function_1(j_calls->handle_htlc_fail_channel_update_meth, ret_update);
5967 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) {
5968 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5969 uint32_tArray ret = js_invoke_function_2(j_calls->get_next_channel_announcements_meth, starting_point, batch_amount);
5970 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_constr;
5971 ret_constr.datalen = *((uint32_t*)ret);
5972 if (ret_constr.datalen > 0)
5973 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
5975 ret_constr.data = NULL;
5976 uint32_t* ret_vals = (uint32_t*)(ret + 4);
5977 for (size_t l = 0; l < ret_constr.datalen; l++) {
5978 uint32_t ret_conv_63 = ret_vals[l];
5979 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1);
5980 ret_conv_63_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1));
5981 ret_constr.data[l] = ret_conv_63_conv;
5985 LDKCVec_NodeAnnouncementZ get_next_node_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey starting_point, uint8_t batch_amount) {
5986 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
5987 int8_tArray starting_point_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
5988 memcpy((uint8_t*)(starting_point_arr + 4), starting_point.compressed_form, 33);
5989 uint32_tArray ret = js_invoke_function_2(j_calls->get_next_node_announcements_meth, starting_point_arr, batch_amount);
5990 LDKCVec_NodeAnnouncementZ ret_constr;
5991 ret_constr.datalen = *((uint32_t*)ret);
5992 if (ret_constr.datalen > 0)
5993 ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
5995 ret_constr.data = NULL;
5996 uint32_t* ret_vals = (uint32_t*)(ret + 4);
5997 for (size_t s = 0; s < ret_constr.datalen; s++) {
5998 uint32_t ret_conv_18 = ret_vals[s];
5999 LDKNodeAnnouncement ret_conv_18_conv;
6000 ret_conv_18_conv.inner = (void*)(ret_conv_18 & (~1));
6001 ret_conv_18_conv.is_owned = (ret_conv_18 & 1) || (ret_conv_18 == 0);
6002 ret_conv_18_conv = NodeAnnouncement_clone(&ret_conv_18_conv);
6003 ret_constr.data[s] = ret_conv_18_conv;
6007 void sync_routing_table_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, const LDKInit * init) {
6008 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6009 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
6010 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
6011 LDKInit init_var = *init;
6012 init_var = Init_clone(init);
6013 CHECK((((uint64_t)init_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6014 CHECK((((uint64_t)&init_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6015 uint64_t init_ref = (uint64_t)init_var.inner;
6016 if (init_var.is_owned) {
6019 js_invoke_function_2(j_calls->sync_routing_table_meth, their_node_id_arr, init_ref);
6021 LDKCResult_NoneLightningErrorZ handle_reply_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyChannelRange msg) {
6022 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6023 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
6024 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
6025 LDKReplyChannelRange msg_var = msg;
6026 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6027 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6028 uint64_t msg_ref = (uint64_t)msg_var.inner;
6029 if (msg_var.is_owned) {
6032 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)js_invoke_function_2(j_calls->handle_reply_channel_range_meth, their_node_id_arr, msg_ref);
6033 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6034 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
6037 LDKCResult_NoneLightningErrorZ handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKReplyShortChannelIdsEnd msg) {
6038 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6039 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
6040 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
6041 LDKReplyShortChannelIdsEnd msg_var = msg;
6042 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6043 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6044 uint64_t msg_ref = (uint64_t)msg_var.inner;
6045 if (msg_var.is_owned) {
6048 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)js_invoke_function_2(j_calls->handle_reply_short_channel_ids_end_meth, their_node_id_arr, msg_ref);
6049 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6050 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
6053 LDKCResult_NoneLightningErrorZ handle_query_channel_range_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryChannelRange msg) {
6054 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6055 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
6056 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
6057 LDKQueryChannelRange msg_var = msg;
6058 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6059 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6060 uint64_t msg_ref = (uint64_t)msg_var.inner;
6061 if (msg_var.is_owned) {
6064 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)js_invoke_function_2(j_calls->handle_query_channel_range_meth, their_node_id_arr, msg_ref);
6065 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6066 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
6069 LDKCResult_NoneLightningErrorZ handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall(const void* this_arg, LDKPublicKey their_node_id, LDKQueryShortChannelIds msg) {
6070 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6071 int8_tArray their_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
6072 memcpy((uint8_t*)(their_node_id_arr + 4), their_node_id.compressed_form, 33);
6073 LDKQueryShortChannelIds msg_var = msg;
6074 CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6075 CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6076 uint64_t msg_ref = (uint64_t)msg_var.inner;
6077 if (msg_var.is_owned) {
6080 LDKCResult_NoneLightningErrorZ* ret = (LDKCResult_NoneLightningErrorZ*)js_invoke_function_2(j_calls->handle_query_short_channel_ids_meth, their_node_id_arr, msg_ref);
6081 LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1);
6082 ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1));
6085 static void* LDKRoutingMessageHandler_JCalls_clone(const void* this_arg) {
6086 LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg;
6087 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6088 atomic_fetch_add_explicit(&j_calls->MessageSendEventsProvider->refcnt, 1, memory_order_release);
6089 return (void*) this_arg;
6091 static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */void* MessageSendEventsProvider) {
6092 LDKRoutingMessageHandler_JCalls *calls = MALLOC(sizeof(LDKRoutingMessageHandler_JCalls), "LDKRoutingMessageHandler_JCalls");
6093 atomic_init(&calls->refcnt, 1);
6094 //TODO: Assign calls->o from o
6096 LDKRoutingMessageHandler ret = {
6097 .this_arg = (void*) calls,
6098 .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall,
6099 .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall,
6100 .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall,
6101 .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall,
6102 .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall,
6103 .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall,
6104 .sync_routing_table = sync_routing_table_LDKRoutingMessageHandler_jcall,
6105 .handle_reply_channel_range = handle_reply_channel_range_LDKRoutingMessageHandler_jcall,
6106 .handle_reply_short_channel_ids_end = handle_reply_short_channel_ids_end_LDKRoutingMessageHandler_jcall,
6107 .handle_query_channel_range = handle_query_channel_range_LDKRoutingMessageHandler_jcall,
6108 .handle_query_short_channel_ids = handle_query_short_channel_ids_LDKRoutingMessageHandler_jcall,
6109 .free = LDKRoutingMessageHandler_JCalls_free,
6110 .MessageSendEventsProvider = LDKMessageSendEventsProvider_init(MessageSendEventsProvider),
6112 calls->MessageSendEventsProvider = ret.MessageSendEventsProvider.this_arg;
6115 long __attribute__((visibility("default"))) TS_LDKRoutingMessageHandler_new(/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */ void* MessageSendEventsProvider) {
6116 LDKRoutingMessageHandler *res_ptr = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
6117 *res_ptr = LDKRoutingMessageHandler_init(o, MessageSendEventsProvider);
6118 return (long)res_ptr;
6120 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_node_announcement(uint32_t this_arg, uint32_t msg) {
6121 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6122 LDKNodeAnnouncement msg_conv;
6123 msg_conv.inner = (void*)(msg & (~1));
6124 msg_conv.is_owned = false;
6125 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6126 *ret_conv = (this_arg_conv->handle_node_announcement)(this_arg_conv->this_arg, &msg_conv);
6127 return (uint64_t)ret_conv;
6130 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_channel_announcement(uint32_t this_arg, uint32_t msg) {
6131 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6132 LDKChannelAnnouncement msg_conv;
6133 msg_conv.inner = (void*)(msg & (~1));
6134 msg_conv.is_owned = false;
6135 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6136 *ret_conv = (this_arg_conv->handle_channel_announcement)(this_arg_conv->this_arg, &msg_conv);
6137 return (uint64_t)ret_conv;
6140 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_channel_update(uint32_t this_arg, uint32_t msg) {
6141 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6142 LDKChannelUpdate msg_conv;
6143 msg_conv.inner = (void*)(msg & (~1));
6144 msg_conv.is_owned = false;
6145 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
6146 *ret_conv = (this_arg_conv->handle_channel_update)(this_arg_conv->this_arg, &msg_conv);
6147 return (uint64_t)ret_conv;
6150 void __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_htlc_fail_channel_update(uint32_t this_arg, uint32_t update) {
6151 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6152 LDKHTLCFailChannelUpdate* update_conv = (LDKHTLCFailChannelUpdate*)update;
6153 (this_arg_conv->handle_htlc_fail_channel_update)(this_arg_conv->this_arg, update_conv);
6156 uint32_tArray __attribute__((visibility("default"))) TS_RoutingMessageHandler_get_next_channel_announcements(uint32_t this_arg, int64_t starting_point, int8_t batch_amount) {
6157 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6158 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount);
6159 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
6160 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
6161 for (size_t l = 0; l < ret_var.datalen; l++) {
6162 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_63_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
6163 *ret_conv_63_ref = ret_var.data[l];
6164 ret_arr_ptr[l] = (uint64_t)ret_conv_63_ref;
6170 uint32_tArray __attribute__((visibility("default"))) TS_RoutingMessageHandler_get_next_node_announcements(uint32_t this_arg, int8_tArray starting_point, int8_t batch_amount) {
6171 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6172 LDKPublicKey starting_point_ref;
6173 CHECK(*((uint32_t*)starting_point) == 33);
6174 memcpy(starting_point_ref.compressed_form, (uint8_t*)(starting_point + 4), 33);
6175 LDKCVec_NodeAnnouncementZ ret_var = (this_arg_conv->get_next_node_announcements)(this_arg_conv->this_arg, starting_point_ref, batch_amount);
6176 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
6177 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
6178 for (size_t s = 0; s < ret_var.datalen; s++) {
6179 LDKNodeAnnouncement ret_conv_18_var = ret_var.data[s];
6180 CHECK((((uint64_t)ret_conv_18_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6181 CHECK((((uint64_t)&ret_conv_18_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6182 uint64_t ret_conv_18_ref = (uint64_t)ret_conv_18_var.inner;
6183 if (ret_conv_18_var.is_owned) {
6184 ret_conv_18_ref |= 1;
6186 ret_arr_ptr[s] = ret_conv_18_ref;
6192 void __attribute__((visibility("default"))) TS_RoutingMessageHandler_sync_routing_table(uint32_t this_arg, int8_tArray their_node_id, uint32_t init) {
6193 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6194 LDKPublicKey their_node_id_ref;
6195 CHECK(*((uint32_t*)their_node_id) == 33);
6196 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
6198 init_conv.inner = (void*)(init & (~1));
6199 init_conv.is_owned = false;
6200 (this_arg_conv->sync_routing_table)(this_arg_conv->this_arg, their_node_id_ref, &init_conv);
6203 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_reply_channel_range(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
6204 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6205 LDKPublicKey their_node_id_ref;
6206 CHECK(*((uint32_t*)their_node_id) == 33);
6207 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
6208 LDKReplyChannelRange msg_conv;
6209 msg_conv.inner = (void*)(msg & (~1));
6210 msg_conv.is_owned = (msg & 1) || (msg == 0);
6211 msg_conv = ReplyChannelRange_clone(&msg_conv);
6212 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6213 *ret_conv = (this_arg_conv->handle_reply_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6214 return (uint64_t)ret_conv;
6217 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_reply_short_channel_ids_end(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
6218 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6219 LDKPublicKey their_node_id_ref;
6220 CHECK(*((uint32_t*)their_node_id) == 33);
6221 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
6222 LDKReplyShortChannelIdsEnd msg_conv;
6223 msg_conv.inner = (void*)(msg & (~1));
6224 msg_conv.is_owned = (msg & 1) || (msg == 0);
6225 msg_conv = ReplyShortChannelIdsEnd_clone(&msg_conv);
6226 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6227 *ret_conv = (this_arg_conv->handle_reply_short_channel_ids_end)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6228 return (uint64_t)ret_conv;
6231 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_query_channel_range(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
6232 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6233 LDKPublicKey their_node_id_ref;
6234 CHECK(*((uint32_t*)their_node_id) == 33);
6235 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
6236 LDKQueryChannelRange msg_conv;
6237 msg_conv.inner = (void*)(msg & (~1));
6238 msg_conv.is_owned = (msg & 1) || (msg == 0);
6239 msg_conv = QueryChannelRange_clone(&msg_conv);
6240 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6241 *ret_conv = (this_arg_conv->handle_query_channel_range)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6242 return (uint64_t)ret_conv;
6245 uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_query_short_channel_ids(uint32_t this_arg, int8_tArray their_node_id, uint32_t msg) {
6246 LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1);
6247 LDKPublicKey their_node_id_ref;
6248 CHECK(*((uint32_t*)their_node_id) == 33);
6249 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
6250 LDKQueryShortChannelIds msg_conv;
6251 msg_conv.inner = (void*)(msg & (~1));
6252 msg_conv.is_owned = (msg & 1) || (msg == 0);
6253 msg_conv = QueryShortChannelIds_clone(&msg_conv);
6254 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
6255 *ret_conv = (this_arg_conv->handle_query_short_channel_ids)(this_arg_conv->this_arg, their_node_id_ref, msg_conv);
6256 return (uint64_t)ret_conv;
6259 typedef struct LDKSocketDescriptor_JCalls {
6260 atomic_size_t refcnt;
6261 uint32_t send_data_meth;
6262 uint32_t disconnect_socket_meth;
6265 } LDKSocketDescriptor_JCalls;
6266 static void LDKSocketDescriptor_JCalls_free(void* this_arg) {
6267 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6268 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6269 js_free(j_calls->send_data_meth);
6270 js_free(j_calls->disconnect_socket_meth);
6271 js_free(j_calls->eq_meth);
6272 js_free(j_calls->hash_meth);
6276 uintptr_t send_data_LDKSocketDescriptor_jcall(void* this_arg, LDKu8slice data, bool resume_read) {
6277 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6278 LDKu8slice data_var = data;
6279 int8_tArray data_arr = init_arr(data_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
6280 memcpy((uint8_t*)(data_arr + 4), data_var.data, data_var.datalen);
6281 return js_invoke_function_2(j_calls->send_data_meth, data_arr, resume_read);
6283 void disconnect_socket_LDKSocketDescriptor_jcall(void* this_arg) {
6284 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6285 js_invoke_function_0(j_calls->disconnect_socket_meth);
6287 bool eq_LDKSocketDescriptor_jcall(const void* this_arg, const LDKSocketDescriptor * other_arg) {
6288 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6289 LDKSocketDescriptor *other_arg_clone = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
6290 *other_arg_clone = SocketDescriptor_clone(other_arg);
6291 return js_invoke_function_1(j_calls->eq_meth, (uint64_t)other_arg_clone);
6293 uint64_t hash_LDKSocketDescriptor_jcall(const void* this_arg) {
6294 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6295 return js_invoke_function_0(j_calls->hash_meth);
6297 static void* LDKSocketDescriptor_JCalls_clone(const void* this_arg) {
6298 LDKSocketDescriptor_JCalls *j_calls = (LDKSocketDescriptor_JCalls*) this_arg;
6299 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6300 return (void*) this_arg;
6302 static inline LDKSocketDescriptor LDKSocketDescriptor_init (/*TODO: JS Object Reference */void* o) {
6303 LDKSocketDescriptor_JCalls *calls = MALLOC(sizeof(LDKSocketDescriptor_JCalls), "LDKSocketDescriptor_JCalls");
6304 atomic_init(&calls->refcnt, 1);
6305 //TODO: Assign calls->o from o
6307 LDKSocketDescriptor ret = {
6308 .this_arg = (void*) calls,
6309 .send_data = send_data_LDKSocketDescriptor_jcall,
6310 .disconnect_socket = disconnect_socket_LDKSocketDescriptor_jcall,
6311 .eq = eq_LDKSocketDescriptor_jcall,
6312 .hash = hash_LDKSocketDescriptor_jcall,
6313 .clone = LDKSocketDescriptor_JCalls_clone,
6314 .free = LDKSocketDescriptor_JCalls_free,
6318 long __attribute__((visibility("default"))) TS_LDKSocketDescriptor_new(/*TODO: JS Object Reference */void* o) {
6319 LDKSocketDescriptor *res_ptr = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
6320 *res_ptr = LDKSocketDescriptor_init(o);
6321 return (long)res_ptr;
6323 int64_t __attribute__((visibility("default"))) TS_SocketDescriptor_send_data(uint32_t this_arg, int8_tArray data, jboolean resume_read) {
6324 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6325 LDKu8slice data_ref;
6326 data_ref.datalen = *((uint32_t*)data);
6327 data_ref.data = (int8_t*)(data + 4);
6328 int64_t ret_val = (this_arg_conv->send_data)(this_arg_conv->this_arg, data_ref, resume_read);
6332 void __attribute__((visibility("default"))) TS_SocketDescriptor_disconnect_socket(uint32_t this_arg) {
6333 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6334 (this_arg_conv->disconnect_socket)(this_arg_conv->this_arg);
6337 int64_t __attribute__((visibility("default"))) TS_SocketDescriptor_hash(uint32_t this_arg) {
6338 LDKSocketDescriptor* this_arg_conv = (LDKSocketDescriptor*)(((uint64_t)this_arg) & ~1);
6339 int64_t ret_val = (this_arg_conv->hash)(this_arg_conv->this_arg);
6343 typedef struct LDKChannelManagerPersister_JCalls {
6344 atomic_size_t refcnt;
6345 uint32_t persist_manager_meth;
6346 } LDKChannelManagerPersister_JCalls;
6347 static void LDKChannelManagerPersister_JCalls_free(void* this_arg) {
6348 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
6349 if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) {
6350 js_free(j_calls->persist_manager_meth);
6354 LDKCResult_NoneErrorZ persist_manager_LDKChannelManagerPersister_jcall(const void* this_arg, const LDKChannelManager * channel_manager) {
6355 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
6356 LDKChannelManager channel_manager_var = *channel_manager;
6357 // Warning: we may need a move here but no clone is available for LDKChannelManager
6358 CHECK((((uint64_t)channel_manager_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
6359 CHECK((((uint64_t)&channel_manager_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
6360 uint64_t channel_manager_ref = (uint64_t)channel_manager_var.inner;
6361 if (channel_manager_var.is_owned) {
6362 channel_manager_ref |= 1;
6364 LDKCResult_NoneErrorZ* ret = (LDKCResult_NoneErrorZ*)js_invoke_function_1(j_calls->persist_manager_meth, channel_manager_ref);
6365 LDKCResult_NoneErrorZ ret_conv = *(LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1);
6366 ret_conv = CResult_NoneErrorZ_clone((LDKCResult_NoneErrorZ*)(((uint64_t)ret) & ~1));
6369 static void* LDKChannelManagerPersister_JCalls_clone(const void* this_arg) {
6370 LDKChannelManagerPersister_JCalls *j_calls = (LDKChannelManagerPersister_JCalls*) this_arg;
6371 atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release);
6372 return (void*) this_arg;
6374 static inline LDKChannelManagerPersister LDKChannelManagerPersister_init (/*TODO: JS Object Reference */void* o) {
6375 LDKChannelManagerPersister_JCalls *calls = MALLOC(sizeof(LDKChannelManagerPersister_JCalls), "LDKChannelManagerPersister_JCalls");
6376 atomic_init(&calls->refcnt, 1);
6377 //TODO: Assign calls->o from o
6379 LDKChannelManagerPersister ret = {
6380 .this_arg = (void*) calls,
6381 .persist_manager = persist_manager_LDKChannelManagerPersister_jcall,
6382 .free = LDKChannelManagerPersister_JCalls_free,
6386 long __attribute__((visibility("default"))) TS_LDKChannelManagerPersister_new(/*TODO: JS Object Reference */void* o) {
6387 LDKChannelManagerPersister *res_ptr = MALLOC(sizeof(LDKChannelManagerPersister), "LDKChannelManagerPersister");
6388 *res_ptr = LDKChannelManagerPersister_init(o);
6389 return (long)res_ptr;
6391 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerPersister_persist_manager(uint32_t this_arg, uint32_t channel_manager) {
6392 LDKChannelManagerPersister* this_arg_conv = (LDKChannelManagerPersister*)(((uint64_t)this_arg) & ~1);
6393 LDKChannelManager channel_manager_conv;
6394 channel_manager_conv.inner = (void*)(channel_manager & (~1));
6395 channel_manager_conv.is_owned = false;
6396 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
6397 *ret_conv = (this_arg_conv->persist_manager)(this_arg_conv->this_arg, &channel_manager_conv);
6398 return (uint64_t)ret_conv;
6401 uint32_t __attribute__((visibility("default"))) TS_LDKFallback_ref_from_ptr(uint32_t ptr) {
6402 LDKFallback *obj = (LDKFallback*)(ptr & ~1);
6404 case LDKFallback_SegWitProgram: {
6405 uint8_t version_val = obj->seg_wit_program.version._0;
6406 LDKCVec_u8Z program_var = obj->seg_wit_program.program;
6407 int8_tArray program_arr = init_arr(program_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
6408 memcpy((uint8_t*)(program_arr + 4), program_var.data, program_var.datalen);
6409 return 0 /* LDKFallback - SegWitProgram */; (void) version_val; (void) program_arr;
6411 case LDKFallback_PubKeyHash: {
6412 int8_tArray pub_key_hash_arr = init_arr(20, sizeof(uint8_t), "Native int8_tArray Bytes");
6413 memcpy((uint8_t*)(pub_key_hash_arr + 4), obj->pub_key_hash.data, 20);
6414 return 0 /* LDKFallback - PubKeyHash */; (void) pub_key_hash_arr;
6416 case LDKFallback_ScriptHash: {
6417 int8_tArray script_hash_arr = init_arr(20, sizeof(uint8_t), "Native int8_tArray Bytes");
6418 memcpy((uint8_t*)(script_hash_arr + 4), obj->script_hash.data, 20);
6419 return 0 /* LDKFallback - ScriptHash */; (void) script_hash_arr;
6424 jstring __attribute__((visibility("default"))) TS__ldk_get_compiled_version() {
6425 LDKStr ret_str = _ldk_get_compiled_version();
6426 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6430 jstring __attribute__((visibility("default"))) TS__ldk_c_bindings_get_compiled_version() {
6431 LDKStr ret_str = _ldk_c_bindings_get_compiled_version();
6432 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
6436 void __attribute__((visibility("default"))) TS_Transaction_free(int8_tArray _res) {
6437 LDKTransaction _res_ref;
6438 _res_ref.datalen = *((uint32_t*)_res);
6439 _res_ref.data = MALLOC(_res_ref.datalen, "LDKTransaction Bytes");
6440 memcpy(_res_ref.data, (uint8_t*)(_res + 4), _res_ref.datalen);
6441 _res_ref.data_is_owned = true;
6442 Transaction_free(_res_ref);
6445 void __attribute__((visibility("default"))) TS_TxOut_free(uint32_t _res) {
6446 if ((_res & 1) != 0) return;
6447 LDKTxOut _res_conv = *(LDKTxOut*)(((uint64_t)_res) & ~1);
6449 TxOut_free(_res_conv);
6452 uint32_t __attribute__((visibility("default"))) TS_TxOut_clone(uint32_t orig) {
6453 LDKTxOut* orig_conv = (LDKTxOut*)(orig & ~1);
6454 LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut");
6455 *ret_ref = TxOut_clone(orig_conv);
6456 return (uint64_t)ret_ref;
6459 void __attribute__((visibility("default"))) TS_Str_free(jstring _res) {
6460 LDKStr dummy = { .chars = NULL, .len = 0, .chars_is_owned = false };
6464 uint32_t __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_ok(int8_tArray o) {
6466 CHECK(*((uint32_t*)o) == 32);
6467 memcpy(o_ref.bytes, (uint8_t*)(o + 4), 32);
6468 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
6469 *ret_conv = CResult_SecretKeyErrorZ_ok(o_ref);
6470 return (uint64_t)ret_conv;
6473 uint32_t __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_err(uint32_t e) {
6474 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
6475 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
6476 *ret_conv = CResult_SecretKeyErrorZ_err(e_conv);
6477 return (uint64_t)ret_conv;
6480 void __attribute__((visibility("default"))) TS_CResult_SecretKeyErrorZ_free(uint32_t _res) {
6481 if ((_res & 1) != 0) return;
6482 LDKCResult_SecretKeyErrorZ _res_conv = *(LDKCResult_SecretKeyErrorZ*)(((uint64_t)_res) & ~1);
6484 CResult_SecretKeyErrorZ_free(_res_conv);
6487 uint32_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_ok(int8_tArray o) {
6489 CHECK(*((uint32_t*)o) == 33);
6490 memcpy(o_ref.compressed_form, (uint8_t*)(o + 4), 33);
6491 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
6492 *ret_conv = CResult_PublicKeyErrorZ_ok(o_ref);
6493 return (uint64_t)ret_conv;
6496 uint32_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_err(uint32_t e) {
6497 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
6498 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
6499 *ret_conv = CResult_PublicKeyErrorZ_err(e_conv);
6500 return (uint64_t)ret_conv;
6503 void __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_free(uint32_t _res) {
6504 if ((_res & 1) != 0) return;
6505 LDKCResult_PublicKeyErrorZ _res_conv = *(LDKCResult_PublicKeyErrorZ*)(((uint64_t)_res) & ~1);
6507 CResult_PublicKeyErrorZ_free(_res_conv);
6510 uint32_t __attribute__((visibility("default"))) TS_CResult_PublicKeyErrorZ_clone(uint32_t orig) {
6511 LDKCResult_PublicKeyErrorZ* orig_conv = (LDKCResult_PublicKeyErrorZ*)(orig & ~1);
6512 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
6513 *ret_conv = CResult_PublicKeyErrorZ_clone(orig_conv);
6514 return (uint64_t)ret_conv;
6517 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_ok(uint32_t o) {
6518 LDKTxCreationKeys o_conv;
6519 o_conv.inner = (void*)(o & (~1));
6520 o_conv.is_owned = (o & 1) || (o == 0);
6521 o_conv = TxCreationKeys_clone(&o_conv);
6522 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6523 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_ok(o_conv);
6524 return (uint64_t)ret_conv;
6527 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_err(uint32_t e) {
6528 LDKDecodeError e_conv;
6529 e_conv.inner = (void*)(e & (~1));
6530 e_conv.is_owned = (e & 1) || (e == 0);
6531 e_conv = DecodeError_clone(&e_conv);
6532 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6533 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_err(e_conv);
6534 return (uint64_t)ret_conv;
6537 void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_free(uint32_t _res) {
6538 if ((_res & 1) != 0) return;
6539 LDKCResult_TxCreationKeysDecodeErrorZ _res_conv = *(LDKCResult_TxCreationKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
6541 CResult_TxCreationKeysDecodeErrorZ_free(_res_conv);
6544 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysDecodeErrorZ_clone(uint32_t orig) {
6545 LDKCResult_TxCreationKeysDecodeErrorZ* orig_conv = (LDKCResult_TxCreationKeysDecodeErrorZ*)(orig & ~1);
6546 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
6547 *ret_conv = CResult_TxCreationKeysDecodeErrorZ_clone(orig_conv);
6548 return (uint64_t)ret_conv;
6551 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_ok(uint32_t o) {
6552 LDKChannelPublicKeys o_conv;
6553 o_conv.inner = (void*)(o & (~1));
6554 o_conv.is_owned = (o & 1) || (o == 0);
6555 o_conv = ChannelPublicKeys_clone(&o_conv);
6556 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6557 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_ok(o_conv);
6558 return (uint64_t)ret_conv;
6561 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_err(uint32_t e) {
6562 LDKDecodeError e_conv;
6563 e_conv.inner = (void*)(e & (~1));
6564 e_conv.is_owned = (e & 1) || (e == 0);
6565 e_conv = DecodeError_clone(&e_conv);
6566 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6567 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_err(e_conv);
6568 return (uint64_t)ret_conv;
6571 void __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_free(uint32_t _res) {
6572 if ((_res & 1) != 0) return;
6573 LDKCResult_ChannelPublicKeysDecodeErrorZ _res_conv = *(LDKCResult_ChannelPublicKeysDecodeErrorZ*)(((uint64_t)_res) & ~1);
6575 CResult_ChannelPublicKeysDecodeErrorZ_free(_res_conv);
6578 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelPublicKeysDecodeErrorZ_clone(uint32_t orig) {
6579 LDKCResult_ChannelPublicKeysDecodeErrorZ* orig_conv = (LDKCResult_ChannelPublicKeysDecodeErrorZ*)(orig & ~1);
6580 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
6581 *ret_conv = CResult_ChannelPublicKeysDecodeErrorZ_clone(orig_conv);
6582 return (uint64_t)ret_conv;
6585 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_ok(uint32_t o) {
6586 LDKTxCreationKeys o_conv;
6587 o_conv.inner = (void*)(o & (~1));
6588 o_conv.is_owned = (o & 1) || (o == 0);
6589 o_conv = TxCreationKeys_clone(&o_conv);
6590 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
6591 *ret_conv = CResult_TxCreationKeysErrorZ_ok(o_conv);
6592 return (uint64_t)ret_conv;
6595 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_err(uint32_t e) {
6596 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
6597 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
6598 *ret_conv = CResult_TxCreationKeysErrorZ_err(e_conv);
6599 return (uint64_t)ret_conv;
6602 void __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_free(uint32_t _res) {
6603 if ((_res & 1) != 0) return;
6604 LDKCResult_TxCreationKeysErrorZ _res_conv = *(LDKCResult_TxCreationKeysErrorZ*)(((uint64_t)_res) & ~1);
6606 CResult_TxCreationKeysErrorZ_free(_res_conv);
6609 uint32_t __attribute__((visibility("default"))) TS_CResult_TxCreationKeysErrorZ_clone(uint32_t orig) {
6610 LDKCResult_TxCreationKeysErrorZ* orig_conv = (LDKCResult_TxCreationKeysErrorZ*)(orig & ~1);
6611 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
6612 *ret_conv = CResult_TxCreationKeysErrorZ_clone(orig_conv);
6613 return (uint64_t)ret_conv;
6616 uint32_t __attribute__((visibility("default"))) TS_COption_u32Z_some(int32_t o) {
6617 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
6618 *ret_copy = COption_u32Z_some(o);
6619 uint64_t ret_ref = (uint64_t)ret_copy;
6623 uint32_t __attribute__((visibility("default"))) TS_COption_u32Z_none() {
6624 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
6625 *ret_copy = COption_u32Z_none();
6626 uint64_t ret_ref = (uint64_t)ret_copy;
6630 void __attribute__((visibility("default"))) TS_COption_u32Z_free(uint32_t _res) {
6631 if ((_res & 1) != 0) return;
6632 LDKCOption_u32Z _res_conv = *(LDKCOption_u32Z*)(((uint64_t)_res) & ~1);
6634 COption_u32Z_free(_res_conv);
6637 uint32_t __attribute__((visibility("default"))) TS_COption_u32Z_clone(uint32_t orig) {
6638 LDKCOption_u32Z* orig_conv = (LDKCOption_u32Z*)orig;
6639 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
6640 *ret_copy = COption_u32Z_clone(orig_conv);
6641 uint64_t ret_ref = (uint64_t)ret_copy;
6645 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(uint32_t o) {
6646 LDKHTLCOutputInCommitment o_conv;
6647 o_conv.inner = (void*)(o & (~1));
6648 o_conv.is_owned = (o & 1) || (o == 0);
6649 o_conv = HTLCOutputInCommitment_clone(&o_conv);
6650 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6651 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_ok(o_conv);
6652 return (uint64_t)ret_conv;
6655 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_err(uint32_t e) {
6656 LDKDecodeError e_conv;
6657 e_conv.inner = (void*)(e & (~1));
6658 e_conv.is_owned = (e & 1) || (e == 0);
6659 e_conv = DecodeError_clone(&e_conv);
6660 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6661 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_err(e_conv);
6662 return (uint64_t)ret_conv;
6665 void __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_free(uint32_t _res) {
6666 if ((_res & 1) != 0) return;
6667 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ _res_conv = *(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(((uint64_t)_res) & ~1);
6669 CResult_HTLCOutputInCommitmentDecodeErrorZ_free(_res_conv);
6672 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(uint32_t orig) {
6673 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* orig_conv = (LDKCResult_HTLCOutputInCommitmentDecodeErrorZ*)(orig & ~1);
6674 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
6675 *ret_conv = CResult_HTLCOutputInCommitmentDecodeErrorZ_clone(orig_conv);
6676 return (uint64_t)ret_conv;
6679 uint32_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(uint32_t o) {
6680 LDKCounterpartyChannelTransactionParameters o_conv;
6681 o_conv.inner = (void*)(o & (~1));
6682 o_conv.is_owned = (o & 1) || (o == 0);
6683 o_conv = CounterpartyChannelTransactionParameters_clone(&o_conv);
6684 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6685 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_ok(o_conv);
6686 return (uint64_t)ret_conv;
6689 uint32_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(uint32_t e) {
6690 LDKDecodeError e_conv;
6691 e_conv.inner = (void*)(e & (~1));
6692 e_conv.is_owned = (e & 1) || (e == 0);
6693 e_conv = DecodeError_clone(&e_conv);
6694 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6695 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_err(e_conv);
6696 return (uint64_t)ret_conv;
6699 void __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
6700 if ((_res & 1) != 0) return;
6701 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
6703 CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_free(_res_conv);
6706 uint32_t __attribute__((visibility("default"))) TS_CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
6707 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
6708 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
6709 *ret_conv = CResult_CounterpartyChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
6710 return (uint64_t)ret_conv;
6713 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_ok(uint32_t o) {
6714 LDKChannelTransactionParameters o_conv;
6715 o_conv.inner = (void*)(o & (~1));
6716 o_conv.is_owned = (o & 1) || (o == 0);
6717 o_conv = ChannelTransactionParameters_clone(&o_conv);
6718 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6719 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_ok(o_conv);
6720 return (uint64_t)ret_conv;
6723 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_err(uint32_t e) {
6724 LDKDecodeError e_conv;
6725 e_conv.inner = (void*)(e & (~1));
6726 e_conv.is_owned = (e & 1) || (e == 0);
6727 e_conv = DecodeError_clone(&e_conv);
6728 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6729 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_err(e_conv);
6730 return (uint64_t)ret_conv;
6733 void __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_free(uint32_t _res) {
6734 if ((_res & 1) != 0) return;
6735 LDKCResult_ChannelTransactionParametersDecodeErrorZ _res_conv = *(LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(((uint64_t)_res) & ~1);
6737 CResult_ChannelTransactionParametersDecodeErrorZ_free(_res_conv);
6740 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelTransactionParametersDecodeErrorZ_clone(uint32_t orig) {
6741 LDKCResult_ChannelTransactionParametersDecodeErrorZ* orig_conv = (LDKCResult_ChannelTransactionParametersDecodeErrorZ*)(orig & ~1);
6742 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
6743 *ret_conv = CResult_ChannelTransactionParametersDecodeErrorZ_clone(orig_conv);
6744 return (uint64_t)ret_conv;
6747 void __attribute__((visibility("default"))) TS_CVec_SignatureZ_free(ptrArray _res) {
6748 LDKCVec_SignatureZ _res_constr;
6749 _res_constr.datalen = *((uint32_t*)_res);
6750 if (_res_constr.datalen > 0)
6751 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
6753 _res_constr.data = NULL;
6754 int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
6755 for (size_t m = 0; m < _res_constr.datalen; m++) {
6756 int8_tArray _res_conv_12 = _res_vals[m];
6757 LDKSignature _res_conv_12_ref;
6758 CHECK(*((uint32_t*)_res_conv_12) == 64);
6759 memcpy(_res_conv_12_ref.compact_form, (uint8_t*)(_res_conv_12 + 4), 64);
6760 _res_constr.data[m] = _res_conv_12_ref;
6762 CVec_SignatureZ_free(_res_constr);
6765 uint32_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
6766 LDKHolderCommitmentTransaction o_conv;
6767 o_conv.inner = (void*)(o & (~1));
6768 o_conv.is_owned = (o & 1) || (o == 0);
6769 o_conv = HolderCommitmentTransaction_clone(&o_conv);
6770 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6771 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_ok(o_conv);
6772 return (uint64_t)ret_conv;
6775 uint32_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_err(uint32_t e) {
6776 LDKDecodeError e_conv;
6777 e_conv.inner = (void*)(e & (~1));
6778 e_conv.is_owned = (e & 1) || (e == 0);
6779 e_conv = DecodeError_clone(&e_conv);
6780 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6781 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_err(e_conv);
6782 return (uint64_t)ret_conv;
6785 void __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
6786 if ((_res & 1) != 0) return;
6787 LDKCResult_HolderCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6789 CResult_HolderCommitmentTransactionDecodeErrorZ_free(_res_conv);
6792 uint32_t __attribute__((visibility("default"))) TS_CResult_HolderCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
6793 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_HolderCommitmentTransactionDecodeErrorZ*)(orig & ~1);
6794 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
6795 *ret_conv = CResult_HolderCommitmentTransactionDecodeErrorZ_clone(orig_conv);
6796 return (uint64_t)ret_conv;
6799 uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
6800 LDKBuiltCommitmentTransaction o_conv;
6801 o_conv.inner = (void*)(o & (~1));
6802 o_conv.is_owned = (o & 1) || (o == 0);
6803 o_conv = BuiltCommitmentTransaction_clone(&o_conv);
6804 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6805 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_ok(o_conv);
6806 return (uint64_t)ret_conv;
6809 uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_err(uint32_t e) {
6810 LDKDecodeError e_conv;
6811 e_conv.inner = (void*)(e & (~1));
6812 e_conv.is_owned = (e & 1) || (e == 0);
6813 e_conv = DecodeError_clone(&e_conv);
6814 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6815 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_err(e_conv);
6816 return (uint64_t)ret_conv;
6819 void __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
6820 if ((_res & 1) != 0) return;
6821 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6823 CResult_BuiltCommitmentTransactionDecodeErrorZ_free(_res_conv);
6826 uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
6827 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_BuiltCommitmentTransactionDecodeErrorZ*)(orig & ~1);
6828 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
6829 *ret_conv = CResult_BuiltCommitmentTransactionDecodeErrorZ_clone(orig_conv);
6830 return (uint64_t)ret_conv;
6833 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint32_t o) {
6834 LDKCommitmentTransaction o_conv;
6835 o_conv.inner = (void*)(o & (~1));
6836 o_conv.is_owned = (o & 1) || (o == 0);
6837 o_conv = CommitmentTransaction_clone(&o_conv);
6838 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6839 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_ok(o_conv);
6840 return (uint64_t)ret_conv;
6843 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_err(uint32_t e) {
6844 LDKDecodeError e_conv;
6845 e_conv.inner = (void*)(e & (~1));
6846 e_conv.is_owned = (e & 1) || (e == 0);
6847 e_conv = DecodeError_clone(&e_conv);
6848 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6849 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_err(e_conv);
6850 return (uint64_t)ret_conv;
6853 void __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_free(uint32_t _res) {
6854 if ((_res & 1) != 0) return;
6855 LDKCResult_CommitmentTransactionDecodeErrorZ _res_conv = *(LDKCResult_CommitmentTransactionDecodeErrorZ*)(((uint64_t)_res) & ~1);
6857 CResult_CommitmentTransactionDecodeErrorZ_free(_res_conv);
6860 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_clone(uint32_t orig) {
6861 LDKCResult_CommitmentTransactionDecodeErrorZ* orig_conv = (LDKCResult_CommitmentTransactionDecodeErrorZ*)(orig & ~1);
6862 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
6863 *ret_conv = CResult_CommitmentTransactionDecodeErrorZ_clone(orig_conv);
6864 return (uint64_t)ret_conv;
6867 uint32_t __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_ok(uint32_t o) {
6868 LDKTrustedCommitmentTransaction o_conv;
6869 o_conv.inner = (void*)(o & (~1));
6870 o_conv.is_owned = (o & 1) || (o == 0);
6871 // Warning: we need a move here but no clone is available for LDKTrustedCommitmentTransaction
6872 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
6873 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_ok(o_conv);
6874 return (uint64_t)ret_conv;
6877 uint32_t __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_err() {
6878 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
6879 *ret_conv = CResult_TrustedCommitmentTransactionNoneZ_err();
6880 return (uint64_t)ret_conv;
6883 void __attribute__((visibility("default"))) TS_CResult_TrustedCommitmentTransactionNoneZ_free(uint32_t _res) {
6884 if ((_res & 1) != 0) return;
6885 LDKCResult_TrustedCommitmentTransactionNoneZ _res_conv = *(LDKCResult_TrustedCommitmentTransactionNoneZ*)(((uint64_t)_res) & ~1);
6887 CResult_TrustedCommitmentTransactionNoneZ_free(_res_conv);
6890 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_ok(ptrArray o) {
6891 LDKCVec_SignatureZ o_constr;
6892 o_constr.datalen = *((uint32_t*)o);
6893 if (o_constr.datalen > 0)
6894 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
6896 o_constr.data = NULL;
6897 int8_tArray* o_vals = (int8_tArray*)(o + 4);
6898 for (size_t m = 0; m < o_constr.datalen; m++) {
6899 int8_tArray o_conv_12 = o_vals[m];
6900 LDKSignature o_conv_12_ref;
6901 CHECK(*((uint32_t*)o_conv_12) == 64);
6902 memcpy(o_conv_12_ref.compact_form, (uint8_t*)(o_conv_12 + 4), 64);
6903 o_constr.data[m] = o_conv_12_ref;
6905 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6906 *ret_conv = CResult_CVec_SignatureZNoneZ_ok(o_constr);
6907 return (uint64_t)ret_conv;
6910 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_err() {
6911 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6912 *ret_conv = CResult_CVec_SignatureZNoneZ_err();
6913 return (uint64_t)ret_conv;
6916 void __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_free(uint32_t _res) {
6917 if ((_res & 1) != 0) return;
6918 LDKCResult_CVec_SignatureZNoneZ _res_conv = *(LDKCResult_CVec_SignatureZNoneZ*)(((uint64_t)_res) & ~1);
6920 CResult_CVec_SignatureZNoneZ_free(_res_conv);
6923 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_SignatureZNoneZ_clone(uint32_t orig) {
6924 LDKCResult_CVec_SignatureZNoneZ* orig_conv = (LDKCResult_CVec_SignatureZNoneZ*)(orig & ~1);
6925 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
6926 *ret_conv = CResult_CVec_SignatureZNoneZ_clone(orig_conv);
6927 return (uint64_t)ret_conv;
6930 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_ok() {
6931 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
6932 *ret_conv = CResult_NoneErrorZ_ok();
6933 return (uint64_t)ret_conv;
6936 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_err(uint32_t e) {
6937 LDKIOError e_conv = LDKIOError_from_js(e);
6938 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
6939 *ret_conv = CResult_NoneErrorZ_err(e_conv);
6940 return (uint64_t)ret_conv;
6943 void __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_free(uint32_t _res) {
6944 if ((_res & 1) != 0) return;
6945 LDKCResult_NoneErrorZ _res_conv = *(LDKCResult_NoneErrorZ*)(((uint64_t)_res) & ~1);
6947 CResult_NoneErrorZ_free(_res_conv);
6950 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneErrorZ_clone(uint32_t orig) {
6951 LDKCResult_NoneErrorZ* orig_conv = (LDKCResult_NoneErrorZ*)(orig & ~1);
6952 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
6953 *ret_conv = CResult_NoneErrorZ_clone(orig_conv);
6954 return (uint64_t)ret_conv;
6957 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_ok(uint32_t o) {
6959 o_conv.inner = (void*)(o & (~1));
6960 o_conv.is_owned = (o & 1) || (o == 0);
6961 o_conv = RouteHop_clone(&o_conv);
6962 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
6963 *ret_conv = CResult_RouteHopDecodeErrorZ_ok(o_conv);
6964 return (uint64_t)ret_conv;
6967 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_err(uint32_t e) {
6968 LDKDecodeError e_conv;
6969 e_conv.inner = (void*)(e & (~1));
6970 e_conv.is_owned = (e & 1) || (e == 0);
6971 e_conv = DecodeError_clone(&e_conv);
6972 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
6973 *ret_conv = CResult_RouteHopDecodeErrorZ_err(e_conv);
6974 return (uint64_t)ret_conv;
6977 void __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_free(uint32_t _res) {
6978 if ((_res & 1) != 0) return;
6979 LDKCResult_RouteHopDecodeErrorZ _res_conv = *(LDKCResult_RouteHopDecodeErrorZ*)(((uint64_t)_res) & ~1);
6981 CResult_RouteHopDecodeErrorZ_free(_res_conv);
6984 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteHopDecodeErrorZ_clone(uint32_t orig) {
6985 LDKCResult_RouteHopDecodeErrorZ* orig_conv = (LDKCResult_RouteHopDecodeErrorZ*)(orig & ~1);
6986 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
6987 *ret_conv = CResult_RouteHopDecodeErrorZ_clone(orig_conv);
6988 return (uint64_t)ret_conv;
6991 void __attribute__((visibility("default"))) TS_CVec_RouteHopZ_free(uint32_tArray _res) {
6992 LDKCVec_RouteHopZ _res_constr;
6993 _res_constr.datalen = *((uint32_t*)_res);
6994 if (_res_constr.datalen > 0)
6995 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
6997 _res_constr.data = NULL;
6998 uint32_t* _res_vals = (uint32_t*)(_res + 4);
6999 for (size_t k = 0; k < _res_constr.datalen; k++) {
7000 uint32_t _res_conv_10 = _res_vals[k];
7001 LDKRouteHop _res_conv_10_conv;
7002 _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1));
7003 _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0);
7004 _res_constr.data[k] = _res_conv_10_conv;
7006 CVec_RouteHopZ_free(_res_constr);
7009 void __attribute__((visibility("default"))) TS_CVec_CVec_RouteHopZZ_free(ptrArray _res) {
7010 LDKCVec_CVec_RouteHopZZ _res_constr;
7011 _res_constr.datalen = *((uint32_t*)_res);
7012 if (_res_constr.datalen > 0)
7013 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
7015 _res_constr.data = NULL;
7016 uint32_tArray* _res_vals = (uint32_tArray*)(_res + 4);
7017 for (size_t m = 0; m < _res_constr.datalen; m++) {
7018 uint32_tArray _res_conv_12 = _res_vals[m];
7019 LDKCVec_RouteHopZ _res_conv_12_constr;
7020 _res_conv_12_constr.datalen = *((uint32_t*)_res_conv_12);
7021 if (_res_conv_12_constr.datalen > 0)
7022 _res_conv_12_constr.data = MALLOC(_res_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
7024 _res_conv_12_constr.data = NULL;
7025 uint32_t* _res_conv_12_vals = (uint32_t*)(_res_conv_12 + 4);
7026 for (size_t k = 0; k < _res_conv_12_constr.datalen; k++) {
7027 uint32_t _res_conv_12_conv_10 = _res_conv_12_vals[k];
7028 LDKRouteHop _res_conv_12_conv_10_conv;
7029 _res_conv_12_conv_10_conv.inner = (void*)(_res_conv_12_conv_10 & (~1));
7030 _res_conv_12_conv_10_conv.is_owned = (_res_conv_12_conv_10 & 1) || (_res_conv_12_conv_10 == 0);
7031 _res_conv_12_constr.data[k] = _res_conv_12_conv_10_conv;
7033 _res_constr.data[m] = _res_conv_12_constr;
7035 CVec_CVec_RouteHopZZ_free(_res_constr);
7038 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_ok(uint32_t o) {
7040 o_conv.inner = (void*)(o & (~1));
7041 o_conv.is_owned = (o & 1) || (o == 0);
7042 o_conv = Route_clone(&o_conv);
7043 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
7044 *ret_conv = CResult_RouteDecodeErrorZ_ok(o_conv);
7045 return (uint64_t)ret_conv;
7048 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_err(uint32_t e) {
7049 LDKDecodeError e_conv;
7050 e_conv.inner = (void*)(e & (~1));
7051 e_conv.is_owned = (e & 1) || (e == 0);
7052 e_conv = DecodeError_clone(&e_conv);
7053 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
7054 *ret_conv = CResult_RouteDecodeErrorZ_err(e_conv);
7055 return (uint64_t)ret_conv;
7058 void __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_free(uint32_t _res) {
7059 if ((_res & 1) != 0) return;
7060 LDKCResult_RouteDecodeErrorZ _res_conv = *(LDKCResult_RouteDecodeErrorZ*)(((uint64_t)_res) & ~1);
7062 CResult_RouteDecodeErrorZ_free(_res_conv);
7065 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteDecodeErrorZ_clone(uint32_t orig) {
7066 LDKCResult_RouteDecodeErrorZ* orig_conv = (LDKCResult_RouteDecodeErrorZ*)(orig & ~1);
7067 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
7068 *ret_conv = CResult_RouteDecodeErrorZ_clone(orig_conv);
7069 return (uint64_t)ret_conv;
7072 uint32_t __attribute__((visibility("default"))) TS_COption_u64Z_some(int64_t o) {
7073 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
7074 *ret_copy = COption_u64Z_some(o);
7075 uint64_t ret_ref = (uint64_t)ret_copy;
7079 uint32_t __attribute__((visibility("default"))) TS_COption_u64Z_none() {
7080 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
7081 *ret_copy = COption_u64Z_none();
7082 uint64_t ret_ref = (uint64_t)ret_copy;
7086 void __attribute__((visibility("default"))) TS_COption_u64Z_free(uint32_t _res) {
7087 if ((_res & 1) != 0) return;
7088 LDKCOption_u64Z _res_conv = *(LDKCOption_u64Z*)(((uint64_t)_res) & ~1);
7090 COption_u64Z_free(_res_conv);
7093 uint32_t __attribute__((visibility("default"))) TS_COption_u64Z_clone(uint32_t orig) {
7094 LDKCOption_u64Z* orig_conv = (LDKCOption_u64Z*)orig;
7095 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
7096 *ret_copy = COption_u64Z_clone(orig_conv);
7097 uint64_t ret_ref = (uint64_t)ret_copy;
7101 void __attribute__((visibility("default"))) TS_CVec_ChannelDetailsZ_free(uint32_tArray _res) {
7102 LDKCVec_ChannelDetailsZ _res_constr;
7103 _res_constr.datalen = *((uint32_t*)_res);
7104 if (_res_constr.datalen > 0)
7105 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
7107 _res_constr.data = NULL;
7108 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7109 for (size_t q = 0; q < _res_constr.datalen; q++) {
7110 uint32_t _res_conv_16 = _res_vals[q];
7111 LDKChannelDetails _res_conv_16_conv;
7112 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
7113 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
7114 _res_constr.data[q] = _res_conv_16_conv;
7116 CVec_ChannelDetailsZ_free(_res_constr);
7119 void __attribute__((visibility("default"))) TS_CVec_RouteHintZ_free(uint32_tArray _res) {
7120 LDKCVec_RouteHintZ _res_constr;
7121 _res_constr.datalen = *((uint32_t*)_res);
7122 if (_res_constr.datalen > 0)
7123 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
7125 _res_constr.data = NULL;
7126 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7127 for (size_t l = 0; l < _res_constr.datalen; l++) {
7128 uint32_t _res_conv_11 = _res_vals[l];
7129 LDKRouteHint _res_conv_11_conv;
7130 _res_conv_11_conv.inner = (void*)(_res_conv_11 & (~1));
7131 _res_conv_11_conv.is_owned = (_res_conv_11 & 1) || (_res_conv_11 == 0);
7132 _res_constr.data[l] = _res_conv_11_conv;
7134 CVec_RouteHintZ_free(_res_constr);
7137 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_ok(uint32_t o) {
7139 o_conv.inner = (void*)(o & (~1));
7140 o_conv.is_owned = (o & 1) || (o == 0);
7141 o_conv = Route_clone(&o_conv);
7142 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
7143 *ret_conv = CResult_RouteLightningErrorZ_ok(o_conv);
7144 return (uint64_t)ret_conv;
7147 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_err(uint32_t e) {
7148 LDKLightningError e_conv;
7149 e_conv.inner = (void*)(e & (~1));
7150 e_conv.is_owned = (e & 1) || (e == 0);
7151 e_conv = LightningError_clone(&e_conv);
7152 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
7153 *ret_conv = CResult_RouteLightningErrorZ_err(e_conv);
7154 return (uint64_t)ret_conv;
7157 void __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_free(uint32_t _res) {
7158 if ((_res & 1) != 0) return;
7159 LDKCResult_RouteLightningErrorZ _res_conv = *(LDKCResult_RouteLightningErrorZ*)(((uint64_t)_res) & ~1);
7161 CResult_RouteLightningErrorZ_free(_res_conv);
7164 uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ_clone(uint32_t orig) {
7165 LDKCResult_RouteLightningErrorZ* orig_conv = (LDKCResult_RouteLightningErrorZ*)(orig & ~1);
7166 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
7167 *ret_conv = CResult_RouteLightningErrorZ_clone(orig_conv);
7168 return (uint64_t)ret_conv;
7171 uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_ok(uint32_t o) {
7172 LDKTxOut o_conv = *(LDKTxOut*)(((uint64_t)o) & ~1);
7173 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7174 *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv);
7175 return (uint64_t)ret_conv;
7178 uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_err(uint32_t e) {
7179 LDKAccessError e_conv = LDKAccessError_from_js(e);
7180 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7181 *ret_conv = CResult_TxOutAccessErrorZ_err(e_conv);
7182 return (uint64_t)ret_conv;
7185 void __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_free(uint32_t _res) {
7186 if ((_res & 1) != 0) return;
7187 LDKCResult_TxOutAccessErrorZ _res_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)_res) & ~1);
7189 CResult_TxOutAccessErrorZ_free(_res_conv);
7192 uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_clone(uint32_t orig) {
7193 LDKCResult_TxOutAccessErrorZ* orig_conv = (LDKCResult_TxOutAccessErrorZ*)(orig & ~1);
7194 LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ");
7195 *ret_conv = CResult_TxOutAccessErrorZ_clone(orig_conv);
7196 return (uint64_t)ret_conv;
7199 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone(uint32_t orig) {
7200 LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1);
7201 LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
7202 *ret_ref = C2Tuple_usizeTransactionZ_clone(orig_conv);
7203 return (uint64_t)ret_ref;
7206 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_new(int64_t a, int8_tArray b) {
7207 LDKTransaction b_ref;
7208 b_ref.datalen = *((uint32_t*)b);
7209 b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes");
7210 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
7211 b_ref.data_is_owned = true;
7212 LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ");
7213 *ret_ref = C2Tuple_usizeTransactionZ_new(a, b_ref);
7214 return (uint64_t)ret_ref;
7217 void __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_free(uint32_t _res) {
7218 if ((_res & 1) != 0) return;
7219 LDKC2Tuple_usizeTransactionZ _res_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res) & ~1);
7221 C2Tuple_usizeTransactionZ_free(_res_conv);
7224 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_usizeTransactionZZ_free(uint32_tArray _res) {
7225 LDKCVec_C2Tuple_usizeTransactionZZ _res_constr;
7226 _res_constr.datalen = *((uint32_t*)_res);
7227 if (_res_constr.datalen > 0)
7228 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
7230 _res_constr.data = NULL;
7231 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7232 for (size_t e = 0; e < _res_constr.datalen; e++) {
7233 uint32_t _res_conv_30 = _res_vals[e];
7234 LDKC2Tuple_usizeTransactionZ _res_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res_conv_30) & ~1);
7235 FREE((void*)_res_conv_30);
7236 _res_constr.data[e] = _res_conv_30_conv;
7238 CVec_C2Tuple_usizeTransactionZZ_free(_res_constr);
7241 void __attribute__((visibility("default"))) TS_CVec_TxidZ_free(ptrArray _res) {
7242 LDKCVec_TxidZ _res_constr;
7243 _res_constr.datalen = *((uint32_t*)_res);
7244 if (_res_constr.datalen > 0)
7245 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKThirtyTwoBytes), "LDKCVec_TxidZ Elements");
7247 _res_constr.data = NULL;
7248 int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
7249 for (size_t m = 0; m < _res_constr.datalen; m++) {
7250 int8_tArray _res_conv_12 = _res_vals[m];
7251 LDKThirtyTwoBytes _res_conv_12_ref;
7252 CHECK(*((uint32_t*)_res_conv_12) == 32);
7253 memcpy(_res_conv_12_ref.data, (uint8_t*)(_res_conv_12 + 4), 32);
7254 _res_constr.data[m] = _res_conv_12_ref;
7256 CVec_TxidZ_free(_res_constr);
7259 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_ok() {
7260 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7261 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_ok();
7262 return (uint64_t)ret_conv;
7265 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_err(uint32_t e) {
7266 LDKChannelMonitorUpdateErr e_conv = LDKChannelMonitorUpdateErr_from_js(e);
7267 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7268 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_err(e_conv);
7269 return (uint64_t)ret_conv;
7272 void __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_free(uint32_t _res) {
7273 if ((_res & 1) != 0) return;
7274 LDKCResult_NoneChannelMonitorUpdateErrZ _res_conv = *(LDKCResult_NoneChannelMonitorUpdateErrZ*)(((uint64_t)_res) & ~1);
7276 CResult_NoneChannelMonitorUpdateErrZ_free(_res_conv);
7279 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneChannelMonitorUpdateErrZ_clone(uint32_t orig) {
7280 LDKCResult_NoneChannelMonitorUpdateErrZ* orig_conv = (LDKCResult_NoneChannelMonitorUpdateErrZ*)(orig & ~1);
7281 LDKCResult_NoneChannelMonitorUpdateErrZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneChannelMonitorUpdateErrZ), "LDKCResult_NoneChannelMonitorUpdateErrZ");
7282 *ret_conv = CResult_NoneChannelMonitorUpdateErrZ_clone(orig_conv);
7283 return (uint64_t)ret_conv;
7286 void __attribute__((visibility("default"))) TS_CVec_MonitorEventZ_free(uint32_tArray _res) {
7287 LDKCVec_MonitorEventZ _res_constr;
7288 _res_constr.datalen = *((uint32_t*)_res);
7289 if (_res_constr.datalen > 0)
7290 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMonitorEvent), "LDKCVec_MonitorEventZ Elements");
7292 _res_constr.data = NULL;
7293 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7294 for (size_t o = 0; o < _res_constr.datalen; o++) {
7295 uint32_t _res_conv_14 = _res_vals[o];
7296 LDKMonitorEvent _res_conv_14_conv = *(LDKMonitorEvent*)(((uint64_t)_res_conv_14) & ~1);
7297 FREE((void*)_res_conv_14);
7298 _res_constr.data[o] = _res_conv_14_conv;
7300 CVec_MonitorEventZ_free(_res_constr);
7303 uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_some(uint32_t o) {
7304 LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)o) & ~1);
7305 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
7306 *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv);
7307 uint64_t ret_ref = (uint64_t)ret_copy;
7311 uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_none() {
7312 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
7313 *ret_copy = COption_C2Tuple_usizeTransactionZZ_none();
7314 uint64_t ret_ref = (uint64_t)ret_copy;
7318 void __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_free(uint32_t _res) {
7319 if ((_res & 1) != 0) return;
7320 LDKCOption_C2Tuple_usizeTransactionZZ _res_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)_res) & ~1);
7322 COption_C2Tuple_usizeTransactionZZ_free(_res_conv);
7325 uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_clone(uint32_t orig) {
7326 LDKCOption_C2Tuple_usizeTransactionZZ* orig_conv = (LDKCOption_C2Tuple_usizeTransactionZZ*)orig;
7327 LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ");
7328 *ret_copy = COption_C2Tuple_usizeTransactionZZ_clone(orig_conv);
7329 uint64_t ret_ref = (uint64_t)ret_copy;
7333 void __attribute__((visibility("default"))) TS_CVec_SpendableOutputDescriptorZ_free(uint32_tArray _res) {
7334 LDKCVec_SpendableOutputDescriptorZ _res_constr;
7335 _res_constr.datalen = *((uint32_t*)_res);
7336 if (_res_constr.datalen > 0)
7337 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
7339 _res_constr.data = NULL;
7340 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7341 for (size_t b = 0; b < _res_constr.datalen; b++) {
7342 uint32_t _res_conv_27 = _res_vals[b];
7343 LDKSpendableOutputDescriptor _res_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)_res_conv_27) & ~1);
7344 FREE((void*)_res_conv_27);
7345 _res_constr.data[b] = _res_conv_27_conv;
7347 CVec_SpendableOutputDescriptorZ_free(_res_constr);
7350 void __attribute__((visibility("default"))) TS_CVec_MessageSendEventZ_free(uint32_tArray _res) {
7351 LDKCVec_MessageSendEventZ _res_constr;
7352 _res_constr.datalen = *((uint32_t*)_res);
7353 if (_res_constr.datalen > 0)
7354 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKMessageSendEvent), "LDKCVec_MessageSendEventZ Elements");
7356 _res_constr.data = NULL;
7357 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7358 for (size_t s = 0; s < _res_constr.datalen; s++) {
7359 uint32_t _res_conv_18 = _res_vals[s];
7360 LDKMessageSendEvent _res_conv_18_conv = *(LDKMessageSendEvent*)(((uint64_t)_res_conv_18) & ~1);
7361 FREE((void*)_res_conv_18);
7362 _res_constr.data[s] = _res_conv_18_conv;
7364 CVec_MessageSendEventZ_free(_res_constr);
7367 uint32_t __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_ok(uint32_t o) {
7368 LDKInitFeatures o_conv;
7369 o_conv.inner = (void*)(o & (~1));
7370 o_conv.is_owned = (o & 1) || (o == 0);
7371 o_conv = InitFeatures_clone(&o_conv);
7372 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
7373 *ret_conv = CResult_InitFeaturesDecodeErrorZ_ok(o_conv);
7374 return (uint64_t)ret_conv;
7377 uint32_t __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_err(uint32_t e) {
7378 LDKDecodeError e_conv;
7379 e_conv.inner = (void*)(e & (~1));
7380 e_conv.is_owned = (e & 1) || (e == 0);
7381 e_conv = DecodeError_clone(&e_conv);
7382 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
7383 *ret_conv = CResult_InitFeaturesDecodeErrorZ_err(e_conv);
7384 return (uint64_t)ret_conv;
7387 void __attribute__((visibility("default"))) TS_CResult_InitFeaturesDecodeErrorZ_free(uint32_t _res) {
7388 if ((_res & 1) != 0) return;
7389 LDKCResult_InitFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InitFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7391 CResult_InitFeaturesDecodeErrorZ_free(_res_conv);
7394 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_ok(uint32_t o) {
7395 LDKNodeFeatures o_conv;
7396 o_conv.inner = (void*)(o & (~1));
7397 o_conv.is_owned = (o & 1) || (o == 0);
7398 o_conv = NodeFeatures_clone(&o_conv);
7399 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
7400 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_ok(o_conv);
7401 return (uint64_t)ret_conv;
7404 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_err(uint32_t e) {
7405 LDKDecodeError e_conv;
7406 e_conv.inner = (void*)(e & (~1));
7407 e_conv.is_owned = (e & 1) || (e == 0);
7408 e_conv = DecodeError_clone(&e_conv);
7409 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
7410 *ret_conv = CResult_NodeFeaturesDecodeErrorZ_err(e_conv);
7411 return (uint64_t)ret_conv;
7414 void __attribute__((visibility("default"))) TS_CResult_NodeFeaturesDecodeErrorZ_free(uint32_t _res) {
7415 if ((_res & 1) != 0) return;
7416 LDKCResult_NodeFeaturesDecodeErrorZ _res_conv = *(LDKCResult_NodeFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7418 CResult_NodeFeaturesDecodeErrorZ_free(_res_conv);
7421 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_ok(uint32_t o) {
7422 LDKChannelFeatures o_conv;
7423 o_conv.inner = (void*)(o & (~1));
7424 o_conv.is_owned = (o & 1) || (o == 0);
7425 o_conv = ChannelFeatures_clone(&o_conv);
7426 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
7427 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_ok(o_conv);
7428 return (uint64_t)ret_conv;
7431 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_err(uint32_t e) {
7432 LDKDecodeError e_conv;
7433 e_conv.inner = (void*)(e & (~1));
7434 e_conv.is_owned = (e & 1) || (e == 0);
7435 e_conv = DecodeError_clone(&e_conv);
7436 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
7437 *ret_conv = CResult_ChannelFeaturesDecodeErrorZ_err(e_conv);
7438 return (uint64_t)ret_conv;
7441 void __attribute__((visibility("default"))) TS_CResult_ChannelFeaturesDecodeErrorZ_free(uint32_t _res) {
7442 if ((_res & 1) != 0) return;
7443 LDKCResult_ChannelFeaturesDecodeErrorZ _res_conv = *(LDKCResult_ChannelFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7445 CResult_ChannelFeaturesDecodeErrorZ_free(_res_conv);
7448 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_ok(uint32_t o) {
7449 LDKInvoiceFeatures o_conv;
7450 o_conv.inner = (void*)(o & (~1));
7451 o_conv.is_owned = (o & 1) || (o == 0);
7452 o_conv = InvoiceFeatures_clone(&o_conv);
7453 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
7454 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_ok(o_conv);
7455 return (uint64_t)ret_conv;
7458 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_err(uint32_t e) {
7459 LDKDecodeError e_conv;
7460 e_conv.inner = (void*)(e & (~1));
7461 e_conv.is_owned = (e & 1) || (e == 0);
7462 e_conv = DecodeError_clone(&e_conv);
7463 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
7464 *ret_conv = CResult_InvoiceFeaturesDecodeErrorZ_err(e_conv);
7465 return (uint64_t)ret_conv;
7468 void __attribute__((visibility("default"))) TS_CResult_InvoiceFeaturesDecodeErrorZ_free(uint32_t _res) {
7469 if ((_res & 1) != 0) return;
7470 LDKCResult_InvoiceFeaturesDecodeErrorZ _res_conv = *(LDKCResult_InvoiceFeaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
7472 CResult_InvoiceFeaturesDecodeErrorZ_free(_res_conv);
7475 uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
7476 LDKDelayedPaymentOutputDescriptor o_conv;
7477 o_conv.inner = (void*)(o & (~1));
7478 o_conv.is_owned = (o & 1) || (o == 0);
7479 o_conv = DelayedPaymentOutputDescriptor_clone(&o_conv);
7480 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
7481 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
7482 return (uint64_t)ret_conv;
7485 uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
7486 LDKDecodeError e_conv;
7487 e_conv.inner = (void*)(e & (~1));
7488 e_conv.is_owned = (e & 1) || (e == 0);
7489 e_conv = DecodeError_clone(&e_conv);
7490 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
7491 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
7492 return (uint64_t)ret_conv;
7495 void __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
7496 if ((_res & 1) != 0) return;
7497 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
7499 CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
7502 uint32_t __attribute__((visibility("default"))) TS_CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
7503 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
7504 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
7505 *ret_conv = CResult_DelayedPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
7506 return (uint64_t)ret_conv;
7509 uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
7510 LDKStaticPaymentOutputDescriptor o_conv;
7511 o_conv.inner = (void*)(o & (~1));
7512 o_conv.is_owned = (o & 1) || (o == 0);
7513 o_conv = StaticPaymentOutputDescriptor_clone(&o_conv);
7514 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
7515 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_ok(o_conv);
7516 return (uint64_t)ret_conv;
7519 uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(uint32_t e) {
7520 LDKDecodeError e_conv;
7521 e_conv.inner = (void*)(e & (~1));
7522 e_conv.is_owned = (e & 1) || (e == 0);
7523 e_conv = DecodeError_clone(&e_conv);
7524 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
7525 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_err(e_conv);
7526 return (uint64_t)ret_conv;
7529 void __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
7530 if ((_res & 1) != 0) return;
7531 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
7533 CResult_StaticPaymentOutputDescriptorDecodeErrorZ_free(_res_conv);
7536 uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
7537 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ*)(orig & ~1);
7538 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
7539 *ret_conv = CResult_StaticPaymentOutputDescriptorDecodeErrorZ_clone(orig_conv);
7540 return (uint64_t)ret_conv;
7543 uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint32_t o) {
7544 LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1);
7545 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
7546 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv);
7547 return (uint64_t)ret_conv;
7550 uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_err(uint32_t e) {
7551 LDKDecodeError e_conv;
7552 e_conv.inner = (void*)(e & (~1));
7553 e_conv.is_owned = (e & 1) || (e == 0);
7554 e_conv = DecodeError_clone(&e_conv);
7555 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
7556 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_err(e_conv);
7557 return (uint64_t)ret_conv;
7560 void __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_free(uint32_t _res) {
7561 if ((_res & 1) != 0) return;
7562 LDKCResult_SpendableOutputDescriptorDecodeErrorZ _res_conv = *(LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(((uint64_t)_res) & ~1);
7564 CResult_SpendableOutputDescriptorDecodeErrorZ_free(_res_conv);
7567 uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_clone(uint32_t orig) {
7568 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* orig_conv = (LDKCResult_SpendableOutputDescriptorDecodeErrorZ*)(orig & ~1);
7569 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
7570 *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_clone(orig_conv);
7571 return (uint64_t)ret_conv;
7574 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) {
7575 LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1);
7576 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
7577 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv);
7578 return (uint64_t)ret_ref;
7581 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) {
7583 CHECK(*((uint32_t*)a) == 64);
7584 memcpy(a_ref.compact_form, (uint8_t*)(a + 4), 64);
7585 LDKCVec_SignatureZ b_constr;
7586 b_constr.datalen = *((uint32_t*)b);
7587 if (b_constr.datalen > 0)
7588 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
7590 b_constr.data = NULL;
7591 int8_tArray* b_vals = (int8_tArray*)(b + 4);
7592 for (size_t m = 0; m < b_constr.datalen; m++) {
7593 int8_tArray b_conv_12 = b_vals[m];
7594 LDKSignature b_conv_12_ref;
7595 CHECK(*((uint32_t*)b_conv_12) == 64);
7596 memcpy(b_conv_12_ref.compact_form, (uint8_t*)(b_conv_12 + 4), 64);
7597 b_constr.data[m] = b_conv_12_ref;
7599 LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ");
7600 *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr);
7601 return (uint64_t)ret_ref;
7604 void __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint32_t _res) {
7605 if ((_res & 1) != 0) return;
7606 LDKC2Tuple_SignatureCVec_SignatureZZ _res_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)_res) & ~1);
7608 C2Tuple_SignatureCVec_SignatureZZ_free(_res_conv);
7611 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint32_t o) {
7612 LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1);
7613 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
7614 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv);
7615 return (uint64_t)ret_conv;
7618 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err() {
7619 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
7620 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_err();
7621 return (uint64_t)ret_conv;
7624 void __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(uint32_t _res) {
7625 if ((_res & 1) != 0) return;
7626 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ _res_conv = *(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)_res) & ~1);
7628 CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_free(_res_conv);
7631 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(uint32_t orig) {
7632 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* orig_conv = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(orig & ~1);
7633 LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ");
7634 *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone(orig_conv);
7635 return (uint64_t)ret_conv;
7638 uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_ok(int8_tArray o) {
7640 CHECK(*((uint32_t*)o) == 64);
7641 memcpy(o_ref.compact_form, (uint8_t*)(o + 4), 64);
7642 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
7643 *ret_conv = CResult_SignatureNoneZ_ok(o_ref);
7644 return (uint64_t)ret_conv;
7647 uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_err() {
7648 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
7649 *ret_conv = CResult_SignatureNoneZ_err();
7650 return (uint64_t)ret_conv;
7653 void __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_free(uint32_t _res) {
7654 if ((_res & 1) != 0) return;
7655 LDKCResult_SignatureNoneZ _res_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)_res) & ~1);
7657 CResult_SignatureNoneZ_free(_res_conv);
7660 uint32_t __attribute__((visibility("default"))) TS_CResult_SignatureNoneZ_clone(uint32_t orig) {
7661 LDKCResult_SignatureNoneZ* orig_conv = (LDKCResult_SignatureNoneZ*)(orig & ~1);
7662 LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ");
7663 *ret_conv = CResult_SignatureNoneZ_clone(orig_conv);
7664 return (uint64_t)ret_conv;
7667 uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_ok(uint32_t o) {
7668 LDKSign o_conv = *(LDKSign*)(((uint64_t)o) & ~1);
7669 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
7670 *ret_conv = CResult_SignDecodeErrorZ_ok(o_conv);
7671 return (uint64_t)ret_conv;
7674 uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_err(uint32_t e) {
7675 LDKDecodeError e_conv;
7676 e_conv.inner = (void*)(e & (~1));
7677 e_conv.is_owned = (e & 1) || (e == 0);
7678 e_conv = DecodeError_clone(&e_conv);
7679 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
7680 *ret_conv = CResult_SignDecodeErrorZ_err(e_conv);
7681 return (uint64_t)ret_conv;
7684 void __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_free(uint32_t _res) {
7685 if ((_res & 1) != 0) return;
7686 LDKCResult_SignDecodeErrorZ _res_conv = *(LDKCResult_SignDecodeErrorZ*)(((uint64_t)_res) & ~1);
7688 CResult_SignDecodeErrorZ_free(_res_conv);
7691 uint32_t __attribute__((visibility("default"))) TS_CResult_SignDecodeErrorZ_clone(uint32_t orig) {
7692 LDKCResult_SignDecodeErrorZ* orig_conv = (LDKCResult_SignDecodeErrorZ*)(orig & ~1);
7693 LDKCResult_SignDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SignDecodeErrorZ), "LDKCResult_SignDecodeErrorZ");
7694 *ret_conv = CResult_SignDecodeErrorZ_clone(orig_conv);
7695 return (uint64_t)ret_conv;
7698 void __attribute__((visibility("default"))) TS_CVec_u8Z_free(int8_tArray _res) {
7699 LDKCVec_u8Z _res_ref;
7700 _res_ref.datalen = *((uint32_t*)_res);
7701 _res_ref.data = MALLOC(_res_ref.datalen, "LDKCVec_u8Z Bytes");
7702 memcpy(_res_ref.data, (uint8_t*)(_res + 4), _res_ref.datalen);
7703 CVec_u8Z_free(_res_ref);
7706 uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_ok(int8_tArray arg) {
7707 LDKRecoverableSignature arg_ref;
7708 CHECK(*((uint32_t*)arg) == 68);
7709 memcpy(arg_ref.serialized_form, (uint8_t*)(arg + 4), 68);
7710 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
7711 *ret_conv = CResult_RecoverableSignatureNoneZ_ok(arg_ref);
7712 return (uint64_t)ret_conv;
7715 uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_err() {
7716 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
7717 *ret_conv = CResult_RecoverableSignatureNoneZ_err();
7718 return (uint64_t)ret_conv;
7721 void __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_free(uint32_t _res) {
7722 if ((_res & 1) != 0) return;
7723 LDKCResult_RecoverableSignatureNoneZ _res_conv = *(LDKCResult_RecoverableSignatureNoneZ*)(((uint64_t)_res) & ~1);
7725 CResult_RecoverableSignatureNoneZ_free(_res_conv);
7728 uint32_t __attribute__((visibility("default"))) TS_CResult_RecoverableSignatureNoneZ_clone(uint32_t orig) {
7729 LDKCResult_RecoverableSignatureNoneZ* orig_conv = (LDKCResult_RecoverableSignatureNoneZ*)(orig & ~1);
7730 LDKCResult_RecoverableSignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_RecoverableSignatureNoneZ), "LDKCResult_RecoverableSignatureNoneZ");
7731 *ret_conv = CResult_RecoverableSignatureNoneZ_clone(orig_conv);
7732 return (uint64_t)ret_conv;
7735 void __attribute__((visibility("default"))) TS_CVec_CVec_u8ZZ_free(ptrArray _res) {
7736 LDKCVec_CVec_u8ZZ _res_constr;
7737 _res_constr.datalen = *((uint32_t*)_res);
7738 if (_res_constr.datalen > 0)
7739 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
7741 _res_constr.data = NULL;
7742 int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
7743 for (size_t m = 0; m < _res_constr.datalen; m++) {
7744 int8_tArray _res_conv_12 = _res_vals[m];
7745 LDKCVec_u8Z _res_conv_12_ref;
7746 _res_conv_12_ref.datalen = *((uint32_t*)_res_conv_12);
7747 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
7748 memcpy(_res_conv_12_ref.data, (uint8_t*)(_res_conv_12 + 4), _res_conv_12_ref.datalen);
7749 _res_constr.data[m] = _res_conv_12_ref;
7751 CVec_CVec_u8ZZ_free(_res_constr);
7754 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_ok(ptrArray o) {
7755 LDKCVec_CVec_u8ZZ o_constr;
7756 o_constr.datalen = *((uint32_t*)o);
7757 if (o_constr.datalen > 0)
7758 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKCVec_u8Z), "LDKCVec_CVec_u8ZZ Elements");
7760 o_constr.data = NULL;
7761 int8_tArray* o_vals = (int8_tArray*)(o + 4);
7762 for (size_t m = 0; m < o_constr.datalen; m++) {
7763 int8_tArray o_conv_12 = o_vals[m];
7764 LDKCVec_u8Z o_conv_12_ref;
7765 o_conv_12_ref.datalen = *((uint32_t*)o_conv_12);
7766 o_conv_12_ref.data = MALLOC(o_conv_12_ref.datalen, "LDKCVec_u8Z Bytes");
7767 memcpy(o_conv_12_ref.data, (uint8_t*)(o_conv_12 + 4), o_conv_12_ref.datalen);
7768 o_constr.data[m] = o_conv_12_ref;
7770 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
7771 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_ok(o_constr);
7772 return (uint64_t)ret_conv;
7775 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_err() {
7776 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
7777 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_err();
7778 return (uint64_t)ret_conv;
7781 void __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_free(uint32_t _res) {
7782 if ((_res & 1) != 0) return;
7783 LDKCResult_CVec_CVec_u8ZZNoneZ _res_conv = *(LDKCResult_CVec_CVec_u8ZZNoneZ*)(((uint64_t)_res) & ~1);
7785 CResult_CVec_CVec_u8ZZNoneZ_free(_res_conv);
7788 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_CVec_u8ZZNoneZ_clone(uint32_t orig) {
7789 LDKCResult_CVec_CVec_u8ZZNoneZ* orig_conv = (LDKCResult_CVec_CVec_u8ZZNoneZ*)(orig & ~1);
7790 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
7791 *ret_conv = CResult_CVec_CVec_u8ZZNoneZ_clone(orig_conv);
7792 return (uint64_t)ret_conv;
7795 uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_ok(uint32_t o) {
7796 LDKInMemorySigner o_conv;
7797 o_conv.inner = (void*)(o & (~1));
7798 o_conv.is_owned = (o & 1) || (o == 0);
7799 o_conv = InMemorySigner_clone(&o_conv);
7800 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
7801 *ret_conv = CResult_InMemorySignerDecodeErrorZ_ok(o_conv);
7802 return (uint64_t)ret_conv;
7805 uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_err(uint32_t e) {
7806 LDKDecodeError e_conv;
7807 e_conv.inner = (void*)(e & (~1));
7808 e_conv.is_owned = (e & 1) || (e == 0);
7809 e_conv = DecodeError_clone(&e_conv);
7810 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
7811 *ret_conv = CResult_InMemorySignerDecodeErrorZ_err(e_conv);
7812 return (uint64_t)ret_conv;
7815 void __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_free(uint32_t _res) {
7816 if ((_res & 1) != 0) return;
7817 LDKCResult_InMemorySignerDecodeErrorZ _res_conv = *(LDKCResult_InMemorySignerDecodeErrorZ*)(((uint64_t)_res) & ~1);
7819 CResult_InMemorySignerDecodeErrorZ_free(_res_conv);
7822 uint32_t __attribute__((visibility("default"))) TS_CResult_InMemorySignerDecodeErrorZ_clone(uint32_t orig) {
7823 LDKCResult_InMemorySignerDecodeErrorZ* orig_conv = (LDKCResult_InMemorySignerDecodeErrorZ*)(orig & ~1);
7824 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
7825 *ret_conv = CResult_InMemorySignerDecodeErrorZ_clone(orig_conv);
7826 return (uint64_t)ret_conv;
7829 void __attribute__((visibility("default"))) TS_CVec_TxOutZ_free(uint32_tArray _res) {
7830 LDKCVec_TxOutZ _res_constr;
7831 _res_constr.datalen = *((uint32_t*)_res);
7832 if (_res_constr.datalen > 0)
7833 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
7835 _res_constr.data = NULL;
7836 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7837 for (size_t h = 0; h < _res_constr.datalen; h++) {
7838 uint32_t _res_conv_7 = _res_vals[h];
7839 LDKTxOut _res_conv_7_conv = *(LDKTxOut*)(((uint64_t)_res_conv_7) & ~1);
7840 FREE((void*)_res_conv_7);
7841 _res_constr.data[h] = _res_conv_7_conv;
7843 CVec_TxOutZ_free(_res_constr);
7846 uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_ok(int8_tArray o) {
7847 LDKTransaction o_ref;
7848 o_ref.datalen = *((uint32_t*)o);
7849 o_ref.data = MALLOC(o_ref.datalen, "LDKTransaction Bytes");
7850 memcpy(o_ref.data, (uint8_t*)(o + 4), o_ref.datalen);
7851 o_ref.data_is_owned = true;
7852 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
7853 *ret_conv = CResult_TransactionNoneZ_ok(o_ref);
7854 return (uint64_t)ret_conv;
7857 uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_err() {
7858 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
7859 *ret_conv = CResult_TransactionNoneZ_err();
7860 return (uint64_t)ret_conv;
7863 void __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_free(uint32_t _res) {
7864 if ((_res & 1) != 0) return;
7865 LDKCResult_TransactionNoneZ _res_conv = *(LDKCResult_TransactionNoneZ*)(((uint64_t)_res) & ~1);
7867 CResult_TransactionNoneZ_free(_res_conv);
7870 uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clone(uint32_t orig) {
7871 LDKCResult_TransactionNoneZ* orig_conv = (LDKCResult_TransactionNoneZ*)(orig & ~1);
7872 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
7873 *ret_conv = CResult_TransactionNoneZ_clone(orig_conv);
7874 return (uint64_t)ret_conv;
7877 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint32_t b) {
7878 LDKThirtyTwoBytes a_ref;
7879 CHECK(*((uint32_t*)a) == 32);
7880 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
7881 LDKChannelMonitor b_conv;
7882 b_conv.inner = (void*)(b & (~1));
7883 b_conv.is_owned = (b & 1) || (b == 0);
7884 b_conv = ChannelMonitor_clone(&b_conv);
7885 LDKC2Tuple_BlockHashChannelMonitorZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ");
7886 *ret_ref = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv);
7887 return (uint64_t)ret_ref;
7890 void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint32_t _res) {
7891 if ((_res & 1) != 0) return;
7892 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res) & ~1);
7894 C2Tuple_BlockHashChannelMonitorZ_free(_res_conv);
7897 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_BlockHashChannelMonitorZZ_free(uint32_tArray _res) {
7898 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ _res_constr;
7899 _res_constr.datalen = *((uint32_t*)_res);
7900 if (_res_constr.datalen > 0)
7901 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
7903 _res_constr.data = NULL;
7904 uint32_t* _res_vals = (uint32_t*)(_res + 4);
7905 for (size_t m = 0; m < _res_constr.datalen; m++) {
7906 uint32_t _res_conv_38 = _res_vals[m];
7907 LDKC2Tuple_BlockHashChannelMonitorZ _res_conv_38_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res_conv_38) & ~1);
7908 FREE((void*)_res_conv_38);
7909 _res_constr.data[m] = _res_conv_38_conv;
7911 CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res_constr);
7914 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(uint32_tArray o) {
7915 LDKCVec_C2Tuple_BlockHashChannelMonitorZZ o_constr;
7916 o_constr.datalen = *((uint32_t*)o);
7917 if (o_constr.datalen > 0)
7918 o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ Elements");
7920 o_constr.data = NULL;
7921 uint32_t* o_vals = (uint32_t*)(o + 4);
7922 for (size_t m = 0; m < o_constr.datalen; m++) {
7923 uint32_t o_conv_38 = o_vals[m];
7924 LDKC2Tuple_BlockHashChannelMonitorZ o_conv_38_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_38) & ~1);
7925 // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ
7926 o_constr.data[m] = o_conv_38_conv;
7928 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
7929 *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o_constr);
7930 return (uint64_t)ret_conv;
7933 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(uint32_t e) {
7934 LDKIOError e_conv = LDKIOError_from_js(e);
7935 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
7936 *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_err(e_conv);
7937 return (uint64_t)ret_conv;
7940 void __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(uint32_t _res) {
7941 if ((_res & 1) != 0) return;
7942 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ _res_conv = *(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(((uint64_t)_res) & ~1);
7944 CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv);
7947 uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_some(int16_t o) {
7948 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
7949 *ret_copy = COption_u16Z_some(o);
7950 uint64_t ret_ref = (uint64_t)ret_copy;
7954 uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_none() {
7955 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
7956 *ret_copy = COption_u16Z_none();
7957 uint64_t ret_ref = (uint64_t)ret_copy;
7961 void __attribute__((visibility("default"))) TS_COption_u16Z_free(uint32_t _res) {
7962 if ((_res & 1) != 0) return;
7963 LDKCOption_u16Z _res_conv = *(LDKCOption_u16Z*)(((uint64_t)_res) & ~1);
7965 COption_u16Z_free(_res_conv);
7968 uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_clone(uint32_t orig) {
7969 LDKCOption_u16Z* orig_conv = (LDKCOption_u16Z*)orig;
7970 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
7971 *ret_copy = COption_u16Z_clone(orig_conv);
7972 uint64_t ret_ref = (uint64_t)ret_copy;
7976 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_ok() {
7977 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7978 *ret_conv = CResult_NoneAPIErrorZ_ok();
7979 return (uint64_t)ret_conv;
7982 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_err(uint32_t e) {
7983 LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1);
7984 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7985 *ret_conv = CResult_NoneAPIErrorZ_err(e_conv);
7986 return (uint64_t)ret_conv;
7989 void __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_free(uint32_t _res) {
7990 if ((_res & 1) != 0) return;
7991 LDKCResult_NoneAPIErrorZ _res_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res) & ~1);
7993 CResult_NoneAPIErrorZ_free(_res_conv);
7996 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_clone(uint32_t orig) {
7997 LDKCResult_NoneAPIErrorZ* orig_conv = (LDKCResult_NoneAPIErrorZ*)(orig & ~1);
7998 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
7999 *ret_conv = CResult_NoneAPIErrorZ_clone(orig_conv);
8000 return (uint64_t)ret_conv;
8003 void __attribute__((visibility("default"))) TS_CVec_CResult_NoneAPIErrorZZ_free(uint32_tArray _res) {
8004 LDKCVec_CResult_NoneAPIErrorZZ _res_constr;
8005 _res_constr.datalen = *((uint32_t*)_res);
8006 if (_res_constr.datalen > 0)
8007 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKCResult_NoneAPIErrorZ), "LDKCVec_CResult_NoneAPIErrorZZ Elements");
8009 _res_constr.data = NULL;
8010 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8011 for (size_t w = 0; w < _res_constr.datalen; w++) {
8012 uint32_t _res_conv_22 = _res_vals[w];
8013 LDKCResult_NoneAPIErrorZ _res_conv_22_conv = *(LDKCResult_NoneAPIErrorZ*)(((uint64_t)_res_conv_22) & ~1);
8014 FREE((void*)_res_conv_22);
8015 _res_constr.data[w] = _res_conv_22_conv;
8017 CVec_CResult_NoneAPIErrorZZ_free(_res_constr);
8020 void __attribute__((visibility("default"))) TS_CVec_APIErrorZ_free(uint32_tArray _res) {
8021 LDKCVec_APIErrorZ _res_constr;
8022 _res_constr.datalen = *((uint32_t*)_res);
8023 if (_res_constr.datalen > 0)
8024 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKAPIError), "LDKCVec_APIErrorZ Elements");
8026 _res_constr.data = NULL;
8027 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8028 for (size_t k = 0; k < _res_constr.datalen; k++) {
8029 uint32_t _res_conv_10 = _res_vals[k];
8030 LDKAPIError _res_conv_10_conv = *(LDKAPIError*)(((uint64_t)_res_conv_10) & ~1);
8031 FREE((void*)_res_conv_10);
8032 _res_constr.data[k] = _res_conv_10_conv;
8034 CVec_APIErrorZ_free(_res_constr);
8037 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_ok() {
8038 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8039 *ret_conv = CResult_NonePaymentSendFailureZ_ok();
8040 return (uint64_t)ret_conv;
8043 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_err(uint32_t e) {
8044 LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1);
8045 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8046 *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv);
8047 return (uint64_t)ret_conv;
8050 void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) {
8051 if ((_res & 1) != 0) return;
8052 LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)_res) & ~1);
8054 CResult_NonePaymentSendFailureZ_free(_res_conv);
8057 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) {
8058 LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1);
8059 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
8060 *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv);
8061 return (uint64_t)ret_conv;
8064 void __attribute__((visibility("default"))) TS_CVec_NetAddressZ_free(uint32_tArray _res) {
8065 LDKCVec_NetAddressZ _res_constr;
8066 _res_constr.datalen = *((uint32_t*)_res);
8067 if (_res_constr.datalen > 0)
8068 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
8070 _res_constr.data = NULL;
8071 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8072 for (size_t m = 0; m < _res_constr.datalen; m++) {
8073 uint32_t _res_conv_12 = _res_vals[m];
8074 LDKNetAddress _res_conv_12_conv = *(LDKNetAddress*)(((uint64_t)_res_conv_12) & ~1);
8075 FREE((void*)_res_conv_12);
8076 _res_constr.data[m] = _res_conv_12_conv;
8078 CVec_NetAddressZ_free(_res_constr);
8081 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) {
8082 LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1);
8083 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
8084 *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv);
8085 return (uint64_t)ret_ref;
8088 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) {
8089 LDKThirtyTwoBytes a_ref;
8090 CHECK(*((uint32_t*)a) == 32);
8091 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
8092 LDKThirtyTwoBytes b_ref;
8093 CHECK(*((uint32_t*)b) == 32);
8094 memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
8095 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
8096 *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref);
8097 return (uint64_t)ret_ref;
8100 void __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint32_t _res) {
8101 if ((_res & 1) != 0) return;
8102 LDKC2Tuple_PaymentHashPaymentSecretZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentSecretZ*)(((uint64_t)_res) & ~1);
8104 C2Tuple_PaymentHashPaymentSecretZ_free(_res_conv);
8107 uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_ok(int8_tArray o) {
8108 LDKThirtyTwoBytes o_ref;
8109 CHECK(*((uint32_t*)o) == 32);
8110 memcpy(o_ref.data, (uint8_t*)(o + 4), 32);
8111 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
8112 *ret_conv = CResult_PaymentSecretAPIErrorZ_ok(o_ref);
8113 return (uint64_t)ret_conv;
8116 uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint32_t e) {
8117 LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1);
8118 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
8119 *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv);
8120 return (uint64_t)ret_conv;
8123 void __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_free(uint32_t _res) {
8124 if ((_res & 1) != 0) return;
8125 LDKCResult_PaymentSecretAPIErrorZ _res_conv = *(LDKCResult_PaymentSecretAPIErrorZ*)(((uint64_t)_res) & ~1);
8127 CResult_PaymentSecretAPIErrorZ_free(_res_conv);
8130 uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_clone(uint32_t orig) {
8131 LDKCResult_PaymentSecretAPIErrorZ* orig_conv = (LDKCResult_PaymentSecretAPIErrorZ*)(orig & ~1);
8132 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
8133 *ret_conv = CResult_PaymentSecretAPIErrorZ_clone(orig_conv);
8134 return (uint64_t)ret_conv;
8137 void __attribute__((visibility("default"))) TS_CVec_ChannelMonitorZ_free(uint32_tArray _res) {
8138 LDKCVec_ChannelMonitorZ _res_constr;
8139 _res_constr.datalen = *((uint32_t*)_res);
8140 if (_res_constr.datalen > 0)
8141 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
8143 _res_constr.data = NULL;
8144 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8145 for (size_t q = 0; q < _res_constr.datalen; q++) {
8146 uint32_t _res_conv_16 = _res_vals[q];
8147 LDKChannelMonitor _res_conv_16_conv;
8148 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
8149 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
8150 _res_constr.data[q] = _res_conv_16_conv;
8152 CVec_ChannelMonitorZ_free(_res_constr);
8155 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_new(int8_tArray a, uint32_t b) {
8156 LDKThirtyTwoBytes a_ref;
8157 CHECK(*((uint32_t*)a) == 32);
8158 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
8159 LDKChannelManager b_conv;
8160 b_conv.inner = (void*)(b & (~1));
8161 b_conv.is_owned = (b & 1) || (b == 0);
8162 // Warning: we need a move here but no clone is available for LDKChannelManager
8163 LDKC2Tuple_BlockHashChannelManagerZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ");
8164 *ret_ref = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv);
8165 return (uint64_t)ret_ref;
8168 void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint32_t _res) {
8169 if ((_res & 1) != 0) return;
8170 LDKC2Tuple_BlockHashChannelManagerZ _res_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)_res) & ~1);
8172 C2Tuple_BlockHashChannelManagerZ_free(_res_conv);
8175 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint32_t o) {
8176 LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)o) & ~1);
8177 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
8178 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv);
8179 return (uint64_t)ret_conv;
8182 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(uint32_t e) {
8183 LDKDecodeError e_conv;
8184 e_conv.inner = (void*)(e & (~1));
8185 e_conv.is_owned = (e & 1) || (e == 0);
8186 e_conv = DecodeError_clone(&e_conv);
8187 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
8188 *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_err(e_conv);
8189 return (uint64_t)ret_conv;
8192 void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(uint32_t _res) {
8193 if ((_res & 1) != 0) return;
8194 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(((uint64_t)_res) & ~1);
8196 CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_free(_res_conv);
8199 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_ok(uint32_t o) {
8200 LDKChannelConfig o_conv;
8201 o_conv.inner = (void*)(o & (~1));
8202 o_conv.is_owned = (o & 1) || (o == 0);
8203 o_conv = ChannelConfig_clone(&o_conv);
8204 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
8205 *ret_conv = CResult_ChannelConfigDecodeErrorZ_ok(o_conv);
8206 return (uint64_t)ret_conv;
8209 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_err(uint32_t e) {
8210 LDKDecodeError e_conv;
8211 e_conv.inner = (void*)(e & (~1));
8212 e_conv.is_owned = (e & 1) || (e == 0);
8213 e_conv = DecodeError_clone(&e_conv);
8214 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
8215 *ret_conv = CResult_ChannelConfigDecodeErrorZ_err(e_conv);
8216 return (uint64_t)ret_conv;
8219 void __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_free(uint32_t _res) {
8220 if ((_res & 1) != 0) return;
8221 LDKCResult_ChannelConfigDecodeErrorZ _res_conv = *(LDKCResult_ChannelConfigDecodeErrorZ*)(((uint64_t)_res) & ~1);
8223 CResult_ChannelConfigDecodeErrorZ_free(_res_conv);
8226 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelConfigDecodeErrorZ_clone(uint32_t orig) {
8227 LDKCResult_ChannelConfigDecodeErrorZ* orig_conv = (LDKCResult_ChannelConfigDecodeErrorZ*)(orig & ~1);
8228 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
8229 *ret_conv = CResult_ChannelConfigDecodeErrorZ_clone(orig_conv);
8230 return (uint64_t)ret_conv;
8233 uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_ok(uint32_t o) {
8235 o_conv.inner = (void*)(o & (~1));
8236 o_conv.is_owned = (o & 1) || (o == 0);
8237 o_conv = OutPoint_clone(&o_conv);
8238 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
8239 *ret_conv = CResult_OutPointDecodeErrorZ_ok(o_conv);
8240 return (uint64_t)ret_conv;
8243 uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_err(uint32_t e) {
8244 LDKDecodeError e_conv;
8245 e_conv.inner = (void*)(e & (~1));
8246 e_conv.is_owned = (e & 1) || (e == 0);
8247 e_conv = DecodeError_clone(&e_conv);
8248 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
8249 *ret_conv = CResult_OutPointDecodeErrorZ_err(e_conv);
8250 return (uint64_t)ret_conv;
8253 void __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_free(uint32_t _res) {
8254 if ((_res & 1) != 0) return;
8255 LDKCResult_OutPointDecodeErrorZ _res_conv = *(LDKCResult_OutPointDecodeErrorZ*)(((uint64_t)_res) & ~1);
8257 CResult_OutPointDecodeErrorZ_free(_res_conv);
8260 uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ_clone(uint32_t orig) {
8261 LDKCResult_OutPointDecodeErrorZ* orig_conv = (LDKCResult_OutPointDecodeErrorZ*)(orig & ~1);
8262 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
8263 *ret_conv = CResult_OutPointDecodeErrorZ_clone(orig_conv);
8264 return (uint64_t)ret_conv;
8267 uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_ok(uint32_t o) {
8268 LDKSiPrefix o_conv = LDKSiPrefix_from_js(o);
8269 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
8270 *ret_conv = CResult_SiPrefixNoneZ_ok(o_conv);
8271 return (uint64_t)ret_conv;
8274 uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_err() {
8275 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
8276 *ret_conv = CResult_SiPrefixNoneZ_err();
8277 return (uint64_t)ret_conv;
8280 void __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_free(uint32_t _res) {
8281 if ((_res & 1) != 0) return;
8282 LDKCResult_SiPrefixNoneZ _res_conv = *(LDKCResult_SiPrefixNoneZ*)(((uint64_t)_res) & ~1);
8284 CResult_SiPrefixNoneZ_free(_res_conv);
8287 uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_clone(uint32_t orig) {
8288 LDKCResult_SiPrefixNoneZ* orig_conv = (LDKCResult_SiPrefixNoneZ*)(orig & ~1);
8289 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
8290 *ret_conv = CResult_SiPrefixNoneZ_clone(orig_conv);
8291 return (uint64_t)ret_conv;
8294 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_ok(uint32_t o) {
8296 o_conv.inner = (void*)(o & (~1));
8297 o_conv.is_owned = (o & 1) || (o == 0);
8298 o_conv = Invoice_clone(&o_conv);
8299 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
8300 *ret_conv = CResult_InvoiceNoneZ_ok(o_conv);
8301 return (uint64_t)ret_conv;
8304 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_err() {
8305 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
8306 *ret_conv = CResult_InvoiceNoneZ_err();
8307 return (uint64_t)ret_conv;
8310 void __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_free(uint32_t _res) {
8311 if ((_res & 1) != 0) return;
8312 LDKCResult_InvoiceNoneZ _res_conv = *(LDKCResult_InvoiceNoneZ*)(((uint64_t)_res) & ~1);
8314 CResult_InvoiceNoneZ_free(_res_conv);
8317 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceNoneZ_clone(uint32_t orig) {
8318 LDKCResult_InvoiceNoneZ* orig_conv = (LDKCResult_InvoiceNoneZ*)(orig & ~1);
8319 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
8320 *ret_conv = CResult_InvoiceNoneZ_clone(orig_conv);
8321 return (uint64_t)ret_conv;
8324 uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_ok(uint32_t o) {
8325 LDKSignedRawInvoice o_conv;
8326 o_conv.inner = (void*)(o & (~1));
8327 o_conv.is_owned = (o & 1) || (o == 0);
8328 o_conv = SignedRawInvoice_clone(&o_conv);
8329 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
8330 *ret_conv = CResult_SignedRawInvoiceNoneZ_ok(o_conv);
8331 return (uint64_t)ret_conv;
8334 uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_err() {
8335 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
8336 *ret_conv = CResult_SignedRawInvoiceNoneZ_err();
8337 return (uint64_t)ret_conv;
8340 void __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_free(uint32_t _res) {
8341 if ((_res & 1) != 0) return;
8342 LDKCResult_SignedRawInvoiceNoneZ _res_conv = *(LDKCResult_SignedRawInvoiceNoneZ*)(((uint64_t)_res) & ~1);
8344 CResult_SignedRawInvoiceNoneZ_free(_res_conv);
8347 uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNoneZ_clone(uint32_t orig) {
8348 LDKCResult_SignedRawInvoiceNoneZ* orig_conv = (LDKCResult_SignedRawInvoiceNoneZ*)(orig & ~1);
8349 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
8350 *ret_conv = CResult_SignedRawInvoiceNoneZ_clone(orig_conv);
8351 return (uint64_t)ret_conv;
8354 uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) {
8355 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1);
8356 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
8357 *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv);
8358 return (uint64_t)ret_ref;
8361 uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint32_t a, int8_tArray b, uint32_t c) {
8362 LDKRawInvoice a_conv;
8363 a_conv.inner = (void*)(a & (~1));
8364 a_conv.is_owned = (a & 1) || (a == 0);
8365 a_conv = RawInvoice_clone(&a_conv);
8366 LDKThirtyTwoBytes b_ref;
8367 CHECK(*((uint32_t*)b) == 32);
8368 memcpy(b_ref.data, (uint8_t*)(b + 4), 32);
8369 LDKInvoiceSignature c_conv;
8370 c_conv.inner = (void*)(c & (~1));
8371 c_conv.is_owned = (c & 1) || (c == 0);
8372 c_conv = InvoiceSignature_clone(&c_conv);
8373 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
8374 *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv);
8375 return (uint64_t)ret_ref;
8378 void __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint32_t _res) {
8379 if ((_res & 1) != 0) return;
8380 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ _res_conv = *(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(((uint64_t)_res) & ~1);
8382 C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(_res_conv);
8385 uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_ok(uint32_t o) {
8386 LDKPayeePubKey o_conv;
8387 o_conv.inner = (void*)(o & (~1));
8388 o_conv.is_owned = (o & 1) || (o == 0);
8389 o_conv = PayeePubKey_clone(&o_conv);
8390 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
8391 *ret_conv = CResult_PayeePubKeyErrorZ_ok(o_conv);
8392 return (uint64_t)ret_conv;
8395 uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_err(uint32_t e) {
8396 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
8397 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
8398 *ret_conv = CResult_PayeePubKeyErrorZ_err(e_conv);
8399 return (uint64_t)ret_conv;
8402 void __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_free(uint32_t _res) {
8403 if ((_res & 1) != 0) return;
8404 LDKCResult_PayeePubKeyErrorZ _res_conv = *(LDKCResult_PayeePubKeyErrorZ*)(((uint64_t)_res) & ~1);
8406 CResult_PayeePubKeyErrorZ_free(_res_conv);
8409 uint32_t __attribute__((visibility("default"))) TS_CResult_PayeePubKeyErrorZ_clone(uint32_t orig) {
8410 LDKCResult_PayeePubKeyErrorZ* orig_conv = (LDKCResult_PayeePubKeyErrorZ*)(orig & ~1);
8411 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
8412 *ret_conv = CResult_PayeePubKeyErrorZ_clone(orig_conv);
8413 return (uint64_t)ret_conv;
8416 void __attribute__((visibility("default"))) TS_CVec_PrivateRouteZ_free(uint32_tArray _res) {
8417 LDKCVec_PrivateRouteZ _res_constr;
8418 _res_constr.datalen = *((uint32_t*)_res);
8419 if (_res_constr.datalen > 0)
8420 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPrivateRoute), "LDKCVec_PrivateRouteZ Elements");
8422 _res_constr.data = NULL;
8423 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8424 for (size_t o = 0; o < _res_constr.datalen; o++) {
8425 uint32_t _res_conv_14 = _res_vals[o];
8426 LDKPrivateRoute _res_conv_14_conv;
8427 _res_conv_14_conv.inner = (void*)(_res_conv_14 & (~1));
8428 _res_conv_14_conv.is_owned = (_res_conv_14 & 1) || (_res_conv_14 == 0);
8429 _res_constr.data[o] = _res_conv_14_conv;
8431 CVec_PrivateRouteZ_free(_res_constr);
8434 uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_ok(uint32_t o) {
8435 LDKPositiveTimestamp o_conv;
8436 o_conv.inner = (void*)(o & (~1));
8437 o_conv.is_owned = (o & 1) || (o == 0);
8438 o_conv = PositiveTimestamp_clone(&o_conv);
8439 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
8440 *ret_conv = CResult_PositiveTimestampCreationErrorZ_ok(o_conv);
8441 return (uint64_t)ret_conv;
8444 uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_err(uint32_t e) {
8445 LDKCreationError e_conv = LDKCreationError_from_js(e);
8446 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
8447 *ret_conv = CResult_PositiveTimestampCreationErrorZ_err(e_conv);
8448 return (uint64_t)ret_conv;
8451 void __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_free(uint32_t _res) {
8452 if ((_res & 1) != 0) return;
8453 LDKCResult_PositiveTimestampCreationErrorZ _res_conv = *(LDKCResult_PositiveTimestampCreationErrorZ*)(((uint64_t)_res) & ~1);
8455 CResult_PositiveTimestampCreationErrorZ_free(_res_conv);
8458 uint32_t __attribute__((visibility("default"))) TS_CResult_PositiveTimestampCreationErrorZ_clone(uint32_t orig) {
8459 LDKCResult_PositiveTimestampCreationErrorZ* orig_conv = (LDKCResult_PositiveTimestampCreationErrorZ*)(orig & ~1);
8460 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
8461 *ret_conv = CResult_PositiveTimestampCreationErrorZ_clone(orig_conv);
8462 return (uint64_t)ret_conv;
8465 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_ok() {
8466 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
8467 *ret_conv = CResult_NoneSemanticErrorZ_ok();
8468 return (uint64_t)ret_conv;
8471 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_err(uint32_t e) {
8472 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
8473 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
8474 *ret_conv = CResult_NoneSemanticErrorZ_err(e_conv);
8475 return (uint64_t)ret_conv;
8478 void __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_free(uint32_t _res) {
8479 if ((_res & 1) != 0) return;
8480 LDKCResult_NoneSemanticErrorZ _res_conv = *(LDKCResult_NoneSemanticErrorZ*)(((uint64_t)_res) & ~1);
8482 CResult_NoneSemanticErrorZ_free(_res_conv);
8485 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneSemanticErrorZ_clone(uint32_t orig) {
8486 LDKCResult_NoneSemanticErrorZ* orig_conv = (LDKCResult_NoneSemanticErrorZ*)(orig & ~1);
8487 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
8488 *ret_conv = CResult_NoneSemanticErrorZ_clone(orig_conv);
8489 return (uint64_t)ret_conv;
8492 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_ok(uint32_t o) {
8494 o_conv.inner = (void*)(o & (~1));
8495 o_conv.is_owned = (o & 1) || (o == 0);
8496 o_conv = Invoice_clone(&o_conv);
8497 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
8498 *ret_conv = CResult_InvoiceSemanticErrorZ_ok(o_conv);
8499 return (uint64_t)ret_conv;
8502 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_err(uint32_t e) {
8503 LDKSemanticError e_conv = LDKSemanticError_from_js(e);
8504 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
8505 *ret_conv = CResult_InvoiceSemanticErrorZ_err(e_conv);
8506 return (uint64_t)ret_conv;
8509 void __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_free(uint32_t _res) {
8510 if ((_res & 1) != 0) return;
8511 LDKCResult_InvoiceSemanticErrorZ _res_conv = *(LDKCResult_InvoiceSemanticErrorZ*)(((uint64_t)_res) & ~1);
8513 CResult_InvoiceSemanticErrorZ_free(_res_conv);
8516 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSemanticErrorZ_clone(uint32_t orig) {
8517 LDKCResult_InvoiceSemanticErrorZ* orig_conv = (LDKCResult_InvoiceSemanticErrorZ*)(orig & ~1);
8518 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
8519 *ret_conv = CResult_InvoiceSemanticErrorZ_clone(orig_conv);
8520 return (uint64_t)ret_conv;
8523 uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_ok(uint32_t o) {
8524 LDKDescription o_conv;
8525 o_conv.inner = (void*)(o & (~1));
8526 o_conv.is_owned = (o & 1) || (o == 0);
8527 o_conv = Description_clone(&o_conv);
8528 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
8529 *ret_conv = CResult_DescriptionCreationErrorZ_ok(o_conv);
8530 return (uint64_t)ret_conv;
8533 uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_err(uint32_t e) {
8534 LDKCreationError e_conv = LDKCreationError_from_js(e);
8535 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
8536 *ret_conv = CResult_DescriptionCreationErrorZ_err(e_conv);
8537 return (uint64_t)ret_conv;
8540 void __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_free(uint32_t _res) {
8541 if ((_res & 1) != 0) return;
8542 LDKCResult_DescriptionCreationErrorZ _res_conv = *(LDKCResult_DescriptionCreationErrorZ*)(((uint64_t)_res) & ~1);
8544 CResult_DescriptionCreationErrorZ_free(_res_conv);
8547 uint32_t __attribute__((visibility("default"))) TS_CResult_DescriptionCreationErrorZ_clone(uint32_t orig) {
8548 LDKCResult_DescriptionCreationErrorZ* orig_conv = (LDKCResult_DescriptionCreationErrorZ*)(orig & ~1);
8549 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
8550 *ret_conv = CResult_DescriptionCreationErrorZ_clone(orig_conv);
8551 return (uint64_t)ret_conv;
8554 uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_ok(uint32_t o) {
8555 LDKExpiryTime o_conv;
8556 o_conv.inner = (void*)(o & (~1));
8557 o_conv.is_owned = (o & 1) || (o == 0);
8558 o_conv = ExpiryTime_clone(&o_conv);
8559 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
8560 *ret_conv = CResult_ExpiryTimeCreationErrorZ_ok(o_conv);
8561 return (uint64_t)ret_conv;
8564 uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_err(uint32_t e) {
8565 LDKCreationError e_conv = LDKCreationError_from_js(e);
8566 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
8567 *ret_conv = CResult_ExpiryTimeCreationErrorZ_err(e_conv);
8568 return (uint64_t)ret_conv;
8571 void __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_free(uint32_t _res) {
8572 if ((_res & 1) != 0) return;
8573 LDKCResult_ExpiryTimeCreationErrorZ _res_conv = *(LDKCResult_ExpiryTimeCreationErrorZ*)(((uint64_t)_res) & ~1);
8575 CResult_ExpiryTimeCreationErrorZ_free(_res_conv);
8578 uint32_t __attribute__((visibility("default"))) TS_CResult_ExpiryTimeCreationErrorZ_clone(uint32_t orig) {
8579 LDKCResult_ExpiryTimeCreationErrorZ* orig_conv = (LDKCResult_ExpiryTimeCreationErrorZ*)(orig & ~1);
8580 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
8581 *ret_conv = CResult_ExpiryTimeCreationErrorZ_clone(orig_conv);
8582 return (uint64_t)ret_conv;
8585 uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_ok(uint32_t o) {
8586 LDKPrivateRoute o_conv;
8587 o_conv.inner = (void*)(o & (~1));
8588 o_conv.is_owned = (o & 1) || (o == 0);
8589 o_conv = PrivateRoute_clone(&o_conv);
8590 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
8591 *ret_conv = CResult_PrivateRouteCreationErrorZ_ok(o_conv);
8592 return (uint64_t)ret_conv;
8595 uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_err(uint32_t e) {
8596 LDKCreationError e_conv = LDKCreationError_from_js(e);
8597 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
8598 *ret_conv = CResult_PrivateRouteCreationErrorZ_err(e_conv);
8599 return (uint64_t)ret_conv;
8602 void __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_free(uint32_t _res) {
8603 if ((_res & 1) != 0) return;
8604 LDKCResult_PrivateRouteCreationErrorZ _res_conv = *(LDKCResult_PrivateRouteCreationErrorZ*)(((uint64_t)_res) & ~1);
8606 CResult_PrivateRouteCreationErrorZ_free(_res_conv);
8609 uint32_t __attribute__((visibility("default"))) TS_CResult_PrivateRouteCreationErrorZ_clone(uint32_t orig) {
8610 LDKCResult_PrivateRouteCreationErrorZ* orig_conv = (LDKCResult_PrivateRouteCreationErrorZ*)(orig & ~1);
8611 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
8612 *ret_conv = CResult_PrivateRouteCreationErrorZ_clone(orig_conv);
8613 return (uint64_t)ret_conv;
8616 uint32_t __attribute__((visibility("default"))) TS_CResult_StringErrorZ_ok(jstring o) {
8617 LDKStr o_conv = str_ref_to_owned_c(o);
8618 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
8619 *ret_conv = CResult_StringErrorZ_ok(o_conv);
8620 return (uint64_t)ret_conv;
8623 uint32_t __attribute__((visibility("default"))) TS_CResult_StringErrorZ_err(uint32_t e) {
8624 LDKSecp256k1Error e_conv = LDKSecp256k1Error_from_js(e);
8625 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
8626 *ret_conv = CResult_StringErrorZ_err(e_conv);
8627 return (uint64_t)ret_conv;
8630 void __attribute__((visibility("default"))) TS_CResult_StringErrorZ_free(uint32_t _res) {
8631 if ((_res & 1) != 0) return;
8632 LDKCResult_StringErrorZ _res_conv = *(LDKCResult_StringErrorZ*)(((uint64_t)_res) & ~1);
8634 CResult_StringErrorZ_free(_res_conv);
8637 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_ok(uint32_t o) {
8638 LDKChannelMonitorUpdate o_conv;
8639 o_conv.inner = (void*)(o & (~1));
8640 o_conv.is_owned = (o & 1) || (o == 0);
8641 o_conv = ChannelMonitorUpdate_clone(&o_conv);
8642 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
8643 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_ok(o_conv);
8644 return (uint64_t)ret_conv;
8647 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_err(uint32_t e) {
8648 LDKDecodeError e_conv;
8649 e_conv.inner = (void*)(e & (~1));
8650 e_conv.is_owned = (e & 1) || (e == 0);
8651 e_conv = DecodeError_clone(&e_conv);
8652 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
8653 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_err(e_conv);
8654 return (uint64_t)ret_conv;
8657 void __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_free(uint32_t _res) {
8658 if ((_res & 1) != 0) return;
8659 LDKCResult_ChannelMonitorUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
8661 CResult_ChannelMonitorUpdateDecodeErrorZ_free(_res_conv);
8664 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelMonitorUpdateDecodeErrorZ_clone(uint32_t orig) {
8665 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelMonitorUpdateDecodeErrorZ*)(orig & ~1);
8666 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
8667 *ret_conv = CResult_ChannelMonitorUpdateDecodeErrorZ_clone(orig_conv);
8668 return (uint64_t)ret_conv;
8671 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_ok(uint32_t o) {
8672 LDKHTLCUpdate o_conv;
8673 o_conv.inner = (void*)(o & (~1));
8674 o_conv.is_owned = (o & 1) || (o == 0);
8675 o_conv = HTLCUpdate_clone(&o_conv);
8676 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
8677 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_ok(o_conv);
8678 return (uint64_t)ret_conv;
8681 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_err(uint32_t e) {
8682 LDKDecodeError e_conv;
8683 e_conv.inner = (void*)(e & (~1));
8684 e_conv.is_owned = (e & 1) || (e == 0);
8685 e_conv = DecodeError_clone(&e_conv);
8686 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
8687 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_err(e_conv);
8688 return (uint64_t)ret_conv;
8691 void __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_free(uint32_t _res) {
8692 if ((_res & 1) != 0) return;
8693 LDKCResult_HTLCUpdateDecodeErrorZ _res_conv = *(LDKCResult_HTLCUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
8695 CResult_HTLCUpdateDecodeErrorZ_free(_res_conv);
8698 uint32_t __attribute__((visibility("default"))) TS_CResult_HTLCUpdateDecodeErrorZ_clone(uint32_t orig) {
8699 LDKCResult_HTLCUpdateDecodeErrorZ* orig_conv = (LDKCResult_HTLCUpdateDecodeErrorZ*)(orig & ~1);
8700 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
8701 *ret_conv = CResult_HTLCUpdateDecodeErrorZ_clone(orig_conv);
8702 return (uint64_t)ret_conv;
8705 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_ok() {
8706 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
8707 *ret_conv = CResult_NoneMonitorUpdateErrorZ_ok();
8708 return (uint64_t)ret_conv;
8711 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_err(uint32_t e) {
8712 LDKMonitorUpdateError e_conv;
8713 e_conv.inner = (void*)(e & (~1));
8714 e_conv.is_owned = (e & 1) || (e == 0);
8715 e_conv = MonitorUpdateError_clone(&e_conv);
8716 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
8717 *ret_conv = CResult_NoneMonitorUpdateErrorZ_err(e_conv);
8718 return (uint64_t)ret_conv;
8721 void __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_free(uint32_t _res) {
8722 if ((_res & 1) != 0) return;
8723 LDKCResult_NoneMonitorUpdateErrorZ _res_conv = *(LDKCResult_NoneMonitorUpdateErrorZ*)(((uint64_t)_res) & ~1);
8725 CResult_NoneMonitorUpdateErrorZ_free(_res_conv);
8728 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErrorZ_clone(uint32_t orig) {
8729 LDKCResult_NoneMonitorUpdateErrorZ* orig_conv = (LDKCResult_NoneMonitorUpdateErrorZ*)(orig & ~1);
8730 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
8731 *ret_conv = CResult_NoneMonitorUpdateErrorZ_clone(orig_conv);
8732 return (uint64_t)ret_conv;
8735 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) {
8736 LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1);
8737 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
8738 *ret_ref = C2Tuple_OutPointScriptZ_clone(orig_conv);
8739 return (uint64_t)ret_ref;
8742 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_new(uint32_t a, int8_tArray b) {
8744 a_conv.inner = (void*)(a & (~1));
8745 a_conv.is_owned = (a & 1) || (a == 0);
8746 a_conv = OutPoint_clone(&a_conv);
8748 b_ref.datalen = *((uint32_t*)b);
8749 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
8750 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
8751 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
8752 *ret_ref = C2Tuple_OutPointScriptZ_new(a_conv, b_ref);
8753 return (uint64_t)ret_ref;
8756 void __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_free(uint32_t _res) {
8757 if ((_res & 1) != 0) return;
8758 LDKC2Tuple_OutPointScriptZ _res_conv = *(LDKC2Tuple_OutPointScriptZ*)(((uint64_t)_res) & ~1);
8760 C2Tuple_OutPointScriptZ_free(_res_conv);
8763 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) {
8764 LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1);
8765 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
8766 *ret_ref = C2Tuple_u32ScriptZ_clone(orig_conv);
8767 return (uint64_t)ret_ref;
8770 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) {
8772 b_ref.datalen = *((uint32_t*)b);
8773 b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes");
8774 memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen);
8775 LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ");
8776 *ret_ref = C2Tuple_u32ScriptZ_new(a, b_ref);
8777 return (uint64_t)ret_ref;
8780 void __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_free(uint32_t _res) {
8781 if ((_res & 1) != 0) return;
8782 LDKC2Tuple_u32ScriptZ _res_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res) & ~1);
8784 C2Tuple_u32ScriptZ_free(_res_conv);
8787 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32ScriptZZ_free(uint32_tArray _res) {
8788 LDKCVec_C2Tuple_u32ScriptZZ _res_constr;
8789 _res_constr.datalen = *((uint32_t*)_res);
8790 if (_res_constr.datalen > 0)
8791 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
8793 _res_constr.data = NULL;
8794 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8795 for (size_t e = 0; e < _res_constr.datalen; e++) {
8796 uint32_t _res_conv_30 = _res_vals[e];
8797 LDKC2Tuple_u32ScriptZ _res_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res_conv_30) & ~1);
8798 FREE((void*)_res_conv_30);
8799 _res_constr.data[e] = _res_conv_30_conv;
8801 CVec_C2Tuple_u32ScriptZZ_free(_res_constr);
8804 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) {
8805 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1);
8806 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
8807 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv);
8808 return (uint64_t)ret_ref;
8811 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint32_tArray b) {
8812 LDKThirtyTwoBytes a_ref;
8813 CHECK(*((uint32_t*)a) == 32);
8814 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
8815 LDKCVec_C2Tuple_u32ScriptZZ b_constr;
8816 b_constr.datalen = *((uint32_t*)b);
8817 if (b_constr.datalen > 0)
8818 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32ScriptZ), "LDKCVec_C2Tuple_u32ScriptZZ Elements");
8820 b_constr.data = NULL;
8821 uint32_t* b_vals = (uint32_t*)(b + 4);
8822 for (size_t e = 0; e < b_constr.datalen; e++) {
8823 uint32_t b_conv_30 = b_vals[e];
8824 LDKC2Tuple_u32ScriptZ b_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1);
8825 b_conv_30_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1));
8826 b_constr.data[e] = b_conv_30_conv;
8828 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
8829 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr);
8830 return (uint64_t)ret_ref;
8833 void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint32_t _res) {
8834 if ((_res & 1) != 0) return;
8835 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res) & ~1);
8837 C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(_res_conv);
8840 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(uint32_tArray _res) {
8841 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ _res_constr;
8842 _res_constr.datalen = *((uint32_t*)_res);
8843 if (_res_constr.datalen > 0)
8844 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ Elements");
8846 _res_constr.data = NULL;
8847 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8848 for (size_t c = 0; c < _res_constr.datalen; c++) {
8849 uint32_t _res_conv_54 = _res_vals[c];
8850 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_54_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res_conv_54) & ~1);
8851 FREE((void*)_res_conv_54);
8852 _res_constr.data[c] = _res_conv_54_conv;
8854 CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr);
8857 void __attribute__((visibility("default"))) TS_CVec_EventZ_free(uint32_tArray _res) {
8858 LDKCVec_EventZ _res_constr;
8859 _res_constr.datalen = *((uint32_t*)_res);
8860 if (_res_constr.datalen > 0)
8861 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKEvent), "LDKCVec_EventZ Elements");
8863 _res_constr.data = NULL;
8864 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8865 for (size_t h = 0; h < _res_constr.datalen; h++) {
8866 uint32_t _res_conv_7 = _res_vals[h];
8867 LDKEvent _res_conv_7_conv = *(LDKEvent*)(((uint64_t)_res_conv_7) & ~1);
8868 FREE((void*)_res_conv_7);
8869 _res_constr.data[h] = _res_conv_7_conv;
8871 CVec_EventZ_free(_res_constr);
8874 void __attribute__((visibility("default"))) TS_CVec_TransactionZ_free(ptrArray _res) {
8875 LDKCVec_TransactionZ _res_constr;
8876 _res_constr.datalen = *((uint32_t*)_res);
8877 if (_res_constr.datalen > 0)
8878 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKTransaction), "LDKCVec_TransactionZ Elements");
8880 _res_constr.data = NULL;
8881 int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
8882 for (size_t m = 0; m < _res_constr.datalen; m++) {
8883 int8_tArray _res_conv_12 = _res_vals[m];
8884 LDKTransaction _res_conv_12_ref;
8885 _res_conv_12_ref.datalen = *((uint32_t*)_res_conv_12);
8886 _res_conv_12_ref.data = MALLOC(_res_conv_12_ref.datalen, "LDKTransaction Bytes");
8887 memcpy(_res_conv_12_ref.data, (uint8_t*)(_res_conv_12 + 4), _res_conv_12_ref.datalen);
8888 _res_conv_12_ref.data_is_owned = true;
8889 _res_constr.data[m] = _res_conv_12_ref;
8891 CVec_TransactionZ_free(_res_constr);
8894 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) {
8895 LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1);
8896 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
8897 *ret_ref = C2Tuple_u32TxOutZ_clone(orig_conv);
8898 return (uint64_t)ret_ref;
8901 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint32_t b) {
8902 LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1);
8903 LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ");
8904 *ret_ref = C2Tuple_u32TxOutZ_new(a, b_conv);
8905 return (uint64_t)ret_ref;
8908 void __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_free(uint32_t _res) {
8909 if ((_res & 1) != 0) return;
8910 LDKC2Tuple_u32TxOutZ _res_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res) & ~1);
8912 C2Tuple_u32TxOutZ_free(_res_conv);
8915 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uint32_tArray _res) {
8916 LDKCVec_C2Tuple_u32TxOutZZ _res_constr;
8917 _res_constr.datalen = *((uint32_t*)_res);
8918 if (_res_constr.datalen > 0)
8919 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
8921 _res_constr.data = NULL;
8922 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8923 for (size_t z = 0; z < _res_constr.datalen; z++) {
8924 uint32_t _res_conv_25 = _res_vals[z];
8925 LDKC2Tuple_u32TxOutZ _res_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res_conv_25) & ~1);
8926 FREE((void*)_res_conv_25);
8927 _res_constr.data[z] = _res_conv_25_conv;
8929 CVec_C2Tuple_u32TxOutZZ_free(_res_constr);
8932 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) {
8933 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1);
8934 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
8935 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv);
8936 return (uint64_t)ret_ref;
8939 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint32_tArray b) {
8940 LDKThirtyTwoBytes a_ref;
8941 CHECK(*((uint32_t*)a) == 32);
8942 memcpy(a_ref.data, (uint8_t*)(a + 4), 32);
8943 LDKCVec_C2Tuple_u32TxOutZZ b_constr;
8944 b_constr.datalen = *((uint32_t*)b);
8945 if (b_constr.datalen > 0)
8946 b_constr.data = MALLOC(b_constr.datalen * sizeof(LDKC2Tuple_u32TxOutZ), "LDKCVec_C2Tuple_u32TxOutZZ Elements");
8948 b_constr.data = NULL;
8949 uint32_t* b_vals = (uint32_t*)(b + 4);
8950 for (size_t z = 0; z < b_constr.datalen; z++) {
8951 uint32_t b_conv_25 = b_vals[z];
8952 LDKC2Tuple_u32TxOutZ b_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1);
8953 b_conv_25_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1));
8954 b_constr.data[z] = b_conv_25_conv;
8956 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
8957 *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr);
8958 return (uint64_t)ret_ref;
8961 void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint32_t _res) {
8962 if ((_res & 1) != 0) return;
8963 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res) & ~1);
8965 C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(_res_conv);
8968 void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(uint32_tArray _res) {
8969 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ _res_constr;
8970 _res_constr.datalen = *((uint32_t*)_res);
8971 if (_res_constr.datalen > 0)
8972 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ Elements");
8974 _res_constr.data = NULL;
8975 uint32_t* _res_vals = (uint32_t*)(_res + 4);
8976 for (size_t x = 0; x < _res_constr.datalen; x++) {
8977 uint32_t _res_conv_49 = _res_vals[x];
8978 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_49_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res_conv_49) & ~1);
8979 FREE((void*)_res_conv_49);
8980 _res_constr.data[x] = _res_conv_49_conv;
8982 CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr);
8985 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint32_t o) {
8986 LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1);
8987 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
8988 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv);
8989 return (uint64_t)ret_conv;
8992 uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(uint32_t e) {
8993 LDKDecodeError e_conv;
8994 e_conv.inner = (void*)(e & (~1));
8995 e_conv.is_owned = (e & 1) || (e == 0);
8996 e_conv = DecodeError_clone(&e_conv);
8997 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
8998 *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_err(e_conv);
8999 return (uint64_t)ret_conv;
9002 void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(uint32_t _res) {
9003 if ((_res & 1) != 0) return;
9004 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ _res_conv = *(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(((uint64_t)_res) & ~1);
9006 CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv);
9009 uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) {
9010 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
9011 *ret_conv = CResult_boolLightningErrorZ_ok(o);
9012 return (uint64_t)ret_conv;
9015 uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_err(uint32_t e) {
9016 LDKLightningError e_conv;
9017 e_conv.inner = (void*)(e & (~1));
9018 e_conv.is_owned = (e & 1) || (e == 0);
9019 e_conv = LightningError_clone(&e_conv);
9020 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
9021 *ret_conv = CResult_boolLightningErrorZ_err(e_conv);
9022 return (uint64_t)ret_conv;
9025 void __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_free(uint32_t _res) {
9026 if ((_res & 1) != 0) return;
9027 LDKCResult_boolLightningErrorZ _res_conv = *(LDKCResult_boolLightningErrorZ*)(((uint64_t)_res) & ~1);
9029 CResult_boolLightningErrorZ_free(_res_conv);
9032 uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_clone(uint32_t orig) {
9033 LDKCResult_boolLightningErrorZ* orig_conv = (LDKCResult_boolLightningErrorZ*)(orig & ~1);
9034 LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ");
9035 *ret_conv = CResult_boolLightningErrorZ_clone(orig_conv);
9036 return (uint64_t)ret_conv;
9039 uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) {
9040 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1);
9041 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
9042 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv);
9043 return (uint64_t)ret_ref;
9046 uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) {
9047 LDKChannelAnnouncement a_conv;
9048 a_conv.inner = (void*)(a & (~1));
9049 a_conv.is_owned = (a & 1) || (a == 0);
9050 a_conv = ChannelAnnouncement_clone(&a_conv);
9051 LDKChannelUpdate b_conv;
9052 b_conv.inner = (void*)(b & (~1));
9053 b_conv.is_owned = (b & 1) || (b == 0);
9054 b_conv = ChannelUpdate_clone(&b_conv);
9055 LDKChannelUpdate c_conv;
9056 c_conv.inner = (void*)(c & (~1));
9057 c_conv.is_owned = (c & 1) || (c == 0);
9058 c_conv = ChannelUpdate_clone(&c_conv);
9059 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ");
9060 *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv);
9061 return (uint64_t)ret_ref;
9064 void __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) {
9065 if ((_res & 1) != 0) return;
9066 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res) & ~1);
9068 C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(_res_conv);
9071 void __attribute__((visibility("default"))) TS_CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(uint32_tArray _res) {
9072 LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ _res_constr;
9073 _res_constr.datalen = *((uint32_t*)_res);
9074 if (_res_constr.datalen > 0)
9075 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ Elements");
9077 _res_constr.data = NULL;
9078 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9079 for (size_t l = 0; l < _res_constr.datalen; l++) {
9080 uint32_t _res_conv_63 = _res_vals[l];
9081 LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1);
9082 FREE((void*)_res_conv_63);
9083 _res_constr.data[l] = _res_conv_63_conv;
9085 CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr);
9088 void __attribute__((visibility("default"))) TS_CVec_NodeAnnouncementZ_free(uint32_tArray _res) {
9089 LDKCVec_NodeAnnouncementZ _res_constr;
9090 _res_constr.datalen = *((uint32_t*)_res);
9091 if (_res_constr.datalen > 0)
9092 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKNodeAnnouncement), "LDKCVec_NodeAnnouncementZ Elements");
9094 _res_constr.data = NULL;
9095 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9096 for (size_t s = 0; s < _res_constr.datalen; s++) {
9097 uint32_t _res_conv_18 = _res_vals[s];
9098 LDKNodeAnnouncement _res_conv_18_conv;
9099 _res_conv_18_conv.inner = (void*)(_res_conv_18 & (~1));
9100 _res_conv_18_conv.is_owned = (_res_conv_18 & 1) || (_res_conv_18 == 0);
9101 _res_constr.data[s] = _res_conv_18_conv;
9103 CVec_NodeAnnouncementZ_free(_res_constr);
9106 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() {
9107 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
9108 *ret_conv = CResult_NoneLightningErrorZ_ok();
9109 return (uint64_t)ret_conv;
9112 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) {
9113 LDKLightningError e_conv;
9114 e_conv.inner = (void*)(e & (~1));
9115 e_conv.is_owned = (e & 1) || (e == 0);
9116 e_conv = LightningError_clone(&e_conv);
9117 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
9118 *ret_conv = CResult_NoneLightningErrorZ_err(e_conv);
9119 return (uint64_t)ret_conv;
9122 void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) {
9123 if ((_res & 1) != 0) return;
9124 LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1);
9126 CResult_NoneLightningErrorZ_free(_res_conv);
9129 uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) {
9130 LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1);
9131 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
9132 *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv);
9133 return (uint64_t)ret_conv;
9136 void __attribute__((visibility("default"))) TS_CVec_PublicKeyZ_free(ptrArray _res) {
9137 LDKCVec_PublicKeyZ _res_constr;
9138 _res_constr.datalen = *((uint32_t*)_res);
9139 if (_res_constr.datalen > 0)
9140 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKPublicKey), "LDKCVec_PublicKeyZ Elements");
9142 _res_constr.data = NULL;
9143 int8_tArray* _res_vals = (int8_tArray*)(_res + 4);
9144 for (size_t m = 0; m < _res_constr.datalen; m++) {
9145 int8_tArray _res_conv_12 = _res_vals[m];
9146 LDKPublicKey _res_conv_12_ref;
9147 CHECK(*((uint32_t*)_res_conv_12) == 33);
9148 memcpy(_res_conv_12_ref.compressed_form, (uint8_t*)(_res_conv_12 + 4), 33);
9149 _res_constr.data[m] = _res_conv_12_ref;
9151 CVec_PublicKeyZ_free(_res_constr);
9154 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_ok(int8_tArray o) {
9156 o_ref.datalen = *((uint32_t*)o);
9157 o_ref.data = MALLOC(o_ref.datalen, "LDKCVec_u8Z Bytes");
9158 memcpy(o_ref.data, (uint8_t*)(o + 4), o_ref.datalen);
9159 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
9160 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_ok(o_ref);
9161 return (uint64_t)ret_conv;
9164 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_err(uint32_t e) {
9165 LDKPeerHandleError e_conv;
9166 e_conv.inner = (void*)(e & (~1));
9167 e_conv.is_owned = (e & 1) || (e == 0);
9168 e_conv = PeerHandleError_clone(&e_conv);
9169 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
9170 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_err(e_conv);
9171 return (uint64_t)ret_conv;
9174 void __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_free(uint32_t _res) {
9175 if ((_res & 1) != 0) return;
9176 LDKCResult_CVec_u8ZPeerHandleErrorZ _res_conv = *(LDKCResult_CVec_u8ZPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
9178 CResult_CVec_u8ZPeerHandleErrorZ_free(_res_conv);
9181 uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_u8ZPeerHandleErrorZ_clone(uint32_t orig) {
9182 LDKCResult_CVec_u8ZPeerHandleErrorZ* orig_conv = (LDKCResult_CVec_u8ZPeerHandleErrorZ*)(orig & ~1);
9183 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
9184 *ret_conv = CResult_CVec_u8ZPeerHandleErrorZ_clone(orig_conv);
9185 return (uint64_t)ret_conv;
9188 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_ok() {
9189 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
9190 *ret_conv = CResult_NonePeerHandleErrorZ_ok();
9191 return (uint64_t)ret_conv;
9194 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_err(uint32_t e) {
9195 LDKPeerHandleError e_conv;
9196 e_conv.inner = (void*)(e & (~1));
9197 e_conv.is_owned = (e & 1) || (e == 0);
9198 e_conv = PeerHandleError_clone(&e_conv);
9199 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
9200 *ret_conv = CResult_NonePeerHandleErrorZ_err(e_conv);
9201 return (uint64_t)ret_conv;
9204 void __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_free(uint32_t _res) {
9205 if ((_res & 1) != 0) return;
9206 LDKCResult_NonePeerHandleErrorZ _res_conv = *(LDKCResult_NonePeerHandleErrorZ*)(((uint64_t)_res) & ~1);
9208 CResult_NonePeerHandleErrorZ_free(_res_conv);
9211 uint32_t __attribute__((visibility("default"))) TS_CResult_NonePeerHandleErrorZ_clone(uint32_t orig) {
9212 LDKCResult_NonePeerHandleErrorZ* orig_conv = (LDKCResult_NonePeerHandleErrorZ*)(orig & ~1);
9213 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
9214 *ret_conv = CResult_NonePeerHandleErrorZ_clone(orig_conv);
9215 return (uint64_t)ret_conv;
9218 uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_ok(jboolean o) {
9219 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
9220 *ret_conv = CResult_boolPeerHandleErrorZ_ok(o);
9221 return (uint64_t)ret_conv;
9224 uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_err(uint32_t e) {
9225 LDKPeerHandleError e_conv;
9226 e_conv.inner = (void*)(e & (~1));
9227 e_conv.is_owned = (e & 1) || (e == 0);
9228 e_conv = PeerHandleError_clone(&e_conv);
9229 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
9230 *ret_conv = CResult_boolPeerHandleErrorZ_err(e_conv);
9231 return (uint64_t)ret_conv;
9234 void __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_free(uint32_t _res) {
9235 if ((_res & 1) != 0) return;
9236 LDKCResult_boolPeerHandleErrorZ _res_conv = *(LDKCResult_boolPeerHandleErrorZ*)(((uint64_t)_res) & ~1);
9238 CResult_boolPeerHandleErrorZ_free(_res_conv);
9241 uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ_clone(uint32_t orig) {
9242 LDKCResult_boolPeerHandleErrorZ* orig_conv = (LDKCResult_boolPeerHandleErrorZ*)(orig & ~1);
9243 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
9244 *ret_conv = CResult_boolPeerHandleErrorZ_clone(orig_conv);
9245 return (uint64_t)ret_conv;
9248 uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(uint32_t o) {
9249 LDKDirectionalChannelInfo o_conv;
9250 o_conv.inner = (void*)(o & (~1));
9251 o_conv.is_owned = (o & 1) || (o == 0);
9252 o_conv = DirectionalChannelInfo_clone(&o_conv);
9253 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
9254 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_ok(o_conv);
9255 return (uint64_t)ret_conv;
9258 uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_err(uint32_t e) {
9259 LDKDecodeError e_conv;
9260 e_conv.inner = (void*)(e & (~1));
9261 e_conv.is_owned = (e & 1) || (e == 0);
9262 e_conv = DecodeError_clone(&e_conv);
9263 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
9264 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_err(e_conv);
9265 return (uint64_t)ret_conv;
9268 void __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_free(uint32_t _res) {
9269 if ((_res & 1) != 0) return;
9270 LDKCResult_DirectionalChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
9272 CResult_DirectionalChannelInfoDecodeErrorZ_free(_res_conv);
9275 uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_clone(uint32_t orig) {
9276 LDKCResult_DirectionalChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(orig & ~1);
9277 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
9278 *ret_conv = CResult_DirectionalChannelInfoDecodeErrorZ_clone(orig_conv);
9279 return (uint64_t)ret_conv;
9282 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_ok(uint32_t o) {
9283 LDKChannelInfo o_conv;
9284 o_conv.inner = (void*)(o & (~1));
9285 o_conv.is_owned = (o & 1) || (o == 0);
9286 o_conv = ChannelInfo_clone(&o_conv);
9287 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
9288 *ret_conv = CResult_ChannelInfoDecodeErrorZ_ok(o_conv);
9289 return (uint64_t)ret_conv;
9292 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_err(uint32_t e) {
9293 LDKDecodeError e_conv;
9294 e_conv.inner = (void*)(e & (~1));
9295 e_conv.is_owned = (e & 1) || (e == 0);
9296 e_conv = DecodeError_clone(&e_conv);
9297 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
9298 *ret_conv = CResult_ChannelInfoDecodeErrorZ_err(e_conv);
9299 return (uint64_t)ret_conv;
9302 void __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_free(uint32_t _res) {
9303 if ((_res & 1) != 0) return;
9304 LDKCResult_ChannelInfoDecodeErrorZ _res_conv = *(LDKCResult_ChannelInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
9306 CResult_ChannelInfoDecodeErrorZ_free(_res_conv);
9309 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelInfoDecodeErrorZ_clone(uint32_t orig) {
9310 LDKCResult_ChannelInfoDecodeErrorZ* orig_conv = (LDKCResult_ChannelInfoDecodeErrorZ*)(orig & ~1);
9311 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
9312 *ret_conv = CResult_ChannelInfoDecodeErrorZ_clone(orig_conv);
9313 return (uint64_t)ret_conv;
9316 uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_ok(uint32_t o) {
9317 LDKRoutingFees o_conv;
9318 o_conv.inner = (void*)(o & (~1));
9319 o_conv.is_owned = (o & 1) || (o == 0);
9320 o_conv = RoutingFees_clone(&o_conv);
9321 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
9322 *ret_conv = CResult_RoutingFeesDecodeErrorZ_ok(o_conv);
9323 return (uint64_t)ret_conv;
9326 uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_err(uint32_t e) {
9327 LDKDecodeError e_conv;
9328 e_conv.inner = (void*)(e & (~1));
9329 e_conv.is_owned = (e & 1) || (e == 0);
9330 e_conv = DecodeError_clone(&e_conv);
9331 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
9332 *ret_conv = CResult_RoutingFeesDecodeErrorZ_err(e_conv);
9333 return (uint64_t)ret_conv;
9336 void __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_free(uint32_t _res) {
9337 if ((_res & 1) != 0) return;
9338 LDKCResult_RoutingFeesDecodeErrorZ _res_conv = *(LDKCResult_RoutingFeesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9340 CResult_RoutingFeesDecodeErrorZ_free(_res_conv);
9343 uint32_t __attribute__((visibility("default"))) TS_CResult_RoutingFeesDecodeErrorZ_clone(uint32_t orig) {
9344 LDKCResult_RoutingFeesDecodeErrorZ* orig_conv = (LDKCResult_RoutingFeesDecodeErrorZ*)(orig & ~1);
9345 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
9346 *ret_conv = CResult_RoutingFeesDecodeErrorZ_clone(orig_conv);
9347 return (uint64_t)ret_conv;
9350 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_ok(uint32_t o) {
9351 LDKNodeAnnouncementInfo o_conv;
9352 o_conv.inner = (void*)(o & (~1));
9353 o_conv.is_owned = (o & 1) || (o == 0);
9354 o_conv = NodeAnnouncementInfo_clone(&o_conv);
9355 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
9356 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_ok(o_conv);
9357 return (uint64_t)ret_conv;
9360 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_err(uint32_t e) {
9361 LDKDecodeError e_conv;
9362 e_conv.inner = (void*)(e & (~1));
9363 e_conv.is_owned = (e & 1) || (e == 0);
9364 e_conv = DecodeError_clone(&e_conv);
9365 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
9366 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_err(e_conv);
9367 return (uint64_t)ret_conv;
9370 void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_free(uint32_t _res) {
9371 if ((_res & 1) != 0) return;
9372 LDKCResult_NodeAnnouncementInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
9374 CResult_NodeAnnouncementInfoDecodeErrorZ_free(_res_conv);
9377 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementInfoDecodeErrorZ_clone(uint32_t orig) {
9378 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementInfoDecodeErrorZ*)(orig & ~1);
9379 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
9380 *ret_conv = CResult_NodeAnnouncementInfoDecodeErrorZ_clone(orig_conv);
9381 return (uint64_t)ret_conv;
9384 void __attribute__((visibility("default"))) TS_CVec_u64Z_free(int64_tArray _res) {
9385 LDKCVec_u64Z _res_constr;
9386 _res_constr.datalen = *((uint32_t*)_res);
9387 if (_res_constr.datalen > 0)
9388 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
9390 _res_constr.data = NULL;
9391 int64_t* _res_vals = (int64_t*)(_res + 4);
9392 for (size_t i = 0; i < _res_constr.datalen; i++) {
9393 int64_t _res_conv_8 = _res_vals[i];
9394 _res_constr.data[i] = _res_conv_8;
9396 CVec_u64Z_free(_res_constr);
9399 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_ok(uint32_t o) {
9401 o_conv.inner = (void*)(o & (~1));
9402 o_conv.is_owned = (o & 1) || (o == 0);
9403 o_conv = NodeInfo_clone(&o_conv);
9404 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
9405 *ret_conv = CResult_NodeInfoDecodeErrorZ_ok(o_conv);
9406 return (uint64_t)ret_conv;
9409 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_err(uint32_t e) {
9410 LDKDecodeError e_conv;
9411 e_conv.inner = (void*)(e & (~1));
9412 e_conv.is_owned = (e & 1) || (e == 0);
9413 e_conv = DecodeError_clone(&e_conv);
9414 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
9415 *ret_conv = CResult_NodeInfoDecodeErrorZ_err(e_conv);
9416 return (uint64_t)ret_conv;
9419 void __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_free(uint32_t _res) {
9420 if ((_res & 1) != 0) return;
9421 LDKCResult_NodeInfoDecodeErrorZ _res_conv = *(LDKCResult_NodeInfoDecodeErrorZ*)(((uint64_t)_res) & ~1);
9423 CResult_NodeInfoDecodeErrorZ_free(_res_conv);
9426 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeInfoDecodeErrorZ_clone(uint32_t orig) {
9427 LDKCResult_NodeInfoDecodeErrorZ* orig_conv = (LDKCResult_NodeInfoDecodeErrorZ*)(orig & ~1);
9428 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
9429 *ret_conv = CResult_NodeInfoDecodeErrorZ_clone(orig_conv);
9430 return (uint64_t)ret_conv;
9433 uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_ok(uint32_t o) {
9434 LDKNetworkGraph o_conv;
9435 o_conv.inner = (void*)(o & (~1));
9436 o_conv.is_owned = (o & 1) || (o == 0);
9437 o_conv = NetworkGraph_clone(&o_conv);
9438 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
9439 *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv);
9440 return (uint64_t)ret_conv;
9443 uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_err(uint32_t e) {
9444 LDKDecodeError e_conv;
9445 e_conv.inner = (void*)(e & (~1));
9446 e_conv.is_owned = (e & 1) || (e == 0);
9447 e_conv = DecodeError_clone(&e_conv);
9448 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
9449 *ret_conv = CResult_NetworkGraphDecodeErrorZ_err(e_conv);
9450 return (uint64_t)ret_conv;
9453 void __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_free(uint32_t _res) {
9454 if ((_res & 1) != 0) return;
9455 LDKCResult_NetworkGraphDecodeErrorZ _res_conv = *(LDKCResult_NetworkGraphDecodeErrorZ*)(((uint64_t)_res) & ~1);
9457 CResult_NetworkGraphDecodeErrorZ_free(_res_conv);
9460 uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone(uint32_t orig) {
9461 LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1);
9462 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
9463 *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(orig_conv);
9464 return (uint64_t)ret_conv;
9467 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_ok(uint32_t o) {
9468 LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1);
9469 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
9470 *ret_conv = CResult_NetAddressu8Z_ok(o_conv);
9471 return (uint64_t)ret_conv;
9474 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_err(int8_t e) {
9475 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
9476 *ret_conv = CResult_NetAddressu8Z_err(e);
9477 return (uint64_t)ret_conv;
9480 void __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_free(uint32_t _res) {
9481 if ((_res & 1) != 0) return;
9482 LDKCResult_NetAddressu8Z _res_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)_res) & ~1);
9484 CResult_NetAddressu8Z_free(_res_conv);
9487 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_clone(uint32_t orig) {
9488 LDKCResult_NetAddressu8Z* orig_conv = (LDKCResult_NetAddressu8Z*)(orig & ~1);
9489 LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z");
9490 *ret_conv = CResult_NetAddressu8Z_clone(orig_conv);
9491 return (uint64_t)ret_conv;
9494 uint32_t __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(uint32_t o) {
9495 LDKCResult_NetAddressu8Z o_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)o) & ~1);
9496 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
9497 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o_conv);
9498 return (uint64_t)ret_conv;
9501 uint32_t __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8ZDecodeErrorZ_err(uint32_t e) {
9502 LDKDecodeError e_conv;
9503 e_conv.inner = (void*)(e & (~1));
9504 e_conv.is_owned = (e & 1) || (e == 0);
9505 e_conv = DecodeError_clone(&e_conv);
9506 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
9507 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_err(e_conv);
9508 return (uint64_t)ret_conv;
9511 void __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8ZDecodeErrorZ_free(uint32_t _res) {
9512 if ((_res & 1) != 0) return;
9513 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ _res_conv = *(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(((uint64_t)_res) & ~1);
9515 CResult_CResult_NetAddressu8ZDecodeErrorZ_free(_res_conv);
9518 uint32_t __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(uint32_t orig) {
9519 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* orig_conv = (LDKCResult_CResult_NetAddressu8ZDecodeErrorZ*)(orig & ~1);
9520 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
9521 *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_clone(orig_conv);
9522 return (uint64_t)ret_conv;
9525 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint32_t o) {
9526 LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1);
9527 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
9528 *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv);
9529 return (uint64_t)ret_conv;
9532 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_err(uint32_t e) {
9533 LDKDecodeError e_conv;
9534 e_conv.inner = (void*)(e & (~1));
9535 e_conv.is_owned = (e & 1) || (e == 0);
9536 e_conv = DecodeError_clone(&e_conv);
9537 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
9538 *ret_conv = CResult_NetAddressDecodeErrorZ_err(e_conv);
9539 return (uint64_t)ret_conv;
9542 void __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_free(uint32_t _res) {
9543 if ((_res & 1) != 0) return;
9544 LDKCResult_NetAddressDecodeErrorZ _res_conv = *(LDKCResult_NetAddressDecodeErrorZ*)(((uint64_t)_res) & ~1);
9546 CResult_NetAddressDecodeErrorZ_free(_res_conv);
9549 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_clone(uint32_t orig) {
9550 LDKCResult_NetAddressDecodeErrorZ* orig_conv = (LDKCResult_NetAddressDecodeErrorZ*)(orig & ~1);
9551 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
9552 *ret_conv = CResult_NetAddressDecodeErrorZ_clone(orig_conv);
9553 return (uint64_t)ret_conv;
9556 void __attribute__((visibility("default"))) TS_CVec_UpdateAddHTLCZ_free(uint32_tArray _res) {
9557 LDKCVec_UpdateAddHTLCZ _res_constr;
9558 _res_constr.datalen = *((uint32_t*)_res);
9559 if (_res_constr.datalen > 0)
9560 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
9562 _res_constr.data = NULL;
9563 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9564 for (size_t p = 0; p < _res_constr.datalen; p++) {
9565 uint32_t _res_conv_15 = _res_vals[p];
9566 LDKUpdateAddHTLC _res_conv_15_conv;
9567 _res_conv_15_conv.inner = (void*)(_res_conv_15 & (~1));
9568 _res_conv_15_conv.is_owned = (_res_conv_15 & 1) || (_res_conv_15 == 0);
9569 _res_constr.data[p] = _res_conv_15_conv;
9571 CVec_UpdateAddHTLCZ_free(_res_constr);
9574 void __attribute__((visibility("default"))) TS_CVec_UpdateFulfillHTLCZ_free(uint32_tArray _res) {
9575 LDKCVec_UpdateFulfillHTLCZ _res_constr;
9576 _res_constr.datalen = *((uint32_t*)_res);
9577 if (_res_constr.datalen > 0)
9578 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
9580 _res_constr.data = NULL;
9581 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9582 for (size_t t = 0; t < _res_constr.datalen; t++) {
9583 uint32_t _res_conv_19 = _res_vals[t];
9584 LDKUpdateFulfillHTLC _res_conv_19_conv;
9585 _res_conv_19_conv.inner = (void*)(_res_conv_19 & (~1));
9586 _res_conv_19_conv.is_owned = (_res_conv_19 & 1) || (_res_conv_19 == 0);
9587 _res_constr.data[t] = _res_conv_19_conv;
9589 CVec_UpdateFulfillHTLCZ_free(_res_constr);
9592 void __attribute__((visibility("default"))) TS_CVec_UpdateFailHTLCZ_free(uint32_tArray _res) {
9593 LDKCVec_UpdateFailHTLCZ _res_constr;
9594 _res_constr.datalen = *((uint32_t*)_res);
9595 if (_res_constr.datalen > 0)
9596 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
9598 _res_constr.data = NULL;
9599 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9600 for (size_t q = 0; q < _res_constr.datalen; q++) {
9601 uint32_t _res_conv_16 = _res_vals[q];
9602 LDKUpdateFailHTLC _res_conv_16_conv;
9603 _res_conv_16_conv.inner = (void*)(_res_conv_16 & (~1));
9604 _res_conv_16_conv.is_owned = (_res_conv_16 & 1) || (_res_conv_16 == 0);
9605 _res_constr.data[q] = _res_conv_16_conv;
9607 CVec_UpdateFailHTLCZ_free(_res_constr);
9610 void __attribute__((visibility("default"))) TS_CVec_UpdateFailMalformedHTLCZ_free(uint32_tArray _res) {
9611 LDKCVec_UpdateFailMalformedHTLCZ _res_constr;
9612 _res_constr.datalen = *((uint32_t*)_res);
9613 if (_res_constr.datalen > 0)
9614 _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
9616 _res_constr.data = NULL;
9617 uint32_t* _res_vals = (uint32_t*)(_res + 4);
9618 for (size_t z = 0; z < _res_constr.datalen; z++) {
9619 uint32_t _res_conv_25 = _res_vals[z];
9620 LDKUpdateFailMalformedHTLC _res_conv_25_conv;
9621 _res_conv_25_conv.inner = (void*)(_res_conv_25 & (~1));
9622 _res_conv_25_conv.is_owned = (_res_conv_25 & 1) || (_res_conv_25 == 0);
9623 _res_constr.data[z] = _res_conv_25_conv;
9625 CVec_UpdateFailMalformedHTLCZ_free(_res_constr);
9628 uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_ok(uint32_t o) {
9629 LDKAcceptChannel o_conv;
9630 o_conv.inner = (void*)(o & (~1));
9631 o_conv.is_owned = (o & 1) || (o == 0);
9632 o_conv = AcceptChannel_clone(&o_conv);
9633 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
9634 *ret_conv = CResult_AcceptChannelDecodeErrorZ_ok(o_conv);
9635 return (uint64_t)ret_conv;
9638 uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_err(uint32_t e) {
9639 LDKDecodeError e_conv;
9640 e_conv.inner = (void*)(e & (~1));
9641 e_conv.is_owned = (e & 1) || (e == 0);
9642 e_conv = DecodeError_clone(&e_conv);
9643 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
9644 *ret_conv = CResult_AcceptChannelDecodeErrorZ_err(e_conv);
9645 return (uint64_t)ret_conv;
9648 void __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_free(uint32_t _res) {
9649 if ((_res & 1) != 0) return;
9650 LDKCResult_AcceptChannelDecodeErrorZ _res_conv = *(LDKCResult_AcceptChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
9652 CResult_AcceptChannelDecodeErrorZ_free(_res_conv);
9655 uint32_t __attribute__((visibility("default"))) TS_CResult_AcceptChannelDecodeErrorZ_clone(uint32_t orig) {
9656 LDKCResult_AcceptChannelDecodeErrorZ* orig_conv = (LDKCResult_AcceptChannelDecodeErrorZ*)(orig & ~1);
9657 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
9658 *ret_conv = CResult_AcceptChannelDecodeErrorZ_clone(orig_conv);
9659 return (uint64_t)ret_conv;
9662 uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_ok(uint32_t o) {
9663 LDKAnnouncementSignatures o_conv;
9664 o_conv.inner = (void*)(o & (~1));
9665 o_conv.is_owned = (o & 1) || (o == 0);
9666 o_conv = AnnouncementSignatures_clone(&o_conv);
9667 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
9668 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_ok(o_conv);
9669 return (uint64_t)ret_conv;
9672 uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_err(uint32_t e) {
9673 LDKDecodeError e_conv;
9674 e_conv.inner = (void*)(e & (~1));
9675 e_conv.is_owned = (e & 1) || (e == 0);
9676 e_conv = DecodeError_clone(&e_conv);
9677 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
9678 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_err(e_conv);
9679 return (uint64_t)ret_conv;
9682 void __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_free(uint32_t _res) {
9683 if ((_res & 1) != 0) return;
9684 LDKCResult_AnnouncementSignaturesDecodeErrorZ _res_conv = *(LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(((uint64_t)_res) & ~1);
9686 CResult_AnnouncementSignaturesDecodeErrorZ_free(_res_conv);
9689 uint32_t __attribute__((visibility("default"))) TS_CResult_AnnouncementSignaturesDecodeErrorZ_clone(uint32_t orig) {
9690 LDKCResult_AnnouncementSignaturesDecodeErrorZ* orig_conv = (LDKCResult_AnnouncementSignaturesDecodeErrorZ*)(orig & ~1);
9691 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
9692 *ret_conv = CResult_AnnouncementSignaturesDecodeErrorZ_clone(orig_conv);
9693 return (uint64_t)ret_conv;
9696 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_ok(uint32_t o) {
9697 LDKChannelReestablish o_conv;
9698 o_conv.inner = (void*)(o & (~1));
9699 o_conv.is_owned = (o & 1) || (o == 0);
9700 o_conv = ChannelReestablish_clone(&o_conv);
9701 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
9702 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_ok(o_conv);
9703 return (uint64_t)ret_conv;
9706 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_err(uint32_t e) {
9707 LDKDecodeError e_conv;
9708 e_conv.inner = (void*)(e & (~1));
9709 e_conv.is_owned = (e & 1) || (e == 0);
9710 e_conv = DecodeError_clone(&e_conv);
9711 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
9712 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_err(e_conv);
9713 return (uint64_t)ret_conv;
9716 void __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_free(uint32_t _res) {
9717 if ((_res & 1) != 0) return;
9718 LDKCResult_ChannelReestablishDecodeErrorZ _res_conv = *(LDKCResult_ChannelReestablishDecodeErrorZ*)(((uint64_t)_res) & ~1);
9720 CResult_ChannelReestablishDecodeErrorZ_free(_res_conv);
9723 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelReestablishDecodeErrorZ_clone(uint32_t orig) {
9724 LDKCResult_ChannelReestablishDecodeErrorZ* orig_conv = (LDKCResult_ChannelReestablishDecodeErrorZ*)(orig & ~1);
9725 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
9726 *ret_conv = CResult_ChannelReestablishDecodeErrorZ_clone(orig_conv);
9727 return (uint64_t)ret_conv;
9730 uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_ok(uint32_t o) {
9731 LDKClosingSigned o_conv;
9732 o_conv.inner = (void*)(o & (~1));
9733 o_conv.is_owned = (o & 1) || (o == 0);
9734 o_conv = ClosingSigned_clone(&o_conv);
9735 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
9736 *ret_conv = CResult_ClosingSignedDecodeErrorZ_ok(o_conv);
9737 return (uint64_t)ret_conv;
9740 uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_err(uint32_t e) {
9741 LDKDecodeError e_conv;
9742 e_conv.inner = (void*)(e & (~1));
9743 e_conv.is_owned = (e & 1) || (e == 0);
9744 e_conv = DecodeError_clone(&e_conv);
9745 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
9746 *ret_conv = CResult_ClosingSignedDecodeErrorZ_err(e_conv);
9747 return (uint64_t)ret_conv;
9750 void __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_free(uint32_t _res) {
9751 if ((_res & 1) != 0) return;
9752 LDKCResult_ClosingSignedDecodeErrorZ _res_conv = *(LDKCResult_ClosingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
9754 CResult_ClosingSignedDecodeErrorZ_free(_res_conv);
9757 uint32_t __attribute__((visibility("default"))) TS_CResult_ClosingSignedDecodeErrorZ_clone(uint32_t orig) {
9758 LDKCResult_ClosingSignedDecodeErrorZ* orig_conv = (LDKCResult_ClosingSignedDecodeErrorZ*)(orig & ~1);
9759 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
9760 *ret_conv = CResult_ClosingSignedDecodeErrorZ_clone(orig_conv);
9761 return (uint64_t)ret_conv;
9764 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_ok(uint32_t o) {
9765 LDKCommitmentSigned o_conv;
9766 o_conv.inner = (void*)(o & (~1));
9767 o_conv.is_owned = (o & 1) || (o == 0);
9768 o_conv = CommitmentSigned_clone(&o_conv);
9769 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
9770 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_ok(o_conv);
9771 return (uint64_t)ret_conv;
9774 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_err(uint32_t e) {
9775 LDKDecodeError e_conv;
9776 e_conv.inner = (void*)(e & (~1));
9777 e_conv.is_owned = (e & 1) || (e == 0);
9778 e_conv = DecodeError_clone(&e_conv);
9779 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
9780 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_err(e_conv);
9781 return (uint64_t)ret_conv;
9784 void __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_free(uint32_t _res) {
9785 if ((_res & 1) != 0) return;
9786 LDKCResult_CommitmentSignedDecodeErrorZ _res_conv = *(LDKCResult_CommitmentSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
9788 CResult_CommitmentSignedDecodeErrorZ_free(_res_conv);
9791 uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentSignedDecodeErrorZ_clone(uint32_t orig) {
9792 LDKCResult_CommitmentSignedDecodeErrorZ* orig_conv = (LDKCResult_CommitmentSignedDecodeErrorZ*)(orig & ~1);
9793 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
9794 *ret_conv = CResult_CommitmentSignedDecodeErrorZ_clone(orig_conv);
9795 return (uint64_t)ret_conv;
9798 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_ok(uint32_t o) {
9799 LDKFundingCreated o_conv;
9800 o_conv.inner = (void*)(o & (~1));
9801 o_conv.is_owned = (o & 1) || (o == 0);
9802 o_conv = FundingCreated_clone(&o_conv);
9803 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
9804 *ret_conv = CResult_FundingCreatedDecodeErrorZ_ok(o_conv);
9805 return (uint64_t)ret_conv;
9808 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_err(uint32_t e) {
9809 LDKDecodeError e_conv;
9810 e_conv.inner = (void*)(e & (~1));
9811 e_conv.is_owned = (e & 1) || (e == 0);
9812 e_conv = DecodeError_clone(&e_conv);
9813 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
9814 *ret_conv = CResult_FundingCreatedDecodeErrorZ_err(e_conv);
9815 return (uint64_t)ret_conv;
9818 void __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_free(uint32_t _res) {
9819 if ((_res & 1) != 0) return;
9820 LDKCResult_FundingCreatedDecodeErrorZ _res_conv = *(LDKCResult_FundingCreatedDecodeErrorZ*)(((uint64_t)_res) & ~1);
9822 CResult_FundingCreatedDecodeErrorZ_free(_res_conv);
9825 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingCreatedDecodeErrorZ_clone(uint32_t orig) {
9826 LDKCResult_FundingCreatedDecodeErrorZ* orig_conv = (LDKCResult_FundingCreatedDecodeErrorZ*)(orig & ~1);
9827 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
9828 *ret_conv = CResult_FundingCreatedDecodeErrorZ_clone(orig_conv);
9829 return (uint64_t)ret_conv;
9832 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_ok(uint32_t o) {
9833 LDKFundingSigned o_conv;
9834 o_conv.inner = (void*)(o & (~1));
9835 o_conv.is_owned = (o & 1) || (o == 0);
9836 o_conv = FundingSigned_clone(&o_conv);
9837 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
9838 *ret_conv = CResult_FundingSignedDecodeErrorZ_ok(o_conv);
9839 return (uint64_t)ret_conv;
9842 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_err(uint32_t e) {
9843 LDKDecodeError e_conv;
9844 e_conv.inner = (void*)(e & (~1));
9845 e_conv.is_owned = (e & 1) || (e == 0);
9846 e_conv = DecodeError_clone(&e_conv);
9847 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
9848 *ret_conv = CResult_FundingSignedDecodeErrorZ_err(e_conv);
9849 return (uint64_t)ret_conv;
9852 void __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_free(uint32_t _res) {
9853 if ((_res & 1) != 0) return;
9854 LDKCResult_FundingSignedDecodeErrorZ _res_conv = *(LDKCResult_FundingSignedDecodeErrorZ*)(((uint64_t)_res) & ~1);
9856 CResult_FundingSignedDecodeErrorZ_free(_res_conv);
9859 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingSignedDecodeErrorZ_clone(uint32_t orig) {
9860 LDKCResult_FundingSignedDecodeErrorZ* orig_conv = (LDKCResult_FundingSignedDecodeErrorZ*)(orig & ~1);
9861 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
9862 *ret_conv = CResult_FundingSignedDecodeErrorZ_clone(orig_conv);
9863 return (uint64_t)ret_conv;
9866 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_ok(uint32_t o) {
9867 LDKFundingLocked o_conv;
9868 o_conv.inner = (void*)(o & (~1));
9869 o_conv.is_owned = (o & 1) || (o == 0);
9870 o_conv = FundingLocked_clone(&o_conv);
9871 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
9872 *ret_conv = CResult_FundingLockedDecodeErrorZ_ok(o_conv);
9873 return (uint64_t)ret_conv;
9876 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_err(uint32_t e) {
9877 LDKDecodeError e_conv;
9878 e_conv.inner = (void*)(e & (~1));
9879 e_conv.is_owned = (e & 1) || (e == 0);
9880 e_conv = DecodeError_clone(&e_conv);
9881 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
9882 *ret_conv = CResult_FundingLockedDecodeErrorZ_err(e_conv);
9883 return (uint64_t)ret_conv;
9886 void __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_free(uint32_t _res) {
9887 if ((_res & 1) != 0) return;
9888 LDKCResult_FundingLockedDecodeErrorZ _res_conv = *(LDKCResult_FundingLockedDecodeErrorZ*)(((uint64_t)_res) & ~1);
9890 CResult_FundingLockedDecodeErrorZ_free(_res_conv);
9893 uint32_t __attribute__((visibility("default"))) TS_CResult_FundingLockedDecodeErrorZ_clone(uint32_t orig) {
9894 LDKCResult_FundingLockedDecodeErrorZ* orig_conv = (LDKCResult_FundingLockedDecodeErrorZ*)(orig & ~1);
9895 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
9896 *ret_conv = CResult_FundingLockedDecodeErrorZ_clone(orig_conv);
9897 return (uint64_t)ret_conv;
9900 uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_ok(uint32_t o) {
9902 o_conv.inner = (void*)(o & (~1));
9903 o_conv.is_owned = (o & 1) || (o == 0);
9904 o_conv = Init_clone(&o_conv);
9905 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
9906 *ret_conv = CResult_InitDecodeErrorZ_ok(o_conv);
9907 return (uint64_t)ret_conv;
9910 uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_err(uint32_t e) {
9911 LDKDecodeError e_conv;
9912 e_conv.inner = (void*)(e & (~1));
9913 e_conv.is_owned = (e & 1) || (e == 0);
9914 e_conv = DecodeError_clone(&e_conv);
9915 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
9916 *ret_conv = CResult_InitDecodeErrorZ_err(e_conv);
9917 return (uint64_t)ret_conv;
9920 void __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_free(uint32_t _res) {
9921 if ((_res & 1) != 0) return;
9922 LDKCResult_InitDecodeErrorZ _res_conv = *(LDKCResult_InitDecodeErrorZ*)(((uint64_t)_res) & ~1);
9924 CResult_InitDecodeErrorZ_free(_res_conv);
9927 uint32_t __attribute__((visibility("default"))) TS_CResult_InitDecodeErrorZ_clone(uint32_t orig) {
9928 LDKCResult_InitDecodeErrorZ* orig_conv = (LDKCResult_InitDecodeErrorZ*)(orig & ~1);
9929 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
9930 *ret_conv = CResult_InitDecodeErrorZ_clone(orig_conv);
9931 return (uint64_t)ret_conv;
9934 uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_ok(uint32_t o) {
9935 LDKOpenChannel o_conv;
9936 o_conv.inner = (void*)(o & (~1));
9937 o_conv.is_owned = (o & 1) || (o == 0);
9938 o_conv = OpenChannel_clone(&o_conv);
9939 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9940 *ret_conv = CResult_OpenChannelDecodeErrorZ_ok(o_conv);
9941 return (uint64_t)ret_conv;
9944 uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_err(uint32_t e) {
9945 LDKDecodeError e_conv;
9946 e_conv.inner = (void*)(e & (~1));
9947 e_conv.is_owned = (e & 1) || (e == 0);
9948 e_conv = DecodeError_clone(&e_conv);
9949 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9950 *ret_conv = CResult_OpenChannelDecodeErrorZ_err(e_conv);
9951 return (uint64_t)ret_conv;
9954 void __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_free(uint32_t _res) {
9955 if ((_res & 1) != 0) return;
9956 LDKCResult_OpenChannelDecodeErrorZ _res_conv = *(LDKCResult_OpenChannelDecodeErrorZ*)(((uint64_t)_res) & ~1);
9958 CResult_OpenChannelDecodeErrorZ_free(_res_conv);
9961 uint32_t __attribute__((visibility("default"))) TS_CResult_OpenChannelDecodeErrorZ_clone(uint32_t orig) {
9962 LDKCResult_OpenChannelDecodeErrorZ* orig_conv = (LDKCResult_OpenChannelDecodeErrorZ*)(orig & ~1);
9963 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
9964 *ret_conv = CResult_OpenChannelDecodeErrorZ_clone(orig_conv);
9965 return (uint64_t)ret_conv;
9968 uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_ok(uint32_t o) {
9969 LDKRevokeAndACK o_conv;
9970 o_conv.inner = (void*)(o & (~1));
9971 o_conv.is_owned = (o & 1) || (o == 0);
9972 o_conv = RevokeAndACK_clone(&o_conv);
9973 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9974 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_ok(o_conv);
9975 return (uint64_t)ret_conv;
9978 uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_err(uint32_t e) {
9979 LDKDecodeError e_conv;
9980 e_conv.inner = (void*)(e & (~1));
9981 e_conv.is_owned = (e & 1) || (e == 0);
9982 e_conv = DecodeError_clone(&e_conv);
9983 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9984 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_err(e_conv);
9985 return (uint64_t)ret_conv;
9988 void __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_free(uint32_t _res) {
9989 if ((_res & 1) != 0) return;
9990 LDKCResult_RevokeAndACKDecodeErrorZ _res_conv = *(LDKCResult_RevokeAndACKDecodeErrorZ*)(((uint64_t)_res) & ~1);
9992 CResult_RevokeAndACKDecodeErrorZ_free(_res_conv);
9995 uint32_t __attribute__((visibility("default"))) TS_CResult_RevokeAndACKDecodeErrorZ_clone(uint32_t orig) {
9996 LDKCResult_RevokeAndACKDecodeErrorZ* orig_conv = (LDKCResult_RevokeAndACKDecodeErrorZ*)(orig & ~1);
9997 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
9998 *ret_conv = CResult_RevokeAndACKDecodeErrorZ_clone(orig_conv);
9999 return (uint64_t)ret_conv;
10002 uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_ok(uint32_t o) {
10003 LDKShutdown o_conv;
10004 o_conv.inner = (void*)(o & (~1));
10005 o_conv.is_owned = (o & 1) || (o == 0);
10006 o_conv = Shutdown_clone(&o_conv);
10007 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
10008 *ret_conv = CResult_ShutdownDecodeErrorZ_ok(o_conv);
10009 return (uint64_t)ret_conv;
10012 uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_err(uint32_t e) {
10013 LDKDecodeError e_conv;
10014 e_conv.inner = (void*)(e & (~1));
10015 e_conv.is_owned = (e & 1) || (e == 0);
10016 e_conv = DecodeError_clone(&e_conv);
10017 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
10018 *ret_conv = CResult_ShutdownDecodeErrorZ_err(e_conv);
10019 return (uint64_t)ret_conv;
10022 void __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_free(uint32_t _res) {
10023 if ((_res & 1) != 0) return;
10024 LDKCResult_ShutdownDecodeErrorZ _res_conv = *(LDKCResult_ShutdownDecodeErrorZ*)(((uint64_t)_res) & ~1);
10026 CResult_ShutdownDecodeErrorZ_free(_res_conv);
10029 uint32_t __attribute__((visibility("default"))) TS_CResult_ShutdownDecodeErrorZ_clone(uint32_t orig) {
10030 LDKCResult_ShutdownDecodeErrorZ* orig_conv = (LDKCResult_ShutdownDecodeErrorZ*)(orig & ~1);
10031 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
10032 *ret_conv = CResult_ShutdownDecodeErrorZ_clone(orig_conv);
10033 return (uint64_t)ret_conv;
10036 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_ok(uint32_t o) {
10037 LDKUpdateFailHTLC o_conv;
10038 o_conv.inner = (void*)(o & (~1));
10039 o_conv.is_owned = (o & 1) || (o == 0);
10040 o_conv = UpdateFailHTLC_clone(&o_conv);
10041 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
10042 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_ok(o_conv);
10043 return (uint64_t)ret_conv;
10046 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_err(uint32_t e) {
10047 LDKDecodeError e_conv;
10048 e_conv.inner = (void*)(e & (~1));
10049 e_conv.is_owned = (e & 1) || (e == 0);
10050 e_conv = DecodeError_clone(&e_conv);
10051 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
10052 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_err(e_conv);
10053 return (uint64_t)ret_conv;
10056 void __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_free(uint32_t _res) {
10057 if ((_res & 1) != 0) return;
10058 LDKCResult_UpdateFailHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
10060 CResult_UpdateFailHTLCDecodeErrorZ_free(_res_conv);
10063 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailHTLCDecodeErrorZ_clone(uint32_t orig) {
10064 LDKCResult_UpdateFailHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailHTLCDecodeErrorZ*)(orig & ~1);
10065 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
10066 *ret_conv = CResult_UpdateFailHTLCDecodeErrorZ_clone(orig_conv);
10067 return (uint64_t)ret_conv;
10070 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(uint32_t o) {
10071 LDKUpdateFailMalformedHTLC o_conv;
10072 o_conv.inner = (void*)(o & (~1));
10073 o_conv.is_owned = (o & 1) || (o == 0);
10074 o_conv = UpdateFailMalformedHTLC_clone(&o_conv);
10075 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
10076 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_ok(o_conv);
10077 return (uint64_t)ret_conv;
10080 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(uint32_t e) {
10081 LDKDecodeError e_conv;
10082 e_conv.inner = (void*)(e & (~1));
10083 e_conv.is_owned = (e & 1) || (e == 0);
10084 e_conv = DecodeError_clone(&e_conv);
10085 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
10086 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_err(e_conv);
10087 return (uint64_t)ret_conv;
10090 void __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(uint32_t _res) {
10091 if ((_res & 1) != 0) return;
10092 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
10094 CResult_UpdateFailMalformedHTLCDecodeErrorZ_free(_res_conv);
10097 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(uint32_t orig) {
10098 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ*)(orig & ~1);
10099 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
10100 *ret_conv = CResult_UpdateFailMalformedHTLCDecodeErrorZ_clone(orig_conv);
10101 return (uint64_t)ret_conv;
10104 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_ok(uint32_t o) {
10105 LDKUpdateFee o_conv;
10106 o_conv.inner = (void*)(o & (~1));
10107 o_conv.is_owned = (o & 1) || (o == 0);
10108 o_conv = UpdateFee_clone(&o_conv);
10109 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
10110 *ret_conv = CResult_UpdateFeeDecodeErrorZ_ok(o_conv);
10111 return (uint64_t)ret_conv;
10114 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_err(uint32_t e) {
10115 LDKDecodeError e_conv;
10116 e_conv.inner = (void*)(e & (~1));
10117 e_conv.is_owned = (e & 1) || (e == 0);
10118 e_conv = DecodeError_clone(&e_conv);
10119 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
10120 *ret_conv = CResult_UpdateFeeDecodeErrorZ_err(e_conv);
10121 return (uint64_t)ret_conv;
10124 void __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_free(uint32_t _res) {
10125 if ((_res & 1) != 0) return;
10126 LDKCResult_UpdateFeeDecodeErrorZ _res_conv = *(LDKCResult_UpdateFeeDecodeErrorZ*)(((uint64_t)_res) & ~1);
10128 CResult_UpdateFeeDecodeErrorZ_free(_res_conv);
10131 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFeeDecodeErrorZ_clone(uint32_t orig) {
10132 LDKCResult_UpdateFeeDecodeErrorZ* orig_conv = (LDKCResult_UpdateFeeDecodeErrorZ*)(orig & ~1);
10133 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
10134 *ret_conv = CResult_UpdateFeeDecodeErrorZ_clone(orig_conv);
10135 return (uint64_t)ret_conv;
10138 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_ok(uint32_t o) {
10139 LDKUpdateFulfillHTLC o_conv;
10140 o_conv.inner = (void*)(o & (~1));
10141 o_conv.is_owned = (o & 1) || (o == 0);
10142 o_conv = UpdateFulfillHTLC_clone(&o_conv);
10143 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
10144 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_ok(o_conv);
10145 return (uint64_t)ret_conv;
10148 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_err(uint32_t e) {
10149 LDKDecodeError e_conv;
10150 e_conv.inner = (void*)(e & (~1));
10151 e_conv.is_owned = (e & 1) || (e == 0);
10152 e_conv = DecodeError_clone(&e_conv);
10153 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
10154 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_err(e_conv);
10155 return (uint64_t)ret_conv;
10158 void __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_free(uint32_t _res) {
10159 if ((_res & 1) != 0) return;
10160 LDKCResult_UpdateFulfillHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
10162 CResult_UpdateFulfillHTLCDecodeErrorZ_free(_res_conv);
10165 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateFulfillHTLCDecodeErrorZ_clone(uint32_t orig) {
10166 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateFulfillHTLCDecodeErrorZ*)(orig & ~1);
10167 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
10168 *ret_conv = CResult_UpdateFulfillHTLCDecodeErrorZ_clone(orig_conv);
10169 return (uint64_t)ret_conv;
10172 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_ok(uint32_t o) {
10173 LDKUpdateAddHTLC o_conv;
10174 o_conv.inner = (void*)(o & (~1));
10175 o_conv.is_owned = (o & 1) || (o == 0);
10176 o_conv = UpdateAddHTLC_clone(&o_conv);
10177 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
10178 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_ok(o_conv);
10179 return (uint64_t)ret_conv;
10182 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_err(uint32_t e) {
10183 LDKDecodeError e_conv;
10184 e_conv.inner = (void*)(e & (~1));
10185 e_conv.is_owned = (e & 1) || (e == 0);
10186 e_conv = DecodeError_clone(&e_conv);
10187 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
10188 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_err(e_conv);
10189 return (uint64_t)ret_conv;
10192 void __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_free(uint32_t _res) {
10193 if ((_res & 1) != 0) return;
10194 LDKCResult_UpdateAddHTLCDecodeErrorZ _res_conv = *(LDKCResult_UpdateAddHTLCDecodeErrorZ*)(((uint64_t)_res) & ~1);
10196 CResult_UpdateAddHTLCDecodeErrorZ_free(_res_conv);
10199 uint32_t __attribute__((visibility("default"))) TS_CResult_UpdateAddHTLCDecodeErrorZ_clone(uint32_t orig) {
10200 LDKCResult_UpdateAddHTLCDecodeErrorZ* orig_conv = (LDKCResult_UpdateAddHTLCDecodeErrorZ*)(orig & ~1);
10201 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
10202 *ret_conv = CResult_UpdateAddHTLCDecodeErrorZ_clone(orig_conv);
10203 return (uint64_t)ret_conv;
10206 uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_ok(uint32_t o) {
10208 o_conv.inner = (void*)(o & (~1));
10209 o_conv.is_owned = (o & 1) || (o == 0);
10210 o_conv = Ping_clone(&o_conv);
10211 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
10212 *ret_conv = CResult_PingDecodeErrorZ_ok(o_conv);
10213 return (uint64_t)ret_conv;
10216 uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_err(uint32_t e) {
10217 LDKDecodeError e_conv;
10218 e_conv.inner = (void*)(e & (~1));
10219 e_conv.is_owned = (e & 1) || (e == 0);
10220 e_conv = DecodeError_clone(&e_conv);
10221 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
10222 *ret_conv = CResult_PingDecodeErrorZ_err(e_conv);
10223 return (uint64_t)ret_conv;
10226 void __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_free(uint32_t _res) {
10227 if ((_res & 1) != 0) return;
10228 LDKCResult_PingDecodeErrorZ _res_conv = *(LDKCResult_PingDecodeErrorZ*)(((uint64_t)_res) & ~1);
10230 CResult_PingDecodeErrorZ_free(_res_conv);
10233 uint32_t __attribute__((visibility("default"))) TS_CResult_PingDecodeErrorZ_clone(uint32_t orig) {
10234 LDKCResult_PingDecodeErrorZ* orig_conv = (LDKCResult_PingDecodeErrorZ*)(orig & ~1);
10235 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
10236 *ret_conv = CResult_PingDecodeErrorZ_clone(orig_conv);
10237 return (uint64_t)ret_conv;
10240 uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_ok(uint32_t o) {
10242 o_conv.inner = (void*)(o & (~1));
10243 o_conv.is_owned = (o & 1) || (o == 0);
10244 o_conv = Pong_clone(&o_conv);
10245 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
10246 *ret_conv = CResult_PongDecodeErrorZ_ok(o_conv);
10247 return (uint64_t)ret_conv;
10250 uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_err(uint32_t e) {
10251 LDKDecodeError e_conv;
10252 e_conv.inner = (void*)(e & (~1));
10253 e_conv.is_owned = (e & 1) || (e == 0);
10254 e_conv = DecodeError_clone(&e_conv);
10255 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
10256 *ret_conv = CResult_PongDecodeErrorZ_err(e_conv);
10257 return (uint64_t)ret_conv;
10260 void __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_free(uint32_t _res) {
10261 if ((_res & 1) != 0) return;
10262 LDKCResult_PongDecodeErrorZ _res_conv = *(LDKCResult_PongDecodeErrorZ*)(((uint64_t)_res) & ~1);
10264 CResult_PongDecodeErrorZ_free(_res_conv);
10267 uint32_t __attribute__((visibility("default"))) TS_CResult_PongDecodeErrorZ_clone(uint32_t orig) {
10268 LDKCResult_PongDecodeErrorZ* orig_conv = (LDKCResult_PongDecodeErrorZ*)(orig & ~1);
10269 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
10270 *ret_conv = CResult_PongDecodeErrorZ_clone(orig_conv);
10271 return (uint64_t)ret_conv;
10274 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
10275 LDKUnsignedChannelAnnouncement o_conv;
10276 o_conv.inner = (void*)(o & (~1));
10277 o_conv.is_owned = (o & 1) || (o == 0);
10278 o_conv = UnsignedChannelAnnouncement_clone(&o_conv);
10279 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
10280 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_ok(o_conv);
10281 return (uint64_t)ret_conv;
10284 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
10285 LDKDecodeError e_conv;
10286 e_conv.inner = (void*)(e & (~1));
10287 e_conv.is_owned = (e & 1) || (e == 0);
10288 e_conv = DecodeError_clone(&e_conv);
10289 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
10290 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_err(e_conv);
10291 return (uint64_t)ret_conv;
10294 void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
10295 if ((_res & 1) != 0) return;
10296 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
10298 CResult_UnsignedChannelAnnouncementDecodeErrorZ_free(_res_conv);
10301 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
10302 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ*)(orig & ~1);
10303 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
10304 *ret_conv = CResult_UnsignedChannelAnnouncementDecodeErrorZ_clone(orig_conv);
10305 return (uint64_t)ret_conv;
10308 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_ok(uint32_t o) {
10309 LDKChannelAnnouncement o_conv;
10310 o_conv.inner = (void*)(o & (~1));
10311 o_conv.is_owned = (o & 1) || (o == 0);
10312 o_conv = ChannelAnnouncement_clone(&o_conv);
10313 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
10314 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_ok(o_conv);
10315 return (uint64_t)ret_conv;
10318 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_err(uint32_t e) {
10319 LDKDecodeError e_conv;
10320 e_conv.inner = (void*)(e & (~1));
10321 e_conv.is_owned = (e & 1) || (e == 0);
10322 e_conv = DecodeError_clone(&e_conv);
10323 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
10324 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_err(e_conv);
10325 return (uint64_t)ret_conv;
10328 void __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_free(uint32_t _res) {
10329 if ((_res & 1) != 0) return;
10330 LDKCResult_ChannelAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_ChannelAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
10332 CResult_ChannelAnnouncementDecodeErrorZ_free(_res_conv);
10335 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelAnnouncementDecodeErrorZ_clone(uint32_t orig) {
10336 LDKCResult_ChannelAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_ChannelAnnouncementDecodeErrorZ*)(orig & ~1);
10337 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
10338 *ret_conv = CResult_ChannelAnnouncementDecodeErrorZ_clone(orig_conv);
10339 return (uint64_t)ret_conv;
10342 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_ok(uint32_t o) {
10343 LDKUnsignedChannelUpdate o_conv;
10344 o_conv.inner = (void*)(o & (~1));
10345 o_conv.is_owned = (o & 1) || (o == 0);
10346 o_conv = UnsignedChannelUpdate_clone(&o_conv);
10347 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
10348 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_ok(o_conv);
10349 return (uint64_t)ret_conv;
10352 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_err(uint32_t e) {
10353 LDKDecodeError e_conv;
10354 e_conv.inner = (void*)(e & (~1));
10355 e_conv.is_owned = (e & 1) || (e == 0);
10356 e_conv = DecodeError_clone(&e_conv);
10357 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
10358 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_err(e_conv);
10359 return (uint64_t)ret_conv;
10362 void __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_free(uint32_t _res) {
10363 if ((_res & 1) != 0) return;
10364 LDKCResult_UnsignedChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
10366 CResult_UnsignedChannelUpdateDecodeErrorZ_free(_res_conv);
10369 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
10370 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_UnsignedChannelUpdateDecodeErrorZ*)(orig & ~1);
10371 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
10372 *ret_conv = CResult_UnsignedChannelUpdateDecodeErrorZ_clone(orig_conv);
10373 return (uint64_t)ret_conv;
10376 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_ok(uint32_t o) {
10377 LDKChannelUpdate o_conv;
10378 o_conv.inner = (void*)(o & (~1));
10379 o_conv.is_owned = (o & 1) || (o == 0);
10380 o_conv = ChannelUpdate_clone(&o_conv);
10381 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
10382 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_ok(o_conv);
10383 return (uint64_t)ret_conv;
10386 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_err(uint32_t e) {
10387 LDKDecodeError e_conv;
10388 e_conv.inner = (void*)(e & (~1));
10389 e_conv.is_owned = (e & 1) || (e == 0);
10390 e_conv = DecodeError_clone(&e_conv);
10391 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
10392 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_err(e_conv);
10393 return (uint64_t)ret_conv;
10396 void __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_free(uint32_t _res) {
10397 if ((_res & 1) != 0) return;
10398 LDKCResult_ChannelUpdateDecodeErrorZ _res_conv = *(LDKCResult_ChannelUpdateDecodeErrorZ*)(((uint64_t)_res) & ~1);
10400 CResult_ChannelUpdateDecodeErrorZ_free(_res_conv);
10403 uint32_t __attribute__((visibility("default"))) TS_CResult_ChannelUpdateDecodeErrorZ_clone(uint32_t orig) {
10404 LDKCResult_ChannelUpdateDecodeErrorZ* orig_conv = (LDKCResult_ChannelUpdateDecodeErrorZ*)(orig & ~1);
10405 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
10406 *ret_conv = CResult_ChannelUpdateDecodeErrorZ_clone(orig_conv);
10407 return (uint64_t)ret_conv;
10410 uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_ok(uint32_t o) {
10411 LDKErrorMessage o_conv;
10412 o_conv.inner = (void*)(o & (~1));
10413 o_conv.is_owned = (o & 1) || (o == 0);
10414 o_conv = ErrorMessage_clone(&o_conv);
10415 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
10416 *ret_conv = CResult_ErrorMessageDecodeErrorZ_ok(o_conv);
10417 return (uint64_t)ret_conv;
10420 uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_err(uint32_t e) {
10421 LDKDecodeError e_conv;
10422 e_conv.inner = (void*)(e & (~1));
10423 e_conv.is_owned = (e & 1) || (e == 0);
10424 e_conv = DecodeError_clone(&e_conv);
10425 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
10426 *ret_conv = CResult_ErrorMessageDecodeErrorZ_err(e_conv);
10427 return (uint64_t)ret_conv;
10430 void __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_free(uint32_t _res) {
10431 if ((_res & 1) != 0) return;
10432 LDKCResult_ErrorMessageDecodeErrorZ _res_conv = *(LDKCResult_ErrorMessageDecodeErrorZ*)(((uint64_t)_res) & ~1);
10434 CResult_ErrorMessageDecodeErrorZ_free(_res_conv);
10437 uint32_t __attribute__((visibility("default"))) TS_CResult_ErrorMessageDecodeErrorZ_clone(uint32_t orig) {
10438 LDKCResult_ErrorMessageDecodeErrorZ* orig_conv = (LDKCResult_ErrorMessageDecodeErrorZ*)(orig & ~1);
10439 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
10440 *ret_conv = CResult_ErrorMessageDecodeErrorZ_clone(orig_conv);
10441 return (uint64_t)ret_conv;
10444 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
10445 LDKUnsignedNodeAnnouncement o_conv;
10446 o_conv.inner = (void*)(o & (~1));
10447 o_conv.is_owned = (o & 1) || (o == 0);
10448 o_conv = UnsignedNodeAnnouncement_clone(&o_conv);
10449 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
10450 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_ok(o_conv);
10451 return (uint64_t)ret_conv;
10454 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(uint32_t e) {
10455 LDKDecodeError e_conv;
10456 e_conv.inner = (void*)(e & (~1));
10457 e_conv.is_owned = (e & 1) || (e == 0);
10458 e_conv = DecodeError_clone(&e_conv);
10459 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
10460 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_err(e_conv);
10461 return (uint64_t)ret_conv;
10464 void __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
10465 if ((_res & 1) != 0) return;
10466 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
10468 CResult_UnsignedNodeAnnouncementDecodeErrorZ_free(_res_conv);
10471 uint32_t __attribute__((visibility("default"))) TS_CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
10472 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ*)(orig & ~1);
10473 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
10474 *ret_conv = CResult_UnsignedNodeAnnouncementDecodeErrorZ_clone(orig_conv);
10475 return (uint64_t)ret_conv;
10478 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_ok(uint32_t o) {
10479 LDKNodeAnnouncement o_conv;
10480 o_conv.inner = (void*)(o & (~1));
10481 o_conv.is_owned = (o & 1) || (o == 0);
10482 o_conv = NodeAnnouncement_clone(&o_conv);
10483 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
10484 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_ok(o_conv);
10485 return (uint64_t)ret_conv;
10488 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_err(uint32_t e) {
10489 LDKDecodeError e_conv;
10490 e_conv.inner = (void*)(e & (~1));
10491 e_conv.is_owned = (e & 1) || (e == 0);
10492 e_conv = DecodeError_clone(&e_conv);
10493 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
10494 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_err(e_conv);
10495 return (uint64_t)ret_conv;
10498 void __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_free(uint32_t _res) {
10499 if ((_res & 1) != 0) return;
10500 LDKCResult_NodeAnnouncementDecodeErrorZ _res_conv = *(LDKCResult_NodeAnnouncementDecodeErrorZ*)(((uint64_t)_res) & ~1);
10502 CResult_NodeAnnouncementDecodeErrorZ_free(_res_conv);
10505 uint32_t __attribute__((visibility("default"))) TS_CResult_NodeAnnouncementDecodeErrorZ_clone(uint32_t orig) {
10506 LDKCResult_NodeAnnouncementDecodeErrorZ* orig_conv = (LDKCResult_NodeAnnouncementDecodeErrorZ*)(orig & ~1);
10507 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
10508 *ret_conv = CResult_NodeAnnouncementDecodeErrorZ_clone(orig_conv);
10509 return (uint64_t)ret_conv;
10512 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_ok(uint32_t o) {
10513 LDKQueryShortChannelIds o_conv;
10514 o_conv.inner = (void*)(o & (~1));
10515 o_conv.is_owned = (o & 1) || (o == 0);
10516 o_conv = QueryShortChannelIds_clone(&o_conv);
10517 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
10518 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_ok(o_conv);
10519 return (uint64_t)ret_conv;
10522 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_err(uint32_t e) {
10523 LDKDecodeError e_conv;
10524 e_conv.inner = (void*)(e & (~1));
10525 e_conv.is_owned = (e & 1) || (e == 0);
10526 e_conv = DecodeError_clone(&e_conv);
10527 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
10528 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_err(e_conv);
10529 return (uint64_t)ret_conv;
10532 void __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_free(uint32_t _res) {
10533 if ((_res & 1) != 0) return;
10534 LDKCResult_QueryShortChannelIdsDecodeErrorZ _res_conv = *(LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(((uint64_t)_res) & ~1);
10536 CResult_QueryShortChannelIdsDecodeErrorZ_free(_res_conv);
10539 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryShortChannelIdsDecodeErrorZ_clone(uint32_t orig) {
10540 LDKCResult_QueryShortChannelIdsDecodeErrorZ* orig_conv = (LDKCResult_QueryShortChannelIdsDecodeErrorZ*)(orig & ~1);
10541 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
10542 *ret_conv = CResult_QueryShortChannelIdsDecodeErrorZ_clone(orig_conv);
10543 return (uint64_t)ret_conv;
10546 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(uint32_t o) {
10547 LDKReplyShortChannelIdsEnd o_conv;
10548 o_conv.inner = (void*)(o & (~1));
10549 o_conv.is_owned = (o & 1) || (o == 0);
10550 o_conv = ReplyShortChannelIdsEnd_clone(&o_conv);
10551 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
10552 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_ok(o_conv);
10553 return (uint64_t)ret_conv;
10556 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(uint32_t e) {
10557 LDKDecodeError e_conv;
10558 e_conv.inner = (void*)(e & (~1));
10559 e_conv.is_owned = (e & 1) || (e == 0);
10560 e_conv = DecodeError_clone(&e_conv);
10561 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
10562 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_err(e_conv);
10563 return (uint64_t)ret_conv;
10566 void __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(uint32_t _res) {
10567 if ((_res & 1) != 0) return;
10568 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ _res_conv = *(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(((uint64_t)_res) & ~1);
10570 CResult_ReplyShortChannelIdsEndDecodeErrorZ_free(_res_conv);
10573 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(uint32_t orig) {
10574 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* orig_conv = (LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ*)(orig & ~1);
10575 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
10576 *ret_conv = CResult_ReplyShortChannelIdsEndDecodeErrorZ_clone(orig_conv);
10577 return (uint64_t)ret_conv;
10580 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_ok(uint32_t o) {
10581 LDKQueryChannelRange o_conv;
10582 o_conv.inner = (void*)(o & (~1));
10583 o_conv.is_owned = (o & 1) || (o == 0);
10584 o_conv = QueryChannelRange_clone(&o_conv);
10585 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
10586 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_ok(o_conv);
10587 return (uint64_t)ret_conv;
10590 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_err(uint32_t e) {
10591 LDKDecodeError e_conv;
10592 e_conv.inner = (void*)(e & (~1));
10593 e_conv.is_owned = (e & 1) || (e == 0);
10594 e_conv = DecodeError_clone(&e_conv);
10595 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
10596 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_err(e_conv);
10597 return (uint64_t)ret_conv;
10600 void __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_free(uint32_t _res) {
10601 if ((_res & 1) != 0) return;
10602 LDKCResult_QueryChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_QueryChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
10604 CResult_QueryChannelRangeDecodeErrorZ_free(_res_conv);
10607 uint32_t __attribute__((visibility("default"))) TS_CResult_QueryChannelRangeDecodeErrorZ_clone(uint32_t orig) {
10608 LDKCResult_QueryChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_QueryChannelRangeDecodeErrorZ*)(orig & ~1);
10609 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
10610 *ret_conv = CResult_QueryChannelRangeDecodeErrorZ_clone(orig_conv);
10611 return (uint64_t)ret_conv;
10614 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_ok(uint32_t o) {
10615 LDKReplyChannelRange o_conv;
10616 o_conv.inner = (void*)(o & (~1));
10617 o_conv.is_owned = (o & 1) || (o == 0);
10618 o_conv = ReplyChannelRange_clone(&o_conv);
10619 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
10620 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_ok(o_conv);
10621 return (uint64_t)ret_conv;
10624 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_err(uint32_t e) {
10625 LDKDecodeError e_conv;
10626 e_conv.inner = (void*)(e & (~1));
10627 e_conv.is_owned = (e & 1) || (e == 0);
10628 e_conv = DecodeError_clone(&e_conv);
10629 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
10630 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_err(e_conv);
10631 return (uint64_t)ret_conv;
10634 void __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_free(uint32_t _res) {
10635 if ((_res & 1) != 0) return;
10636 LDKCResult_ReplyChannelRangeDecodeErrorZ _res_conv = *(LDKCResult_ReplyChannelRangeDecodeErrorZ*)(((uint64_t)_res) & ~1);
10638 CResult_ReplyChannelRangeDecodeErrorZ_free(_res_conv);
10641 uint32_t __attribute__((visibility("default"))) TS_CResult_ReplyChannelRangeDecodeErrorZ_clone(uint32_t orig) {
10642 LDKCResult_ReplyChannelRangeDecodeErrorZ* orig_conv = (LDKCResult_ReplyChannelRangeDecodeErrorZ*)(orig & ~1);
10643 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
10644 *ret_conv = CResult_ReplyChannelRangeDecodeErrorZ_clone(orig_conv);
10645 return (uint64_t)ret_conv;
10648 uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_ok(uint32_t o) {
10649 LDKGossipTimestampFilter o_conv;
10650 o_conv.inner = (void*)(o & (~1));
10651 o_conv.is_owned = (o & 1) || (o == 0);
10652 o_conv = GossipTimestampFilter_clone(&o_conv);
10653 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
10654 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_ok(o_conv);
10655 return (uint64_t)ret_conv;
10658 uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_err(uint32_t e) {
10659 LDKDecodeError e_conv;
10660 e_conv.inner = (void*)(e & (~1));
10661 e_conv.is_owned = (e & 1) || (e == 0);
10662 e_conv = DecodeError_clone(&e_conv);
10663 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
10664 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_err(e_conv);
10665 return (uint64_t)ret_conv;
10668 void __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_free(uint32_t _res) {
10669 if ((_res & 1) != 0) return;
10670 LDKCResult_GossipTimestampFilterDecodeErrorZ _res_conv = *(LDKCResult_GossipTimestampFilterDecodeErrorZ*)(((uint64_t)_res) & ~1);
10672 CResult_GossipTimestampFilterDecodeErrorZ_free(_res_conv);
10675 uint32_t __attribute__((visibility("default"))) TS_CResult_GossipTimestampFilterDecodeErrorZ_clone(uint32_t orig) {
10676 LDKCResult_GossipTimestampFilterDecodeErrorZ* orig_conv = (LDKCResult_GossipTimestampFilterDecodeErrorZ*)(orig & ~1);
10677 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
10678 *ret_conv = CResult_GossipTimestampFilterDecodeErrorZ_clone(orig_conv);
10679 return (uint64_t)ret_conv;
10682 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_ok(uint32_t o) {
10684 o_conv.inner = (void*)(o & (~1));
10685 o_conv.is_owned = (o & 1) || (o == 0);
10686 o_conv = Invoice_clone(&o_conv);
10687 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
10688 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_ok(o_conv);
10689 return (uint64_t)ret_conv;
10692 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint32_t e) {
10693 LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(((uint64_t)e) & ~1);
10694 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
10695 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv);
10696 return (uint64_t)ret_conv;
10699 void __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_free(uint32_t _res) {
10700 if ((_res & 1) != 0) return;
10701 LDKCResult_InvoiceSignOrCreationErrorZ _res_conv = *(LDKCResult_InvoiceSignOrCreationErrorZ*)(((uint64_t)_res) & ~1);
10703 CResult_InvoiceSignOrCreationErrorZ_free(_res_conv);
10706 uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_clone(uint32_t orig) {
10707 LDKCResult_InvoiceSignOrCreationErrorZ* orig_conv = (LDKCResult_InvoiceSignOrCreationErrorZ*)(orig & ~1);
10708 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
10709 *ret_conv = CResult_InvoiceSignOrCreationErrorZ_clone(orig_conv);
10710 return (uint64_t)ret_conv;
10713 void __attribute__((visibility("default"))) TS_Event_free(uint32_t this_ptr) {
10714 if ((this_ptr & 1) != 0) return;
10715 LDKEvent this_ptr_conv = *(LDKEvent*)(((uint64_t)this_ptr) & ~1);
10716 FREE((void*)this_ptr);
10717 Event_free(this_ptr_conv);
10720 uint32_t __attribute__((visibility("default"))) TS_Event_clone(uint32_t orig) {
10721 LDKEvent* orig_conv = (LDKEvent*)orig;
10722 LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
10723 *ret_copy = Event_clone(orig_conv);
10724 uint64_t ret_ref = (uint64_t)ret_copy;
10728 int8_tArray __attribute__((visibility("default"))) TS_Event_write(uint32_t obj) {
10729 LDKEvent* obj_conv = (LDKEvent*)obj;
10730 LDKCVec_u8Z ret_var = Event_write(obj_conv);
10731 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
10732 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
10733 CVec_u8Z_free(ret_var);
10737 void __attribute__((visibility("default"))) TS_MessageSendEvent_free(uint32_t this_ptr) {
10738 if ((this_ptr & 1) != 0) return;
10739 LDKMessageSendEvent this_ptr_conv = *(LDKMessageSendEvent*)(((uint64_t)this_ptr) & ~1);
10740 FREE((void*)this_ptr);
10741 MessageSendEvent_free(this_ptr_conv);
10744 uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_clone(uint32_t orig) {
10745 LDKMessageSendEvent* orig_conv = (LDKMessageSendEvent*)orig;
10746 LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent");
10747 *ret_copy = MessageSendEvent_clone(orig_conv);
10748 uint64_t ret_ref = (uint64_t)ret_copy;
10752 void __attribute__((visibility("default"))) TS_MessageSendEventsProvider_free(uint32_t this_ptr) {
10753 if ((this_ptr & 1) != 0) return;
10754 LDKMessageSendEventsProvider this_ptr_conv = *(LDKMessageSendEventsProvider*)(((uint64_t)this_ptr) & ~1);
10755 FREE((void*)this_ptr);
10756 MessageSendEventsProvider_free(this_ptr_conv);
10759 void __attribute__((visibility("default"))) TS_EventsProvider_free(uint32_t this_ptr) {
10760 if ((this_ptr & 1) != 0) return;
10761 LDKEventsProvider this_ptr_conv = *(LDKEventsProvider*)(((uint64_t)this_ptr) & ~1);
10762 FREE((void*)this_ptr);
10763 EventsProvider_free(this_ptr_conv);
10766 void __attribute__((visibility("default"))) TS_EventHandler_free(uint32_t this_ptr) {
10767 if ((this_ptr & 1) != 0) return;
10768 LDKEventHandler this_ptr_conv = *(LDKEventHandler*)(((uint64_t)this_ptr) & ~1);
10769 FREE((void*)this_ptr);
10770 EventHandler_free(this_ptr_conv);
10773 void __attribute__((visibility("default"))) TS_APIError_free(uint32_t this_ptr) {
10774 if ((this_ptr & 1) != 0) return;
10775 LDKAPIError this_ptr_conv = *(LDKAPIError*)(((uint64_t)this_ptr) & ~1);
10776 FREE((void*)this_ptr);
10777 APIError_free(this_ptr_conv);
10780 uint32_t __attribute__((visibility("default"))) TS_APIError_clone(uint32_t orig) {
10781 LDKAPIError* orig_conv = (LDKAPIError*)orig;
10782 LDKAPIError *ret_copy = MALLOC(sizeof(LDKAPIError), "LDKAPIError");
10783 *ret_copy = APIError_clone(orig_conv);
10784 uint64_t ret_ref = (uint64_t)ret_copy;
10788 uint32_t __attribute__((visibility("default"))) TS_sign(int8_tArray msg, int8_tArray sk) {
10789 LDKu8slice msg_ref;
10790 msg_ref.datalen = *((uint32_t*)msg);
10791 msg_ref.data = (int8_t*)(msg + 4);
10792 unsigned char sk_arr[32];
10793 CHECK(*((uint32_t*)sk) == 32);
10794 memcpy(sk_arr, (uint8_t*)(sk + 4), 32);
10795 unsigned char (*sk_ref)[32] = &sk_arr;
10796 LDKCResult_StringErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StringErrorZ), "LDKCResult_StringErrorZ");
10797 *ret_conv = sign(msg_ref, sk_ref);
10798 return (uint64_t)ret_conv;
10801 uint32_t __attribute__((visibility("default"))) TS_recover_pk(int8_tArray msg, jstring sig) {
10802 LDKu8slice msg_ref;
10803 msg_ref.datalen = *((uint32_t*)msg);
10804 msg_ref.data = (int8_t*)(msg + 4);
10805 LDKStr sig_conv = str_ref_to_owned_c(sig);
10806 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
10807 *ret_conv = recover_pk(msg_ref, sig_conv);
10808 return (uint64_t)ret_conv;
10811 jboolean __attribute__((visibility("default"))) TS_verify(int8_tArray msg, jstring sig, int8_tArray pk) {
10812 LDKu8slice msg_ref;
10813 msg_ref.datalen = *((uint32_t*)msg);
10814 msg_ref.data = (int8_t*)(msg + 4);
10815 LDKStr sig_conv = str_ref_to_owned_c(sig);
10816 LDKPublicKey pk_ref;
10817 CHECK(*((uint32_t*)pk) == 33);
10818 memcpy(pk_ref.compressed_form, (uint8_t*)(pk + 4), 33);
10819 jboolean ret_val = verify(msg_ref, sig_conv, pk_ref);
10823 uint32_t __attribute__((visibility("default"))) TS_Level_clone(uint32_t orig) {
10824 LDKLevel* orig_conv = (LDKLevel*)(orig & ~1);
10825 uint32_t ret_conv = LDKLevel_to_js(Level_clone(orig_conv));
10829 jboolean __attribute__((visibility("default"))) TS_Level_eq(uint32_t a, uint32_t b) {
10830 LDKLevel* a_conv = (LDKLevel*)(a & ~1);
10831 LDKLevel* b_conv = (LDKLevel*)(b & ~1);
10832 jboolean ret_val = Level_eq(a_conv, b_conv);
10836 int64_t __attribute__((visibility("default"))) TS_Level_hash(uint32_t o) {
10837 LDKLevel* o_conv = (LDKLevel*)(o & ~1);
10838 int64_t ret_val = Level_hash(o_conv);
10842 uint32_t __attribute__((visibility("default"))) TS_Level_max() {
10843 uint32_t ret_conv = LDKLevel_to_js(Level_max());
10847 void __attribute__((visibility("default"))) TS_Logger_free(uint32_t this_ptr) {
10848 if ((this_ptr & 1) != 0) return;
10849 LDKLogger this_ptr_conv = *(LDKLogger*)(((uint64_t)this_ptr) & ~1);
10850 FREE((void*)this_ptr);
10851 Logger_free(this_ptr_conv);
10854 void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_free(uint32_t this_obj) {
10855 LDKChannelHandshakeConfig this_obj_conv;
10856 this_obj_conv.inner = (void*)(this_obj & (~1));
10857 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10858 ChannelHandshakeConfig_free(this_obj_conv);
10861 int32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_minimum_depth(uint32_t this_ptr) {
10862 LDKChannelHandshakeConfig this_ptr_conv;
10863 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10864 this_ptr_conv.is_owned = false;
10865 int32_t ret_val = ChannelHandshakeConfig_get_minimum_depth(&this_ptr_conv);
10869 void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_minimum_depth(uint32_t this_ptr, int32_t val) {
10870 LDKChannelHandshakeConfig this_ptr_conv;
10871 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10872 this_ptr_conv.is_owned = false;
10873 ChannelHandshakeConfig_set_minimum_depth(&this_ptr_conv, val);
10876 int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_our_to_self_delay(uint32_t this_ptr) {
10877 LDKChannelHandshakeConfig this_ptr_conv;
10878 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10879 this_ptr_conv.is_owned = false;
10880 int16_t ret_val = ChannelHandshakeConfig_get_our_to_self_delay(&this_ptr_conv);
10884 void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_our_to_self_delay(uint32_t this_ptr, int16_t val) {
10885 LDKChannelHandshakeConfig this_ptr_conv;
10886 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10887 this_ptr_conv.is_owned = false;
10888 ChannelHandshakeConfig_set_our_to_self_delay(&this_ptr_conv, val);
10891 int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_get_our_htlc_minimum_msat(uint32_t this_ptr) {
10892 LDKChannelHandshakeConfig this_ptr_conv;
10893 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10894 this_ptr_conv.is_owned = false;
10895 int64_t ret_val = ChannelHandshakeConfig_get_our_htlc_minimum_msat(&this_ptr_conv);
10899 void __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_set_our_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
10900 LDKChannelHandshakeConfig this_ptr_conv;
10901 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10902 this_ptr_conv.is_owned = false;
10903 ChannelHandshakeConfig_set_our_htlc_minimum_msat(&this_ptr_conv, val);
10906 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_new(int32_t minimum_depth_arg, int16_t our_to_self_delay_arg, int64_t our_htlc_minimum_msat_arg) {
10907 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_new(minimum_depth_arg, our_to_self_delay_arg, our_htlc_minimum_msat_arg);
10908 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10909 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10910 uint64_t ret_ref = (uint64_t)ret_var.inner;
10911 if (ret_var.is_owned) {
10917 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_clone(uint32_t orig) {
10918 LDKChannelHandshakeConfig orig_conv;
10919 orig_conv.inner = (void*)(orig & (~1));
10920 orig_conv.is_owned = false;
10921 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_clone(&orig_conv);
10922 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10923 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10924 uint64_t ret_ref = (uint64_t)ret_var.inner;
10925 if (ret_var.is_owned) {
10931 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeConfig_default() {
10932 LDKChannelHandshakeConfig ret_var = ChannelHandshakeConfig_default();
10933 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
10934 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
10935 uint64_t ret_ref = (uint64_t)ret_var.inner;
10936 if (ret_var.is_owned) {
10942 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_free(uint32_t this_obj) {
10943 LDKChannelHandshakeLimits this_obj_conv;
10944 this_obj_conv.inner = (void*)(this_obj & (~1));
10945 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
10946 ChannelHandshakeLimits_free(this_obj_conv);
10949 int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_funding_satoshis(uint32_t this_ptr) {
10950 LDKChannelHandshakeLimits this_ptr_conv;
10951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10952 this_ptr_conv.is_owned = false;
10953 int64_t ret_val = ChannelHandshakeLimits_get_min_funding_satoshis(&this_ptr_conv);
10957 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_funding_satoshis(uint32_t this_ptr, int64_t val) {
10958 LDKChannelHandshakeLimits this_ptr_conv;
10959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10960 this_ptr_conv.is_owned = false;
10961 ChannelHandshakeLimits_set_min_funding_satoshis(&this_ptr_conv, val);
10964 int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_htlc_minimum_msat(uint32_t this_ptr) {
10965 LDKChannelHandshakeLimits this_ptr_conv;
10966 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10967 this_ptr_conv.is_owned = false;
10968 int64_t ret_val = ChannelHandshakeLimits_get_max_htlc_minimum_msat(&this_ptr_conv);
10972 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
10973 LDKChannelHandshakeLimits this_ptr_conv;
10974 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10975 this_ptr_conv.is_owned = false;
10976 ChannelHandshakeLimits_set_max_htlc_minimum_msat(&this_ptr_conv, val);
10979 int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
10980 LDKChannelHandshakeLimits this_ptr_conv;
10981 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10982 this_ptr_conv.is_owned = false;
10983 int64_t ret_val = ChannelHandshakeLimits_get_min_max_htlc_value_in_flight_msat(&this_ptr_conv);
10987 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
10988 LDKChannelHandshakeLimits this_ptr_conv;
10989 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10990 this_ptr_conv.is_owned = false;
10991 ChannelHandshakeLimits_set_min_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
10994 int64_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_channel_reserve_satoshis(uint32_t this_ptr) {
10995 LDKChannelHandshakeLimits this_ptr_conv;
10996 this_ptr_conv.inner = (void*)(this_ptr & (~1));
10997 this_ptr_conv.is_owned = false;
10998 int64_t ret_val = ChannelHandshakeLimits_get_max_channel_reserve_satoshis(&this_ptr_conv);
11002 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
11003 LDKChannelHandshakeLimits this_ptr_conv;
11004 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11005 this_ptr_conv.is_owned = false;
11006 ChannelHandshakeLimits_set_max_channel_reserve_satoshis(&this_ptr_conv, val);
11009 int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_min_max_accepted_htlcs(uint32_t this_ptr) {
11010 LDKChannelHandshakeLimits this_ptr_conv;
11011 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11012 this_ptr_conv.is_owned = false;
11013 int16_t ret_val = ChannelHandshakeLimits_get_min_max_accepted_htlcs(&this_ptr_conv);
11017 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_min_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
11018 LDKChannelHandshakeLimits this_ptr_conv;
11019 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11020 this_ptr_conv.is_owned = false;
11021 ChannelHandshakeLimits_set_min_max_accepted_htlcs(&this_ptr_conv, val);
11024 int32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_max_minimum_depth(uint32_t this_ptr) {
11025 LDKChannelHandshakeLimits this_ptr_conv;
11026 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11027 this_ptr_conv.is_owned = false;
11028 int32_t ret_val = ChannelHandshakeLimits_get_max_minimum_depth(&this_ptr_conv);
11032 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_max_minimum_depth(uint32_t this_ptr, int32_t val) {
11033 LDKChannelHandshakeLimits this_ptr_conv;
11034 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11035 this_ptr_conv.is_owned = false;
11036 ChannelHandshakeLimits_set_max_minimum_depth(&this_ptr_conv, val);
11039 jboolean __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_force_announced_channel_preference(uint32_t this_ptr) {
11040 LDKChannelHandshakeLimits this_ptr_conv;
11041 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11042 this_ptr_conv.is_owned = false;
11043 jboolean ret_val = ChannelHandshakeLimits_get_force_announced_channel_preference(&this_ptr_conv);
11047 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_force_announced_channel_preference(uint32_t this_ptr, jboolean val) {
11048 LDKChannelHandshakeLimits this_ptr_conv;
11049 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11050 this_ptr_conv.is_owned = false;
11051 ChannelHandshakeLimits_set_force_announced_channel_preference(&this_ptr_conv, val);
11054 int16_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_get_their_to_self_delay(uint32_t this_ptr) {
11055 LDKChannelHandshakeLimits this_ptr_conv;
11056 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11057 this_ptr_conv.is_owned = false;
11058 int16_t ret_val = ChannelHandshakeLimits_get_their_to_self_delay(&this_ptr_conv);
11062 void __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_set_their_to_self_delay(uint32_t this_ptr, int16_t val) {
11063 LDKChannelHandshakeLimits this_ptr_conv;
11064 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11065 this_ptr_conv.is_owned = false;
11066 ChannelHandshakeLimits_set_their_to_self_delay(&this_ptr_conv, val);
11069 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_new(int64_t min_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 force_announced_channel_preference_arg, int16_t their_to_self_delay_arg) {
11070 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_new(min_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, force_announced_channel_preference_arg, their_to_self_delay_arg);
11071 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11072 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11073 uint64_t ret_ref = (uint64_t)ret_var.inner;
11074 if (ret_var.is_owned) {
11080 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_clone(uint32_t orig) {
11081 LDKChannelHandshakeLimits orig_conv;
11082 orig_conv.inner = (void*)(orig & (~1));
11083 orig_conv.is_owned = false;
11084 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_clone(&orig_conv);
11085 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11086 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11087 uint64_t ret_ref = (uint64_t)ret_var.inner;
11088 if (ret_var.is_owned) {
11094 uint32_t __attribute__((visibility("default"))) TS_ChannelHandshakeLimits_default() {
11095 LDKChannelHandshakeLimits ret_var = ChannelHandshakeLimits_default();
11096 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11097 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11098 uint64_t ret_ref = (uint64_t)ret_var.inner;
11099 if (ret_var.is_owned) {
11105 void __attribute__((visibility("default"))) TS_ChannelConfig_free(uint32_t this_obj) {
11106 LDKChannelConfig this_obj_conv;
11107 this_obj_conv.inner = (void*)(this_obj & (~1));
11108 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11109 ChannelConfig_free(this_obj_conv);
11112 int32_t __attribute__((visibility("default"))) TS_ChannelConfig_get_forwarding_fee_proportional_millionths(uint32_t this_ptr) {
11113 LDKChannelConfig this_ptr_conv;
11114 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11115 this_ptr_conv.is_owned = false;
11116 int32_t ret_val = ChannelConfig_get_forwarding_fee_proportional_millionths(&this_ptr_conv);
11120 void __attribute__((visibility("default"))) TS_ChannelConfig_set_forwarding_fee_proportional_millionths(uint32_t this_ptr, int32_t val) {
11121 LDKChannelConfig this_ptr_conv;
11122 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11123 this_ptr_conv.is_owned = false;
11124 ChannelConfig_set_forwarding_fee_proportional_millionths(&this_ptr_conv, val);
11127 int32_t __attribute__((visibility("default"))) TS_ChannelConfig_get_forwarding_fee_base_msat(uint32_t this_ptr) {
11128 LDKChannelConfig this_ptr_conv;
11129 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11130 this_ptr_conv.is_owned = false;
11131 int32_t ret_val = ChannelConfig_get_forwarding_fee_base_msat(&this_ptr_conv);
11135 void __attribute__((visibility("default"))) TS_ChannelConfig_set_forwarding_fee_base_msat(uint32_t this_ptr, int32_t val) {
11136 LDKChannelConfig this_ptr_conv;
11137 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11138 this_ptr_conv.is_owned = false;
11139 ChannelConfig_set_forwarding_fee_base_msat(&this_ptr_conv, val);
11142 int16_t __attribute__((visibility("default"))) TS_ChannelConfig_get_cltv_expiry_delta(uint32_t this_ptr) {
11143 LDKChannelConfig this_ptr_conv;
11144 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11145 this_ptr_conv.is_owned = false;
11146 int16_t ret_val = ChannelConfig_get_cltv_expiry_delta(&this_ptr_conv);
11150 void __attribute__((visibility("default"))) TS_ChannelConfig_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
11151 LDKChannelConfig this_ptr_conv;
11152 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11153 this_ptr_conv.is_owned = false;
11154 ChannelConfig_set_cltv_expiry_delta(&this_ptr_conv, val);
11157 jboolean __attribute__((visibility("default"))) TS_ChannelConfig_get_announced_channel(uint32_t this_ptr) {
11158 LDKChannelConfig this_ptr_conv;
11159 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11160 this_ptr_conv.is_owned = false;
11161 jboolean ret_val = ChannelConfig_get_announced_channel(&this_ptr_conv);
11165 void __attribute__((visibility("default"))) TS_ChannelConfig_set_announced_channel(uint32_t this_ptr, jboolean val) {
11166 LDKChannelConfig this_ptr_conv;
11167 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11168 this_ptr_conv.is_owned = false;
11169 ChannelConfig_set_announced_channel(&this_ptr_conv, val);
11172 jboolean __attribute__((visibility("default"))) TS_ChannelConfig_get_commit_upfront_shutdown_pubkey(uint32_t this_ptr) {
11173 LDKChannelConfig this_ptr_conv;
11174 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11175 this_ptr_conv.is_owned = false;
11176 jboolean ret_val = ChannelConfig_get_commit_upfront_shutdown_pubkey(&this_ptr_conv);
11180 void __attribute__((visibility("default"))) TS_ChannelConfig_set_commit_upfront_shutdown_pubkey(uint32_t this_ptr, jboolean val) {
11181 LDKChannelConfig this_ptr_conv;
11182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11183 this_ptr_conv.is_owned = false;
11184 ChannelConfig_set_commit_upfront_shutdown_pubkey(&this_ptr_conv, val);
11187 uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_new(int32_t forwarding_fee_proportional_millionths_arg, int32_t forwarding_fee_base_msat_arg, int16_t cltv_expiry_delta_arg, jboolean announced_channel_arg, jboolean commit_upfront_shutdown_pubkey_arg) {
11188 LDKChannelConfig ret_var = ChannelConfig_new(forwarding_fee_proportional_millionths_arg, forwarding_fee_base_msat_arg, cltv_expiry_delta_arg, announced_channel_arg, commit_upfront_shutdown_pubkey_arg);
11189 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11190 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11191 uint64_t ret_ref = (uint64_t)ret_var.inner;
11192 if (ret_var.is_owned) {
11198 uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_clone(uint32_t orig) {
11199 LDKChannelConfig orig_conv;
11200 orig_conv.inner = (void*)(orig & (~1));
11201 orig_conv.is_owned = false;
11202 LDKChannelConfig ret_var = ChannelConfig_clone(&orig_conv);
11203 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11204 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11205 uint64_t ret_ref = (uint64_t)ret_var.inner;
11206 if (ret_var.is_owned) {
11212 uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_default() {
11213 LDKChannelConfig ret_var = ChannelConfig_default();
11214 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11215 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11216 uint64_t ret_ref = (uint64_t)ret_var.inner;
11217 if (ret_var.is_owned) {
11223 int8_tArray __attribute__((visibility("default"))) TS_ChannelConfig_write(uint32_t obj) {
11224 LDKChannelConfig obj_conv;
11225 obj_conv.inner = (void*)(obj & (~1));
11226 obj_conv.is_owned = false;
11227 LDKCVec_u8Z ret_var = ChannelConfig_write(&obj_conv);
11228 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11229 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
11230 CVec_u8Z_free(ret_var);
11234 uint32_t __attribute__((visibility("default"))) TS_ChannelConfig_read(int8_tArray ser) {
11235 LDKu8slice ser_ref;
11236 ser_ref.datalen = *((uint32_t*)ser);
11237 ser_ref.data = (int8_t*)(ser + 4);
11238 LDKCResult_ChannelConfigDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelConfigDecodeErrorZ), "LDKCResult_ChannelConfigDecodeErrorZ");
11239 *ret_conv = ChannelConfig_read(ser_ref);
11240 return (uint64_t)ret_conv;
11243 void __attribute__((visibility("default"))) TS_UserConfig_free(uint32_t this_obj) {
11244 LDKUserConfig this_obj_conv;
11245 this_obj_conv.inner = (void*)(this_obj & (~1));
11246 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11247 UserConfig_free(this_obj_conv);
11250 uint32_t __attribute__((visibility("default"))) TS_UserConfig_get_own_channel_config(uint32_t this_ptr) {
11251 LDKUserConfig this_ptr_conv;
11252 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11253 this_ptr_conv.is_owned = false;
11254 LDKChannelHandshakeConfig ret_var = UserConfig_get_own_channel_config(&this_ptr_conv);
11255 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11256 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11257 uint64_t ret_ref = (uint64_t)ret_var.inner;
11258 if (ret_var.is_owned) {
11264 void __attribute__((visibility("default"))) TS_UserConfig_set_own_channel_config(uint32_t this_ptr, uint32_t val) {
11265 LDKUserConfig this_ptr_conv;
11266 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11267 this_ptr_conv.is_owned = false;
11268 LDKChannelHandshakeConfig val_conv;
11269 val_conv.inner = (void*)(val & (~1));
11270 val_conv.is_owned = (val & 1) || (val == 0);
11271 val_conv = ChannelHandshakeConfig_clone(&val_conv);
11272 UserConfig_set_own_channel_config(&this_ptr_conv, val_conv);
11275 uint32_t __attribute__((visibility("default"))) TS_UserConfig_get_peer_channel_config_limits(uint32_t this_ptr) {
11276 LDKUserConfig this_ptr_conv;
11277 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11278 this_ptr_conv.is_owned = false;
11279 LDKChannelHandshakeLimits ret_var = UserConfig_get_peer_channel_config_limits(&this_ptr_conv);
11280 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11281 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11282 uint64_t ret_ref = (uint64_t)ret_var.inner;
11283 if (ret_var.is_owned) {
11289 void __attribute__((visibility("default"))) TS_UserConfig_set_peer_channel_config_limits(uint32_t this_ptr, uint32_t val) {
11290 LDKUserConfig this_ptr_conv;
11291 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11292 this_ptr_conv.is_owned = false;
11293 LDKChannelHandshakeLimits val_conv;
11294 val_conv.inner = (void*)(val & (~1));
11295 val_conv.is_owned = (val & 1) || (val == 0);
11296 val_conv = ChannelHandshakeLimits_clone(&val_conv);
11297 UserConfig_set_peer_channel_config_limits(&this_ptr_conv, val_conv);
11300 uint32_t __attribute__((visibility("default"))) TS_UserConfig_get_channel_options(uint32_t this_ptr) {
11301 LDKUserConfig this_ptr_conv;
11302 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11303 this_ptr_conv.is_owned = false;
11304 LDKChannelConfig ret_var = UserConfig_get_channel_options(&this_ptr_conv);
11305 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11306 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11307 uint64_t ret_ref = (uint64_t)ret_var.inner;
11308 if (ret_var.is_owned) {
11314 void __attribute__((visibility("default"))) TS_UserConfig_set_channel_options(uint32_t this_ptr, uint32_t val) {
11315 LDKUserConfig this_ptr_conv;
11316 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11317 this_ptr_conv.is_owned = false;
11318 LDKChannelConfig val_conv;
11319 val_conv.inner = (void*)(val & (~1));
11320 val_conv.is_owned = (val & 1) || (val == 0);
11321 val_conv = ChannelConfig_clone(&val_conv);
11322 UserConfig_set_channel_options(&this_ptr_conv, val_conv);
11325 jboolean __attribute__((visibility("default"))) TS_UserConfig_get_accept_forwards_to_priv_channels(uint32_t this_ptr) {
11326 LDKUserConfig this_ptr_conv;
11327 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11328 this_ptr_conv.is_owned = false;
11329 jboolean ret_val = UserConfig_get_accept_forwards_to_priv_channels(&this_ptr_conv);
11333 void __attribute__((visibility("default"))) TS_UserConfig_set_accept_forwards_to_priv_channels(uint32_t this_ptr, jboolean val) {
11334 LDKUserConfig this_ptr_conv;
11335 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11336 this_ptr_conv.is_owned = false;
11337 UserConfig_set_accept_forwards_to_priv_channels(&this_ptr_conv, val);
11340 uint32_t __attribute__((visibility("default"))) TS_UserConfig_new(uint32_t own_channel_config_arg, uint32_t peer_channel_config_limits_arg, uint32_t channel_options_arg, jboolean accept_forwards_to_priv_channels_arg) {
11341 LDKChannelHandshakeConfig own_channel_config_arg_conv;
11342 own_channel_config_arg_conv.inner = (void*)(own_channel_config_arg & (~1));
11343 own_channel_config_arg_conv.is_owned = (own_channel_config_arg & 1) || (own_channel_config_arg == 0);
11344 own_channel_config_arg_conv = ChannelHandshakeConfig_clone(&own_channel_config_arg_conv);
11345 LDKChannelHandshakeLimits peer_channel_config_limits_arg_conv;
11346 peer_channel_config_limits_arg_conv.inner = (void*)(peer_channel_config_limits_arg & (~1));
11347 peer_channel_config_limits_arg_conv.is_owned = (peer_channel_config_limits_arg & 1) || (peer_channel_config_limits_arg == 0);
11348 peer_channel_config_limits_arg_conv = ChannelHandshakeLimits_clone(&peer_channel_config_limits_arg_conv);
11349 LDKChannelConfig channel_options_arg_conv;
11350 channel_options_arg_conv.inner = (void*)(channel_options_arg & (~1));
11351 channel_options_arg_conv.is_owned = (channel_options_arg & 1) || (channel_options_arg == 0);
11352 channel_options_arg_conv = ChannelConfig_clone(&channel_options_arg_conv);
11353 LDKUserConfig ret_var = UserConfig_new(own_channel_config_arg_conv, peer_channel_config_limits_arg_conv, channel_options_arg_conv, accept_forwards_to_priv_channels_arg);
11354 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11355 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11356 uint64_t ret_ref = (uint64_t)ret_var.inner;
11357 if (ret_var.is_owned) {
11363 uint32_t __attribute__((visibility("default"))) TS_UserConfig_clone(uint32_t orig) {
11364 LDKUserConfig orig_conv;
11365 orig_conv.inner = (void*)(orig & (~1));
11366 orig_conv.is_owned = false;
11367 LDKUserConfig ret_var = UserConfig_clone(&orig_conv);
11368 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11369 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11370 uint64_t ret_ref = (uint64_t)ret_var.inner;
11371 if (ret_var.is_owned) {
11377 uint32_t __attribute__((visibility("default"))) TS_UserConfig_default() {
11378 LDKUserConfig ret_var = UserConfig_default();
11379 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11380 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11381 uint64_t ret_ref = (uint64_t)ret_var.inner;
11382 if (ret_var.is_owned) {
11388 void __attribute__((visibility("default"))) TS_BestBlock_free(uint32_t this_obj) {
11389 LDKBestBlock this_obj_conv;
11390 this_obj_conv.inner = (void*)(this_obj & (~1));
11391 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11392 BestBlock_free(this_obj_conv);
11395 uint32_t __attribute__((visibility("default"))) TS_BestBlock_clone(uint32_t orig) {
11396 LDKBestBlock orig_conv;
11397 orig_conv.inner = (void*)(orig & (~1));
11398 orig_conv.is_owned = false;
11399 LDKBestBlock ret_var = BestBlock_clone(&orig_conv);
11400 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11401 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11402 uint64_t ret_ref = (uint64_t)ret_var.inner;
11403 if (ret_var.is_owned) {
11409 uint32_t __attribute__((visibility("default"))) TS_BestBlock_from_genesis(uint32_t network) {
11410 LDKNetwork network_conv = LDKNetwork_from_js(network);
11411 LDKBestBlock ret_var = BestBlock_from_genesis(network_conv);
11412 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11413 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11414 uint64_t ret_ref = (uint64_t)ret_var.inner;
11415 if (ret_var.is_owned) {
11421 uint32_t __attribute__((visibility("default"))) TS_BestBlock_new(int8_tArray block_hash, int32_t height) {
11422 LDKThirtyTwoBytes block_hash_ref;
11423 CHECK(*((uint32_t*)block_hash) == 32);
11424 memcpy(block_hash_ref.data, (uint8_t*)(block_hash + 4), 32);
11425 LDKBestBlock ret_var = BestBlock_new(block_hash_ref, height);
11426 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11427 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11428 uint64_t ret_ref = (uint64_t)ret_var.inner;
11429 if (ret_var.is_owned) {
11435 int8_tArray __attribute__((visibility("default"))) TS_BestBlock_block_hash(uint32_t this_arg) {
11436 LDKBestBlock this_arg_conv;
11437 this_arg_conv.inner = (void*)(this_arg & (~1));
11438 this_arg_conv.is_owned = false;
11439 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
11440 memcpy((uint8_t*)(ret_arr + 4), BestBlock_block_hash(&this_arg_conv).data, 32);
11444 int32_t __attribute__((visibility("default"))) TS_BestBlock_height(uint32_t this_arg) {
11445 LDKBestBlock this_arg_conv;
11446 this_arg_conv.inner = (void*)(this_arg & (~1));
11447 this_arg_conv.is_owned = false;
11448 int32_t ret_val = BestBlock_height(&this_arg_conv);
11452 uint32_t __attribute__((visibility("default"))) TS_AccessError_clone(uint32_t orig) {
11453 LDKAccessError* orig_conv = (LDKAccessError*)(orig & ~1);
11454 uint32_t ret_conv = LDKAccessError_to_js(AccessError_clone(orig_conv));
11458 void __attribute__((visibility("default"))) TS_Access_free(uint32_t this_ptr) {
11459 if ((this_ptr & 1) != 0) return;
11460 LDKAccess this_ptr_conv = *(LDKAccess*)(((uint64_t)this_ptr) & ~1);
11461 FREE((void*)this_ptr);
11462 Access_free(this_ptr_conv);
11465 void __attribute__((visibility("default"))) TS_Listen_free(uint32_t this_ptr) {
11466 if ((this_ptr & 1) != 0) return;
11467 LDKListen this_ptr_conv = *(LDKListen*)(((uint64_t)this_ptr) & ~1);
11468 FREE((void*)this_ptr);
11469 Listen_free(this_ptr_conv);
11472 void __attribute__((visibility("default"))) TS_Confirm_free(uint32_t this_ptr) {
11473 if ((this_ptr & 1) != 0) return;
11474 LDKConfirm this_ptr_conv = *(LDKConfirm*)(((uint64_t)this_ptr) & ~1);
11475 FREE((void*)this_ptr);
11476 Confirm_free(this_ptr_conv);
11479 void __attribute__((visibility("default"))) TS_Watch_free(uint32_t this_ptr) {
11480 if ((this_ptr & 1) != 0) return;
11481 LDKWatch this_ptr_conv = *(LDKWatch*)(((uint64_t)this_ptr) & ~1);
11482 FREE((void*)this_ptr);
11483 Watch_free(this_ptr_conv);
11486 void __attribute__((visibility("default"))) TS_Filter_free(uint32_t this_ptr) {
11487 if ((this_ptr & 1) != 0) return;
11488 LDKFilter this_ptr_conv = *(LDKFilter*)(((uint64_t)this_ptr) & ~1);
11489 FREE((void*)this_ptr);
11490 Filter_free(this_ptr_conv);
11493 void __attribute__((visibility("default"))) TS_WatchedOutput_free(uint32_t this_obj) {
11494 LDKWatchedOutput this_obj_conv;
11495 this_obj_conv.inner = (void*)(this_obj & (~1));
11496 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11497 WatchedOutput_free(this_obj_conv);
11500 int8_tArray __attribute__((visibility("default"))) TS_WatchedOutput_get_block_hash(uint32_t this_ptr) {
11501 LDKWatchedOutput this_ptr_conv;
11502 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11503 this_ptr_conv.is_owned = false;
11504 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
11505 memcpy((uint8_t*)(ret_arr + 4), WatchedOutput_get_block_hash(&this_ptr_conv).data, 32);
11509 void __attribute__((visibility("default"))) TS_WatchedOutput_set_block_hash(uint32_t this_ptr, int8_tArray val) {
11510 LDKWatchedOutput this_ptr_conv;
11511 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11512 this_ptr_conv.is_owned = false;
11513 LDKThirtyTwoBytes val_ref;
11514 CHECK(*((uint32_t*)val) == 32);
11515 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
11516 WatchedOutput_set_block_hash(&this_ptr_conv, val_ref);
11519 uint32_t __attribute__((visibility("default"))) TS_WatchedOutput_get_outpoint(uint32_t this_ptr) {
11520 LDKWatchedOutput this_ptr_conv;
11521 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11522 this_ptr_conv.is_owned = false;
11523 LDKOutPoint ret_var = WatchedOutput_get_outpoint(&this_ptr_conv);
11524 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11525 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11526 uint64_t ret_ref = (uint64_t)ret_var.inner;
11527 if (ret_var.is_owned) {
11533 void __attribute__((visibility("default"))) TS_WatchedOutput_set_outpoint(uint32_t this_ptr, uint32_t val) {
11534 LDKWatchedOutput this_ptr_conv;
11535 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11536 this_ptr_conv.is_owned = false;
11537 LDKOutPoint val_conv;
11538 val_conv.inner = (void*)(val & (~1));
11539 val_conv.is_owned = (val & 1) || (val == 0);
11540 val_conv = OutPoint_clone(&val_conv);
11541 WatchedOutput_set_outpoint(&this_ptr_conv, val_conv);
11544 int8_tArray __attribute__((visibility("default"))) TS_WatchedOutput_get_script_pubkey(uint32_t this_ptr) {
11545 LDKWatchedOutput this_ptr_conv;
11546 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11547 this_ptr_conv.is_owned = false;
11548 LDKu8slice ret_var = WatchedOutput_get_script_pubkey(&this_ptr_conv);
11549 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11550 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
11554 void __attribute__((visibility("default"))) TS_WatchedOutput_set_script_pubkey(uint32_t this_ptr, int8_tArray val) {
11555 LDKWatchedOutput this_ptr_conv;
11556 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11557 this_ptr_conv.is_owned = false;
11558 LDKCVec_u8Z val_ref;
11559 val_ref.datalen = *((uint32_t*)val);
11560 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
11561 memcpy(val_ref.data, (uint8_t*)(val + 4), val_ref.datalen);
11562 WatchedOutput_set_script_pubkey(&this_ptr_conv, val_ref);
11565 uint32_t __attribute__((visibility("default"))) TS_WatchedOutput_new(int8_tArray block_hash_arg, uint32_t outpoint_arg, int8_tArray script_pubkey_arg) {
11566 LDKThirtyTwoBytes block_hash_arg_ref;
11567 CHECK(*((uint32_t*)block_hash_arg) == 32);
11568 memcpy(block_hash_arg_ref.data, (uint8_t*)(block_hash_arg + 4), 32);
11569 LDKOutPoint outpoint_arg_conv;
11570 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
11571 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
11572 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
11573 LDKCVec_u8Z script_pubkey_arg_ref;
11574 script_pubkey_arg_ref.datalen = *((uint32_t*)script_pubkey_arg);
11575 script_pubkey_arg_ref.data = MALLOC(script_pubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
11576 memcpy(script_pubkey_arg_ref.data, (uint8_t*)(script_pubkey_arg + 4), script_pubkey_arg_ref.datalen);
11577 LDKWatchedOutput ret_var = WatchedOutput_new(block_hash_arg_ref, outpoint_arg_conv, script_pubkey_arg_ref);
11578 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11579 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11580 uint64_t ret_ref = (uint64_t)ret_var.inner;
11581 if (ret_var.is_owned) {
11587 uint32_t __attribute__((visibility("default"))) TS_WatchedOutput_clone(uint32_t orig) {
11588 LDKWatchedOutput orig_conv;
11589 orig_conv.inner = (void*)(orig & (~1));
11590 orig_conv.is_owned = false;
11591 LDKWatchedOutput ret_var = WatchedOutput_clone(&orig_conv);
11592 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11593 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11594 uint64_t ret_ref = (uint64_t)ret_var.inner;
11595 if (ret_var.is_owned) {
11601 int64_t __attribute__((visibility("default"))) TS_WatchedOutput_hash(uint32_t o) {
11602 LDKWatchedOutput o_conv;
11603 o_conv.inner = (void*)(o & (~1));
11604 o_conv.is_owned = false;
11605 int64_t ret_val = WatchedOutput_hash(&o_conv);
11609 void __attribute__((visibility("default"))) TS_BroadcasterInterface_free(uint32_t this_ptr) {
11610 if ((this_ptr & 1) != 0) return;
11611 LDKBroadcasterInterface this_ptr_conv = *(LDKBroadcasterInterface*)(((uint64_t)this_ptr) & ~1);
11612 FREE((void*)this_ptr);
11613 BroadcasterInterface_free(this_ptr_conv);
11616 uint32_t __attribute__((visibility("default"))) TS_ConfirmationTarget_clone(uint32_t orig) {
11617 LDKConfirmationTarget* orig_conv = (LDKConfirmationTarget*)(orig & ~1);
11618 uint32_t ret_conv = LDKConfirmationTarget_to_js(ConfirmationTarget_clone(orig_conv));
11622 void __attribute__((visibility("default"))) TS_FeeEstimator_free(uint32_t this_ptr) {
11623 if ((this_ptr & 1) != 0) return;
11624 LDKFeeEstimator this_ptr_conv = *(LDKFeeEstimator*)(((uint64_t)this_ptr) & ~1);
11625 FREE((void*)this_ptr);
11626 FeeEstimator_free(this_ptr_conv);
11629 void __attribute__((visibility("default"))) TS_ChainMonitor_free(uint32_t this_obj) {
11630 LDKChainMonitor this_obj_conv;
11631 this_obj_conv.inner = (void*)(this_obj & (~1));
11632 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11633 ChainMonitor_free(this_obj_conv);
11636 uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_new(uint32_t chain_source, uint32_t broadcaster, uint32_t logger, uint32_t feeest, uint32_t persister) {
11637 LDKFilter *chain_source_conv_ptr = NULL;
11638 if (chain_source != 0) {
11639 LDKFilter chain_source_conv;
11640 chain_source_conv = *(LDKFilter*)(((uint64_t)chain_source) & ~1);
11641 chain_source_conv_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter");
11642 *chain_source_conv_ptr = chain_source_conv;
11644 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
11645 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
11646 LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(((uint64_t)feeest) & ~1);
11647 LDKPersist persister_conv = *(LDKPersist*)(((uint64_t)persister) & ~1);
11648 LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv_ptr, broadcaster_conv, logger_conv, feeest_conv, persister_conv);
11649 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11650 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11651 uint64_t ret_ref = (uint64_t)ret_var.inner;
11652 if (ret_var.is_owned) {
11658 uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Listen(uint32_t this_arg) {
11659 LDKChainMonitor this_arg_conv;
11660 this_arg_conv.inner = (void*)(this_arg & (~1));
11661 this_arg_conv.is_owned = false;
11662 LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen");
11663 *ret = ChainMonitor_as_Listen(&this_arg_conv);
11664 return (uint64_t)ret;
11667 uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Confirm(uint32_t this_arg) {
11668 LDKChainMonitor this_arg_conv;
11669 this_arg_conv.inner = (void*)(this_arg & (~1));
11670 this_arg_conv.is_owned = false;
11671 LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
11672 *ret = ChainMonitor_as_Confirm(&this_arg_conv);
11673 return (uint64_t)ret;
11676 uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Watch(uint32_t this_arg) {
11677 LDKChainMonitor this_arg_conv;
11678 this_arg_conv.inner = (void*)(this_arg & (~1));
11679 this_arg_conv.is_owned = false;
11680 LDKWatch* ret = MALLOC(sizeof(LDKWatch), "LDKWatch");
11681 *ret = ChainMonitor_as_Watch(&this_arg_conv);
11682 return (uint64_t)ret;
11685 uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_EventsProvider(uint32_t this_arg) {
11686 LDKChainMonitor this_arg_conv;
11687 this_arg_conv.inner = (void*)(this_arg & (~1));
11688 this_arg_conv.is_owned = false;
11689 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
11690 *ret = ChainMonitor_as_EventsProvider(&this_arg_conv);
11691 return (uint64_t)ret;
11694 void __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_free(uint32_t this_obj) {
11695 LDKChannelMonitorUpdate this_obj_conv;
11696 this_obj_conv.inner = (void*)(this_obj & (~1));
11697 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11698 ChannelMonitorUpdate_free(this_obj_conv);
11701 int64_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_get_update_id(uint32_t this_ptr) {
11702 LDKChannelMonitorUpdate this_ptr_conv;
11703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11704 this_ptr_conv.is_owned = false;
11705 int64_t ret_val = ChannelMonitorUpdate_get_update_id(&this_ptr_conv);
11709 void __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_set_update_id(uint32_t this_ptr, int64_t val) {
11710 LDKChannelMonitorUpdate this_ptr_conv;
11711 this_ptr_conv.inner = (void*)(this_ptr & (~1));
11712 this_ptr_conv.is_owned = false;
11713 ChannelMonitorUpdate_set_update_id(&this_ptr_conv, val);
11716 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_clone(uint32_t orig) {
11717 LDKChannelMonitorUpdate orig_conv;
11718 orig_conv.inner = (void*)(orig & (~1));
11719 orig_conv.is_owned = false;
11720 LDKChannelMonitorUpdate ret_var = ChannelMonitorUpdate_clone(&orig_conv);
11721 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11722 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11723 uint64_t ret_ref = (uint64_t)ret_var.inner;
11724 if (ret_var.is_owned) {
11730 int8_tArray __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_write(uint32_t obj) {
11731 LDKChannelMonitorUpdate obj_conv;
11732 obj_conv.inner = (void*)(obj & (~1));
11733 obj_conv.is_owned = false;
11734 LDKCVec_u8Z ret_var = ChannelMonitorUpdate_write(&obj_conv);
11735 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11736 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
11737 CVec_u8Z_free(ret_var);
11741 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_read(int8_tArray ser) {
11742 LDKu8slice ser_ref;
11743 ser_ref.datalen = *((uint32_t*)ser);
11744 ser_ref.data = (int8_t*)(ser + 4);
11745 LDKCResult_ChannelMonitorUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelMonitorUpdateDecodeErrorZ), "LDKCResult_ChannelMonitorUpdateDecodeErrorZ");
11746 *ret_conv = ChannelMonitorUpdate_read(ser_ref);
11747 return (uint64_t)ret_conv;
11750 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_clone(uint32_t orig) {
11751 LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1);
11752 uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_clone(orig_conv));
11756 void __attribute__((visibility("default"))) TS_MonitorUpdateError_free(uint32_t this_obj) {
11757 LDKMonitorUpdateError this_obj_conv;
11758 this_obj_conv.inner = (void*)(this_obj & (~1));
11759 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11760 MonitorUpdateError_free(this_obj_conv);
11763 uint32_t __attribute__((visibility("default"))) TS_MonitorUpdateError_clone(uint32_t orig) {
11764 LDKMonitorUpdateError orig_conv;
11765 orig_conv.inner = (void*)(orig & (~1));
11766 orig_conv.is_owned = false;
11767 LDKMonitorUpdateError ret_var = MonitorUpdateError_clone(&orig_conv);
11768 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11769 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11770 uint64_t ret_ref = (uint64_t)ret_var.inner;
11771 if (ret_var.is_owned) {
11777 void __attribute__((visibility("default"))) TS_MonitorEvent_free(uint32_t this_ptr) {
11778 if ((this_ptr & 1) != 0) return;
11779 LDKMonitorEvent this_ptr_conv = *(LDKMonitorEvent*)(((uint64_t)this_ptr) & ~1);
11780 FREE((void*)this_ptr);
11781 MonitorEvent_free(this_ptr_conv);
11784 uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_clone(uint32_t orig) {
11785 LDKMonitorEvent* orig_conv = (LDKMonitorEvent*)orig;
11786 LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
11787 *ret_copy = MonitorEvent_clone(orig_conv);
11788 uint64_t ret_ref = (uint64_t)ret_copy;
11792 void __attribute__((visibility("default"))) TS_HTLCUpdate_free(uint32_t this_obj) {
11793 LDKHTLCUpdate this_obj_conv;
11794 this_obj_conv.inner = (void*)(this_obj & (~1));
11795 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11796 HTLCUpdate_free(this_obj_conv);
11799 uint32_t __attribute__((visibility("default"))) TS_HTLCUpdate_clone(uint32_t orig) {
11800 LDKHTLCUpdate orig_conv;
11801 orig_conv.inner = (void*)(orig & (~1));
11802 orig_conv.is_owned = false;
11803 LDKHTLCUpdate ret_var = HTLCUpdate_clone(&orig_conv);
11804 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11805 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11806 uint64_t ret_ref = (uint64_t)ret_var.inner;
11807 if (ret_var.is_owned) {
11813 int8_tArray __attribute__((visibility("default"))) TS_HTLCUpdate_write(uint32_t obj) {
11814 LDKHTLCUpdate obj_conv;
11815 obj_conv.inner = (void*)(obj & (~1));
11816 obj_conv.is_owned = false;
11817 LDKCVec_u8Z ret_var = HTLCUpdate_write(&obj_conv);
11818 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11819 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
11820 CVec_u8Z_free(ret_var);
11824 uint32_t __attribute__((visibility("default"))) TS_HTLCUpdate_read(int8_tArray ser) {
11825 LDKu8slice ser_ref;
11826 ser_ref.datalen = *((uint32_t*)ser);
11827 ser_ref.data = (int8_t*)(ser + 4);
11828 LDKCResult_HTLCUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCUpdateDecodeErrorZ), "LDKCResult_HTLCUpdateDecodeErrorZ");
11829 *ret_conv = HTLCUpdate_read(ser_ref);
11830 return (uint64_t)ret_conv;
11833 void __attribute__((visibility("default"))) TS_ChannelMonitor_free(uint32_t this_obj) {
11834 LDKChannelMonitor this_obj_conv;
11835 this_obj_conv.inner = (void*)(this_obj & (~1));
11836 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
11837 ChannelMonitor_free(this_obj_conv);
11840 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_clone(uint32_t orig) {
11841 LDKChannelMonitor orig_conv;
11842 orig_conv.inner = (void*)(orig & (~1));
11843 orig_conv.is_owned = false;
11844 LDKChannelMonitor ret_var = ChannelMonitor_clone(&orig_conv);
11845 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
11846 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
11847 uint64_t ret_ref = (uint64_t)ret_var.inner;
11848 if (ret_var.is_owned) {
11854 int8_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_write(uint32_t obj) {
11855 LDKChannelMonitor obj_conv;
11856 obj_conv.inner = (void*)(obj & (~1));
11857 obj_conv.is_owned = false;
11858 LDKCVec_u8Z ret_var = ChannelMonitor_write(&obj_conv);
11859 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11860 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
11861 CVec_u8Z_free(ret_var);
11865 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_update_monitor(uint32_t this_arg, uint32_t updates, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
11866 LDKChannelMonitor this_arg_conv;
11867 this_arg_conv.inner = (void*)(this_arg & (~1));
11868 this_arg_conv.is_owned = false;
11869 LDKChannelMonitorUpdate updates_conv;
11870 updates_conv.inner = (void*)(updates & (~1));
11871 updates_conv.is_owned = false;
11872 LDKBroadcasterInterface* broadcaster_conv = (LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
11873 LDKFeeEstimator* fee_estimator_conv = (LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
11874 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
11875 LDKCResult_NoneMonitorUpdateErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneMonitorUpdateErrorZ), "LDKCResult_NoneMonitorUpdateErrorZ");
11876 *ret_conv = ChannelMonitor_update_monitor(&this_arg_conv, &updates_conv, broadcaster_conv, fee_estimator_conv, logger_conv);
11877 return (uint64_t)ret_conv;
11880 int64_t __attribute__((visibility("default"))) TS_ChannelMonitor_get_latest_update_id(uint32_t this_arg) {
11881 LDKChannelMonitor this_arg_conv;
11882 this_arg_conv.inner = (void*)(this_arg & (~1));
11883 this_arg_conv.is_owned = false;
11884 int64_t ret_val = ChannelMonitor_get_latest_update_id(&this_arg_conv);
11888 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_get_funding_txo(uint32_t this_arg) {
11889 LDKChannelMonitor this_arg_conv;
11890 this_arg_conv.inner = (void*)(this_arg & (~1));
11891 this_arg_conv.is_owned = false;
11892 LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ");
11893 *ret_ref = ChannelMonitor_get_funding_txo(&this_arg_conv);
11894 return (uint64_t)ret_ref;
11897 uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_outputs_to_watch(uint32_t this_arg) {
11898 LDKChannelMonitor this_arg_conv;
11899 this_arg_conv.inner = (void*)(this_arg & (~1));
11900 this_arg_conv.is_owned = false;
11901 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv);
11902 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
11903 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
11904 for (size_t c = 0; c < ret_var.datalen; c++) {
11905 LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_54_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ");
11906 *ret_conv_54_ref = ret_var.data[c];
11907 ret_arr_ptr[c] = (uint64_t)ret_conv_54_ref;
11909 FREE(ret_var.data);
11913 void __attribute__((visibility("default"))) TS_ChannelMonitor_load_outputs_to_watch(uint32_t this_arg, uint32_t filter) {
11914 LDKChannelMonitor this_arg_conv;
11915 this_arg_conv.inner = (void*)(this_arg & (~1));
11916 this_arg_conv.is_owned = false;
11917 LDKFilter* filter_conv = (LDKFilter*)(((uint64_t)filter) & ~1);
11918 ChannelMonitor_load_outputs_to_watch(&this_arg_conv, filter_conv);
11921 uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_and_clear_pending_monitor_events(uint32_t this_arg) {
11922 LDKChannelMonitor this_arg_conv;
11923 this_arg_conv.inner = (void*)(this_arg & (~1));
11924 this_arg_conv.is_owned = false;
11925 LDKCVec_MonitorEventZ ret_var = ChannelMonitor_get_and_clear_pending_monitor_events(&this_arg_conv);
11926 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
11927 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
11928 for (size_t o = 0; o < ret_var.datalen; o++) {
11929 LDKMonitorEvent *ret_conv_14_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent");
11930 *ret_conv_14_copy = MonitorEvent_clone(&ret_var.data[o]);
11931 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_copy;
11932 ret_arr_ptr[o] = ret_conv_14_ref;
11934 FREE(ret_var.data);
11938 uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_and_clear_pending_events(uint32_t this_arg) {
11939 LDKChannelMonitor this_arg_conv;
11940 this_arg_conv.inner = (void*)(this_arg & (~1));
11941 this_arg_conv.is_owned = false;
11942 LDKCVec_EventZ ret_var = ChannelMonitor_get_and_clear_pending_events(&this_arg_conv);
11943 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
11944 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
11945 for (size_t h = 0; h < ret_var.datalen; h++) {
11946 LDKEvent *ret_conv_7_copy = MALLOC(sizeof(LDKEvent), "LDKEvent");
11947 *ret_conv_7_copy = Event_clone(&ret_var.data[h]);
11948 uint64_t ret_conv_7_ref = (uint64_t)ret_conv_7_copy;
11949 ret_arr_ptr[h] = ret_conv_7_ref;
11951 FREE(ret_var.data);
11955 ptrArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_latest_holder_commitment_txn(uint32_t this_arg, uint32_t logger) {
11956 LDKChannelMonitor this_arg_conv;
11957 this_arg_conv.inner = (void*)(this_arg & (~1));
11958 this_arg_conv.is_owned = false;
11959 LDKLogger* logger_conv = (LDKLogger*)(((uint64_t)logger) & ~1);
11960 LDKCVec_TransactionZ ret_var = ChannelMonitor_get_latest_holder_commitment_txn(&this_arg_conv, logger_conv);
11961 ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
11962 int8_tArray *ret_arr_ptr = (int8_tArray*)(ret_arr + 4);
11963 for (size_t m = 0; m < ret_var.datalen; m++) {
11964 LDKTransaction ret_conv_12_var = ret_var.data[m];
11965 int8_tArray ret_conv_12_arr = init_arr(ret_conv_12_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
11966 memcpy((uint8_t*)(ret_conv_12_arr + 4), ret_conv_12_var.data, ret_conv_12_var.datalen);
11967 Transaction_free(ret_conv_12_var);
11968 ret_arr_ptr[m] = ret_conv_12_arr;
11970 FREE(ret_var.data);
11974 uint32_tArray __attribute__((visibility("default"))) 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) {
11975 LDKChannelMonitor this_arg_conv;
11976 this_arg_conv.inner = (void*)(this_arg & (~1));
11977 this_arg_conv.is_owned = false;
11978 unsigned char header_arr[80];
11979 CHECK(*((uint32_t*)header) == 80);
11980 memcpy(header_arr, (uint8_t*)(header + 4), 80);
11981 unsigned char (*header_ref)[80] = &header_arr;
11982 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
11983 txdata_constr.datalen = *((uint32_t*)txdata);
11984 if (txdata_constr.datalen > 0)
11985 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
11987 txdata_constr.data = NULL;
11988 uint32_t* txdata_vals = (uint32_t*)(txdata + 4);
11989 for (size_t e = 0; e < txdata_constr.datalen; e++) {
11990 uint32_t txdata_conv_30 = txdata_vals[e];
11991 LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1);
11992 txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1));
11993 txdata_constr.data[e] = txdata_conv_30_conv;
11995 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
11996 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
11997 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
11998 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);
11999 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
12000 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
12001 for (size_t x = 0; x < ret_var.datalen; x++) {
12002 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
12003 *ret_conv_49_ref = ret_var.data[x];
12004 ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref;
12006 FREE(ret_var.data);
12010 void __attribute__((visibility("default"))) TS_ChannelMonitor_block_disconnected(uint32_t this_arg, int8_tArray header, int32_t height, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
12011 LDKChannelMonitor this_arg_conv;
12012 this_arg_conv.inner = (void*)(this_arg & (~1));
12013 this_arg_conv.is_owned = false;
12014 unsigned char header_arr[80];
12015 CHECK(*((uint32_t*)header) == 80);
12016 memcpy(header_arr, (uint8_t*)(header + 4), 80);
12017 unsigned char (*header_ref)[80] = &header_arr;
12018 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
12019 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
12020 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
12021 ChannelMonitor_block_disconnected(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
12024 uint32_tArray __attribute__((visibility("default"))) 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) {
12025 LDKChannelMonitor this_arg_conv;
12026 this_arg_conv.inner = (void*)(this_arg & (~1));
12027 this_arg_conv.is_owned = false;
12028 unsigned char header_arr[80];
12029 CHECK(*((uint32_t*)header) == 80);
12030 memcpy(header_arr, (uint8_t*)(header + 4), 80);
12031 unsigned char (*header_ref)[80] = &header_arr;
12032 LDKCVec_C2Tuple_usizeTransactionZZ txdata_constr;
12033 txdata_constr.datalen = *((uint32_t*)txdata);
12034 if (txdata_constr.datalen > 0)
12035 txdata_constr.data = MALLOC(txdata_constr.datalen * sizeof(LDKC2Tuple_usizeTransactionZ), "LDKCVec_C2Tuple_usizeTransactionZZ Elements");
12037 txdata_constr.data = NULL;
12038 uint32_t* txdata_vals = (uint32_t*)(txdata + 4);
12039 for (size_t e = 0; e < txdata_constr.datalen; e++) {
12040 uint32_t txdata_conv_30 = txdata_vals[e];
12041 LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1);
12042 txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1));
12043 txdata_constr.data[e] = txdata_conv_30_conv;
12045 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
12046 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
12047 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
12048 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);
12049 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
12050 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
12051 for (size_t x = 0; x < ret_var.datalen; x++) {
12052 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
12053 *ret_conv_49_ref = ret_var.data[x];
12054 ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref;
12056 FREE(ret_var.data);
12060 void __attribute__((visibility("default"))) TS_ChannelMonitor_transaction_unconfirmed(uint32_t this_arg, int8_tArray txid, uint32_t broadcaster, uint32_t fee_estimator, uint32_t logger) {
12061 LDKChannelMonitor this_arg_conv;
12062 this_arg_conv.inner = (void*)(this_arg & (~1));
12063 this_arg_conv.is_owned = false;
12064 unsigned char txid_arr[32];
12065 CHECK(*((uint32_t*)txid) == 32);
12066 memcpy(txid_arr, (uint8_t*)(txid + 4), 32);
12067 unsigned char (*txid_ref)[32] = &txid_arr;
12068 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
12069 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
12070 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
12071 ChannelMonitor_transaction_unconfirmed(&this_arg_conv, txid_ref, broadcaster_conv, fee_estimator_conv, logger_conv);
12074 uint32_tArray __attribute__((visibility("default"))) 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) {
12075 LDKChannelMonitor this_arg_conv;
12076 this_arg_conv.inner = (void*)(this_arg & (~1));
12077 this_arg_conv.is_owned = false;
12078 unsigned char header_arr[80];
12079 CHECK(*((uint32_t*)header) == 80);
12080 memcpy(header_arr, (uint8_t*)(header + 4), 80);
12081 unsigned char (*header_ref)[80] = &header_arr;
12082 LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1);
12083 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
12084 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
12085 LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv);
12086 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
12087 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
12088 for (size_t x = 0; x < ret_var.datalen; x++) {
12089 LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ");
12090 *ret_conv_49_ref = ret_var.data[x];
12091 ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref;
12093 FREE(ret_var.data);
12097 ptrArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_relevant_txids(uint32_t this_arg) {
12098 LDKChannelMonitor this_arg_conv;
12099 this_arg_conv.inner = (void*)(this_arg & (~1));
12100 this_arg_conv.is_owned = false;
12101 LDKCVec_TxidZ ret_var = ChannelMonitor_get_relevant_txids(&this_arg_conv);
12102 ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
12103 int8_tArray *ret_arr_ptr = (int8_tArray*)(ret_arr + 4);
12104 for (size_t m = 0; m < ret_var.datalen; m++) {
12105 int8_tArray ret_conv_12_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12106 memcpy((uint8_t*)(ret_conv_12_arr + 4), ret_var.data[m].data, 32);
12107 ret_arr_ptr[m] = ret_conv_12_arr;
12109 FREE(ret_var.data);
12113 uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_current_best_block(uint32_t this_arg) {
12114 LDKChannelMonitor this_arg_conv;
12115 this_arg_conv.inner = (void*)(this_arg & (~1));
12116 this_arg_conv.is_owned = false;
12117 LDKBestBlock ret_var = ChannelMonitor_current_best_block(&this_arg_conv);
12118 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12119 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12120 uint64_t ret_ref = (uint64_t)ret_var.inner;
12121 if (ret_var.is_owned) {
12127 void __attribute__((visibility("default"))) TS_Persist_free(uint32_t this_ptr) {
12128 if ((this_ptr & 1) != 0) return;
12129 LDKPersist this_ptr_conv = *(LDKPersist*)(((uint64_t)this_ptr) & ~1);
12130 FREE((void*)this_ptr);
12131 Persist_free(this_ptr_conv);
12134 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint32_t arg) {
12135 LDKu8slice ser_ref;
12136 ser_ref.datalen = *((uint32_t*)ser);
12137 ser_ref.data = (int8_t*)(ser + 4);
12138 LDKKeysInterface* arg_conv = (LDKKeysInterface*)(((uint64_t)arg) & ~1);
12139 LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ");
12140 *ret_conv = C2Tuple_BlockHashChannelMonitorZ_read(ser_ref, arg_conv);
12141 return (uint64_t)ret_conv;
12144 void __attribute__((visibility("default"))) TS_OutPoint_free(uint32_t this_obj) {
12145 LDKOutPoint this_obj_conv;
12146 this_obj_conv.inner = (void*)(this_obj & (~1));
12147 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12148 OutPoint_free(this_obj_conv);
12151 int8_tArray __attribute__((visibility("default"))) TS_OutPoint_get_txid(uint32_t this_ptr) {
12152 LDKOutPoint this_ptr_conv;
12153 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12154 this_ptr_conv.is_owned = false;
12155 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12156 memcpy((uint8_t*)(ret_arr + 4), *OutPoint_get_txid(&this_ptr_conv), 32);
12160 void __attribute__((visibility("default"))) TS_OutPoint_set_txid(uint32_t this_ptr, int8_tArray val) {
12161 LDKOutPoint this_ptr_conv;
12162 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12163 this_ptr_conv.is_owned = false;
12164 LDKThirtyTwoBytes val_ref;
12165 CHECK(*((uint32_t*)val) == 32);
12166 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
12167 OutPoint_set_txid(&this_ptr_conv, val_ref);
12170 int16_t __attribute__((visibility("default"))) TS_OutPoint_get_index(uint32_t this_ptr) {
12171 LDKOutPoint this_ptr_conv;
12172 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12173 this_ptr_conv.is_owned = false;
12174 int16_t ret_val = OutPoint_get_index(&this_ptr_conv);
12178 void __attribute__((visibility("default"))) TS_OutPoint_set_index(uint32_t this_ptr, int16_t val) {
12179 LDKOutPoint this_ptr_conv;
12180 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12181 this_ptr_conv.is_owned = false;
12182 OutPoint_set_index(&this_ptr_conv, val);
12185 uint32_t __attribute__((visibility("default"))) TS_OutPoint_new(int8_tArray txid_arg, int16_t index_arg) {
12186 LDKThirtyTwoBytes txid_arg_ref;
12187 CHECK(*((uint32_t*)txid_arg) == 32);
12188 memcpy(txid_arg_ref.data, (uint8_t*)(txid_arg + 4), 32);
12189 LDKOutPoint ret_var = OutPoint_new(txid_arg_ref, index_arg);
12190 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12191 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12192 uint64_t ret_ref = (uint64_t)ret_var.inner;
12193 if (ret_var.is_owned) {
12199 uint32_t __attribute__((visibility("default"))) TS_OutPoint_clone(uint32_t orig) {
12200 LDKOutPoint orig_conv;
12201 orig_conv.inner = (void*)(orig & (~1));
12202 orig_conv.is_owned = false;
12203 LDKOutPoint ret_var = OutPoint_clone(&orig_conv);
12204 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12205 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12206 uint64_t ret_ref = (uint64_t)ret_var.inner;
12207 if (ret_var.is_owned) {
12213 jboolean __attribute__((visibility("default"))) TS_OutPoint_eq(uint32_t a, uint32_t b) {
12214 LDKOutPoint a_conv;
12215 a_conv.inner = (void*)(a & (~1));
12216 a_conv.is_owned = false;
12217 LDKOutPoint b_conv;
12218 b_conv.inner = (void*)(b & (~1));
12219 b_conv.is_owned = false;
12220 jboolean ret_val = OutPoint_eq(&a_conv, &b_conv);
12224 int64_t __attribute__((visibility("default"))) TS_OutPoint_hash(uint32_t o) {
12225 LDKOutPoint o_conv;
12226 o_conv.inner = (void*)(o & (~1));
12227 o_conv.is_owned = false;
12228 int64_t ret_val = OutPoint_hash(&o_conv);
12232 int8_tArray __attribute__((visibility("default"))) TS_OutPoint_to_channel_id(uint32_t this_arg) {
12233 LDKOutPoint this_arg_conv;
12234 this_arg_conv.inner = (void*)(this_arg & (~1));
12235 this_arg_conv.is_owned = false;
12236 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12237 memcpy((uint8_t*)(ret_arr + 4), OutPoint_to_channel_id(&this_arg_conv).data, 32);
12241 int8_tArray __attribute__((visibility("default"))) TS_OutPoint_write(uint32_t obj) {
12242 LDKOutPoint obj_conv;
12243 obj_conv.inner = (void*)(obj & (~1));
12244 obj_conv.is_owned = false;
12245 LDKCVec_u8Z ret_var = OutPoint_write(&obj_conv);
12246 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
12247 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
12248 CVec_u8Z_free(ret_var);
12252 uint32_t __attribute__((visibility("default"))) TS_OutPoint_read(int8_tArray ser) {
12253 LDKu8slice ser_ref;
12254 ser_ref.datalen = *((uint32_t*)ser);
12255 ser_ref.data = (int8_t*)(ser + 4);
12256 LDKCResult_OutPointDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OutPointDecodeErrorZ), "LDKCResult_OutPointDecodeErrorZ");
12257 *ret_conv = OutPoint_read(ser_ref);
12258 return (uint64_t)ret_conv;
12261 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_free(uint32_t this_obj) {
12262 LDKDelayedPaymentOutputDescriptor this_obj_conv;
12263 this_obj_conv.inner = (void*)(this_obj & (~1));
12264 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12265 DelayedPaymentOutputDescriptor_free(this_obj_conv);
12268 uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_outpoint(uint32_t this_ptr) {
12269 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12270 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12271 this_ptr_conv.is_owned = false;
12272 LDKOutPoint ret_var = DelayedPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
12273 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12274 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12275 uint64_t ret_ref = (uint64_t)ret_var.inner;
12276 if (ret_var.is_owned) {
12282 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_outpoint(uint32_t this_ptr, uint32_t val) {
12283 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12284 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12285 this_ptr_conv.is_owned = false;
12286 LDKOutPoint val_conv;
12287 val_conv.inner = (void*)(val & (~1));
12288 val_conv.is_owned = (val & 1) || (val == 0);
12289 val_conv = OutPoint_clone(&val_conv);
12290 DelayedPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
12293 int8_tArray __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_per_commitment_point(uint32_t this_ptr) {
12294 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12295 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12296 this_ptr_conv.is_owned = false;
12297 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
12298 memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
12302 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
12303 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12305 this_ptr_conv.is_owned = false;
12306 LDKPublicKey val_ref;
12307 CHECK(*((uint32_t*)val) == 33);
12308 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
12309 DelayedPaymentOutputDescriptor_set_per_commitment_point(&this_ptr_conv, val_ref);
12312 int16_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_to_self_delay(uint32_t this_ptr) {
12313 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12314 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12315 this_ptr_conv.is_owned = false;
12316 int16_t ret_val = DelayedPaymentOutputDescriptor_get_to_self_delay(&this_ptr_conv);
12320 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_to_self_delay(uint32_t this_ptr, int16_t val) {
12321 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12323 this_ptr_conv.is_owned = false;
12324 DelayedPaymentOutputDescriptor_set_to_self_delay(&this_ptr_conv, val);
12327 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_output(uint32_t this_ptr, uint32_t val) {
12328 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12329 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12330 this_ptr_conv.is_owned = false;
12331 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
12332 DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
12335 int8_tArray __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_revocation_pubkey(uint32_t this_ptr) {
12336 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12337 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12338 this_ptr_conv.is_owned = false;
12339 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
12340 memcpy((uint8_t*)(ret_arr + 4), DelayedPaymentOutputDescriptor_get_revocation_pubkey(&this_ptr_conv).compressed_form, 33);
12344 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_revocation_pubkey(uint32_t this_ptr, int8_tArray val) {
12345 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12346 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12347 this_ptr_conv.is_owned = false;
12348 LDKPublicKey val_ref;
12349 CHECK(*((uint32_t*)val) == 33);
12350 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
12351 DelayedPaymentOutputDescriptor_set_revocation_pubkey(&this_ptr_conv, val_ref);
12354 int8_tArray __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_channel_keys_id(uint32_t this_ptr) {
12355 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12356 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12357 this_ptr_conv.is_owned = false;
12358 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12359 memcpy((uint8_t*)(ret_arr + 4), *DelayedPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
12363 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_channel_keys_id(uint32_t this_ptr, int8_tArray val) {
12364 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12365 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12366 this_ptr_conv.is_owned = false;
12367 LDKThirtyTwoBytes val_ref;
12368 CHECK(*((uint32_t*)val) == 32);
12369 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
12370 DelayedPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
12373 int64_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_get_channel_value_satoshis(uint32_t this_ptr) {
12374 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12375 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12376 this_ptr_conv.is_owned = false;
12377 int64_t ret_val = DelayedPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
12381 void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
12382 LDKDelayedPaymentOutputDescriptor this_ptr_conv;
12383 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12384 this_ptr_conv.is_owned = false;
12385 DelayedPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
12388 uint32_t __attribute__((visibility("default"))) 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) {
12389 LDKOutPoint outpoint_arg_conv;
12390 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
12391 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
12392 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
12393 LDKPublicKey per_commitment_point_arg_ref;
12394 CHECK(*((uint32_t*)per_commitment_point_arg) == 33);
12395 memcpy(per_commitment_point_arg_ref.compressed_form, (uint8_t*)(per_commitment_point_arg + 4), 33);
12396 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
12397 LDKPublicKey revocation_pubkey_arg_ref;
12398 CHECK(*((uint32_t*)revocation_pubkey_arg) == 33);
12399 memcpy(revocation_pubkey_arg_ref.compressed_form, (uint8_t*)(revocation_pubkey_arg + 4), 33);
12400 LDKThirtyTwoBytes channel_keys_id_arg_ref;
12401 CHECK(*((uint32_t*)channel_keys_id_arg) == 32);
12402 memcpy(channel_keys_id_arg_ref.data, (uint8_t*)(channel_keys_id_arg + 4), 32);
12403 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);
12404 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12405 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12406 uint64_t ret_ref = (uint64_t)ret_var.inner;
12407 if (ret_var.is_owned) {
12413 uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_clone(uint32_t orig) {
12414 LDKDelayedPaymentOutputDescriptor orig_conv;
12415 orig_conv.inner = (void*)(orig & (~1));
12416 orig_conv.is_owned = false;
12417 LDKDelayedPaymentOutputDescriptor ret_var = DelayedPaymentOutputDescriptor_clone(&orig_conv);
12418 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12419 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12420 uint64_t ret_ref = (uint64_t)ret_var.inner;
12421 if (ret_var.is_owned) {
12427 int8_tArray __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_write(uint32_t obj) {
12428 LDKDelayedPaymentOutputDescriptor obj_conv;
12429 obj_conv.inner = (void*)(obj & (~1));
12430 obj_conv.is_owned = false;
12431 LDKCVec_u8Z ret_var = DelayedPaymentOutputDescriptor_write(&obj_conv);
12432 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
12433 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
12434 CVec_u8Z_free(ret_var);
12438 uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_read(int8_tArray ser) {
12439 LDKu8slice ser_ref;
12440 ser_ref.datalen = *((uint32_t*)ser);
12441 ser_ref.data = (int8_t*)(ser + 4);
12442 LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_DelayedPaymentOutputDescriptorDecodeErrorZ");
12443 *ret_conv = DelayedPaymentOutputDescriptor_read(ser_ref);
12444 return (uint64_t)ret_conv;
12447 void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_free(uint32_t this_obj) {
12448 LDKStaticPaymentOutputDescriptor this_obj_conv;
12449 this_obj_conv.inner = (void*)(this_obj & (~1));
12450 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12451 StaticPaymentOutputDescriptor_free(this_obj_conv);
12454 uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_get_outpoint(uint32_t this_ptr) {
12455 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12456 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12457 this_ptr_conv.is_owned = false;
12458 LDKOutPoint ret_var = StaticPaymentOutputDescriptor_get_outpoint(&this_ptr_conv);
12459 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12460 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12461 uint64_t ret_ref = (uint64_t)ret_var.inner;
12462 if (ret_var.is_owned) {
12468 void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_set_outpoint(uint32_t this_ptr, uint32_t val) {
12469 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12470 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12471 this_ptr_conv.is_owned = false;
12472 LDKOutPoint val_conv;
12473 val_conv.inner = (void*)(val & (~1));
12474 val_conv.is_owned = (val & 1) || (val == 0);
12475 val_conv = OutPoint_clone(&val_conv);
12476 StaticPaymentOutputDescriptor_set_outpoint(&this_ptr_conv, val_conv);
12479 void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_set_output(uint32_t this_ptr, uint32_t val) {
12480 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12481 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12482 this_ptr_conv.is_owned = false;
12483 LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1);
12484 StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv);
12487 int8_tArray __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_get_channel_keys_id(uint32_t this_ptr) {
12488 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12489 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12490 this_ptr_conv.is_owned = false;
12491 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12492 memcpy((uint8_t*)(ret_arr + 4), *StaticPaymentOutputDescriptor_get_channel_keys_id(&this_ptr_conv), 32);
12496 void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_set_channel_keys_id(uint32_t this_ptr, int8_tArray val) {
12497 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12498 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12499 this_ptr_conv.is_owned = false;
12500 LDKThirtyTwoBytes val_ref;
12501 CHECK(*((uint32_t*)val) == 32);
12502 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
12503 StaticPaymentOutputDescriptor_set_channel_keys_id(&this_ptr_conv, val_ref);
12506 int64_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_get_channel_value_satoshis(uint32_t this_ptr) {
12507 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12508 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12509 this_ptr_conv.is_owned = false;
12510 int64_t ret_val = StaticPaymentOutputDescriptor_get_channel_value_satoshis(&this_ptr_conv);
12514 void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
12515 LDKStaticPaymentOutputDescriptor this_ptr_conv;
12516 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12517 this_ptr_conv.is_owned = false;
12518 StaticPaymentOutputDescriptor_set_channel_value_satoshis(&this_ptr_conv, val);
12521 uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_new(uint32_t outpoint_arg, uint32_t output_arg, int8_tArray channel_keys_id_arg, int64_t channel_value_satoshis_arg) {
12522 LDKOutPoint outpoint_arg_conv;
12523 outpoint_arg_conv.inner = (void*)(outpoint_arg & (~1));
12524 outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0);
12525 outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv);
12526 LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1);
12527 LDKThirtyTwoBytes channel_keys_id_arg_ref;
12528 CHECK(*((uint32_t*)channel_keys_id_arg) == 32);
12529 memcpy(channel_keys_id_arg_ref.data, (uint8_t*)(channel_keys_id_arg + 4), 32);
12530 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_new(outpoint_arg_conv, output_arg_conv, channel_keys_id_arg_ref, channel_value_satoshis_arg);
12531 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12532 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12533 uint64_t ret_ref = (uint64_t)ret_var.inner;
12534 if (ret_var.is_owned) {
12540 uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_clone(uint32_t orig) {
12541 LDKStaticPaymentOutputDescriptor orig_conv;
12542 orig_conv.inner = (void*)(orig & (~1));
12543 orig_conv.is_owned = false;
12544 LDKStaticPaymentOutputDescriptor ret_var = StaticPaymentOutputDescriptor_clone(&orig_conv);
12545 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12546 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12547 uint64_t ret_ref = (uint64_t)ret_var.inner;
12548 if (ret_var.is_owned) {
12554 int8_tArray __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_write(uint32_t obj) {
12555 LDKStaticPaymentOutputDescriptor obj_conv;
12556 obj_conv.inner = (void*)(obj & (~1));
12557 obj_conv.is_owned = false;
12558 LDKCVec_u8Z ret_var = StaticPaymentOutputDescriptor_write(&obj_conv);
12559 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
12560 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
12561 CVec_u8Z_free(ret_var);
12565 uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_read(int8_tArray ser) {
12566 LDKu8slice ser_ref;
12567 ser_ref.datalen = *((uint32_t*)ser);
12568 ser_ref.data = (int8_t*)(ser + 4);
12569 LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ), "LDKCResult_StaticPaymentOutputDescriptorDecodeErrorZ");
12570 *ret_conv = StaticPaymentOutputDescriptor_read(ser_ref);
12571 return (uint64_t)ret_conv;
12574 void __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_free(uint32_t this_ptr) {
12575 if ((this_ptr & 1) != 0) return;
12576 LDKSpendableOutputDescriptor this_ptr_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)this_ptr) & ~1);
12577 FREE((void*)this_ptr);
12578 SpendableOutputDescriptor_free(this_ptr_conv);
12581 uint32_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_clone(uint32_t orig) {
12582 LDKSpendableOutputDescriptor* orig_conv = (LDKSpendableOutputDescriptor*)orig;
12583 LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor");
12584 *ret_copy = SpendableOutputDescriptor_clone(orig_conv);
12585 uint64_t ret_ref = (uint64_t)ret_copy;
12589 int8_tArray __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_write(uint32_t obj) {
12590 LDKSpendableOutputDescriptor* obj_conv = (LDKSpendableOutputDescriptor*)obj;
12591 LDKCVec_u8Z ret_var = SpendableOutputDescriptor_write(obj_conv);
12592 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
12593 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
12594 CVec_u8Z_free(ret_var);
12598 uint32_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_read(int8_tArray ser) {
12599 LDKu8slice ser_ref;
12600 ser_ref.datalen = *((uint32_t*)ser);
12601 ser_ref.data = (int8_t*)(ser + 4);
12602 LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ");
12603 *ret_conv = SpendableOutputDescriptor_read(ser_ref);
12604 return (uint64_t)ret_conv;
12607 void __attribute__((visibility("default"))) TS_BaseSign_free(uint32_t this_ptr) {
12608 if ((this_ptr & 1) != 0) return;
12609 LDKBaseSign this_ptr_conv = *(LDKBaseSign*)(((uint64_t)this_ptr) & ~1);
12610 FREE((void*)this_ptr);
12611 BaseSign_free(this_ptr_conv);
12614 uint32_t __attribute__((visibility("default"))) TS_Sign_clone(uint32_t orig) {
12615 LDKSign* orig_conv = (LDKSign*)(((uint64_t)orig) & ~1);
12616 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
12617 *ret = Sign_clone(orig_conv);
12618 return (uint64_t)ret;
12621 void __attribute__((visibility("default"))) TS_Sign_free(uint32_t this_ptr) {
12622 if ((this_ptr & 1) != 0) return;
12623 LDKSign this_ptr_conv = *(LDKSign*)(((uint64_t)this_ptr) & ~1);
12624 FREE((void*)this_ptr);
12625 Sign_free(this_ptr_conv);
12628 void __attribute__((visibility("default"))) TS_KeysInterface_free(uint32_t this_ptr) {
12629 if ((this_ptr & 1) != 0) return;
12630 LDKKeysInterface this_ptr_conv = *(LDKKeysInterface*)(((uint64_t)this_ptr) & ~1);
12631 FREE((void*)this_ptr);
12632 KeysInterface_free(this_ptr_conv);
12635 void __attribute__((visibility("default"))) TS_InMemorySigner_free(uint32_t this_obj) {
12636 LDKInMemorySigner this_obj_conv;
12637 this_obj_conv.inner = (void*)(this_obj & (~1));
12638 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12639 InMemorySigner_free(this_obj_conv);
12642 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_funding_key(uint32_t this_ptr) {
12643 LDKInMemorySigner this_ptr_conv;
12644 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12645 this_ptr_conv.is_owned = false;
12646 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12647 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_funding_key(&this_ptr_conv), 32);
12651 void __attribute__((visibility("default"))) TS_InMemorySigner_set_funding_key(uint32_t this_ptr, int8_tArray val) {
12652 LDKInMemorySigner this_ptr_conv;
12653 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12654 this_ptr_conv.is_owned = false;
12655 LDKSecretKey val_ref;
12656 CHECK(*((uint32_t*)val) == 32);
12657 memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
12658 InMemorySigner_set_funding_key(&this_ptr_conv, val_ref);
12661 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_revocation_base_key(uint32_t this_ptr) {
12662 LDKInMemorySigner this_ptr_conv;
12663 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12664 this_ptr_conv.is_owned = false;
12665 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12666 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_revocation_base_key(&this_ptr_conv), 32);
12670 void __attribute__((visibility("default"))) TS_InMemorySigner_set_revocation_base_key(uint32_t this_ptr, int8_tArray val) {
12671 LDKInMemorySigner this_ptr_conv;
12672 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12673 this_ptr_conv.is_owned = false;
12674 LDKSecretKey val_ref;
12675 CHECK(*((uint32_t*)val) == 32);
12676 memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
12677 InMemorySigner_set_revocation_base_key(&this_ptr_conv, val_ref);
12680 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_payment_key(uint32_t this_ptr) {
12681 LDKInMemorySigner this_ptr_conv;
12682 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12683 this_ptr_conv.is_owned = false;
12684 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12685 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_payment_key(&this_ptr_conv), 32);
12689 void __attribute__((visibility("default"))) TS_InMemorySigner_set_payment_key(uint32_t this_ptr, int8_tArray val) {
12690 LDKInMemorySigner this_ptr_conv;
12691 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12692 this_ptr_conv.is_owned = false;
12693 LDKSecretKey val_ref;
12694 CHECK(*((uint32_t*)val) == 32);
12695 memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
12696 InMemorySigner_set_payment_key(&this_ptr_conv, val_ref);
12699 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_delayed_payment_base_key(uint32_t this_ptr) {
12700 LDKInMemorySigner this_ptr_conv;
12701 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12702 this_ptr_conv.is_owned = false;
12703 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12704 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_delayed_payment_base_key(&this_ptr_conv), 32);
12708 void __attribute__((visibility("default"))) TS_InMemorySigner_set_delayed_payment_base_key(uint32_t this_ptr, int8_tArray val) {
12709 LDKInMemorySigner this_ptr_conv;
12710 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12711 this_ptr_conv.is_owned = false;
12712 LDKSecretKey val_ref;
12713 CHECK(*((uint32_t*)val) == 32);
12714 memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
12715 InMemorySigner_set_delayed_payment_base_key(&this_ptr_conv, val_ref);
12718 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_htlc_base_key(uint32_t this_ptr) {
12719 LDKInMemorySigner this_ptr_conv;
12720 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12721 this_ptr_conv.is_owned = false;
12722 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12723 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_htlc_base_key(&this_ptr_conv), 32);
12727 void __attribute__((visibility("default"))) TS_InMemorySigner_set_htlc_base_key(uint32_t this_ptr, int8_tArray val) {
12728 LDKInMemorySigner this_ptr_conv;
12729 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12730 this_ptr_conv.is_owned = false;
12731 LDKSecretKey val_ref;
12732 CHECK(*((uint32_t*)val) == 32);
12733 memcpy(val_ref.bytes, (uint8_t*)(val + 4), 32);
12734 InMemorySigner_set_htlc_base_key(&this_ptr_conv, val_ref);
12737 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_get_commitment_seed(uint32_t this_ptr) {
12738 LDKInMemorySigner this_ptr_conv;
12739 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12740 this_ptr_conv.is_owned = false;
12741 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
12742 memcpy((uint8_t*)(ret_arr + 4), *InMemorySigner_get_commitment_seed(&this_ptr_conv), 32);
12746 void __attribute__((visibility("default"))) TS_InMemorySigner_set_commitment_seed(uint32_t this_ptr, int8_tArray val) {
12747 LDKInMemorySigner this_ptr_conv;
12748 this_ptr_conv.inner = (void*)(this_ptr & (~1));
12749 this_ptr_conv.is_owned = false;
12750 LDKThirtyTwoBytes val_ref;
12751 CHECK(*((uint32_t*)val) == 32);
12752 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
12753 InMemorySigner_set_commitment_seed(&this_ptr_conv, val_ref);
12756 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_clone(uint32_t orig) {
12757 LDKInMemorySigner orig_conv;
12758 orig_conv.inner = (void*)(orig & (~1));
12759 orig_conv.is_owned = false;
12760 LDKInMemorySigner ret_var = InMemorySigner_clone(&orig_conv);
12761 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12762 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12763 uint64_t ret_ref = (uint64_t)ret_var.inner;
12764 if (ret_var.is_owned) {
12770 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_new(int8_tArray funding_key, int8_tArray revocation_base_key, int8_tArray payment_key, int8_tArray delayed_payment_base_key, int8_tArray htlc_base_key, int8_tArray commitment_seed, int64_t channel_value_satoshis, int8_tArray channel_keys_id) {
12771 LDKSecretKey funding_key_ref;
12772 CHECK(*((uint32_t*)funding_key) == 32);
12773 memcpy(funding_key_ref.bytes, (uint8_t*)(funding_key + 4), 32);
12774 LDKSecretKey revocation_base_key_ref;
12775 CHECK(*((uint32_t*)revocation_base_key) == 32);
12776 memcpy(revocation_base_key_ref.bytes, (uint8_t*)(revocation_base_key + 4), 32);
12777 LDKSecretKey payment_key_ref;
12778 CHECK(*((uint32_t*)payment_key) == 32);
12779 memcpy(payment_key_ref.bytes, (uint8_t*)(payment_key + 4), 32);
12780 LDKSecretKey delayed_payment_base_key_ref;
12781 CHECK(*((uint32_t*)delayed_payment_base_key) == 32);
12782 memcpy(delayed_payment_base_key_ref.bytes, (uint8_t*)(delayed_payment_base_key + 4), 32);
12783 LDKSecretKey htlc_base_key_ref;
12784 CHECK(*((uint32_t*)htlc_base_key) == 32);
12785 memcpy(htlc_base_key_ref.bytes, (uint8_t*)(htlc_base_key + 4), 32);
12786 LDKThirtyTwoBytes commitment_seed_ref;
12787 CHECK(*((uint32_t*)commitment_seed) == 32);
12788 memcpy(commitment_seed_ref.data, (uint8_t*)(commitment_seed + 4), 32);
12789 LDKThirtyTwoBytes channel_keys_id_ref;
12790 CHECK(*((uint32_t*)channel_keys_id) == 32);
12791 memcpy(channel_keys_id_ref.data, (uint8_t*)(channel_keys_id + 4), 32);
12792 LDKInMemorySigner ret_var = InMemorySigner_new(funding_key_ref, revocation_base_key_ref, payment_key_ref, delayed_payment_base_key_ref, htlc_base_key_ref, commitment_seed_ref, channel_value_satoshis, channel_keys_id_ref);
12793 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12794 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12795 uint64_t ret_ref = (uint64_t)ret_var.inner;
12796 if (ret_var.is_owned) {
12802 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_counterparty_pubkeys(uint32_t this_arg) {
12803 LDKInMemorySigner this_arg_conv;
12804 this_arg_conv.inner = (void*)(this_arg & (~1));
12805 this_arg_conv.is_owned = false;
12806 LDKChannelPublicKeys ret_var = InMemorySigner_counterparty_pubkeys(&this_arg_conv);
12807 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12808 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12809 uint64_t ret_ref = (uint64_t)ret_var.inner;
12810 if (ret_var.is_owned) {
12816 int16_t __attribute__((visibility("default"))) TS_InMemorySigner_counterparty_selected_contest_delay(uint32_t this_arg) {
12817 LDKInMemorySigner this_arg_conv;
12818 this_arg_conv.inner = (void*)(this_arg & (~1));
12819 this_arg_conv.is_owned = false;
12820 int16_t ret_val = InMemorySigner_counterparty_selected_contest_delay(&this_arg_conv);
12824 int16_t __attribute__((visibility("default"))) TS_InMemorySigner_holder_selected_contest_delay(uint32_t this_arg) {
12825 LDKInMemorySigner this_arg_conv;
12826 this_arg_conv.inner = (void*)(this_arg & (~1));
12827 this_arg_conv.is_owned = false;
12828 int16_t ret_val = InMemorySigner_holder_selected_contest_delay(&this_arg_conv);
12832 jboolean __attribute__((visibility("default"))) TS_InMemorySigner_is_outbound(uint32_t this_arg) {
12833 LDKInMemorySigner this_arg_conv;
12834 this_arg_conv.inner = (void*)(this_arg & (~1));
12835 this_arg_conv.is_owned = false;
12836 jboolean ret_val = InMemorySigner_is_outbound(&this_arg_conv);
12840 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_funding_outpoint(uint32_t this_arg) {
12841 LDKInMemorySigner this_arg_conv;
12842 this_arg_conv.inner = (void*)(this_arg & (~1));
12843 this_arg_conv.is_owned = false;
12844 LDKOutPoint ret_var = InMemorySigner_funding_outpoint(&this_arg_conv);
12845 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12846 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12847 uint64_t ret_ref = (uint64_t)ret_var.inner;
12848 if (ret_var.is_owned) {
12854 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_get_channel_parameters(uint32_t this_arg) {
12855 LDKInMemorySigner this_arg_conv;
12856 this_arg_conv.inner = (void*)(this_arg & (~1));
12857 this_arg_conv.is_owned = false;
12858 LDKChannelTransactionParameters ret_var = InMemorySigner_get_channel_parameters(&this_arg_conv);
12859 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12860 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12861 uint64_t ret_ref = (uint64_t)ret_var.inner;
12862 if (ret_var.is_owned) {
12868 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_sign_counterparty_payment_input(uint32_t this_arg, int8_tArray spend_tx, int64_t input_idx, uint32_t descriptor) {
12869 LDKInMemorySigner this_arg_conv;
12870 this_arg_conv.inner = (void*)(this_arg & (~1));
12871 this_arg_conv.is_owned = false;
12872 LDKTransaction spend_tx_ref;
12873 spend_tx_ref.datalen = *((uint32_t*)spend_tx);
12874 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
12875 memcpy(spend_tx_ref.data, (uint8_t*)(spend_tx + 4), spend_tx_ref.datalen);
12876 spend_tx_ref.data_is_owned = true;
12877 LDKStaticPaymentOutputDescriptor descriptor_conv;
12878 descriptor_conv.inner = (void*)(descriptor & (~1));
12879 descriptor_conv.is_owned = false;
12880 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
12881 *ret_conv = InMemorySigner_sign_counterparty_payment_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
12882 return (uint64_t)ret_conv;
12885 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_sign_dynamic_p2wsh_input(uint32_t this_arg, int8_tArray spend_tx, int64_t input_idx, uint32_t descriptor) {
12886 LDKInMemorySigner this_arg_conv;
12887 this_arg_conv.inner = (void*)(this_arg & (~1));
12888 this_arg_conv.is_owned = false;
12889 LDKTransaction spend_tx_ref;
12890 spend_tx_ref.datalen = *((uint32_t*)spend_tx);
12891 spend_tx_ref.data = MALLOC(spend_tx_ref.datalen, "LDKTransaction Bytes");
12892 memcpy(spend_tx_ref.data, (uint8_t*)(spend_tx + 4), spend_tx_ref.datalen);
12893 spend_tx_ref.data_is_owned = true;
12894 LDKDelayedPaymentOutputDescriptor descriptor_conv;
12895 descriptor_conv.inner = (void*)(descriptor & (~1));
12896 descriptor_conv.is_owned = false;
12897 LDKCResult_CVec_CVec_u8ZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_CVec_u8ZZNoneZ), "LDKCResult_CVec_CVec_u8ZZNoneZ");
12898 *ret_conv = InMemorySigner_sign_dynamic_p2wsh_input(&this_arg_conv, spend_tx_ref, input_idx, &descriptor_conv);
12899 return (uint64_t)ret_conv;
12902 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_as_BaseSign(uint32_t this_arg) {
12903 LDKInMemorySigner this_arg_conv;
12904 this_arg_conv.inner = (void*)(this_arg & (~1));
12905 this_arg_conv.is_owned = false;
12906 LDKBaseSign* ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign");
12907 *ret = InMemorySigner_as_BaseSign(&this_arg_conv);
12908 return (uint64_t)ret;
12911 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_as_Sign(uint32_t this_arg) {
12912 LDKInMemorySigner this_arg_conv;
12913 this_arg_conv.inner = (void*)(this_arg & (~1));
12914 this_arg_conv.is_owned = false;
12915 LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign");
12916 *ret = InMemorySigner_as_Sign(&this_arg_conv);
12917 return (uint64_t)ret;
12920 int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_write(uint32_t obj) {
12921 LDKInMemorySigner obj_conv;
12922 obj_conv.inner = (void*)(obj & (~1));
12923 obj_conv.is_owned = false;
12924 LDKCVec_u8Z ret_var = InMemorySigner_write(&obj_conv);
12925 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
12926 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
12927 CVec_u8Z_free(ret_var);
12931 uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_read(int8_tArray ser) {
12932 LDKu8slice ser_ref;
12933 ser_ref.datalen = *((uint32_t*)ser);
12934 ser_ref.data = (int8_t*)(ser + 4);
12935 LDKCResult_InMemorySignerDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InMemorySignerDecodeErrorZ), "LDKCResult_InMemorySignerDecodeErrorZ");
12936 *ret_conv = InMemorySigner_read(ser_ref);
12937 return (uint64_t)ret_conv;
12940 void __attribute__((visibility("default"))) TS_KeysManager_free(uint32_t this_obj) {
12941 LDKKeysManager this_obj_conv;
12942 this_obj_conv.inner = (void*)(this_obj & (~1));
12943 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
12944 KeysManager_free(this_obj_conv);
12947 uint32_t __attribute__((visibility("default"))) TS_KeysManager_new(int8_tArray seed, int64_t starting_time_secs, int32_t starting_time_nanos) {
12948 unsigned char seed_arr[32];
12949 CHECK(*((uint32_t*)seed) == 32);
12950 memcpy(seed_arr, (uint8_t*)(seed + 4), 32);
12951 unsigned char (*seed_ref)[32] = &seed_arr;
12952 LDKKeysManager ret_var = KeysManager_new(seed_ref, starting_time_secs, starting_time_nanos);
12953 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12954 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12955 uint64_t ret_ref = (uint64_t)ret_var.inner;
12956 if (ret_var.is_owned) {
12962 uint32_t __attribute__((visibility("default"))) TS_KeysManager_derive_channel_keys(uint32_t this_arg, int64_t channel_value_satoshis, int8_tArray params) {
12963 LDKKeysManager this_arg_conv;
12964 this_arg_conv.inner = (void*)(this_arg & (~1));
12965 this_arg_conv.is_owned = false;
12966 unsigned char params_arr[32];
12967 CHECK(*((uint32_t*)params) == 32);
12968 memcpy(params_arr, (uint8_t*)(params + 4), 32);
12969 unsigned char (*params_ref)[32] = ¶ms_arr;
12970 LDKInMemorySigner ret_var = KeysManager_derive_channel_keys(&this_arg_conv, channel_value_satoshis, params_ref);
12971 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
12972 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
12973 uint64_t ret_ref = (uint64_t)ret_var.inner;
12974 if (ret_var.is_owned) {
12980 uint32_t __attribute__((visibility("default"))) 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) {
12981 LDKKeysManager this_arg_conv;
12982 this_arg_conv.inner = (void*)(this_arg & (~1));
12983 this_arg_conv.is_owned = false;
12984 LDKCVec_SpendableOutputDescriptorZ descriptors_constr;
12985 descriptors_constr.datalen = *((uint32_t*)descriptors);
12986 if (descriptors_constr.datalen > 0)
12987 descriptors_constr.data = MALLOC(descriptors_constr.datalen * sizeof(LDKSpendableOutputDescriptor), "LDKCVec_SpendableOutputDescriptorZ Elements");
12989 descriptors_constr.data = NULL;
12990 uint32_t* descriptors_vals = (uint32_t*)(descriptors + 4);
12991 for (size_t b = 0; b < descriptors_constr.datalen; b++) {
12992 uint32_t descriptors_conv_27 = descriptors_vals[b];
12993 LDKSpendableOutputDescriptor descriptors_conv_27_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)descriptors_conv_27) & ~1);
12994 descriptors_conv_27_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)descriptors_conv_27) & ~1));
12995 descriptors_constr.data[b] = descriptors_conv_27_conv;
12997 LDKCVec_TxOutZ outputs_constr;
12998 outputs_constr.datalen = *((uint32_t*)outputs);
12999 if (outputs_constr.datalen > 0)
13000 outputs_constr.data = MALLOC(outputs_constr.datalen * sizeof(LDKTxOut), "LDKCVec_TxOutZ Elements");
13002 outputs_constr.data = NULL;
13003 uint32_t* outputs_vals = (uint32_t*)(outputs + 4);
13004 for (size_t h = 0; h < outputs_constr.datalen; h++) {
13005 uint32_t outputs_conv_7 = outputs_vals[h];
13006 LDKTxOut outputs_conv_7_conv = *(LDKTxOut*)(((uint64_t)outputs_conv_7) & ~1);
13007 outputs_conv_7_conv = TxOut_clone((LDKTxOut*)(((uint64_t)outputs_conv_7) & ~1));
13008 outputs_constr.data[h] = outputs_conv_7_conv;
13010 LDKCVec_u8Z change_destination_script_ref;
13011 change_destination_script_ref.datalen = *((uint32_t*)change_destination_script);
13012 change_destination_script_ref.data = MALLOC(change_destination_script_ref.datalen, "LDKCVec_u8Z Bytes");
13013 memcpy(change_destination_script_ref.data, (uint8_t*)(change_destination_script + 4), change_destination_script_ref.datalen);
13014 LDKCResult_TransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TransactionNoneZ), "LDKCResult_TransactionNoneZ");
13015 *ret_conv = KeysManager_spend_spendable_outputs(&this_arg_conv, descriptors_constr, outputs_constr, change_destination_script_ref, feerate_sat_per_1000_weight);
13016 return (uint64_t)ret_conv;
13019 uint32_t __attribute__((visibility("default"))) TS_KeysManager_as_KeysInterface(uint32_t this_arg) {
13020 LDKKeysManager this_arg_conv;
13021 this_arg_conv.inner = (void*)(this_arg & (~1));
13022 this_arg_conv.is_owned = false;
13023 LDKKeysInterface* ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface");
13024 *ret = KeysManager_as_KeysInterface(&this_arg_conv);
13025 return (uint64_t)ret;
13028 void __attribute__((visibility("default"))) TS_ChannelManager_free(uint32_t this_obj) {
13029 LDKChannelManager this_obj_conv;
13030 this_obj_conv.inner = (void*)(this_obj & (~1));
13031 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13032 ChannelManager_free(this_obj_conv);
13035 void __attribute__((visibility("default"))) TS_ChainParameters_free(uint32_t this_obj) {
13036 LDKChainParameters this_obj_conv;
13037 this_obj_conv.inner = (void*)(this_obj & (~1));
13038 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13039 ChainParameters_free(this_obj_conv);
13042 uint32_t __attribute__((visibility("default"))) TS_ChainParameters_get_network(uint32_t this_ptr) {
13043 LDKChainParameters this_ptr_conv;
13044 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13045 this_ptr_conv.is_owned = false;
13046 uint32_t ret_conv = LDKNetwork_to_js(ChainParameters_get_network(&this_ptr_conv));
13050 void __attribute__((visibility("default"))) TS_ChainParameters_set_network(uint32_t this_ptr, uint32_t val) {
13051 LDKChainParameters this_ptr_conv;
13052 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13053 this_ptr_conv.is_owned = false;
13054 LDKNetwork val_conv = LDKNetwork_from_js(val);
13055 ChainParameters_set_network(&this_ptr_conv, val_conv);
13058 uint32_t __attribute__((visibility("default"))) TS_ChainParameters_get_best_block(uint32_t this_ptr) {
13059 LDKChainParameters this_ptr_conv;
13060 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13061 this_ptr_conv.is_owned = false;
13062 LDKBestBlock ret_var = ChainParameters_get_best_block(&this_ptr_conv);
13063 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13064 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13065 uint64_t ret_ref = (uint64_t)ret_var.inner;
13066 if (ret_var.is_owned) {
13072 void __attribute__((visibility("default"))) TS_ChainParameters_set_best_block(uint32_t this_ptr, uint32_t val) {
13073 LDKChainParameters this_ptr_conv;
13074 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13075 this_ptr_conv.is_owned = false;
13076 LDKBestBlock val_conv;
13077 val_conv.inner = (void*)(val & (~1));
13078 val_conv.is_owned = (val & 1) || (val == 0);
13079 val_conv = BestBlock_clone(&val_conv);
13080 ChainParameters_set_best_block(&this_ptr_conv, val_conv);
13083 uint32_t __attribute__((visibility("default"))) TS_ChainParameters_new(uint32_t network_arg, uint32_t best_block_arg) {
13084 LDKNetwork network_arg_conv = LDKNetwork_from_js(network_arg);
13085 LDKBestBlock best_block_arg_conv;
13086 best_block_arg_conv.inner = (void*)(best_block_arg & (~1));
13087 best_block_arg_conv.is_owned = (best_block_arg & 1) || (best_block_arg == 0);
13088 best_block_arg_conv = BestBlock_clone(&best_block_arg_conv);
13089 LDKChainParameters ret_var = ChainParameters_new(network_arg_conv, best_block_arg_conv);
13090 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13091 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13092 uint64_t ret_ref = (uint64_t)ret_var.inner;
13093 if (ret_var.is_owned) {
13099 uint32_t __attribute__((visibility("default"))) TS_ChainParameters_clone(uint32_t orig) {
13100 LDKChainParameters orig_conv;
13101 orig_conv.inner = (void*)(orig & (~1));
13102 orig_conv.is_owned = false;
13103 LDKChainParameters ret_var = ChainParameters_clone(&orig_conv);
13104 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13105 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13106 uint64_t ret_ref = (uint64_t)ret_var.inner;
13107 if (ret_var.is_owned) {
13113 void __attribute__((visibility("default"))) TS_ChannelCounterparty_free(uint32_t this_obj) {
13114 LDKChannelCounterparty this_obj_conv;
13115 this_obj_conv.inner = (void*)(this_obj & (~1));
13116 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13117 ChannelCounterparty_free(this_obj_conv);
13120 int8_tArray __attribute__((visibility("default"))) TS_ChannelCounterparty_get_node_id(uint32_t this_ptr) {
13121 LDKChannelCounterparty this_ptr_conv;
13122 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13123 this_ptr_conv.is_owned = false;
13124 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
13125 memcpy((uint8_t*)(ret_arr + 4), ChannelCounterparty_get_node_id(&this_ptr_conv).compressed_form, 33);
13129 void __attribute__((visibility("default"))) TS_ChannelCounterparty_set_node_id(uint32_t this_ptr, int8_tArray val) {
13130 LDKChannelCounterparty this_ptr_conv;
13131 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13132 this_ptr_conv.is_owned = false;
13133 LDKPublicKey val_ref;
13134 CHECK(*((uint32_t*)val) == 33);
13135 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
13136 ChannelCounterparty_set_node_id(&this_ptr_conv, val_ref);
13139 uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_get_features(uint32_t this_ptr) {
13140 LDKChannelCounterparty this_ptr_conv;
13141 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13142 this_ptr_conv.is_owned = false;
13143 LDKInitFeatures ret_var = ChannelCounterparty_get_features(&this_ptr_conv);
13144 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13145 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13146 uint64_t ret_ref = (uint64_t)ret_var.inner;
13147 if (ret_var.is_owned) {
13153 void __attribute__((visibility("default"))) TS_ChannelCounterparty_set_features(uint32_t this_ptr, uint32_t val) {
13154 LDKChannelCounterparty this_ptr_conv;
13155 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13156 this_ptr_conv.is_owned = false;
13157 LDKInitFeatures val_conv;
13158 val_conv.inner = (void*)(val & (~1));
13159 val_conv.is_owned = (val & 1) || (val == 0);
13160 val_conv = InitFeatures_clone(&val_conv);
13161 ChannelCounterparty_set_features(&this_ptr_conv, val_conv);
13164 int64_t __attribute__((visibility("default"))) TS_ChannelCounterparty_get_unspendable_punishment_reserve(uint32_t this_ptr) {
13165 LDKChannelCounterparty this_ptr_conv;
13166 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13167 this_ptr_conv.is_owned = false;
13168 int64_t ret_val = ChannelCounterparty_get_unspendable_punishment_reserve(&this_ptr_conv);
13172 void __attribute__((visibility("default"))) TS_ChannelCounterparty_set_unspendable_punishment_reserve(uint32_t this_ptr, int64_t val) {
13173 LDKChannelCounterparty this_ptr_conv;
13174 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13175 this_ptr_conv.is_owned = false;
13176 ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val);
13179 uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_clone(uint32_t orig) {
13180 LDKChannelCounterparty orig_conv;
13181 orig_conv.inner = (void*)(orig & (~1));
13182 orig_conv.is_owned = false;
13183 LDKChannelCounterparty ret_var = ChannelCounterparty_clone(&orig_conv);
13184 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13185 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13186 uint64_t ret_ref = (uint64_t)ret_var.inner;
13187 if (ret_var.is_owned) {
13193 void __attribute__((visibility("default"))) TS_ChannelDetails_free(uint32_t this_obj) {
13194 LDKChannelDetails this_obj_conv;
13195 this_obj_conv.inner = (void*)(this_obj & (~1));
13196 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13197 ChannelDetails_free(this_obj_conv);
13200 int8_tArray __attribute__((visibility("default"))) TS_ChannelDetails_get_channel_id(uint32_t this_ptr) {
13201 LDKChannelDetails this_ptr_conv;
13202 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13203 this_ptr_conv.is_owned = false;
13204 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
13205 memcpy((uint8_t*)(ret_arr + 4), *ChannelDetails_get_channel_id(&this_ptr_conv), 32);
13209 void __attribute__((visibility("default"))) TS_ChannelDetails_set_channel_id(uint32_t this_ptr, int8_tArray val) {
13210 LDKChannelDetails this_ptr_conv;
13211 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13212 this_ptr_conv.is_owned = false;
13213 LDKThirtyTwoBytes val_ref;
13214 CHECK(*((uint32_t*)val) == 32);
13215 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
13216 ChannelDetails_set_channel_id(&this_ptr_conv, val_ref);
13219 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_counterparty(uint32_t this_ptr) {
13220 LDKChannelDetails this_ptr_conv;
13221 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13222 this_ptr_conv.is_owned = false;
13223 LDKChannelCounterparty ret_var = ChannelDetails_get_counterparty(&this_ptr_conv);
13224 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13225 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13226 uint64_t ret_ref = (uint64_t)ret_var.inner;
13227 if (ret_var.is_owned) {
13233 void __attribute__((visibility("default"))) TS_ChannelDetails_set_counterparty(uint32_t this_ptr, uint32_t val) {
13234 LDKChannelDetails this_ptr_conv;
13235 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13236 this_ptr_conv.is_owned = false;
13237 LDKChannelCounterparty val_conv;
13238 val_conv.inner = (void*)(val & (~1));
13239 val_conv.is_owned = (val & 1) || (val == 0);
13240 val_conv = ChannelCounterparty_clone(&val_conv);
13241 ChannelDetails_set_counterparty(&this_ptr_conv, val_conv);
13244 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_funding_txo(uint32_t this_ptr) {
13245 LDKChannelDetails this_ptr_conv;
13246 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13247 this_ptr_conv.is_owned = false;
13248 LDKOutPoint ret_var = ChannelDetails_get_funding_txo(&this_ptr_conv);
13249 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13250 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13251 uint64_t ret_ref = (uint64_t)ret_var.inner;
13252 if (ret_var.is_owned) {
13258 void __attribute__((visibility("default"))) TS_ChannelDetails_set_funding_txo(uint32_t this_ptr, uint32_t val) {
13259 LDKChannelDetails this_ptr_conv;
13260 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13261 this_ptr_conv.is_owned = false;
13262 LDKOutPoint val_conv;
13263 val_conv.inner = (void*)(val & (~1));
13264 val_conv.is_owned = (val & 1) || (val == 0);
13265 val_conv = OutPoint_clone(&val_conv);
13266 ChannelDetails_set_funding_txo(&this_ptr_conv, val_conv);
13269 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_short_channel_id(uint32_t this_ptr) {
13270 LDKChannelDetails this_ptr_conv;
13271 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13272 this_ptr_conv.is_owned = false;
13273 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
13274 *ret_copy = ChannelDetails_get_short_channel_id(&this_ptr_conv);
13275 uint64_t ret_ref = (uint64_t)ret_copy;
13279 void __attribute__((visibility("default"))) TS_ChannelDetails_set_short_channel_id(uint32_t this_ptr, uint32_t val) {
13280 LDKChannelDetails this_ptr_conv;
13281 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13282 this_ptr_conv.is_owned = false;
13283 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
13284 ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv);
13287 int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_channel_value_satoshis(uint32_t this_ptr) {
13288 LDKChannelDetails this_ptr_conv;
13289 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13290 this_ptr_conv.is_owned = false;
13291 int64_t ret_val = ChannelDetails_get_channel_value_satoshis(&this_ptr_conv);
13295 void __attribute__((visibility("default"))) TS_ChannelDetails_set_channel_value_satoshis(uint32_t this_ptr, int64_t val) {
13296 LDKChannelDetails this_ptr_conv;
13297 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13298 this_ptr_conv.is_owned = false;
13299 ChannelDetails_set_channel_value_satoshis(&this_ptr_conv, val);
13302 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_unspendable_punishment_reserve(uint32_t this_ptr) {
13303 LDKChannelDetails this_ptr_conv;
13304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13305 this_ptr_conv.is_owned = false;
13306 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
13307 *ret_copy = ChannelDetails_get_unspendable_punishment_reserve(&this_ptr_conv);
13308 uint64_t ret_ref = (uint64_t)ret_copy;
13312 void __attribute__((visibility("default"))) TS_ChannelDetails_set_unspendable_punishment_reserve(uint32_t this_ptr, uint32_t val) {
13313 LDKChannelDetails this_ptr_conv;
13314 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13315 this_ptr_conv.is_owned = false;
13316 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
13317 ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv);
13320 int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_user_id(uint32_t this_ptr) {
13321 LDKChannelDetails this_ptr_conv;
13322 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13323 this_ptr_conv.is_owned = false;
13324 int64_t ret_val = ChannelDetails_get_user_id(&this_ptr_conv);
13328 void __attribute__((visibility("default"))) TS_ChannelDetails_set_user_id(uint32_t this_ptr, int64_t val) {
13329 LDKChannelDetails this_ptr_conv;
13330 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13331 this_ptr_conv.is_owned = false;
13332 ChannelDetails_set_user_id(&this_ptr_conv, val);
13335 int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_outbound_capacity_msat(uint32_t this_ptr) {
13336 LDKChannelDetails this_ptr_conv;
13337 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13338 this_ptr_conv.is_owned = false;
13339 int64_t ret_val = ChannelDetails_get_outbound_capacity_msat(&this_ptr_conv);
13343 void __attribute__((visibility("default"))) TS_ChannelDetails_set_outbound_capacity_msat(uint32_t this_ptr, int64_t val) {
13344 LDKChannelDetails this_ptr_conv;
13345 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13346 this_ptr_conv.is_owned = false;
13347 ChannelDetails_set_outbound_capacity_msat(&this_ptr_conv, val);
13350 int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_inbound_capacity_msat(uint32_t this_ptr) {
13351 LDKChannelDetails this_ptr_conv;
13352 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13353 this_ptr_conv.is_owned = false;
13354 int64_t ret_val = ChannelDetails_get_inbound_capacity_msat(&this_ptr_conv);
13358 void __attribute__((visibility("default"))) TS_ChannelDetails_set_inbound_capacity_msat(uint32_t this_ptr, int64_t val) {
13359 LDKChannelDetails this_ptr_conv;
13360 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13361 this_ptr_conv.is_owned = false;
13362 ChannelDetails_set_inbound_capacity_msat(&this_ptr_conv, val);
13365 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_confirmations_required(uint32_t this_ptr) {
13366 LDKChannelDetails this_ptr_conv;
13367 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13368 this_ptr_conv.is_owned = false;
13369 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
13370 *ret_copy = ChannelDetails_get_confirmations_required(&this_ptr_conv);
13371 uint64_t ret_ref = (uint64_t)ret_copy;
13375 void __attribute__((visibility("default"))) TS_ChannelDetails_set_confirmations_required(uint32_t this_ptr, uint32_t val) {
13376 LDKChannelDetails this_ptr_conv;
13377 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13378 this_ptr_conv.is_owned = false;
13379 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1);
13380 ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv);
13383 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_get_force_close_spend_delay(uint32_t this_ptr) {
13384 LDKChannelDetails this_ptr_conv;
13385 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13386 this_ptr_conv.is_owned = false;
13387 LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z");
13388 *ret_copy = ChannelDetails_get_force_close_spend_delay(&this_ptr_conv);
13389 uint64_t ret_ref = (uint64_t)ret_copy;
13393 void __attribute__((visibility("default"))) TS_ChannelDetails_set_force_close_spend_delay(uint32_t this_ptr, uint32_t val) {
13394 LDKChannelDetails this_ptr_conv;
13395 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13396 this_ptr_conv.is_owned = false;
13397 LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(((uint64_t)val) & ~1);
13398 ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv);
13401 jboolean __attribute__((visibility("default"))) TS_ChannelDetails_get_is_outbound(uint32_t this_ptr) {
13402 LDKChannelDetails this_ptr_conv;
13403 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13404 this_ptr_conv.is_owned = false;
13405 jboolean ret_val = ChannelDetails_get_is_outbound(&this_ptr_conv);
13409 void __attribute__((visibility("default"))) TS_ChannelDetails_set_is_outbound(uint32_t this_ptr, jboolean val) {
13410 LDKChannelDetails this_ptr_conv;
13411 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13412 this_ptr_conv.is_owned = false;
13413 ChannelDetails_set_is_outbound(&this_ptr_conv, val);
13416 jboolean __attribute__((visibility("default"))) TS_ChannelDetails_get_is_funding_locked(uint32_t this_ptr) {
13417 LDKChannelDetails this_ptr_conv;
13418 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13419 this_ptr_conv.is_owned = false;
13420 jboolean ret_val = ChannelDetails_get_is_funding_locked(&this_ptr_conv);
13424 void __attribute__((visibility("default"))) TS_ChannelDetails_set_is_funding_locked(uint32_t this_ptr, jboolean val) {
13425 LDKChannelDetails this_ptr_conv;
13426 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13427 this_ptr_conv.is_owned = false;
13428 ChannelDetails_set_is_funding_locked(&this_ptr_conv, val);
13431 jboolean __attribute__((visibility("default"))) TS_ChannelDetails_get_is_usable(uint32_t this_ptr) {
13432 LDKChannelDetails this_ptr_conv;
13433 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13434 this_ptr_conv.is_owned = false;
13435 jboolean ret_val = ChannelDetails_get_is_usable(&this_ptr_conv);
13439 void __attribute__((visibility("default"))) TS_ChannelDetails_set_is_usable(uint32_t this_ptr, jboolean val) {
13440 LDKChannelDetails this_ptr_conv;
13441 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13442 this_ptr_conv.is_owned = false;
13443 ChannelDetails_set_is_usable(&this_ptr_conv, val);
13446 jboolean __attribute__((visibility("default"))) TS_ChannelDetails_get_is_public(uint32_t this_ptr) {
13447 LDKChannelDetails this_ptr_conv;
13448 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13449 this_ptr_conv.is_owned = false;
13450 jboolean ret_val = ChannelDetails_get_is_public(&this_ptr_conv);
13454 void __attribute__((visibility("default"))) TS_ChannelDetails_set_is_public(uint32_t this_ptr, jboolean val) {
13455 LDKChannelDetails this_ptr_conv;
13456 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13457 this_ptr_conv.is_owned = false;
13458 ChannelDetails_set_is_public(&this_ptr_conv, val);
13461 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_new(int8_tArray channel_id_arg, uint32_t counterparty_arg, uint32_t funding_txo_arg, uint32_t short_channel_id_arg, int64_t channel_value_satoshis_arg, uint32_t unspendable_punishment_reserve_arg, int64_t user_id_arg, int64_t outbound_capacity_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_funding_locked_arg, jboolean is_usable_arg, jboolean is_public_arg) {
13462 LDKThirtyTwoBytes channel_id_arg_ref;
13463 CHECK(*((uint32_t*)channel_id_arg) == 32);
13464 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
13465 LDKChannelCounterparty counterparty_arg_conv;
13466 counterparty_arg_conv.inner = (void*)(counterparty_arg & (~1));
13467 counterparty_arg_conv.is_owned = (counterparty_arg & 1) || (counterparty_arg == 0);
13468 counterparty_arg_conv = ChannelCounterparty_clone(&counterparty_arg_conv);
13469 LDKOutPoint funding_txo_arg_conv;
13470 funding_txo_arg_conv.inner = (void*)(funding_txo_arg & (~1));
13471 funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0);
13472 funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv);
13473 LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)short_channel_id_arg) & ~1);
13474 LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)unspendable_punishment_reserve_arg) & ~1);
13475 LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)confirmations_required_arg) & ~1);
13476 LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(((uint64_t)force_close_spend_delay_arg) & ~1);
13477 LDKChannelDetails ret_var = ChannelDetails_new(channel_id_arg_ref, counterparty_arg_conv, funding_txo_arg_conv, short_channel_id_arg_conv, channel_value_satoshis_arg, unspendable_punishment_reserve_arg_conv, user_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg);
13478 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13479 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13480 uint64_t ret_ref = (uint64_t)ret_var.inner;
13481 if (ret_var.is_owned) {
13487 uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_clone(uint32_t orig) {
13488 LDKChannelDetails orig_conv;
13489 orig_conv.inner = (void*)(orig & (~1));
13490 orig_conv.is_owned = false;
13491 LDKChannelDetails ret_var = ChannelDetails_clone(&orig_conv);
13492 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13493 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13494 uint64_t ret_ref = (uint64_t)ret_var.inner;
13495 if (ret_var.is_owned) {
13501 void __attribute__((visibility("default"))) TS_PaymentSendFailure_free(uint32_t this_ptr) {
13502 if ((this_ptr & 1) != 0) return;
13503 LDKPaymentSendFailure this_ptr_conv = *(LDKPaymentSendFailure*)(((uint64_t)this_ptr) & ~1);
13504 FREE((void*)this_ptr);
13505 PaymentSendFailure_free(this_ptr_conv);
13508 uint32_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone(uint32_t orig) {
13509 LDKPaymentSendFailure* orig_conv = (LDKPaymentSendFailure*)orig;
13510 LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure");
13511 *ret_copy = PaymentSendFailure_clone(orig_conv);
13512 uint64_t ret_ref = (uint64_t)ret_copy;
13516 uint32_t __attribute__((visibility("default"))) 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) {
13517 LDKFeeEstimator fee_est_conv = *(LDKFeeEstimator*)(((uint64_t)fee_est) & ~1);
13518 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
13519 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
13520 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
13521 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
13522 LDKUserConfig config_conv;
13523 config_conv.inner = (void*)(config & (~1));
13524 config_conv.is_owned = (config & 1) || (config == 0);
13525 config_conv = UserConfig_clone(&config_conv);
13526 LDKChainParameters params_conv;
13527 params_conv.inner = (void*)(params & (~1));
13528 params_conv.is_owned = (params & 1) || (params == 0);
13529 params_conv = ChainParameters_clone(¶ms_conv);
13530 LDKChannelManager ret_var = ChannelManager_new(fee_est_conv, chain_monitor_conv, tx_broadcaster_conv, logger_conv, keys_manager_conv, config_conv, params_conv);
13531 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13532 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13533 uint64_t ret_ref = (uint64_t)ret_var.inner;
13534 if (ret_var.is_owned) {
13540 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_get_current_default_configuration(uint32_t this_arg) {
13541 LDKChannelManager this_arg_conv;
13542 this_arg_conv.inner = (void*)(this_arg & (~1));
13543 this_arg_conv.is_owned = false;
13544 LDKUserConfig ret_var = ChannelManager_get_current_default_configuration(&this_arg_conv);
13545 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13546 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13547 uint64_t ret_ref = (uint64_t)ret_var.inner;
13548 if (ret_var.is_owned) {
13554 uint32_t __attribute__((visibility("default"))) 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_id, uint32_t override_config) {
13555 LDKChannelManager this_arg_conv;
13556 this_arg_conv.inner = (void*)(this_arg & (~1));
13557 this_arg_conv.is_owned = false;
13558 LDKPublicKey their_network_key_ref;
13559 CHECK(*((uint32_t*)their_network_key) == 33);
13560 memcpy(their_network_key_ref.compressed_form, (uint8_t*)(their_network_key + 4), 33);
13561 LDKUserConfig override_config_conv;
13562 override_config_conv.inner = (void*)(override_config & (~1));
13563 override_config_conv.is_owned = (override_config & 1) || (override_config == 0);
13564 override_config_conv = UserConfig_clone(&override_config_conv);
13565 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
13566 *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_id, override_config_conv);
13567 return (uint64_t)ret_conv;
13570 uint32_tArray __attribute__((visibility("default"))) TS_ChannelManager_list_channels(uint32_t this_arg) {
13571 LDKChannelManager this_arg_conv;
13572 this_arg_conv.inner = (void*)(this_arg & (~1));
13573 this_arg_conv.is_owned = false;
13574 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_channels(&this_arg_conv);
13575 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
13576 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
13577 for (size_t q = 0; q < ret_var.datalen; q++) {
13578 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
13579 CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13580 CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13581 uint64_t ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
13582 if (ret_conv_16_var.is_owned) {
13583 ret_conv_16_ref |= 1;
13585 ret_arr_ptr[q] = ret_conv_16_ref;
13587 FREE(ret_var.data);
13591 uint32_tArray __attribute__((visibility("default"))) TS_ChannelManager_list_usable_channels(uint32_t this_arg) {
13592 LDKChannelManager this_arg_conv;
13593 this_arg_conv.inner = (void*)(this_arg & (~1));
13594 this_arg_conv.is_owned = false;
13595 LDKCVec_ChannelDetailsZ ret_var = ChannelManager_list_usable_channels(&this_arg_conv);
13596 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
13597 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
13598 for (size_t q = 0; q < ret_var.datalen; q++) {
13599 LDKChannelDetails ret_conv_16_var = ret_var.data[q];
13600 CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13601 CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13602 uint64_t ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner;
13603 if (ret_conv_16_var.is_owned) {
13604 ret_conv_16_ref |= 1;
13606 ret_arr_ptr[q] = ret_conv_16_ref;
13608 FREE(ret_var.data);
13612 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_close_channel(uint32_t this_arg, int8_tArray channel_id) {
13613 LDKChannelManager this_arg_conv;
13614 this_arg_conv.inner = (void*)(this_arg & (~1));
13615 this_arg_conv.is_owned = false;
13616 unsigned char channel_id_arr[32];
13617 CHECK(*((uint32_t*)channel_id) == 32);
13618 memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
13619 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
13620 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
13621 *ret_conv = ChannelManager_close_channel(&this_arg_conv, channel_id_ref);
13622 return (uint64_t)ret_conv;
13625 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_force_close_channel(uint32_t this_arg, int8_tArray channel_id) {
13626 LDKChannelManager this_arg_conv;
13627 this_arg_conv.inner = (void*)(this_arg & (~1));
13628 this_arg_conv.is_owned = false;
13629 unsigned char channel_id_arr[32];
13630 CHECK(*((uint32_t*)channel_id) == 32);
13631 memcpy(channel_id_arr, (uint8_t*)(channel_id + 4), 32);
13632 unsigned char (*channel_id_ref)[32] = &channel_id_arr;
13633 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
13634 *ret_conv = ChannelManager_force_close_channel(&this_arg_conv, channel_id_ref);
13635 return (uint64_t)ret_conv;
13638 void __attribute__((visibility("default"))) TS_ChannelManager_force_close_all_channels(uint32_t this_arg) {
13639 LDKChannelManager this_arg_conv;
13640 this_arg_conv.inner = (void*)(this_arg & (~1));
13641 this_arg_conv.is_owned = false;
13642 ChannelManager_force_close_all_channels(&this_arg_conv);
13645 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_send_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_hash, int8_tArray payment_secret) {
13646 LDKChannelManager this_arg_conv;
13647 this_arg_conv.inner = (void*)(this_arg & (~1));
13648 this_arg_conv.is_owned = false;
13649 LDKRoute route_conv;
13650 route_conv.inner = (void*)(route & (~1));
13651 route_conv.is_owned = false;
13652 LDKThirtyTwoBytes payment_hash_ref;
13653 CHECK(*((uint32_t*)payment_hash) == 32);
13654 memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
13655 LDKThirtyTwoBytes payment_secret_ref;
13656 CHECK(*((uint32_t*)payment_secret) == 32);
13657 memcpy(payment_secret_ref.data, (uint8_t*)(payment_secret + 4), 32);
13658 LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ");
13659 *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref);
13660 return (uint64_t)ret_conv;
13663 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_funding_transaction_generated(uint32_t this_arg, int8_tArray temporary_channel_id, int8_tArray funding_transaction) {
13664 LDKChannelManager this_arg_conv;
13665 this_arg_conv.inner = (void*)(this_arg & (~1));
13666 this_arg_conv.is_owned = false;
13667 unsigned char temporary_channel_id_arr[32];
13668 CHECK(*((uint32_t*)temporary_channel_id) == 32);
13669 memcpy(temporary_channel_id_arr, (uint8_t*)(temporary_channel_id + 4), 32);
13670 unsigned char (*temporary_channel_id_ref)[32] = &temporary_channel_id_arr;
13671 LDKTransaction funding_transaction_ref;
13672 funding_transaction_ref.datalen = *((uint32_t*)funding_transaction);
13673 funding_transaction_ref.data = MALLOC(funding_transaction_ref.datalen, "LDKTransaction Bytes");
13674 memcpy(funding_transaction_ref.data, (uint8_t*)(funding_transaction + 4), funding_transaction_ref.datalen);
13675 funding_transaction_ref.data_is_owned = true;
13676 LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ");
13677 *ret_conv = ChannelManager_funding_transaction_generated(&this_arg_conv, temporary_channel_id_ref, funding_transaction_ref);
13678 return (uint64_t)ret_conv;
13681 void __attribute__((visibility("default"))) TS_ChannelManager_broadcast_node_announcement(uint32_t this_arg, int8_tArray rgb, int8_tArray alias, uint32_tArray addresses) {
13682 LDKChannelManager this_arg_conv;
13683 this_arg_conv.inner = (void*)(this_arg & (~1));
13684 this_arg_conv.is_owned = false;
13685 LDKThreeBytes rgb_ref;
13686 CHECK(*((uint32_t*)rgb) == 3);
13687 memcpy(rgb_ref.data, (uint8_t*)(rgb + 4), 3);
13688 LDKThirtyTwoBytes alias_ref;
13689 CHECK(*((uint32_t*)alias) == 32);
13690 memcpy(alias_ref.data, (uint8_t*)(alias + 4), 32);
13691 LDKCVec_NetAddressZ addresses_constr;
13692 addresses_constr.datalen = *((uint32_t*)addresses);
13693 if (addresses_constr.datalen > 0)
13694 addresses_constr.data = MALLOC(addresses_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
13696 addresses_constr.data = NULL;
13697 uint32_t* addresses_vals = (uint32_t*)(addresses + 4);
13698 for (size_t m = 0; m < addresses_constr.datalen; m++) {
13699 uint32_t addresses_conv_12 = addresses_vals[m];
13700 LDKNetAddress addresses_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_conv_12) & ~1);
13701 addresses_constr.data[m] = addresses_conv_12_conv;
13703 ChannelManager_broadcast_node_announcement(&this_arg_conv, rgb_ref, alias_ref, addresses_constr);
13706 void __attribute__((visibility("default"))) TS_ChannelManager_process_pending_htlc_forwards(uint32_t this_arg) {
13707 LDKChannelManager this_arg_conv;
13708 this_arg_conv.inner = (void*)(this_arg & (~1));
13709 this_arg_conv.is_owned = false;
13710 ChannelManager_process_pending_htlc_forwards(&this_arg_conv);
13713 void __attribute__((visibility("default"))) TS_ChannelManager_timer_tick_occurred(uint32_t this_arg) {
13714 LDKChannelManager this_arg_conv;
13715 this_arg_conv.inner = (void*)(this_arg & (~1));
13716 this_arg_conv.is_owned = false;
13717 ChannelManager_timer_tick_occurred(&this_arg_conv);
13720 jboolean __attribute__((visibility("default"))) TS_ChannelManager_fail_htlc_backwards(uint32_t this_arg, int8_tArray payment_hash) {
13721 LDKChannelManager this_arg_conv;
13722 this_arg_conv.inner = (void*)(this_arg & (~1));
13723 this_arg_conv.is_owned = false;
13724 unsigned char payment_hash_arr[32];
13725 CHECK(*((uint32_t*)payment_hash) == 32);
13726 memcpy(payment_hash_arr, (uint8_t*)(payment_hash + 4), 32);
13727 unsigned char (*payment_hash_ref)[32] = &payment_hash_arr;
13728 jboolean ret_val = ChannelManager_fail_htlc_backwards(&this_arg_conv, payment_hash_ref);
13732 jboolean __attribute__((visibility("default"))) TS_ChannelManager_claim_funds(uint32_t this_arg, int8_tArray payment_preimage) {
13733 LDKChannelManager this_arg_conv;
13734 this_arg_conv.inner = (void*)(this_arg & (~1));
13735 this_arg_conv.is_owned = false;
13736 LDKThirtyTwoBytes payment_preimage_ref;
13737 CHECK(*((uint32_t*)payment_preimage) == 32);
13738 memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32);
13739 jboolean ret_val = ChannelManager_claim_funds(&this_arg_conv, payment_preimage_ref);
13743 int8_tArray __attribute__((visibility("default"))) TS_ChannelManager_get_our_node_id(uint32_t this_arg) {
13744 LDKChannelManager this_arg_conv;
13745 this_arg_conv.inner = (void*)(this_arg & (~1));
13746 this_arg_conv.is_owned = false;
13747 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
13748 memcpy((uint8_t*)(ret_arr + 4), ChannelManager_get_our_node_id(&this_arg_conv).compressed_form, 33);
13752 void __attribute__((visibility("default"))) TS_ChannelManager_channel_monitor_updated(uint32_t this_arg, uint32_t funding_txo, int64_t highest_applied_update_id) {
13753 LDKChannelManager this_arg_conv;
13754 this_arg_conv.inner = (void*)(this_arg & (~1));
13755 this_arg_conv.is_owned = false;
13756 LDKOutPoint funding_txo_conv;
13757 funding_txo_conv.inner = (void*)(funding_txo & (~1));
13758 funding_txo_conv.is_owned = false;
13759 ChannelManager_channel_monitor_updated(&this_arg_conv, &funding_txo_conv, highest_applied_update_id);
13762 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_inbound_payment(uint32_t this_arg, uint32_t min_value_msat, int32_t invoice_expiry_delta_secs, int64_t user_payment_id) {
13763 LDKChannelManager this_arg_conv;
13764 this_arg_conv.inner = (void*)(this_arg & (~1));
13765 this_arg_conv.is_owned = false;
13766 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1);
13767 LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ");
13768 *ret_ref = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id);
13769 return (uint64_t)ret_ref;
13772 uint32_t __attribute__((visibility("default"))) 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, int64_t user_payment_id) {
13773 LDKChannelManager this_arg_conv;
13774 this_arg_conv.inner = (void*)(this_arg & (~1));
13775 this_arg_conv.is_owned = false;
13776 LDKThirtyTwoBytes payment_hash_ref;
13777 CHECK(*((uint32_t*)payment_hash) == 32);
13778 memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32);
13779 LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1);
13780 LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ");
13781 *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id);
13782 return (uint64_t)ret_conv;
13785 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_MessageSendEventsProvider(uint32_t this_arg) {
13786 LDKChannelManager this_arg_conv;
13787 this_arg_conv.inner = (void*)(this_arg & (~1));
13788 this_arg_conv.is_owned = false;
13789 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
13790 *ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv);
13791 return (uint64_t)ret;
13794 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_EventsProvider(uint32_t this_arg) {
13795 LDKChannelManager this_arg_conv;
13796 this_arg_conv.inner = (void*)(this_arg & (~1));
13797 this_arg_conv.is_owned = false;
13798 LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider");
13799 *ret = ChannelManager_as_EventsProvider(&this_arg_conv);
13800 return (uint64_t)ret;
13803 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_Listen(uint32_t this_arg) {
13804 LDKChannelManager this_arg_conv;
13805 this_arg_conv.inner = (void*)(this_arg & (~1));
13806 this_arg_conv.is_owned = false;
13807 LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen");
13808 *ret = ChannelManager_as_Listen(&this_arg_conv);
13809 return (uint64_t)ret;
13812 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_Confirm(uint32_t this_arg) {
13813 LDKChannelManager this_arg_conv;
13814 this_arg_conv.inner = (void*)(this_arg & (~1));
13815 this_arg_conv.is_owned = false;
13816 LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm");
13817 *ret = ChannelManager_as_Confirm(&this_arg_conv);
13818 return (uint64_t)ret;
13821 jboolean __attribute__((visibility("default"))) TS_ChannelManager_await_persistable_update_timeout(uint32_t this_arg, int64_t max_wait) {
13822 LDKChannelManager this_arg_conv;
13823 this_arg_conv.inner = (void*)(this_arg & (~1));
13824 this_arg_conv.is_owned = false;
13825 jboolean ret_val = ChannelManager_await_persistable_update_timeout(&this_arg_conv, max_wait);
13829 void __attribute__((visibility("default"))) TS_ChannelManager_await_persistable_update(uint32_t this_arg) {
13830 LDKChannelManager this_arg_conv;
13831 this_arg_conv.inner = (void*)(this_arg & (~1));
13832 this_arg_conv.is_owned = false;
13833 ChannelManager_await_persistable_update(&this_arg_conv);
13836 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_current_best_block(uint32_t this_arg) {
13837 LDKChannelManager this_arg_conv;
13838 this_arg_conv.inner = (void*)(this_arg & (~1));
13839 this_arg_conv.is_owned = false;
13840 LDKBestBlock ret_var = ChannelManager_current_best_block(&this_arg_conv);
13841 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13842 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13843 uint64_t ret_ref = (uint64_t)ret_var.inner;
13844 if (ret_var.is_owned) {
13850 uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_ChannelMessageHandler(uint32_t this_arg) {
13851 LDKChannelManager this_arg_conv;
13852 this_arg_conv.inner = (void*)(this_arg & (~1));
13853 this_arg_conv.is_owned = false;
13854 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
13855 *ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv);
13856 return (uint64_t)ret;
13859 int8_tArray __attribute__((visibility("default"))) TS_ChannelManager_write(uint32_t obj) {
13860 LDKChannelManager obj_conv;
13861 obj_conv.inner = (void*)(obj & (~1));
13862 obj_conv.is_owned = false;
13863 LDKCVec_u8Z ret_var = ChannelManager_write(&obj_conv);
13864 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
13865 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
13866 CVec_u8Z_free(ret_var);
13870 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_free(uint32_t this_obj) {
13871 LDKChannelManagerReadArgs this_obj_conv;
13872 this_obj_conv.inner = (void*)(this_obj & (~1));
13873 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
13874 ChannelManagerReadArgs_free(this_obj_conv);
13877 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_keys_manager(uint32_t this_ptr) {
13878 LDKChannelManagerReadArgs this_ptr_conv;
13879 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13880 this_ptr_conv.is_owned = false;
13881 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_keys_manager(&this_ptr_conv);
13885 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_keys_manager(uint32_t this_ptr, uint32_t val) {
13886 LDKChannelManagerReadArgs this_ptr_conv;
13887 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13888 this_ptr_conv.is_owned = false;
13889 LDKKeysInterface val_conv = *(LDKKeysInterface*)(((uint64_t)val) & ~1);
13890 ChannelManagerReadArgs_set_keys_manager(&this_ptr_conv, val_conv);
13893 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_fee_estimator(uint32_t this_ptr) {
13894 LDKChannelManagerReadArgs this_ptr_conv;
13895 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13896 this_ptr_conv.is_owned = false;
13897 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_fee_estimator(&this_ptr_conv);
13901 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_fee_estimator(uint32_t this_ptr, uint32_t val) {
13902 LDKChannelManagerReadArgs this_ptr_conv;
13903 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13904 this_ptr_conv.is_owned = false;
13905 LDKFeeEstimator val_conv = *(LDKFeeEstimator*)(((uint64_t)val) & ~1);
13906 ChannelManagerReadArgs_set_fee_estimator(&this_ptr_conv, val_conv);
13909 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_chain_monitor(uint32_t this_ptr) {
13910 LDKChannelManagerReadArgs this_ptr_conv;
13911 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13912 this_ptr_conv.is_owned = false;
13913 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_chain_monitor(&this_ptr_conv);
13917 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_chain_monitor(uint32_t this_ptr, uint32_t val) {
13918 LDKChannelManagerReadArgs this_ptr_conv;
13919 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13920 this_ptr_conv.is_owned = false;
13921 LDKWatch val_conv = *(LDKWatch*)(((uint64_t)val) & ~1);
13922 ChannelManagerReadArgs_set_chain_monitor(&this_ptr_conv, val_conv);
13925 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_tx_broadcaster(uint32_t this_ptr) {
13926 LDKChannelManagerReadArgs this_ptr_conv;
13927 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13928 this_ptr_conv.is_owned = false;
13929 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_tx_broadcaster(&this_ptr_conv);
13933 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_tx_broadcaster(uint32_t this_ptr, uint32_t val) {
13934 LDKChannelManagerReadArgs this_ptr_conv;
13935 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13936 this_ptr_conv.is_owned = false;
13937 LDKBroadcasterInterface val_conv = *(LDKBroadcasterInterface*)(((uint64_t)val) & ~1);
13938 ChannelManagerReadArgs_set_tx_broadcaster(&this_ptr_conv, val_conv);
13941 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_logger(uint32_t this_ptr) {
13942 LDKChannelManagerReadArgs this_ptr_conv;
13943 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13944 this_ptr_conv.is_owned = false;
13945 uint64_t ret_ret = (uint64_t)ChannelManagerReadArgs_get_logger(&this_ptr_conv);
13949 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_logger(uint32_t this_ptr, uint32_t val) {
13950 LDKChannelManagerReadArgs this_ptr_conv;
13951 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13952 this_ptr_conv.is_owned = false;
13953 LDKLogger val_conv = *(LDKLogger*)(((uint64_t)val) & ~1);
13954 ChannelManagerReadArgs_set_logger(&this_ptr_conv, val_conv);
13957 uint32_t __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_get_default_config(uint32_t this_ptr) {
13958 LDKChannelManagerReadArgs this_ptr_conv;
13959 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13960 this_ptr_conv.is_owned = false;
13961 LDKUserConfig ret_var = ChannelManagerReadArgs_get_default_config(&this_ptr_conv);
13962 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
13963 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
13964 uint64_t ret_ref = (uint64_t)ret_var.inner;
13965 if (ret_var.is_owned) {
13971 void __attribute__((visibility("default"))) TS_ChannelManagerReadArgs_set_default_config(uint32_t this_ptr, uint32_t val) {
13972 LDKChannelManagerReadArgs this_ptr_conv;
13973 this_ptr_conv.inner = (void*)(this_ptr & (~1));
13974 this_ptr_conv.is_owned = false;
13975 LDKUserConfig val_conv;
13976 val_conv.inner = (void*)(val & (~1));
13977 val_conv.is_owned = (val & 1) || (val == 0);
13978 val_conv = UserConfig_clone(&val_conv);
13979 ChannelManagerReadArgs_set_default_config(&this_ptr_conv, val_conv);
13982 uint32_t __attribute__((visibility("default"))) 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) {
13983 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
13984 LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1);
13985 LDKWatch chain_monitor_conv = *(LDKWatch*)(((uint64_t)chain_monitor) & ~1);
13986 LDKBroadcasterInterface tx_broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)tx_broadcaster) & ~1);
13987 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
13988 LDKUserConfig default_config_conv;
13989 default_config_conv.inner = (void*)(default_config & (~1));
13990 default_config_conv.is_owned = (default_config & 1) || (default_config == 0);
13991 default_config_conv = UserConfig_clone(&default_config_conv);
13992 LDKCVec_ChannelMonitorZ channel_monitors_constr;
13993 channel_monitors_constr.datalen = *((uint32_t*)channel_monitors);
13994 if (channel_monitors_constr.datalen > 0)
13995 channel_monitors_constr.data = MALLOC(channel_monitors_constr.datalen * sizeof(LDKChannelMonitor), "LDKCVec_ChannelMonitorZ Elements");
13997 channel_monitors_constr.data = NULL;
13998 uint32_t* channel_monitors_vals = (uint32_t*)(channel_monitors + 4);
13999 for (size_t q = 0; q < channel_monitors_constr.datalen; q++) {
14000 uint32_t channel_monitors_conv_16 = channel_monitors_vals[q];
14001 LDKChannelMonitor channel_monitors_conv_16_conv;
14002 channel_monitors_conv_16_conv.inner = (void*)(channel_monitors_conv_16 & (~1));
14003 channel_monitors_conv_16_conv.is_owned = (channel_monitors_conv_16 & 1) || (channel_monitors_conv_16 == 0);
14004 channel_monitors_constr.data[q] = channel_monitors_conv_16_conv;
14006 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);
14007 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14008 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14009 uint64_t ret_ref = (uint64_t)ret_var.inner;
14010 if (ret_var.is_owned) {
14016 uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_read(int8_tArray ser, uint32_t arg) {
14017 LDKu8slice ser_ref;
14018 ser_ref.datalen = *((uint32_t*)ser);
14019 ser_ref.data = (int8_t*)(ser + 4);
14020 LDKChannelManagerReadArgs arg_conv;
14021 arg_conv.inner = (void*)(arg & (~1));
14022 arg_conv.is_owned = (arg & 1) || (arg == 0);
14023 // Warning: we need a move here but no clone is available for LDKChannelManagerReadArgs
14024 LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ");
14025 *ret_conv = C2Tuple_BlockHashChannelManagerZ_read(ser_ref, arg_conv);
14026 return (uint64_t)ret_conv;
14029 void __attribute__((visibility("default"))) TS_DecodeError_free(uint32_t this_obj) {
14030 LDKDecodeError this_obj_conv;
14031 this_obj_conv.inner = (void*)(this_obj & (~1));
14032 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14033 DecodeError_free(this_obj_conv);
14036 uint32_t __attribute__((visibility("default"))) TS_DecodeError_clone(uint32_t orig) {
14037 LDKDecodeError orig_conv;
14038 orig_conv.inner = (void*)(orig & (~1));
14039 orig_conv.is_owned = false;
14040 LDKDecodeError ret_var = DecodeError_clone(&orig_conv);
14041 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14042 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14043 uint64_t ret_ref = (uint64_t)ret_var.inner;
14044 if (ret_var.is_owned) {
14050 void __attribute__((visibility("default"))) TS_Init_free(uint32_t this_obj) {
14051 LDKInit this_obj_conv;
14052 this_obj_conv.inner = (void*)(this_obj & (~1));
14053 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14054 Init_free(this_obj_conv);
14057 uint32_t __attribute__((visibility("default"))) TS_Init_get_features(uint32_t this_ptr) {
14058 LDKInit this_ptr_conv;
14059 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14060 this_ptr_conv.is_owned = false;
14061 LDKInitFeatures ret_var = Init_get_features(&this_ptr_conv);
14062 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14063 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14064 uint64_t ret_ref = (uint64_t)ret_var.inner;
14065 if (ret_var.is_owned) {
14071 void __attribute__((visibility("default"))) TS_Init_set_features(uint32_t this_ptr, uint32_t val) {
14072 LDKInit this_ptr_conv;
14073 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14074 this_ptr_conv.is_owned = false;
14075 LDKInitFeatures val_conv;
14076 val_conv.inner = (void*)(val & (~1));
14077 val_conv.is_owned = (val & 1) || (val == 0);
14078 val_conv = InitFeatures_clone(&val_conv);
14079 Init_set_features(&this_ptr_conv, val_conv);
14082 uint32_t __attribute__((visibility("default"))) TS_Init_new(uint32_t features_arg) {
14083 LDKInitFeatures features_arg_conv;
14084 features_arg_conv.inner = (void*)(features_arg & (~1));
14085 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
14086 features_arg_conv = InitFeatures_clone(&features_arg_conv);
14087 LDKInit ret_var = Init_new(features_arg_conv);
14088 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14089 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14090 uint64_t ret_ref = (uint64_t)ret_var.inner;
14091 if (ret_var.is_owned) {
14097 uint32_t __attribute__((visibility("default"))) TS_Init_clone(uint32_t orig) {
14099 orig_conv.inner = (void*)(orig & (~1));
14100 orig_conv.is_owned = false;
14101 LDKInit ret_var = Init_clone(&orig_conv);
14102 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14103 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14104 uint64_t ret_ref = (uint64_t)ret_var.inner;
14105 if (ret_var.is_owned) {
14111 void __attribute__((visibility("default"))) TS_ErrorMessage_free(uint32_t this_obj) {
14112 LDKErrorMessage this_obj_conv;
14113 this_obj_conv.inner = (void*)(this_obj & (~1));
14114 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14115 ErrorMessage_free(this_obj_conv);
14118 int8_tArray __attribute__((visibility("default"))) TS_ErrorMessage_get_channel_id(uint32_t this_ptr) {
14119 LDKErrorMessage this_ptr_conv;
14120 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14121 this_ptr_conv.is_owned = false;
14122 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14123 memcpy((uint8_t*)(ret_arr + 4), *ErrorMessage_get_channel_id(&this_ptr_conv), 32);
14127 void __attribute__((visibility("default"))) TS_ErrorMessage_set_channel_id(uint32_t this_ptr, int8_tArray val) {
14128 LDKErrorMessage this_ptr_conv;
14129 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14130 this_ptr_conv.is_owned = false;
14131 LDKThirtyTwoBytes val_ref;
14132 CHECK(*((uint32_t*)val) == 32);
14133 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14134 ErrorMessage_set_channel_id(&this_ptr_conv, val_ref);
14137 jstring __attribute__((visibility("default"))) TS_ErrorMessage_get_data(uint32_t this_ptr) {
14138 LDKErrorMessage this_ptr_conv;
14139 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14140 this_ptr_conv.is_owned = false;
14141 LDKStr ret_str = ErrorMessage_get_data(&this_ptr_conv);
14142 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
14146 void __attribute__((visibility("default"))) TS_ErrorMessage_set_data(uint32_t this_ptr, jstring val) {
14147 LDKErrorMessage this_ptr_conv;
14148 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14149 this_ptr_conv.is_owned = false;
14150 LDKStr val_conv = str_ref_to_owned_c(val);
14151 ErrorMessage_set_data(&this_ptr_conv, val_conv);
14154 uint32_t __attribute__((visibility("default"))) TS_ErrorMessage_new(int8_tArray channel_id_arg, jstring data_arg) {
14155 LDKThirtyTwoBytes channel_id_arg_ref;
14156 CHECK(*((uint32_t*)channel_id_arg) == 32);
14157 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
14158 LDKStr data_arg_conv = str_ref_to_owned_c(data_arg);
14159 LDKErrorMessage ret_var = ErrorMessage_new(channel_id_arg_ref, data_arg_conv);
14160 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14161 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14162 uint64_t ret_ref = (uint64_t)ret_var.inner;
14163 if (ret_var.is_owned) {
14169 uint32_t __attribute__((visibility("default"))) TS_ErrorMessage_clone(uint32_t orig) {
14170 LDKErrorMessage orig_conv;
14171 orig_conv.inner = (void*)(orig & (~1));
14172 orig_conv.is_owned = false;
14173 LDKErrorMessage ret_var = ErrorMessage_clone(&orig_conv);
14174 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14175 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14176 uint64_t ret_ref = (uint64_t)ret_var.inner;
14177 if (ret_var.is_owned) {
14183 void __attribute__((visibility("default"))) TS_Ping_free(uint32_t this_obj) {
14184 LDKPing this_obj_conv;
14185 this_obj_conv.inner = (void*)(this_obj & (~1));
14186 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14187 Ping_free(this_obj_conv);
14190 int16_t __attribute__((visibility("default"))) TS_Ping_get_ponglen(uint32_t this_ptr) {
14191 LDKPing this_ptr_conv;
14192 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14193 this_ptr_conv.is_owned = false;
14194 int16_t ret_val = Ping_get_ponglen(&this_ptr_conv);
14198 void __attribute__((visibility("default"))) TS_Ping_set_ponglen(uint32_t this_ptr, int16_t val) {
14199 LDKPing this_ptr_conv;
14200 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14201 this_ptr_conv.is_owned = false;
14202 Ping_set_ponglen(&this_ptr_conv, val);
14205 int16_t __attribute__((visibility("default"))) TS_Ping_get_byteslen(uint32_t this_ptr) {
14206 LDKPing this_ptr_conv;
14207 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14208 this_ptr_conv.is_owned = false;
14209 int16_t ret_val = Ping_get_byteslen(&this_ptr_conv);
14213 void __attribute__((visibility("default"))) TS_Ping_set_byteslen(uint32_t this_ptr, int16_t val) {
14214 LDKPing this_ptr_conv;
14215 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14216 this_ptr_conv.is_owned = false;
14217 Ping_set_byteslen(&this_ptr_conv, val);
14220 uint32_t __attribute__((visibility("default"))) TS_Ping_new(int16_t ponglen_arg, int16_t byteslen_arg) {
14221 LDKPing ret_var = Ping_new(ponglen_arg, byteslen_arg);
14222 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14223 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14224 uint64_t ret_ref = (uint64_t)ret_var.inner;
14225 if (ret_var.is_owned) {
14231 uint32_t __attribute__((visibility("default"))) TS_Ping_clone(uint32_t orig) {
14233 orig_conv.inner = (void*)(orig & (~1));
14234 orig_conv.is_owned = false;
14235 LDKPing ret_var = Ping_clone(&orig_conv);
14236 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14237 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14238 uint64_t ret_ref = (uint64_t)ret_var.inner;
14239 if (ret_var.is_owned) {
14245 void __attribute__((visibility("default"))) TS_Pong_free(uint32_t this_obj) {
14246 LDKPong this_obj_conv;
14247 this_obj_conv.inner = (void*)(this_obj & (~1));
14248 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14249 Pong_free(this_obj_conv);
14252 int16_t __attribute__((visibility("default"))) TS_Pong_get_byteslen(uint32_t this_ptr) {
14253 LDKPong this_ptr_conv;
14254 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14255 this_ptr_conv.is_owned = false;
14256 int16_t ret_val = Pong_get_byteslen(&this_ptr_conv);
14260 void __attribute__((visibility("default"))) TS_Pong_set_byteslen(uint32_t this_ptr, int16_t val) {
14261 LDKPong this_ptr_conv;
14262 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14263 this_ptr_conv.is_owned = false;
14264 Pong_set_byteslen(&this_ptr_conv, val);
14267 uint32_t __attribute__((visibility("default"))) TS_Pong_new(int16_t byteslen_arg) {
14268 LDKPong ret_var = Pong_new(byteslen_arg);
14269 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14270 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14271 uint64_t ret_ref = (uint64_t)ret_var.inner;
14272 if (ret_var.is_owned) {
14278 uint32_t __attribute__((visibility("default"))) TS_Pong_clone(uint32_t orig) {
14280 orig_conv.inner = (void*)(orig & (~1));
14281 orig_conv.is_owned = false;
14282 LDKPong ret_var = Pong_clone(&orig_conv);
14283 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14284 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14285 uint64_t ret_ref = (uint64_t)ret_var.inner;
14286 if (ret_var.is_owned) {
14292 void __attribute__((visibility("default"))) TS_OpenChannel_free(uint32_t this_obj) {
14293 LDKOpenChannel this_obj_conv;
14294 this_obj_conv.inner = (void*)(this_obj & (~1));
14295 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14296 OpenChannel_free(this_obj_conv);
14299 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_chain_hash(uint32_t this_ptr) {
14300 LDKOpenChannel this_ptr_conv;
14301 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14302 this_ptr_conv.is_owned = false;
14303 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14304 memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_chain_hash(&this_ptr_conv), 32);
14308 void __attribute__((visibility("default"))) TS_OpenChannel_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
14309 LDKOpenChannel this_ptr_conv;
14310 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14311 this_ptr_conv.is_owned = false;
14312 LDKThirtyTwoBytes val_ref;
14313 CHECK(*((uint32_t*)val) == 32);
14314 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14315 OpenChannel_set_chain_hash(&this_ptr_conv, val_ref);
14318 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_temporary_channel_id(uint32_t this_ptr) {
14319 LDKOpenChannel this_ptr_conv;
14320 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14321 this_ptr_conv.is_owned = false;
14322 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14323 memcpy((uint8_t*)(ret_arr + 4), *OpenChannel_get_temporary_channel_id(&this_ptr_conv), 32);
14327 void __attribute__((visibility("default"))) TS_OpenChannel_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
14328 LDKOpenChannel this_ptr_conv;
14329 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14330 this_ptr_conv.is_owned = false;
14331 LDKThirtyTwoBytes val_ref;
14332 CHECK(*((uint32_t*)val) == 32);
14333 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14334 OpenChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
14337 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_funding_satoshis(uint32_t this_ptr) {
14338 LDKOpenChannel this_ptr_conv;
14339 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14340 this_ptr_conv.is_owned = false;
14341 int64_t ret_val = OpenChannel_get_funding_satoshis(&this_ptr_conv);
14345 void __attribute__((visibility("default"))) TS_OpenChannel_set_funding_satoshis(uint32_t this_ptr, int64_t val) {
14346 LDKOpenChannel this_ptr_conv;
14347 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14348 this_ptr_conv.is_owned = false;
14349 OpenChannel_set_funding_satoshis(&this_ptr_conv, val);
14352 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_push_msat(uint32_t this_ptr) {
14353 LDKOpenChannel this_ptr_conv;
14354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14355 this_ptr_conv.is_owned = false;
14356 int64_t ret_val = OpenChannel_get_push_msat(&this_ptr_conv);
14360 void __attribute__((visibility("default"))) TS_OpenChannel_set_push_msat(uint32_t this_ptr, int64_t val) {
14361 LDKOpenChannel this_ptr_conv;
14362 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14363 this_ptr_conv.is_owned = false;
14364 OpenChannel_set_push_msat(&this_ptr_conv, val);
14367 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_dust_limit_satoshis(uint32_t this_ptr) {
14368 LDKOpenChannel this_ptr_conv;
14369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14370 this_ptr_conv.is_owned = false;
14371 int64_t ret_val = OpenChannel_get_dust_limit_satoshis(&this_ptr_conv);
14375 void __attribute__((visibility("default"))) TS_OpenChannel_set_dust_limit_satoshis(uint32_t this_ptr, int64_t val) {
14376 LDKOpenChannel this_ptr_conv;
14377 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14378 this_ptr_conv.is_owned = false;
14379 OpenChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
14382 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
14383 LDKOpenChannel this_ptr_conv;
14384 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14385 this_ptr_conv.is_owned = false;
14386 int64_t ret_val = OpenChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
14390 void __attribute__((visibility("default"))) TS_OpenChannel_set_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
14391 LDKOpenChannel this_ptr_conv;
14392 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14393 this_ptr_conv.is_owned = false;
14394 OpenChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
14397 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_channel_reserve_satoshis(uint32_t this_ptr) {
14398 LDKOpenChannel this_ptr_conv;
14399 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14400 this_ptr_conv.is_owned = false;
14401 int64_t ret_val = OpenChannel_get_channel_reserve_satoshis(&this_ptr_conv);
14405 void __attribute__((visibility("default"))) TS_OpenChannel_set_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
14406 LDKOpenChannel this_ptr_conv;
14407 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14408 this_ptr_conv.is_owned = false;
14409 OpenChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
14412 int64_t __attribute__((visibility("default"))) TS_OpenChannel_get_htlc_minimum_msat(uint32_t this_ptr) {
14413 LDKOpenChannel this_ptr_conv;
14414 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14415 this_ptr_conv.is_owned = false;
14416 int64_t ret_val = OpenChannel_get_htlc_minimum_msat(&this_ptr_conv);
14420 void __attribute__((visibility("default"))) TS_OpenChannel_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
14421 LDKOpenChannel this_ptr_conv;
14422 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14423 this_ptr_conv.is_owned = false;
14424 OpenChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
14427 int32_t __attribute__((visibility("default"))) TS_OpenChannel_get_feerate_per_kw(uint32_t this_ptr) {
14428 LDKOpenChannel this_ptr_conv;
14429 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14430 this_ptr_conv.is_owned = false;
14431 int32_t ret_val = OpenChannel_get_feerate_per_kw(&this_ptr_conv);
14435 void __attribute__((visibility("default"))) TS_OpenChannel_set_feerate_per_kw(uint32_t this_ptr, int32_t val) {
14436 LDKOpenChannel this_ptr_conv;
14437 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14438 this_ptr_conv.is_owned = false;
14439 OpenChannel_set_feerate_per_kw(&this_ptr_conv, val);
14442 int16_t __attribute__((visibility("default"))) TS_OpenChannel_get_to_self_delay(uint32_t this_ptr) {
14443 LDKOpenChannel this_ptr_conv;
14444 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14445 this_ptr_conv.is_owned = false;
14446 int16_t ret_val = OpenChannel_get_to_self_delay(&this_ptr_conv);
14450 void __attribute__((visibility("default"))) TS_OpenChannel_set_to_self_delay(uint32_t this_ptr, int16_t val) {
14451 LDKOpenChannel this_ptr_conv;
14452 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14453 this_ptr_conv.is_owned = false;
14454 OpenChannel_set_to_self_delay(&this_ptr_conv, val);
14457 int16_t __attribute__((visibility("default"))) TS_OpenChannel_get_max_accepted_htlcs(uint32_t this_ptr) {
14458 LDKOpenChannel this_ptr_conv;
14459 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14460 this_ptr_conv.is_owned = false;
14461 int16_t ret_val = OpenChannel_get_max_accepted_htlcs(&this_ptr_conv);
14465 void __attribute__((visibility("default"))) TS_OpenChannel_set_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
14466 LDKOpenChannel this_ptr_conv;
14467 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14468 this_ptr_conv.is_owned = false;
14469 OpenChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
14472 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_funding_pubkey(uint32_t this_ptr) {
14473 LDKOpenChannel this_ptr_conv;
14474 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14475 this_ptr_conv.is_owned = false;
14476 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14477 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
14481 void __attribute__((visibility("default"))) TS_OpenChannel_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
14482 LDKOpenChannel this_ptr_conv;
14483 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14484 this_ptr_conv.is_owned = false;
14485 LDKPublicKey val_ref;
14486 CHECK(*((uint32_t*)val) == 33);
14487 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14488 OpenChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
14491 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_revocation_basepoint(uint32_t this_ptr) {
14492 LDKOpenChannel this_ptr_conv;
14493 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14494 this_ptr_conv.is_owned = false;
14495 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14496 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
14500 void __attribute__((visibility("default"))) TS_OpenChannel_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
14501 LDKOpenChannel this_ptr_conv;
14502 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14503 this_ptr_conv.is_owned = false;
14504 LDKPublicKey val_ref;
14505 CHECK(*((uint32_t*)val) == 33);
14506 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14507 OpenChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
14510 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_payment_point(uint32_t this_ptr) {
14511 LDKOpenChannel this_ptr_conv;
14512 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14513 this_ptr_conv.is_owned = false;
14514 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14515 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
14519 void __attribute__((visibility("default"))) TS_OpenChannel_set_payment_point(uint32_t this_ptr, int8_tArray val) {
14520 LDKOpenChannel this_ptr_conv;
14521 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14522 this_ptr_conv.is_owned = false;
14523 LDKPublicKey val_ref;
14524 CHECK(*((uint32_t*)val) == 33);
14525 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14526 OpenChannel_set_payment_point(&this_ptr_conv, val_ref);
14529 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_delayed_payment_basepoint(uint32_t this_ptr) {
14530 LDKOpenChannel this_ptr_conv;
14531 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14532 this_ptr_conv.is_owned = false;
14533 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14534 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
14538 void __attribute__((visibility("default"))) TS_OpenChannel_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
14539 LDKOpenChannel this_ptr_conv;
14540 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14541 this_ptr_conv.is_owned = false;
14542 LDKPublicKey val_ref;
14543 CHECK(*((uint32_t*)val) == 33);
14544 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14545 OpenChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
14548 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_htlc_basepoint(uint32_t this_ptr) {
14549 LDKOpenChannel this_ptr_conv;
14550 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14551 this_ptr_conv.is_owned = false;
14552 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14553 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
14557 void __attribute__((visibility("default"))) TS_OpenChannel_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
14558 LDKOpenChannel this_ptr_conv;
14559 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14560 this_ptr_conv.is_owned = false;
14561 LDKPublicKey val_ref;
14562 CHECK(*((uint32_t*)val) == 33);
14563 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14564 OpenChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
14567 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_get_first_per_commitment_point(uint32_t this_ptr) {
14568 LDKOpenChannel this_ptr_conv;
14569 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14570 this_ptr_conv.is_owned = false;
14571 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14572 memcpy((uint8_t*)(ret_arr + 4), OpenChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
14576 void __attribute__((visibility("default"))) TS_OpenChannel_set_first_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
14577 LDKOpenChannel this_ptr_conv;
14578 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14579 this_ptr_conv.is_owned = false;
14580 LDKPublicKey val_ref;
14581 CHECK(*((uint32_t*)val) == 33);
14582 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14583 OpenChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
14586 int8_t __attribute__((visibility("default"))) TS_OpenChannel_get_channel_flags(uint32_t this_ptr) {
14587 LDKOpenChannel this_ptr_conv;
14588 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14589 this_ptr_conv.is_owned = false;
14590 int8_t ret_val = OpenChannel_get_channel_flags(&this_ptr_conv);
14594 void __attribute__((visibility("default"))) TS_OpenChannel_set_channel_flags(uint32_t this_ptr, int8_t val) {
14595 LDKOpenChannel this_ptr_conv;
14596 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14597 this_ptr_conv.is_owned = false;
14598 OpenChannel_set_channel_flags(&this_ptr_conv, val);
14601 uint32_t __attribute__((visibility("default"))) TS_OpenChannel_clone(uint32_t orig) {
14602 LDKOpenChannel orig_conv;
14603 orig_conv.inner = (void*)(orig & (~1));
14604 orig_conv.is_owned = false;
14605 LDKOpenChannel ret_var = OpenChannel_clone(&orig_conv);
14606 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14607 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14608 uint64_t ret_ref = (uint64_t)ret_var.inner;
14609 if (ret_var.is_owned) {
14615 void __attribute__((visibility("default"))) TS_AcceptChannel_free(uint32_t this_obj) {
14616 LDKAcceptChannel this_obj_conv;
14617 this_obj_conv.inner = (void*)(this_obj & (~1));
14618 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14619 AcceptChannel_free(this_obj_conv);
14622 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_temporary_channel_id(uint32_t this_ptr) {
14623 LDKAcceptChannel this_ptr_conv;
14624 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14625 this_ptr_conv.is_owned = false;
14626 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14627 memcpy((uint8_t*)(ret_arr + 4), *AcceptChannel_get_temporary_channel_id(&this_ptr_conv), 32);
14631 void __attribute__((visibility("default"))) TS_AcceptChannel_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
14632 LDKAcceptChannel this_ptr_conv;
14633 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14634 this_ptr_conv.is_owned = false;
14635 LDKThirtyTwoBytes val_ref;
14636 CHECK(*((uint32_t*)val) == 32);
14637 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14638 AcceptChannel_set_temporary_channel_id(&this_ptr_conv, val_ref);
14641 int64_t __attribute__((visibility("default"))) TS_AcceptChannel_get_dust_limit_satoshis(uint32_t this_ptr) {
14642 LDKAcceptChannel this_ptr_conv;
14643 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14644 this_ptr_conv.is_owned = false;
14645 int64_t ret_val = AcceptChannel_get_dust_limit_satoshis(&this_ptr_conv);
14649 void __attribute__((visibility("default"))) TS_AcceptChannel_set_dust_limit_satoshis(uint32_t this_ptr, int64_t val) {
14650 LDKAcceptChannel this_ptr_conv;
14651 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14652 this_ptr_conv.is_owned = false;
14653 AcceptChannel_set_dust_limit_satoshis(&this_ptr_conv, val);
14656 int64_t __attribute__((visibility("default"))) TS_AcceptChannel_get_max_htlc_value_in_flight_msat(uint32_t this_ptr) {
14657 LDKAcceptChannel this_ptr_conv;
14658 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14659 this_ptr_conv.is_owned = false;
14660 int64_t ret_val = AcceptChannel_get_max_htlc_value_in_flight_msat(&this_ptr_conv);
14664 void __attribute__((visibility("default"))) TS_AcceptChannel_set_max_htlc_value_in_flight_msat(uint32_t this_ptr, int64_t val) {
14665 LDKAcceptChannel this_ptr_conv;
14666 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14667 this_ptr_conv.is_owned = false;
14668 AcceptChannel_set_max_htlc_value_in_flight_msat(&this_ptr_conv, val);
14671 int64_t __attribute__((visibility("default"))) TS_AcceptChannel_get_channel_reserve_satoshis(uint32_t this_ptr) {
14672 LDKAcceptChannel this_ptr_conv;
14673 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14674 this_ptr_conv.is_owned = false;
14675 int64_t ret_val = AcceptChannel_get_channel_reserve_satoshis(&this_ptr_conv);
14679 void __attribute__((visibility("default"))) TS_AcceptChannel_set_channel_reserve_satoshis(uint32_t this_ptr, int64_t val) {
14680 LDKAcceptChannel this_ptr_conv;
14681 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14682 this_ptr_conv.is_owned = false;
14683 AcceptChannel_set_channel_reserve_satoshis(&this_ptr_conv, val);
14686 int64_t __attribute__((visibility("default"))) TS_AcceptChannel_get_htlc_minimum_msat(uint32_t this_ptr) {
14687 LDKAcceptChannel this_ptr_conv;
14688 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14689 this_ptr_conv.is_owned = false;
14690 int64_t ret_val = AcceptChannel_get_htlc_minimum_msat(&this_ptr_conv);
14694 void __attribute__((visibility("default"))) TS_AcceptChannel_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
14695 LDKAcceptChannel this_ptr_conv;
14696 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14697 this_ptr_conv.is_owned = false;
14698 AcceptChannel_set_htlc_minimum_msat(&this_ptr_conv, val);
14701 int32_t __attribute__((visibility("default"))) TS_AcceptChannel_get_minimum_depth(uint32_t this_ptr) {
14702 LDKAcceptChannel this_ptr_conv;
14703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14704 this_ptr_conv.is_owned = false;
14705 int32_t ret_val = AcceptChannel_get_minimum_depth(&this_ptr_conv);
14709 void __attribute__((visibility("default"))) TS_AcceptChannel_set_minimum_depth(uint32_t this_ptr, int32_t val) {
14710 LDKAcceptChannel this_ptr_conv;
14711 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14712 this_ptr_conv.is_owned = false;
14713 AcceptChannel_set_minimum_depth(&this_ptr_conv, val);
14716 int16_t __attribute__((visibility("default"))) TS_AcceptChannel_get_to_self_delay(uint32_t this_ptr) {
14717 LDKAcceptChannel this_ptr_conv;
14718 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14719 this_ptr_conv.is_owned = false;
14720 int16_t ret_val = AcceptChannel_get_to_self_delay(&this_ptr_conv);
14724 void __attribute__((visibility("default"))) TS_AcceptChannel_set_to_self_delay(uint32_t this_ptr, int16_t val) {
14725 LDKAcceptChannel this_ptr_conv;
14726 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14727 this_ptr_conv.is_owned = false;
14728 AcceptChannel_set_to_self_delay(&this_ptr_conv, val);
14731 int16_t __attribute__((visibility("default"))) TS_AcceptChannel_get_max_accepted_htlcs(uint32_t this_ptr) {
14732 LDKAcceptChannel this_ptr_conv;
14733 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14734 this_ptr_conv.is_owned = false;
14735 int16_t ret_val = AcceptChannel_get_max_accepted_htlcs(&this_ptr_conv);
14739 void __attribute__((visibility("default"))) TS_AcceptChannel_set_max_accepted_htlcs(uint32_t this_ptr, int16_t val) {
14740 LDKAcceptChannel this_ptr_conv;
14741 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14742 this_ptr_conv.is_owned = false;
14743 AcceptChannel_set_max_accepted_htlcs(&this_ptr_conv, val);
14746 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_funding_pubkey(uint32_t this_ptr) {
14747 LDKAcceptChannel this_ptr_conv;
14748 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14749 this_ptr_conv.is_owned = false;
14750 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14751 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
14755 void __attribute__((visibility("default"))) TS_AcceptChannel_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
14756 LDKAcceptChannel this_ptr_conv;
14757 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14758 this_ptr_conv.is_owned = false;
14759 LDKPublicKey val_ref;
14760 CHECK(*((uint32_t*)val) == 33);
14761 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14762 AcceptChannel_set_funding_pubkey(&this_ptr_conv, val_ref);
14765 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_revocation_basepoint(uint32_t this_ptr) {
14766 LDKAcceptChannel this_ptr_conv;
14767 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14768 this_ptr_conv.is_owned = false;
14769 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14770 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
14774 void __attribute__((visibility("default"))) TS_AcceptChannel_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
14775 LDKAcceptChannel this_ptr_conv;
14776 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14777 this_ptr_conv.is_owned = false;
14778 LDKPublicKey val_ref;
14779 CHECK(*((uint32_t*)val) == 33);
14780 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14781 AcceptChannel_set_revocation_basepoint(&this_ptr_conv, val_ref);
14784 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_payment_point(uint32_t this_ptr) {
14785 LDKAcceptChannel this_ptr_conv;
14786 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14787 this_ptr_conv.is_owned = false;
14788 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14789 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_payment_point(&this_ptr_conv).compressed_form, 33);
14793 void __attribute__((visibility("default"))) TS_AcceptChannel_set_payment_point(uint32_t this_ptr, int8_tArray val) {
14794 LDKAcceptChannel this_ptr_conv;
14795 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14796 this_ptr_conv.is_owned = false;
14797 LDKPublicKey val_ref;
14798 CHECK(*((uint32_t*)val) == 33);
14799 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14800 AcceptChannel_set_payment_point(&this_ptr_conv, val_ref);
14803 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_delayed_payment_basepoint(uint32_t this_ptr) {
14804 LDKAcceptChannel this_ptr_conv;
14805 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14806 this_ptr_conv.is_owned = false;
14807 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14808 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
14812 void __attribute__((visibility("default"))) TS_AcceptChannel_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
14813 LDKAcceptChannel this_ptr_conv;
14814 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14815 this_ptr_conv.is_owned = false;
14816 LDKPublicKey val_ref;
14817 CHECK(*((uint32_t*)val) == 33);
14818 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14819 AcceptChannel_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
14822 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_htlc_basepoint(uint32_t this_ptr) {
14823 LDKAcceptChannel this_ptr_conv;
14824 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14825 this_ptr_conv.is_owned = false;
14826 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14827 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
14831 void __attribute__((visibility("default"))) TS_AcceptChannel_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
14832 LDKAcceptChannel this_ptr_conv;
14833 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14834 this_ptr_conv.is_owned = false;
14835 LDKPublicKey val_ref;
14836 CHECK(*((uint32_t*)val) == 33);
14837 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14838 AcceptChannel_set_htlc_basepoint(&this_ptr_conv, val_ref);
14841 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_get_first_per_commitment_point(uint32_t this_ptr) {
14842 LDKAcceptChannel this_ptr_conv;
14843 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14844 this_ptr_conv.is_owned = false;
14845 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
14846 memcpy((uint8_t*)(ret_arr + 4), AcceptChannel_get_first_per_commitment_point(&this_ptr_conv).compressed_form, 33);
14850 void __attribute__((visibility("default"))) TS_AcceptChannel_set_first_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
14851 LDKAcceptChannel this_ptr_conv;
14852 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14853 this_ptr_conv.is_owned = false;
14854 LDKPublicKey val_ref;
14855 CHECK(*((uint32_t*)val) == 33);
14856 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
14857 AcceptChannel_set_first_per_commitment_point(&this_ptr_conv, val_ref);
14860 uint32_t __attribute__((visibility("default"))) TS_AcceptChannel_clone(uint32_t orig) {
14861 LDKAcceptChannel orig_conv;
14862 orig_conv.inner = (void*)(orig & (~1));
14863 orig_conv.is_owned = false;
14864 LDKAcceptChannel ret_var = AcceptChannel_clone(&orig_conv);
14865 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14866 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14867 uint64_t ret_ref = (uint64_t)ret_var.inner;
14868 if (ret_var.is_owned) {
14874 void __attribute__((visibility("default"))) TS_FundingCreated_free(uint32_t this_obj) {
14875 LDKFundingCreated this_obj_conv;
14876 this_obj_conv.inner = (void*)(this_obj & (~1));
14877 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14878 FundingCreated_free(this_obj_conv);
14881 int8_tArray __attribute__((visibility("default"))) TS_FundingCreated_get_temporary_channel_id(uint32_t this_ptr) {
14882 LDKFundingCreated this_ptr_conv;
14883 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14884 this_ptr_conv.is_owned = false;
14885 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14886 memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_temporary_channel_id(&this_ptr_conv), 32);
14890 void __attribute__((visibility("default"))) TS_FundingCreated_set_temporary_channel_id(uint32_t this_ptr, int8_tArray val) {
14891 LDKFundingCreated this_ptr_conv;
14892 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14893 this_ptr_conv.is_owned = false;
14894 LDKThirtyTwoBytes val_ref;
14895 CHECK(*((uint32_t*)val) == 32);
14896 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14897 FundingCreated_set_temporary_channel_id(&this_ptr_conv, val_ref);
14900 int8_tArray __attribute__((visibility("default"))) TS_FundingCreated_get_funding_txid(uint32_t this_ptr) {
14901 LDKFundingCreated this_ptr_conv;
14902 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14903 this_ptr_conv.is_owned = false;
14904 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14905 memcpy((uint8_t*)(ret_arr + 4), *FundingCreated_get_funding_txid(&this_ptr_conv), 32);
14909 void __attribute__((visibility("default"))) TS_FundingCreated_set_funding_txid(uint32_t this_ptr, int8_tArray val) {
14910 LDKFundingCreated this_ptr_conv;
14911 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14912 this_ptr_conv.is_owned = false;
14913 LDKThirtyTwoBytes val_ref;
14914 CHECK(*((uint32_t*)val) == 32);
14915 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
14916 FundingCreated_set_funding_txid(&this_ptr_conv, val_ref);
14919 int16_t __attribute__((visibility("default"))) TS_FundingCreated_get_funding_output_index(uint32_t this_ptr) {
14920 LDKFundingCreated this_ptr_conv;
14921 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14922 this_ptr_conv.is_owned = false;
14923 int16_t ret_val = FundingCreated_get_funding_output_index(&this_ptr_conv);
14927 void __attribute__((visibility("default"))) TS_FundingCreated_set_funding_output_index(uint32_t this_ptr, int16_t val) {
14928 LDKFundingCreated this_ptr_conv;
14929 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14930 this_ptr_conv.is_owned = false;
14931 FundingCreated_set_funding_output_index(&this_ptr_conv, val);
14934 int8_tArray __attribute__((visibility("default"))) TS_FundingCreated_get_signature(uint32_t this_ptr) {
14935 LDKFundingCreated this_ptr_conv;
14936 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14937 this_ptr_conv.is_owned = false;
14938 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
14939 memcpy((uint8_t*)(ret_arr + 4), FundingCreated_get_signature(&this_ptr_conv).compact_form, 64);
14943 void __attribute__((visibility("default"))) TS_FundingCreated_set_signature(uint32_t this_ptr, int8_tArray val) {
14944 LDKFundingCreated this_ptr_conv;
14945 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14946 this_ptr_conv.is_owned = false;
14947 LDKSignature val_ref;
14948 CHECK(*((uint32_t*)val) == 64);
14949 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
14950 FundingCreated_set_signature(&this_ptr_conv, val_ref);
14953 uint32_t __attribute__((visibility("default"))) TS_FundingCreated_new(int8_tArray temporary_channel_id_arg, int8_tArray funding_txid_arg, int16_t funding_output_index_arg, int8_tArray signature_arg) {
14954 LDKThirtyTwoBytes temporary_channel_id_arg_ref;
14955 CHECK(*((uint32_t*)temporary_channel_id_arg) == 32);
14956 memcpy(temporary_channel_id_arg_ref.data, (uint8_t*)(temporary_channel_id_arg + 4), 32);
14957 LDKThirtyTwoBytes funding_txid_arg_ref;
14958 CHECK(*((uint32_t*)funding_txid_arg) == 32);
14959 memcpy(funding_txid_arg_ref.data, (uint8_t*)(funding_txid_arg + 4), 32);
14960 LDKSignature signature_arg_ref;
14961 CHECK(*((uint32_t*)signature_arg) == 64);
14962 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
14963 LDKFundingCreated ret_var = FundingCreated_new(temporary_channel_id_arg_ref, funding_txid_arg_ref, funding_output_index_arg, signature_arg_ref);
14964 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14965 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14966 uint64_t ret_ref = (uint64_t)ret_var.inner;
14967 if (ret_var.is_owned) {
14973 uint32_t __attribute__((visibility("default"))) TS_FundingCreated_clone(uint32_t orig) {
14974 LDKFundingCreated orig_conv;
14975 orig_conv.inner = (void*)(orig & (~1));
14976 orig_conv.is_owned = false;
14977 LDKFundingCreated ret_var = FundingCreated_clone(&orig_conv);
14978 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
14979 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
14980 uint64_t ret_ref = (uint64_t)ret_var.inner;
14981 if (ret_var.is_owned) {
14987 void __attribute__((visibility("default"))) TS_FundingSigned_free(uint32_t this_obj) {
14988 LDKFundingSigned this_obj_conv;
14989 this_obj_conv.inner = (void*)(this_obj & (~1));
14990 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
14991 FundingSigned_free(this_obj_conv);
14994 int8_tArray __attribute__((visibility("default"))) TS_FundingSigned_get_channel_id(uint32_t this_ptr) {
14995 LDKFundingSigned this_ptr_conv;
14996 this_ptr_conv.inner = (void*)(this_ptr & (~1));
14997 this_ptr_conv.is_owned = false;
14998 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
14999 memcpy((uint8_t*)(ret_arr + 4), *FundingSigned_get_channel_id(&this_ptr_conv), 32);
15003 void __attribute__((visibility("default"))) TS_FundingSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15004 LDKFundingSigned this_ptr_conv;
15005 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15006 this_ptr_conv.is_owned = false;
15007 LDKThirtyTwoBytes val_ref;
15008 CHECK(*((uint32_t*)val) == 32);
15009 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15010 FundingSigned_set_channel_id(&this_ptr_conv, val_ref);
15013 int8_tArray __attribute__((visibility("default"))) TS_FundingSigned_get_signature(uint32_t this_ptr) {
15014 LDKFundingSigned this_ptr_conv;
15015 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15016 this_ptr_conv.is_owned = false;
15017 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
15018 memcpy((uint8_t*)(ret_arr + 4), FundingSigned_get_signature(&this_ptr_conv).compact_form, 64);
15022 void __attribute__((visibility("default"))) TS_FundingSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
15023 LDKFundingSigned this_ptr_conv;
15024 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15025 this_ptr_conv.is_owned = false;
15026 LDKSignature val_ref;
15027 CHECK(*((uint32_t*)val) == 64);
15028 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
15029 FundingSigned_set_signature(&this_ptr_conv, val_ref);
15032 uint32_t __attribute__((visibility("default"))) TS_FundingSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg) {
15033 LDKThirtyTwoBytes channel_id_arg_ref;
15034 CHECK(*((uint32_t*)channel_id_arg) == 32);
15035 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15036 LDKSignature signature_arg_ref;
15037 CHECK(*((uint32_t*)signature_arg) == 64);
15038 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
15039 LDKFundingSigned ret_var = FundingSigned_new(channel_id_arg_ref, signature_arg_ref);
15040 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15041 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15042 uint64_t ret_ref = (uint64_t)ret_var.inner;
15043 if (ret_var.is_owned) {
15049 uint32_t __attribute__((visibility("default"))) TS_FundingSigned_clone(uint32_t orig) {
15050 LDKFundingSigned orig_conv;
15051 orig_conv.inner = (void*)(orig & (~1));
15052 orig_conv.is_owned = false;
15053 LDKFundingSigned ret_var = FundingSigned_clone(&orig_conv);
15054 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15055 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15056 uint64_t ret_ref = (uint64_t)ret_var.inner;
15057 if (ret_var.is_owned) {
15063 void __attribute__((visibility("default"))) TS_FundingLocked_free(uint32_t this_obj) {
15064 LDKFundingLocked this_obj_conv;
15065 this_obj_conv.inner = (void*)(this_obj & (~1));
15066 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15067 FundingLocked_free(this_obj_conv);
15070 int8_tArray __attribute__((visibility("default"))) TS_FundingLocked_get_channel_id(uint32_t this_ptr) {
15071 LDKFundingLocked this_ptr_conv;
15072 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15073 this_ptr_conv.is_owned = false;
15074 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15075 memcpy((uint8_t*)(ret_arr + 4), *FundingLocked_get_channel_id(&this_ptr_conv), 32);
15079 void __attribute__((visibility("default"))) TS_FundingLocked_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15080 LDKFundingLocked this_ptr_conv;
15081 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15082 this_ptr_conv.is_owned = false;
15083 LDKThirtyTwoBytes val_ref;
15084 CHECK(*((uint32_t*)val) == 32);
15085 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15086 FundingLocked_set_channel_id(&this_ptr_conv, val_ref);
15089 int8_tArray __attribute__((visibility("default"))) TS_FundingLocked_get_next_per_commitment_point(uint32_t this_ptr) {
15090 LDKFundingLocked this_ptr_conv;
15091 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15092 this_ptr_conv.is_owned = false;
15093 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
15094 memcpy((uint8_t*)(ret_arr + 4), FundingLocked_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
15098 void __attribute__((visibility("default"))) TS_FundingLocked_set_next_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
15099 LDKFundingLocked this_ptr_conv;
15100 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15101 this_ptr_conv.is_owned = false;
15102 LDKPublicKey val_ref;
15103 CHECK(*((uint32_t*)val) == 33);
15104 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
15105 FundingLocked_set_next_per_commitment_point(&this_ptr_conv, val_ref);
15108 uint32_t __attribute__((visibility("default"))) TS_FundingLocked_new(int8_tArray channel_id_arg, int8_tArray next_per_commitment_point_arg) {
15109 LDKThirtyTwoBytes channel_id_arg_ref;
15110 CHECK(*((uint32_t*)channel_id_arg) == 32);
15111 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15112 LDKPublicKey next_per_commitment_point_arg_ref;
15113 CHECK(*((uint32_t*)next_per_commitment_point_arg) == 33);
15114 memcpy(next_per_commitment_point_arg_ref.compressed_form, (uint8_t*)(next_per_commitment_point_arg + 4), 33);
15115 LDKFundingLocked ret_var = FundingLocked_new(channel_id_arg_ref, next_per_commitment_point_arg_ref);
15116 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15117 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15118 uint64_t ret_ref = (uint64_t)ret_var.inner;
15119 if (ret_var.is_owned) {
15125 uint32_t __attribute__((visibility("default"))) TS_FundingLocked_clone(uint32_t orig) {
15126 LDKFundingLocked orig_conv;
15127 orig_conv.inner = (void*)(orig & (~1));
15128 orig_conv.is_owned = false;
15129 LDKFundingLocked ret_var = FundingLocked_clone(&orig_conv);
15130 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15131 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15132 uint64_t ret_ref = (uint64_t)ret_var.inner;
15133 if (ret_var.is_owned) {
15139 void __attribute__((visibility("default"))) TS_Shutdown_free(uint32_t this_obj) {
15140 LDKShutdown this_obj_conv;
15141 this_obj_conv.inner = (void*)(this_obj & (~1));
15142 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15143 Shutdown_free(this_obj_conv);
15146 int8_tArray __attribute__((visibility("default"))) TS_Shutdown_get_channel_id(uint32_t this_ptr) {
15147 LDKShutdown this_ptr_conv;
15148 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15149 this_ptr_conv.is_owned = false;
15150 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15151 memcpy((uint8_t*)(ret_arr + 4), *Shutdown_get_channel_id(&this_ptr_conv), 32);
15155 void __attribute__((visibility("default"))) TS_Shutdown_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15156 LDKShutdown this_ptr_conv;
15157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15158 this_ptr_conv.is_owned = false;
15159 LDKThirtyTwoBytes val_ref;
15160 CHECK(*((uint32_t*)val) == 32);
15161 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15162 Shutdown_set_channel_id(&this_ptr_conv, val_ref);
15165 int8_tArray __attribute__((visibility("default"))) TS_Shutdown_get_scriptpubkey(uint32_t this_ptr) {
15166 LDKShutdown this_ptr_conv;
15167 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15168 this_ptr_conv.is_owned = false;
15169 LDKu8slice ret_var = Shutdown_get_scriptpubkey(&this_ptr_conv);
15170 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
15171 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
15175 void __attribute__((visibility("default"))) TS_Shutdown_set_scriptpubkey(uint32_t this_ptr, int8_tArray val) {
15176 LDKShutdown this_ptr_conv;
15177 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15178 this_ptr_conv.is_owned = false;
15179 LDKCVec_u8Z val_ref;
15180 val_ref.datalen = *((uint32_t*)val);
15181 val_ref.data = MALLOC(val_ref.datalen, "LDKCVec_u8Z Bytes");
15182 memcpy(val_ref.data, (uint8_t*)(val + 4), val_ref.datalen);
15183 Shutdown_set_scriptpubkey(&this_ptr_conv, val_ref);
15186 uint32_t __attribute__((visibility("default"))) TS_Shutdown_new(int8_tArray channel_id_arg, int8_tArray scriptpubkey_arg) {
15187 LDKThirtyTwoBytes channel_id_arg_ref;
15188 CHECK(*((uint32_t*)channel_id_arg) == 32);
15189 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15190 LDKCVec_u8Z scriptpubkey_arg_ref;
15191 scriptpubkey_arg_ref.datalen = *((uint32_t*)scriptpubkey_arg);
15192 scriptpubkey_arg_ref.data = MALLOC(scriptpubkey_arg_ref.datalen, "LDKCVec_u8Z Bytes");
15193 memcpy(scriptpubkey_arg_ref.data, (uint8_t*)(scriptpubkey_arg + 4), scriptpubkey_arg_ref.datalen);
15194 LDKShutdown ret_var = Shutdown_new(channel_id_arg_ref, scriptpubkey_arg_ref);
15195 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15196 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15197 uint64_t ret_ref = (uint64_t)ret_var.inner;
15198 if (ret_var.is_owned) {
15204 uint32_t __attribute__((visibility("default"))) TS_Shutdown_clone(uint32_t orig) {
15205 LDKShutdown orig_conv;
15206 orig_conv.inner = (void*)(orig & (~1));
15207 orig_conv.is_owned = false;
15208 LDKShutdown ret_var = Shutdown_clone(&orig_conv);
15209 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15210 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15211 uint64_t ret_ref = (uint64_t)ret_var.inner;
15212 if (ret_var.is_owned) {
15218 void __attribute__((visibility("default"))) TS_ClosingSigned_free(uint32_t this_obj) {
15219 LDKClosingSigned this_obj_conv;
15220 this_obj_conv.inner = (void*)(this_obj & (~1));
15221 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15222 ClosingSigned_free(this_obj_conv);
15225 int8_tArray __attribute__((visibility("default"))) TS_ClosingSigned_get_channel_id(uint32_t this_ptr) {
15226 LDKClosingSigned this_ptr_conv;
15227 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15228 this_ptr_conv.is_owned = false;
15229 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15230 memcpy((uint8_t*)(ret_arr + 4), *ClosingSigned_get_channel_id(&this_ptr_conv), 32);
15234 void __attribute__((visibility("default"))) TS_ClosingSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15235 LDKClosingSigned this_ptr_conv;
15236 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15237 this_ptr_conv.is_owned = false;
15238 LDKThirtyTwoBytes val_ref;
15239 CHECK(*((uint32_t*)val) == 32);
15240 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15241 ClosingSigned_set_channel_id(&this_ptr_conv, val_ref);
15244 int64_t __attribute__((visibility("default"))) TS_ClosingSigned_get_fee_satoshis(uint32_t this_ptr) {
15245 LDKClosingSigned this_ptr_conv;
15246 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15247 this_ptr_conv.is_owned = false;
15248 int64_t ret_val = ClosingSigned_get_fee_satoshis(&this_ptr_conv);
15252 void __attribute__((visibility("default"))) TS_ClosingSigned_set_fee_satoshis(uint32_t this_ptr, int64_t val) {
15253 LDKClosingSigned this_ptr_conv;
15254 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15255 this_ptr_conv.is_owned = false;
15256 ClosingSigned_set_fee_satoshis(&this_ptr_conv, val);
15259 int8_tArray __attribute__((visibility("default"))) TS_ClosingSigned_get_signature(uint32_t this_ptr) {
15260 LDKClosingSigned this_ptr_conv;
15261 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15262 this_ptr_conv.is_owned = false;
15263 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
15264 memcpy((uint8_t*)(ret_arr + 4), ClosingSigned_get_signature(&this_ptr_conv).compact_form, 64);
15268 void __attribute__((visibility("default"))) TS_ClosingSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
15269 LDKClosingSigned this_ptr_conv;
15270 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15271 this_ptr_conv.is_owned = false;
15272 LDKSignature val_ref;
15273 CHECK(*((uint32_t*)val) == 64);
15274 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
15275 ClosingSigned_set_signature(&this_ptr_conv, val_ref);
15278 uint32_t __attribute__((visibility("default"))) TS_ClosingSigned_new(int8_tArray channel_id_arg, int64_t fee_satoshis_arg, int8_tArray signature_arg) {
15279 LDKThirtyTwoBytes channel_id_arg_ref;
15280 CHECK(*((uint32_t*)channel_id_arg) == 32);
15281 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15282 LDKSignature signature_arg_ref;
15283 CHECK(*((uint32_t*)signature_arg) == 64);
15284 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
15285 LDKClosingSigned ret_var = ClosingSigned_new(channel_id_arg_ref, fee_satoshis_arg, signature_arg_ref);
15286 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15287 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15288 uint64_t ret_ref = (uint64_t)ret_var.inner;
15289 if (ret_var.is_owned) {
15295 uint32_t __attribute__((visibility("default"))) TS_ClosingSigned_clone(uint32_t orig) {
15296 LDKClosingSigned orig_conv;
15297 orig_conv.inner = (void*)(orig & (~1));
15298 orig_conv.is_owned = false;
15299 LDKClosingSigned ret_var = ClosingSigned_clone(&orig_conv);
15300 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15301 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15302 uint64_t ret_ref = (uint64_t)ret_var.inner;
15303 if (ret_var.is_owned) {
15309 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_free(uint32_t this_obj) {
15310 LDKUpdateAddHTLC this_obj_conv;
15311 this_obj_conv.inner = (void*)(this_obj & (~1));
15312 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15313 UpdateAddHTLC_free(this_obj_conv);
15316 int8_tArray __attribute__((visibility("default"))) TS_UpdateAddHTLC_get_channel_id(uint32_t this_ptr) {
15317 LDKUpdateAddHTLC this_ptr_conv;
15318 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15319 this_ptr_conv.is_owned = false;
15320 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15321 memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_channel_id(&this_ptr_conv), 32);
15325 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15326 LDKUpdateAddHTLC this_ptr_conv;
15327 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15328 this_ptr_conv.is_owned = false;
15329 LDKThirtyTwoBytes val_ref;
15330 CHECK(*((uint32_t*)val) == 32);
15331 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15332 UpdateAddHTLC_set_channel_id(&this_ptr_conv, val_ref);
15335 int64_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_get_htlc_id(uint32_t this_ptr) {
15336 LDKUpdateAddHTLC this_ptr_conv;
15337 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15338 this_ptr_conv.is_owned = false;
15339 int64_t ret_val = UpdateAddHTLC_get_htlc_id(&this_ptr_conv);
15343 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
15344 LDKUpdateAddHTLC this_ptr_conv;
15345 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15346 this_ptr_conv.is_owned = false;
15347 UpdateAddHTLC_set_htlc_id(&this_ptr_conv, val);
15350 int64_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_get_amount_msat(uint32_t this_ptr) {
15351 LDKUpdateAddHTLC this_ptr_conv;
15352 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15353 this_ptr_conv.is_owned = false;
15354 int64_t ret_val = UpdateAddHTLC_get_amount_msat(&this_ptr_conv);
15358 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_set_amount_msat(uint32_t this_ptr, int64_t val) {
15359 LDKUpdateAddHTLC this_ptr_conv;
15360 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15361 this_ptr_conv.is_owned = false;
15362 UpdateAddHTLC_set_amount_msat(&this_ptr_conv, val);
15365 int8_tArray __attribute__((visibility("default"))) TS_UpdateAddHTLC_get_payment_hash(uint32_t this_ptr) {
15366 LDKUpdateAddHTLC this_ptr_conv;
15367 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15368 this_ptr_conv.is_owned = false;
15369 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15370 memcpy((uint8_t*)(ret_arr + 4), *UpdateAddHTLC_get_payment_hash(&this_ptr_conv), 32);
15374 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_set_payment_hash(uint32_t this_ptr, int8_tArray val) {
15375 LDKUpdateAddHTLC this_ptr_conv;
15376 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15377 this_ptr_conv.is_owned = false;
15378 LDKThirtyTwoBytes val_ref;
15379 CHECK(*((uint32_t*)val) == 32);
15380 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15381 UpdateAddHTLC_set_payment_hash(&this_ptr_conv, val_ref);
15384 int32_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_get_cltv_expiry(uint32_t this_ptr) {
15385 LDKUpdateAddHTLC this_ptr_conv;
15386 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15387 this_ptr_conv.is_owned = false;
15388 int32_t ret_val = UpdateAddHTLC_get_cltv_expiry(&this_ptr_conv);
15392 void __attribute__((visibility("default"))) TS_UpdateAddHTLC_set_cltv_expiry(uint32_t this_ptr, int32_t val) {
15393 LDKUpdateAddHTLC this_ptr_conv;
15394 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15395 this_ptr_conv.is_owned = false;
15396 UpdateAddHTLC_set_cltv_expiry(&this_ptr_conv, val);
15399 uint32_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_clone(uint32_t orig) {
15400 LDKUpdateAddHTLC orig_conv;
15401 orig_conv.inner = (void*)(orig & (~1));
15402 orig_conv.is_owned = false;
15403 LDKUpdateAddHTLC ret_var = UpdateAddHTLC_clone(&orig_conv);
15404 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15405 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15406 uint64_t ret_ref = (uint64_t)ret_var.inner;
15407 if (ret_var.is_owned) {
15413 void __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_free(uint32_t this_obj) {
15414 LDKUpdateFulfillHTLC this_obj_conv;
15415 this_obj_conv.inner = (void*)(this_obj & (~1));
15416 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15417 UpdateFulfillHTLC_free(this_obj_conv);
15420 int8_tArray __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_get_channel_id(uint32_t this_ptr) {
15421 LDKUpdateFulfillHTLC this_ptr_conv;
15422 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15423 this_ptr_conv.is_owned = false;
15424 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15425 memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_channel_id(&this_ptr_conv), 32);
15429 void __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15430 LDKUpdateFulfillHTLC this_ptr_conv;
15431 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15432 this_ptr_conv.is_owned = false;
15433 LDKThirtyTwoBytes val_ref;
15434 CHECK(*((uint32_t*)val) == 32);
15435 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15436 UpdateFulfillHTLC_set_channel_id(&this_ptr_conv, val_ref);
15439 int64_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_get_htlc_id(uint32_t this_ptr) {
15440 LDKUpdateFulfillHTLC this_ptr_conv;
15441 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15442 this_ptr_conv.is_owned = false;
15443 int64_t ret_val = UpdateFulfillHTLC_get_htlc_id(&this_ptr_conv);
15447 void __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
15448 LDKUpdateFulfillHTLC this_ptr_conv;
15449 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15450 this_ptr_conv.is_owned = false;
15451 UpdateFulfillHTLC_set_htlc_id(&this_ptr_conv, val);
15454 int8_tArray __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_get_payment_preimage(uint32_t this_ptr) {
15455 LDKUpdateFulfillHTLC this_ptr_conv;
15456 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15457 this_ptr_conv.is_owned = false;
15458 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15459 memcpy((uint8_t*)(ret_arr + 4), *UpdateFulfillHTLC_get_payment_preimage(&this_ptr_conv), 32);
15463 void __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_set_payment_preimage(uint32_t this_ptr, int8_tArray val) {
15464 LDKUpdateFulfillHTLC this_ptr_conv;
15465 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15466 this_ptr_conv.is_owned = false;
15467 LDKThirtyTwoBytes val_ref;
15468 CHECK(*((uint32_t*)val) == 32);
15469 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15470 UpdateFulfillHTLC_set_payment_preimage(&this_ptr_conv, val_ref);
15473 uint32_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_new(int8_tArray channel_id_arg, int64_t htlc_id_arg, int8_tArray payment_preimage_arg) {
15474 LDKThirtyTwoBytes channel_id_arg_ref;
15475 CHECK(*((uint32_t*)channel_id_arg) == 32);
15476 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15477 LDKThirtyTwoBytes payment_preimage_arg_ref;
15478 CHECK(*((uint32_t*)payment_preimage_arg) == 32);
15479 memcpy(payment_preimage_arg_ref.data, (uint8_t*)(payment_preimage_arg + 4), 32);
15480 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_new(channel_id_arg_ref, htlc_id_arg, payment_preimage_arg_ref);
15481 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15482 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15483 uint64_t ret_ref = (uint64_t)ret_var.inner;
15484 if (ret_var.is_owned) {
15490 uint32_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_clone(uint32_t orig) {
15491 LDKUpdateFulfillHTLC orig_conv;
15492 orig_conv.inner = (void*)(orig & (~1));
15493 orig_conv.is_owned = false;
15494 LDKUpdateFulfillHTLC ret_var = UpdateFulfillHTLC_clone(&orig_conv);
15495 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15496 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15497 uint64_t ret_ref = (uint64_t)ret_var.inner;
15498 if (ret_var.is_owned) {
15504 void __attribute__((visibility("default"))) TS_UpdateFailHTLC_free(uint32_t this_obj) {
15505 LDKUpdateFailHTLC this_obj_conv;
15506 this_obj_conv.inner = (void*)(this_obj & (~1));
15507 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15508 UpdateFailHTLC_free(this_obj_conv);
15511 int8_tArray __attribute__((visibility("default"))) TS_UpdateFailHTLC_get_channel_id(uint32_t this_ptr) {
15512 LDKUpdateFailHTLC this_ptr_conv;
15513 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15514 this_ptr_conv.is_owned = false;
15515 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15516 memcpy((uint8_t*)(ret_arr + 4), *UpdateFailHTLC_get_channel_id(&this_ptr_conv), 32);
15520 void __attribute__((visibility("default"))) TS_UpdateFailHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15521 LDKUpdateFailHTLC this_ptr_conv;
15522 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15523 this_ptr_conv.is_owned = false;
15524 LDKThirtyTwoBytes val_ref;
15525 CHECK(*((uint32_t*)val) == 32);
15526 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15527 UpdateFailHTLC_set_channel_id(&this_ptr_conv, val_ref);
15530 int64_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_get_htlc_id(uint32_t this_ptr) {
15531 LDKUpdateFailHTLC this_ptr_conv;
15532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15533 this_ptr_conv.is_owned = false;
15534 int64_t ret_val = UpdateFailHTLC_get_htlc_id(&this_ptr_conv);
15538 void __attribute__((visibility("default"))) TS_UpdateFailHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
15539 LDKUpdateFailHTLC this_ptr_conv;
15540 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15541 this_ptr_conv.is_owned = false;
15542 UpdateFailHTLC_set_htlc_id(&this_ptr_conv, val);
15545 uint32_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_clone(uint32_t orig) {
15546 LDKUpdateFailHTLC orig_conv;
15547 orig_conv.inner = (void*)(orig & (~1));
15548 orig_conv.is_owned = false;
15549 LDKUpdateFailHTLC ret_var = UpdateFailHTLC_clone(&orig_conv);
15550 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15551 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15552 uint64_t ret_ref = (uint64_t)ret_var.inner;
15553 if (ret_var.is_owned) {
15559 void __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_free(uint32_t this_obj) {
15560 LDKUpdateFailMalformedHTLC this_obj_conv;
15561 this_obj_conv.inner = (void*)(this_obj & (~1));
15562 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15563 UpdateFailMalformedHTLC_free(this_obj_conv);
15566 int8_tArray __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_get_channel_id(uint32_t this_ptr) {
15567 LDKUpdateFailMalformedHTLC this_ptr_conv;
15568 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15569 this_ptr_conv.is_owned = false;
15570 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15571 memcpy((uint8_t*)(ret_arr + 4), *UpdateFailMalformedHTLC_get_channel_id(&this_ptr_conv), 32);
15575 void __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15576 LDKUpdateFailMalformedHTLC this_ptr_conv;
15577 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15578 this_ptr_conv.is_owned = false;
15579 LDKThirtyTwoBytes val_ref;
15580 CHECK(*((uint32_t*)val) == 32);
15581 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15582 UpdateFailMalformedHTLC_set_channel_id(&this_ptr_conv, val_ref);
15585 int64_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_get_htlc_id(uint32_t this_ptr) {
15586 LDKUpdateFailMalformedHTLC this_ptr_conv;
15587 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15588 this_ptr_conv.is_owned = false;
15589 int64_t ret_val = UpdateFailMalformedHTLC_get_htlc_id(&this_ptr_conv);
15593 void __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_set_htlc_id(uint32_t this_ptr, int64_t val) {
15594 LDKUpdateFailMalformedHTLC this_ptr_conv;
15595 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15596 this_ptr_conv.is_owned = false;
15597 UpdateFailMalformedHTLC_set_htlc_id(&this_ptr_conv, val);
15600 int16_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_get_failure_code(uint32_t this_ptr) {
15601 LDKUpdateFailMalformedHTLC this_ptr_conv;
15602 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15603 this_ptr_conv.is_owned = false;
15604 int16_t ret_val = UpdateFailMalformedHTLC_get_failure_code(&this_ptr_conv);
15608 void __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_set_failure_code(uint32_t this_ptr, int16_t val) {
15609 LDKUpdateFailMalformedHTLC this_ptr_conv;
15610 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15611 this_ptr_conv.is_owned = false;
15612 UpdateFailMalformedHTLC_set_failure_code(&this_ptr_conv, val);
15615 uint32_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_clone(uint32_t orig) {
15616 LDKUpdateFailMalformedHTLC orig_conv;
15617 orig_conv.inner = (void*)(orig & (~1));
15618 orig_conv.is_owned = false;
15619 LDKUpdateFailMalformedHTLC ret_var = UpdateFailMalformedHTLC_clone(&orig_conv);
15620 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15621 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15622 uint64_t ret_ref = (uint64_t)ret_var.inner;
15623 if (ret_var.is_owned) {
15629 void __attribute__((visibility("default"))) TS_CommitmentSigned_free(uint32_t this_obj) {
15630 LDKCommitmentSigned this_obj_conv;
15631 this_obj_conv.inner = (void*)(this_obj & (~1));
15632 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15633 CommitmentSigned_free(this_obj_conv);
15636 int8_tArray __attribute__((visibility("default"))) TS_CommitmentSigned_get_channel_id(uint32_t this_ptr) {
15637 LDKCommitmentSigned this_ptr_conv;
15638 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15639 this_ptr_conv.is_owned = false;
15640 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15641 memcpy((uint8_t*)(ret_arr + 4), *CommitmentSigned_get_channel_id(&this_ptr_conv), 32);
15645 void __attribute__((visibility("default"))) TS_CommitmentSigned_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15646 LDKCommitmentSigned this_ptr_conv;
15647 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15648 this_ptr_conv.is_owned = false;
15649 LDKThirtyTwoBytes val_ref;
15650 CHECK(*((uint32_t*)val) == 32);
15651 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15652 CommitmentSigned_set_channel_id(&this_ptr_conv, val_ref);
15655 int8_tArray __attribute__((visibility("default"))) TS_CommitmentSigned_get_signature(uint32_t this_ptr) {
15656 LDKCommitmentSigned this_ptr_conv;
15657 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15658 this_ptr_conv.is_owned = false;
15659 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
15660 memcpy((uint8_t*)(ret_arr + 4), CommitmentSigned_get_signature(&this_ptr_conv).compact_form, 64);
15664 void __attribute__((visibility("default"))) TS_CommitmentSigned_set_signature(uint32_t this_ptr, int8_tArray val) {
15665 LDKCommitmentSigned this_ptr_conv;
15666 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15667 this_ptr_conv.is_owned = false;
15668 LDKSignature val_ref;
15669 CHECK(*((uint32_t*)val) == 64);
15670 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
15671 CommitmentSigned_set_signature(&this_ptr_conv, val_ref);
15674 void __attribute__((visibility("default"))) TS_CommitmentSigned_set_htlc_signatures(uint32_t this_ptr, ptrArray val) {
15675 LDKCommitmentSigned this_ptr_conv;
15676 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15677 this_ptr_conv.is_owned = false;
15678 LDKCVec_SignatureZ val_constr;
15679 val_constr.datalen = *((uint32_t*)val);
15680 if (val_constr.datalen > 0)
15681 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
15683 val_constr.data = NULL;
15684 int8_tArray* val_vals = (int8_tArray*)(val + 4);
15685 for (size_t m = 0; m < val_constr.datalen; m++) {
15686 int8_tArray val_conv_12 = val_vals[m];
15687 LDKSignature val_conv_12_ref;
15688 CHECK(*((uint32_t*)val_conv_12) == 64);
15689 memcpy(val_conv_12_ref.compact_form, (uint8_t*)(val_conv_12 + 4), 64);
15690 val_constr.data[m] = val_conv_12_ref;
15692 CommitmentSigned_set_htlc_signatures(&this_ptr_conv, val_constr);
15695 uint32_t __attribute__((visibility("default"))) TS_CommitmentSigned_new(int8_tArray channel_id_arg, int8_tArray signature_arg, ptrArray htlc_signatures_arg) {
15696 LDKThirtyTwoBytes channel_id_arg_ref;
15697 CHECK(*((uint32_t*)channel_id_arg) == 32);
15698 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15699 LDKSignature signature_arg_ref;
15700 CHECK(*((uint32_t*)signature_arg) == 64);
15701 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
15702 LDKCVec_SignatureZ htlc_signatures_arg_constr;
15703 htlc_signatures_arg_constr.datalen = *((uint32_t*)htlc_signatures_arg);
15704 if (htlc_signatures_arg_constr.datalen > 0)
15705 htlc_signatures_arg_constr.data = MALLOC(htlc_signatures_arg_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
15707 htlc_signatures_arg_constr.data = NULL;
15708 int8_tArray* htlc_signatures_arg_vals = (int8_tArray*)(htlc_signatures_arg + 4);
15709 for (size_t m = 0; m < htlc_signatures_arg_constr.datalen; m++) {
15710 int8_tArray htlc_signatures_arg_conv_12 = htlc_signatures_arg_vals[m];
15711 LDKSignature htlc_signatures_arg_conv_12_ref;
15712 CHECK(*((uint32_t*)htlc_signatures_arg_conv_12) == 64);
15713 memcpy(htlc_signatures_arg_conv_12_ref.compact_form, (uint8_t*)(htlc_signatures_arg_conv_12 + 4), 64);
15714 htlc_signatures_arg_constr.data[m] = htlc_signatures_arg_conv_12_ref;
15716 LDKCommitmentSigned ret_var = CommitmentSigned_new(channel_id_arg_ref, signature_arg_ref, htlc_signatures_arg_constr);
15717 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15718 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15719 uint64_t ret_ref = (uint64_t)ret_var.inner;
15720 if (ret_var.is_owned) {
15726 uint32_t __attribute__((visibility("default"))) TS_CommitmentSigned_clone(uint32_t orig) {
15727 LDKCommitmentSigned orig_conv;
15728 orig_conv.inner = (void*)(orig & (~1));
15729 orig_conv.is_owned = false;
15730 LDKCommitmentSigned ret_var = CommitmentSigned_clone(&orig_conv);
15731 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15732 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15733 uint64_t ret_ref = (uint64_t)ret_var.inner;
15734 if (ret_var.is_owned) {
15740 void __attribute__((visibility("default"))) TS_RevokeAndACK_free(uint32_t this_obj) {
15741 LDKRevokeAndACK this_obj_conv;
15742 this_obj_conv.inner = (void*)(this_obj & (~1));
15743 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15744 RevokeAndACK_free(this_obj_conv);
15747 int8_tArray __attribute__((visibility("default"))) TS_RevokeAndACK_get_channel_id(uint32_t this_ptr) {
15748 LDKRevokeAndACK this_ptr_conv;
15749 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15750 this_ptr_conv.is_owned = false;
15751 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15752 memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_channel_id(&this_ptr_conv), 32);
15756 void __attribute__((visibility("default"))) TS_RevokeAndACK_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15757 LDKRevokeAndACK this_ptr_conv;
15758 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15759 this_ptr_conv.is_owned = false;
15760 LDKThirtyTwoBytes val_ref;
15761 CHECK(*((uint32_t*)val) == 32);
15762 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15763 RevokeAndACK_set_channel_id(&this_ptr_conv, val_ref);
15766 int8_tArray __attribute__((visibility("default"))) TS_RevokeAndACK_get_per_commitment_secret(uint32_t this_ptr) {
15767 LDKRevokeAndACK this_ptr_conv;
15768 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15769 this_ptr_conv.is_owned = false;
15770 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15771 memcpy((uint8_t*)(ret_arr + 4), *RevokeAndACK_get_per_commitment_secret(&this_ptr_conv), 32);
15775 void __attribute__((visibility("default"))) TS_RevokeAndACK_set_per_commitment_secret(uint32_t this_ptr, int8_tArray val) {
15776 LDKRevokeAndACK this_ptr_conv;
15777 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15778 this_ptr_conv.is_owned = false;
15779 LDKThirtyTwoBytes val_ref;
15780 CHECK(*((uint32_t*)val) == 32);
15781 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15782 RevokeAndACK_set_per_commitment_secret(&this_ptr_conv, val_ref);
15785 int8_tArray __attribute__((visibility("default"))) TS_RevokeAndACK_get_next_per_commitment_point(uint32_t this_ptr) {
15786 LDKRevokeAndACK this_ptr_conv;
15787 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15788 this_ptr_conv.is_owned = false;
15789 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
15790 memcpy((uint8_t*)(ret_arr + 4), RevokeAndACK_get_next_per_commitment_point(&this_ptr_conv).compressed_form, 33);
15794 void __attribute__((visibility("default"))) TS_RevokeAndACK_set_next_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
15795 LDKRevokeAndACK this_ptr_conv;
15796 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15797 this_ptr_conv.is_owned = false;
15798 LDKPublicKey val_ref;
15799 CHECK(*((uint32_t*)val) == 33);
15800 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
15801 RevokeAndACK_set_next_per_commitment_point(&this_ptr_conv, val_ref);
15804 uint32_t __attribute__((visibility("default"))) TS_RevokeAndACK_new(int8_tArray channel_id_arg, int8_tArray per_commitment_secret_arg, int8_tArray next_per_commitment_point_arg) {
15805 LDKThirtyTwoBytes channel_id_arg_ref;
15806 CHECK(*((uint32_t*)channel_id_arg) == 32);
15807 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15808 LDKThirtyTwoBytes per_commitment_secret_arg_ref;
15809 CHECK(*((uint32_t*)per_commitment_secret_arg) == 32);
15810 memcpy(per_commitment_secret_arg_ref.data, (uint8_t*)(per_commitment_secret_arg + 4), 32);
15811 LDKPublicKey next_per_commitment_point_arg_ref;
15812 CHECK(*((uint32_t*)next_per_commitment_point_arg) == 33);
15813 memcpy(next_per_commitment_point_arg_ref.compressed_form, (uint8_t*)(next_per_commitment_point_arg + 4), 33);
15814 LDKRevokeAndACK ret_var = RevokeAndACK_new(channel_id_arg_ref, per_commitment_secret_arg_ref, next_per_commitment_point_arg_ref);
15815 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15816 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15817 uint64_t ret_ref = (uint64_t)ret_var.inner;
15818 if (ret_var.is_owned) {
15824 uint32_t __attribute__((visibility("default"))) TS_RevokeAndACK_clone(uint32_t orig) {
15825 LDKRevokeAndACK orig_conv;
15826 orig_conv.inner = (void*)(orig & (~1));
15827 orig_conv.is_owned = false;
15828 LDKRevokeAndACK ret_var = RevokeAndACK_clone(&orig_conv);
15829 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15830 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15831 uint64_t ret_ref = (uint64_t)ret_var.inner;
15832 if (ret_var.is_owned) {
15838 void __attribute__((visibility("default"))) TS_UpdateFee_free(uint32_t this_obj) {
15839 LDKUpdateFee this_obj_conv;
15840 this_obj_conv.inner = (void*)(this_obj & (~1));
15841 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15842 UpdateFee_free(this_obj_conv);
15845 int8_tArray __attribute__((visibility("default"))) TS_UpdateFee_get_channel_id(uint32_t this_ptr) {
15846 LDKUpdateFee this_ptr_conv;
15847 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15848 this_ptr_conv.is_owned = false;
15849 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15850 memcpy((uint8_t*)(ret_arr + 4), *UpdateFee_get_channel_id(&this_ptr_conv), 32);
15854 void __attribute__((visibility("default"))) TS_UpdateFee_set_channel_id(uint32_t this_ptr, int8_tArray val) {
15855 LDKUpdateFee this_ptr_conv;
15856 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15857 this_ptr_conv.is_owned = false;
15858 LDKThirtyTwoBytes val_ref;
15859 CHECK(*((uint32_t*)val) == 32);
15860 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15861 UpdateFee_set_channel_id(&this_ptr_conv, val_ref);
15864 int32_t __attribute__((visibility("default"))) TS_UpdateFee_get_feerate_per_kw(uint32_t this_ptr) {
15865 LDKUpdateFee this_ptr_conv;
15866 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15867 this_ptr_conv.is_owned = false;
15868 int32_t ret_val = UpdateFee_get_feerate_per_kw(&this_ptr_conv);
15872 void __attribute__((visibility("default"))) TS_UpdateFee_set_feerate_per_kw(uint32_t this_ptr, int32_t val) {
15873 LDKUpdateFee this_ptr_conv;
15874 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15875 this_ptr_conv.is_owned = false;
15876 UpdateFee_set_feerate_per_kw(&this_ptr_conv, val);
15879 uint32_t __attribute__((visibility("default"))) TS_UpdateFee_new(int8_tArray channel_id_arg, int32_t feerate_per_kw_arg) {
15880 LDKThirtyTwoBytes channel_id_arg_ref;
15881 CHECK(*((uint32_t*)channel_id_arg) == 32);
15882 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
15883 LDKUpdateFee ret_var = UpdateFee_new(channel_id_arg_ref, feerate_per_kw_arg);
15884 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15885 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15886 uint64_t ret_ref = (uint64_t)ret_var.inner;
15887 if (ret_var.is_owned) {
15893 uint32_t __attribute__((visibility("default"))) TS_UpdateFee_clone(uint32_t orig) {
15894 LDKUpdateFee orig_conv;
15895 orig_conv.inner = (void*)(orig & (~1));
15896 orig_conv.is_owned = false;
15897 LDKUpdateFee ret_var = UpdateFee_clone(&orig_conv);
15898 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15899 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15900 uint64_t ret_ref = (uint64_t)ret_var.inner;
15901 if (ret_var.is_owned) {
15907 void __attribute__((visibility("default"))) TS_DataLossProtect_free(uint32_t this_obj) {
15908 LDKDataLossProtect this_obj_conv;
15909 this_obj_conv.inner = (void*)(this_obj & (~1));
15910 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15911 DataLossProtect_free(this_obj_conv);
15914 int8_tArray __attribute__((visibility("default"))) TS_DataLossProtect_get_your_last_per_commitment_secret(uint32_t this_ptr) {
15915 LDKDataLossProtect this_ptr_conv;
15916 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15917 this_ptr_conv.is_owned = false;
15918 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15919 memcpy((uint8_t*)(ret_arr + 4), *DataLossProtect_get_your_last_per_commitment_secret(&this_ptr_conv), 32);
15923 void __attribute__((visibility("default"))) TS_DataLossProtect_set_your_last_per_commitment_secret(uint32_t this_ptr, int8_tArray val) {
15924 LDKDataLossProtect this_ptr_conv;
15925 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15926 this_ptr_conv.is_owned = false;
15927 LDKThirtyTwoBytes val_ref;
15928 CHECK(*((uint32_t*)val) == 32);
15929 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
15930 DataLossProtect_set_your_last_per_commitment_secret(&this_ptr_conv, val_ref);
15933 int8_tArray __attribute__((visibility("default"))) TS_DataLossProtect_get_my_current_per_commitment_point(uint32_t this_ptr) {
15934 LDKDataLossProtect this_ptr_conv;
15935 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15936 this_ptr_conv.is_owned = false;
15937 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
15938 memcpy((uint8_t*)(ret_arr + 4), DataLossProtect_get_my_current_per_commitment_point(&this_ptr_conv).compressed_form, 33);
15942 void __attribute__((visibility("default"))) TS_DataLossProtect_set_my_current_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
15943 LDKDataLossProtect this_ptr_conv;
15944 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15945 this_ptr_conv.is_owned = false;
15946 LDKPublicKey val_ref;
15947 CHECK(*((uint32_t*)val) == 33);
15948 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
15949 DataLossProtect_set_my_current_per_commitment_point(&this_ptr_conv, val_ref);
15952 uint32_t __attribute__((visibility("default"))) TS_DataLossProtect_new(int8_tArray your_last_per_commitment_secret_arg, int8_tArray my_current_per_commitment_point_arg) {
15953 LDKThirtyTwoBytes your_last_per_commitment_secret_arg_ref;
15954 CHECK(*((uint32_t*)your_last_per_commitment_secret_arg) == 32);
15955 memcpy(your_last_per_commitment_secret_arg_ref.data, (uint8_t*)(your_last_per_commitment_secret_arg + 4), 32);
15956 LDKPublicKey my_current_per_commitment_point_arg_ref;
15957 CHECK(*((uint32_t*)my_current_per_commitment_point_arg) == 33);
15958 memcpy(my_current_per_commitment_point_arg_ref.compressed_form, (uint8_t*)(my_current_per_commitment_point_arg + 4), 33);
15959 LDKDataLossProtect ret_var = DataLossProtect_new(your_last_per_commitment_secret_arg_ref, my_current_per_commitment_point_arg_ref);
15960 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15961 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15962 uint64_t ret_ref = (uint64_t)ret_var.inner;
15963 if (ret_var.is_owned) {
15969 uint32_t __attribute__((visibility("default"))) TS_DataLossProtect_clone(uint32_t orig) {
15970 LDKDataLossProtect orig_conv;
15971 orig_conv.inner = (void*)(orig & (~1));
15972 orig_conv.is_owned = false;
15973 LDKDataLossProtect ret_var = DataLossProtect_clone(&orig_conv);
15974 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
15975 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
15976 uint64_t ret_ref = (uint64_t)ret_var.inner;
15977 if (ret_var.is_owned) {
15983 void __attribute__((visibility("default"))) TS_ChannelReestablish_free(uint32_t this_obj) {
15984 LDKChannelReestablish this_obj_conv;
15985 this_obj_conv.inner = (void*)(this_obj & (~1));
15986 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
15987 ChannelReestablish_free(this_obj_conv);
15990 int8_tArray __attribute__((visibility("default"))) TS_ChannelReestablish_get_channel_id(uint32_t this_ptr) {
15991 LDKChannelReestablish this_ptr_conv;
15992 this_ptr_conv.inner = (void*)(this_ptr & (~1));
15993 this_ptr_conv.is_owned = false;
15994 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
15995 memcpy((uint8_t*)(ret_arr + 4), *ChannelReestablish_get_channel_id(&this_ptr_conv), 32);
15999 void __attribute__((visibility("default"))) TS_ChannelReestablish_set_channel_id(uint32_t this_ptr, int8_tArray val) {
16000 LDKChannelReestablish this_ptr_conv;
16001 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16002 this_ptr_conv.is_owned = false;
16003 LDKThirtyTwoBytes val_ref;
16004 CHECK(*((uint32_t*)val) == 32);
16005 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16006 ChannelReestablish_set_channel_id(&this_ptr_conv, val_ref);
16009 int64_t __attribute__((visibility("default"))) TS_ChannelReestablish_get_next_local_commitment_number(uint32_t this_ptr) {
16010 LDKChannelReestablish this_ptr_conv;
16011 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16012 this_ptr_conv.is_owned = false;
16013 int64_t ret_val = ChannelReestablish_get_next_local_commitment_number(&this_ptr_conv);
16017 void __attribute__((visibility("default"))) TS_ChannelReestablish_set_next_local_commitment_number(uint32_t this_ptr, int64_t val) {
16018 LDKChannelReestablish this_ptr_conv;
16019 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16020 this_ptr_conv.is_owned = false;
16021 ChannelReestablish_set_next_local_commitment_number(&this_ptr_conv, val);
16024 int64_t __attribute__((visibility("default"))) TS_ChannelReestablish_get_next_remote_commitment_number(uint32_t this_ptr) {
16025 LDKChannelReestablish this_ptr_conv;
16026 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16027 this_ptr_conv.is_owned = false;
16028 int64_t ret_val = ChannelReestablish_get_next_remote_commitment_number(&this_ptr_conv);
16032 void __attribute__((visibility("default"))) TS_ChannelReestablish_set_next_remote_commitment_number(uint32_t this_ptr, int64_t val) {
16033 LDKChannelReestablish this_ptr_conv;
16034 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16035 this_ptr_conv.is_owned = false;
16036 ChannelReestablish_set_next_remote_commitment_number(&this_ptr_conv, val);
16039 uint32_t __attribute__((visibility("default"))) TS_ChannelReestablish_clone(uint32_t orig) {
16040 LDKChannelReestablish orig_conv;
16041 orig_conv.inner = (void*)(orig & (~1));
16042 orig_conv.is_owned = false;
16043 LDKChannelReestablish ret_var = ChannelReestablish_clone(&orig_conv);
16044 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16045 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16046 uint64_t ret_ref = (uint64_t)ret_var.inner;
16047 if (ret_var.is_owned) {
16053 void __attribute__((visibility("default"))) TS_AnnouncementSignatures_free(uint32_t this_obj) {
16054 LDKAnnouncementSignatures this_obj_conv;
16055 this_obj_conv.inner = (void*)(this_obj & (~1));
16056 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16057 AnnouncementSignatures_free(this_obj_conv);
16060 int8_tArray __attribute__((visibility("default"))) TS_AnnouncementSignatures_get_channel_id(uint32_t this_ptr) {
16061 LDKAnnouncementSignatures this_ptr_conv;
16062 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16063 this_ptr_conv.is_owned = false;
16064 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
16065 memcpy((uint8_t*)(ret_arr + 4), *AnnouncementSignatures_get_channel_id(&this_ptr_conv), 32);
16069 void __attribute__((visibility("default"))) TS_AnnouncementSignatures_set_channel_id(uint32_t this_ptr, int8_tArray val) {
16070 LDKAnnouncementSignatures this_ptr_conv;
16071 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16072 this_ptr_conv.is_owned = false;
16073 LDKThirtyTwoBytes val_ref;
16074 CHECK(*((uint32_t*)val) == 32);
16075 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16076 AnnouncementSignatures_set_channel_id(&this_ptr_conv, val_ref);
16079 int64_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_get_short_channel_id(uint32_t this_ptr) {
16080 LDKAnnouncementSignatures this_ptr_conv;
16081 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16082 this_ptr_conv.is_owned = false;
16083 int64_t ret_val = AnnouncementSignatures_get_short_channel_id(&this_ptr_conv);
16087 void __attribute__((visibility("default"))) TS_AnnouncementSignatures_set_short_channel_id(uint32_t this_ptr, int64_t val) {
16088 LDKAnnouncementSignatures this_ptr_conv;
16089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16090 this_ptr_conv.is_owned = false;
16091 AnnouncementSignatures_set_short_channel_id(&this_ptr_conv, val);
16094 int8_tArray __attribute__((visibility("default"))) TS_AnnouncementSignatures_get_node_signature(uint32_t this_ptr) {
16095 LDKAnnouncementSignatures this_ptr_conv;
16096 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16097 this_ptr_conv.is_owned = false;
16098 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16099 memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_node_signature(&this_ptr_conv).compact_form, 64);
16103 void __attribute__((visibility("default"))) TS_AnnouncementSignatures_set_node_signature(uint32_t this_ptr, int8_tArray val) {
16104 LDKAnnouncementSignatures this_ptr_conv;
16105 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16106 this_ptr_conv.is_owned = false;
16107 LDKSignature val_ref;
16108 CHECK(*((uint32_t*)val) == 64);
16109 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16110 AnnouncementSignatures_set_node_signature(&this_ptr_conv, val_ref);
16113 int8_tArray __attribute__((visibility("default"))) TS_AnnouncementSignatures_get_bitcoin_signature(uint32_t this_ptr) {
16114 LDKAnnouncementSignatures this_ptr_conv;
16115 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16116 this_ptr_conv.is_owned = false;
16117 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16118 memcpy((uint8_t*)(ret_arr + 4), AnnouncementSignatures_get_bitcoin_signature(&this_ptr_conv).compact_form, 64);
16122 void __attribute__((visibility("default"))) TS_AnnouncementSignatures_set_bitcoin_signature(uint32_t this_ptr, int8_tArray val) {
16123 LDKAnnouncementSignatures this_ptr_conv;
16124 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16125 this_ptr_conv.is_owned = false;
16126 LDKSignature val_ref;
16127 CHECK(*((uint32_t*)val) == 64);
16128 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16129 AnnouncementSignatures_set_bitcoin_signature(&this_ptr_conv, val_ref);
16132 uint32_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_new(int8_tArray channel_id_arg, int64_t short_channel_id_arg, int8_tArray node_signature_arg, int8_tArray bitcoin_signature_arg) {
16133 LDKThirtyTwoBytes channel_id_arg_ref;
16134 CHECK(*((uint32_t*)channel_id_arg) == 32);
16135 memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32);
16136 LDKSignature node_signature_arg_ref;
16137 CHECK(*((uint32_t*)node_signature_arg) == 64);
16138 memcpy(node_signature_arg_ref.compact_form, (uint8_t*)(node_signature_arg + 4), 64);
16139 LDKSignature bitcoin_signature_arg_ref;
16140 CHECK(*((uint32_t*)bitcoin_signature_arg) == 64);
16141 memcpy(bitcoin_signature_arg_ref.compact_form, (uint8_t*)(bitcoin_signature_arg + 4), 64);
16142 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_new(channel_id_arg_ref, short_channel_id_arg, node_signature_arg_ref, bitcoin_signature_arg_ref);
16143 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16144 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16145 uint64_t ret_ref = (uint64_t)ret_var.inner;
16146 if (ret_var.is_owned) {
16152 uint32_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_clone(uint32_t orig) {
16153 LDKAnnouncementSignatures orig_conv;
16154 orig_conv.inner = (void*)(orig & (~1));
16155 orig_conv.is_owned = false;
16156 LDKAnnouncementSignatures ret_var = AnnouncementSignatures_clone(&orig_conv);
16157 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16158 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16159 uint64_t ret_ref = (uint64_t)ret_var.inner;
16160 if (ret_var.is_owned) {
16166 void __attribute__((visibility("default"))) TS_NetAddress_free(uint32_t this_ptr) {
16167 if ((this_ptr & 1) != 0) return;
16168 LDKNetAddress this_ptr_conv = *(LDKNetAddress*)(((uint64_t)this_ptr) & ~1);
16169 FREE((void*)this_ptr);
16170 NetAddress_free(this_ptr_conv);
16173 uint32_t __attribute__((visibility("default"))) TS_NetAddress_clone(uint32_t orig) {
16174 LDKNetAddress* orig_conv = (LDKNetAddress*)orig;
16175 LDKNetAddress *ret_copy = MALLOC(sizeof(LDKNetAddress), "LDKNetAddress");
16176 *ret_copy = NetAddress_clone(orig_conv);
16177 uint64_t ret_ref = (uint64_t)ret_copy;
16181 int8_tArray __attribute__((visibility("default"))) TS_NetAddress_write(uint32_t obj) {
16182 LDKNetAddress* obj_conv = (LDKNetAddress*)obj;
16183 LDKCVec_u8Z ret_var = NetAddress_write(obj_conv);
16184 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
16185 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
16186 CVec_u8Z_free(ret_var);
16190 uint32_t __attribute__((visibility("default"))) TS_Result_read(int8_tArray ser) {
16191 LDKu8slice ser_ref;
16192 ser_ref.datalen = *((uint32_t*)ser);
16193 ser_ref.data = (int8_t*)(ser + 4);
16194 LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ");
16195 *ret_conv = Result_read(ser_ref);
16196 return (uint64_t)ret_conv;
16199 uint32_t __attribute__((visibility("default"))) TS_NetAddress_read(int8_tArray ser) {
16200 LDKu8slice ser_ref;
16201 ser_ref.datalen = *((uint32_t*)ser);
16202 ser_ref.data = (int8_t*)(ser + 4);
16203 LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ");
16204 *ret_conv = NetAddress_read(ser_ref);
16205 return (uint64_t)ret_conv;
16208 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_free(uint32_t this_obj) {
16209 LDKUnsignedNodeAnnouncement this_obj_conv;
16210 this_obj_conv.inner = (void*)(this_obj & (~1));
16211 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16212 UnsignedNodeAnnouncement_free(this_obj_conv);
16215 uint32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_get_features(uint32_t this_ptr) {
16216 LDKUnsignedNodeAnnouncement this_ptr_conv;
16217 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16218 this_ptr_conv.is_owned = false;
16219 LDKNodeFeatures ret_var = UnsignedNodeAnnouncement_get_features(&this_ptr_conv);
16220 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16221 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16222 uint64_t ret_ref = (uint64_t)ret_var.inner;
16223 if (ret_var.is_owned) {
16229 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_features(uint32_t this_ptr, uint32_t val) {
16230 LDKUnsignedNodeAnnouncement this_ptr_conv;
16231 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16232 this_ptr_conv.is_owned = false;
16233 LDKNodeFeatures val_conv;
16234 val_conv.inner = (void*)(val & (~1));
16235 val_conv.is_owned = (val & 1) || (val == 0);
16236 val_conv = NodeFeatures_clone(&val_conv);
16237 UnsignedNodeAnnouncement_set_features(&this_ptr_conv, val_conv);
16240 int32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_get_timestamp(uint32_t this_ptr) {
16241 LDKUnsignedNodeAnnouncement this_ptr_conv;
16242 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16243 this_ptr_conv.is_owned = false;
16244 int32_t ret_val = UnsignedNodeAnnouncement_get_timestamp(&this_ptr_conv);
16248 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_timestamp(uint32_t this_ptr, int32_t val) {
16249 LDKUnsignedNodeAnnouncement this_ptr_conv;
16250 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16251 this_ptr_conv.is_owned = false;
16252 UnsignedNodeAnnouncement_set_timestamp(&this_ptr_conv, val);
16255 int8_tArray __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_get_node_id(uint32_t this_ptr) {
16256 LDKUnsignedNodeAnnouncement this_ptr_conv;
16257 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16258 this_ptr_conv.is_owned = false;
16259 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
16260 memcpy((uint8_t*)(ret_arr + 4), UnsignedNodeAnnouncement_get_node_id(&this_ptr_conv).compressed_form, 33);
16264 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_node_id(uint32_t this_ptr, int8_tArray val) {
16265 LDKUnsignedNodeAnnouncement this_ptr_conv;
16266 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16267 this_ptr_conv.is_owned = false;
16268 LDKPublicKey val_ref;
16269 CHECK(*((uint32_t*)val) == 33);
16270 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
16271 UnsignedNodeAnnouncement_set_node_id(&this_ptr_conv, val_ref);
16274 int8_tArray __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_get_rgb(uint32_t this_ptr) {
16275 LDKUnsignedNodeAnnouncement this_ptr_conv;
16276 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16277 this_ptr_conv.is_owned = false;
16278 int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
16279 memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_rgb(&this_ptr_conv), 3);
16283 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_rgb(uint32_t this_ptr, int8_tArray val) {
16284 LDKUnsignedNodeAnnouncement this_ptr_conv;
16285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16286 this_ptr_conv.is_owned = false;
16287 LDKThreeBytes val_ref;
16288 CHECK(*((uint32_t*)val) == 3);
16289 memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
16290 UnsignedNodeAnnouncement_set_rgb(&this_ptr_conv, val_ref);
16293 int8_tArray __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_get_alias(uint32_t this_ptr) {
16294 LDKUnsignedNodeAnnouncement this_ptr_conv;
16295 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16296 this_ptr_conv.is_owned = false;
16297 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
16298 memcpy((uint8_t*)(ret_arr + 4), *UnsignedNodeAnnouncement_get_alias(&this_ptr_conv), 32);
16302 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_alias(uint32_t this_ptr, int8_tArray val) {
16303 LDKUnsignedNodeAnnouncement this_ptr_conv;
16304 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16305 this_ptr_conv.is_owned = false;
16306 LDKThirtyTwoBytes val_ref;
16307 CHECK(*((uint32_t*)val) == 32);
16308 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16309 UnsignedNodeAnnouncement_set_alias(&this_ptr_conv, val_ref);
16312 void __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_set_addresses(uint32_t this_ptr, uint32_tArray val) {
16313 LDKUnsignedNodeAnnouncement this_ptr_conv;
16314 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16315 this_ptr_conv.is_owned = false;
16316 LDKCVec_NetAddressZ val_constr;
16317 val_constr.datalen = *((uint32_t*)val);
16318 if (val_constr.datalen > 0)
16319 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
16321 val_constr.data = NULL;
16322 uint32_t* val_vals = (uint32_t*)(val + 4);
16323 for (size_t m = 0; m < val_constr.datalen; m++) {
16324 uint32_t val_conv_12 = val_vals[m];
16325 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
16326 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1));
16327 val_constr.data[m] = val_conv_12_conv;
16329 UnsignedNodeAnnouncement_set_addresses(&this_ptr_conv, val_constr);
16332 uint32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_clone(uint32_t orig) {
16333 LDKUnsignedNodeAnnouncement orig_conv;
16334 orig_conv.inner = (void*)(orig & (~1));
16335 orig_conv.is_owned = false;
16336 LDKUnsignedNodeAnnouncement ret_var = UnsignedNodeAnnouncement_clone(&orig_conv);
16337 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16338 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16339 uint64_t ret_ref = (uint64_t)ret_var.inner;
16340 if (ret_var.is_owned) {
16346 void __attribute__((visibility("default"))) TS_NodeAnnouncement_free(uint32_t this_obj) {
16347 LDKNodeAnnouncement this_obj_conv;
16348 this_obj_conv.inner = (void*)(this_obj & (~1));
16349 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16350 NodeAnnouncement_free(this_obj_conv);
16353 int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncement_get_signature(uint32_t this_ptr) {
16354 LDKNodeAnnouncement this_ptr_conv;
16355 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16356 this_ptr_conv.is_owned = false;
16357 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16358 memcpy((uint8_t*)(ret_arr + 4), NodeAnnouncement_get_signature(&this_ptr_conv).compact_form, 64);
16362 void __attribute__((visibility("default"))) TS_NodeAnnouncement_set_signature(uint32_t this_ptr, int8_tArray val) {
16363 LDKNodeAnnouncement this_ptr_conv;
16364 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16365 this_ptr_conv.is_owned = false;
16366 LDKSignature val_ref;
16367 CHECK(*((uint32_t*)val) == 64);
16368 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16369 NodeAnnouncement_set_signature(&this_ptr_conv, val_ref);
16372 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_get_contents(uint32_t this_ptr) {
16373 LDKNodeAnnouncement this_ptr_conv;
16374 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16375 this_ptr_conv.is_owned = false;
16376 LDKUnsignedNodeAnnouncement ret_var = NodeAnnouncement_get_contents(&this_ptr_conv);
16377 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16378 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16379 uint64_t ret_ref = (uint64_t)ret_var.inner;
16380 if (ret_var.is_owned) {
16386 void __attribute__((visibility("default"))) TS_NodeAnnouncement_set_contents(uint32_t this_ptr, uint32_t val) {
16387 LDKNodeAnnouncement this_ptr_conv;
16388 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16389 this_ptr_conv.is_owned = false;
16390 LDKUnsignedNodeAnnouncement val_conv;
16391 val_conv.inner = (void*)(val & (~1));
16392 val_conv.is_owned = (val & 1) || (val == 0);
16393 val_conv = UnsignedNodeAnnouncement_clone(&val_conv);
16394 NodeAnnouncement_set_contents(&this_ptr_conv, val_conv);
16397 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_new(int8_tArray signature_arg, uint32_t contents_arg) {
16398 LDKSignature signature_arg_ref;
16399 CHECK(*((uint32_t*)signature_arg) == 64);
16400 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
16401 LDKUnsignedNodeAnnouncement contents_arg_conv;
16402 contents_arg_conv.inner = (void*)(contents_arg & (~1));
16403 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
16404 contents_arg_conv = UnsignedNodeAnnouncement_clone(&contents_arg_conv);
16405 LDKNodeAnnouncement ret_var = NodeAnnouncement_new(signature_arg_ref, contents_arg_conv);
16406 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16407 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16408 uint64_t ret_ref = (uint64_t)ret_var.inner;
16409 if (ret_var.is_owned) {
16415 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_clone(uint32_t orig) {
16416 LDKNodeAnnouncement orig_conv;
16417 orig_conv.inner = (void*)(orig & (~1));
16418 orig_conv.is_owned = false;
16419 LDKNodeAnnouncement ret_var = NodeAnnouncement_clone(&orig_conv);
16420 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16421 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16422 uint64_t ret_ref = (uint64_t)ret_var.inner;
16423 if (ret_var.is_owned) {
16429 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_free(uint32_t this_obj) {
16430 LDKUnsignedChannelAnnouncement this_obj_conv;
16431 this_obj_conv.inner = (void*)(this_obj & (~1));
16432 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16433 UnsignedChannelAnnouncement_free(this_obj_conv);
16436 uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_features(uint32_t this_ptr) {
16437 LDKUnsignedChannelAnnouncement this_ptr_conv;
16438 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16439 this_ptr_conv.is_owned = false;
16440 LDKChannelFeatures ret_var = UnsignedChannelAnnouncement_get_features(&this_ptr_conv);
16441 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16442 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16443 uint64_t ret_ref = (uint64_t)ret_var.inner;
16444 if (ret_var.is_owned) {
16450 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_features(uint32_t this_ptr, uint32_t val) {
16451 LDKUnsignedChannelAnnouncement this_ptr_conv;
16452 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16453 this_ptr_conv.is_owned = false;
16454 LDKChannelFeatures val_conv;
16455 val_conv.inner = (void*)(val & (~1));
16456 val_conv.is_owned = (val & 1) || (val == 0);
16457 val_conv = ChannelFeatures_clone(&val_conv);
16458 UnsignedChannelAnnouncement_set_features(&this_ptr_conv, val_conv);
16461 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_chain_hash(uint32_t this_ptr) {
16462 LDKUnsignedChannelAnnouncement this_ptr_conv;
16463 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16464 this_ptr_conv.is_owned = false;
16465 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
16466 memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelAnnouncement_get_chain_hash(&this_ptr_conv), 32);
16470 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
16471 LDKUnsignedChannelAnnouncement this_ptr_conv;
16472 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16473 this_ptr_conv.is_owned = false;
16474 LDKThirtyTwoBytes val_ref;
16475 CHECK(*((uint32_t*)val) == 32);
16476 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16477 UnsignedChannelAnnouncement_set_chain_hash(&this_ptr_conv, val_ref);
16480 int64_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_short_channel_id(uint32_t this_ptr) {
16481 LDKUnsignedChannelAnnouncement this_ptr_conv;
16482 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16483 this_ptr_conv.is_owned = false;
16484 int64_t ret_val = UnsignedChannelAnnouncement_get_short_channel_id(&this_ptr_conv);
16488 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_short_channel_id(uint32_t this_ptr, int64_t val) {
16489 LDKUnsignedChannelAnnouncement this_ptr_conv;
16490 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16491 this_ptr_conv.is_owned = false;
16492 UnsignedChannelAnnouncement_set_short_channel_id(&this_ptr_conv, val);
16495 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_node_id_1(uint32_t this_ptr) {
16496 LDKUnsignedChannelAnnouncement this_ptr_conv;
16497 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16498 this_ptr_conv.is_owned = false;
16499 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
16500 memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_1(&this_ptr_conv).compressed_form, 33);
16504 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_node_id_1(uint32_t this_ptr, int8_tArray val) {
16505 LDKUnsignedChannelAnnouncement this_ptr_conv;
16506 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16507 this_ptr_conv.is_owned = false;
16508 LDKPublicKey val_ref;
16509 CHECK(*((uint32_t*)val) == 33);
16510 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
16511 UnsignedChannelAnnouncement_set_node_id_1(&this_ptr_conv, val_ref);
16514 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_node_id_2(uint32_t this_ptr) {
16515 LDKUnsignedChannelAnnouncement this_ptr_conv;
16516 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16517 this_ptr_conv.is_owned = false;
16518 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
16519 memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_node_id_2(&this_ptr_conv).compressed_form, 33);
16523 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_node_id_2(uint32_t this_ptr, int8_tArray val) {
16524 LDKUnsignedChannelAnnouncement this_ptr_conv;
16525 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16526 this_ptr_conv.is_owned = false;
16527 LDKPublicKey val_ref;
16528 CHECK(*((uint32_t*)val) == 33);
16529 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
16530 UnsignedChannelAnnouncement_set_node_id_2(&this_ptr_conv, val_ref);
16533 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_1(uint32_t this_ptr) {
16534 LDKUnsignedChannelAnnouncement this_ptr_conv;
16535 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16536 this_ptr_conv.is_owned = false;
16537 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
16538 memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_1(&this_ptr_conv).compressed_form, 33);
16542 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_1(uint32_t this_ptr, int8_tArray val) {
16543 LDKUnsignedChannelAnnouncement this_ptr_conv;
16544 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16545 this_ptr_conv.is_owned = false;
16546 LDKPublicKey val_ref;
16547 CHECK(*((uint32_t*)val) == 33);
16548 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
16549 UnsignedChannelAnnouncement_set_bitcoin_key_1(&this_ptr_conv, val_ref);
16552 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_get_bitcoin_key_2(uint32_t this_ptr) {
16553 LDKUnsignedChannelAnnouncement this_ptr_conv;
16554 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16555 this_ptr_conv.is_owned = false;
16556 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
16557 memcpy((uint8_t*)(ret_arr + 4), UnsignedChannelAnnouncement_get_bitcoin_key_2(&this_ptr_conv).compressed_form, 33);
16561 void __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_set_bitcoin_key_2(uint32_t this_ptr, int8_tArray val) {
16562 LDKUnsignedChannelAnnouncement this_ptr_conv;
16563 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16564 this_ptr_conv.is_owned = false;
16565 LDKPublicKey val_ref;
16566 CHECK(*((uint32_t*)val) == 33);
16567 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
16568 UnsignedChannelAnnouncement_set_bitcoin_key_2(&this_ptr_conv, val_ref);
16571 uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_clone(uint32_t orig) {
16572 LDKUnsignedChannelAnnouncement orig_conv;
16573 orig_conv.inner = (void*)(orig & (~1));
16574 orig_conv.is_owned = false;
16575 LDKUnsignedChannelAnnouncement ret_var = UnsignedChannelAnnouncement_clone(&orig_conv);
16576 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16577 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16578 uint64_t ret_ref = (uint64_t)ret_var.inner;
16579 if (ret_var.is_owned) {
16585 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_free(uint32_t this_obj) {
16586 LDKChannelAnnouncement this_obj_conv;
16587 this_obj_conv.inner = (void*)(this_obj & (~1));
16588 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16589 ChannelAnnouncement_free(this_obj_conv);
16592 int8_tArray __attribute__((visibility("default"))) TS_ChannelAnnouncement_get_node_signature_1(uint32_t this_ptr) {
16593 LDKChannelAnnouncement this_ptr_conv;
16594 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16595 this_ptr_conv.is_owned = false;
16596 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16597 memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_1(&this_ptr_conv).compact_form, 64);
16601 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_set_node_signature_1(uint32_t this_ptr, int8_tArray val) {
16602 LDKChannelAnnouncement this_ptr_conv;
16603 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16604 this_ptr_conv.is_owned = false;
16605 LDKSignature val_ref;
16606 CHECK(*((uint32_t*)val) == 64);
16607 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16608 ChannelAnnouncement_set_node_signature_1(&this_ptr_conv, val_ref);
16611 int8_tArray __attribute__((visibility("default"))) TS_ChannelAnnouncement_get_node_signature_2(uint32_t this_ptr) {
16612 LDKChannelAnnouncement this_ptr_conv;
16613 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16614 this_ptr_conv.is_owned = false;
16615 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16616 memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_node_signature_2(&this_ptr_conv).compact_form, 64);
16620 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_set_node_signature_2(uint32_t this_ptr, int8_tArray val) {
16621 LDKChannelAnnouncement this_ptr_conv;
16622 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16623 this_ptr_conv.is_owned = false;
16624 LDKSignature val_ref;
16625 CHECK(*((uint32_t*)val) == 64);
16626 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16627 ChannelAnnouncement_set_node_signature_2(&this_ptr_conv, val_ref);
16630 int8_tArray __attribute__((visibility("default"))) TS_ChannelAnnouncement_get_bitcoin_signature_1(uint32_t this_ptr) {
16631 LDKChannelAnnouncement this_ptr_conv;
16632 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16633 this_ptr_conv.is_owned = false;
16634 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16635 memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_1(&this_ptr_conv).compact_form, 64);
16639 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_set_bitcoin_signature_1(uint32_t this_ptr, int8_tArray val) {
16640 LDKChannelAnnouncement this_ptr_conv;
16641 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16642 this_ptr_conv.is_owned = false;
16643 LDKSignature val_ref;
16644 CHECK(*((uint32_t*)val) == 64);
16645 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16646 ChannelAnnouncement_set_bitcoin_signature_1(&this_ptr_conv, val_ref);
16649 int8_tArray __attribute__((visibility("default"))) TS_ChannelAnnouncement_get_bitcoin_signature_2(uint32_t this_ptr) {
16650 LDKChannelAnnouncement this_ptr_conv;
16651 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16652 this_ptr_conv.is_owned = false;
16653 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16654 memcpy((uint8_t*)(ret_arr + 4), ChannelAnnouncement_get_bitcoin_signature_2(&this_ptr_conv).compact_form, 64);
16658 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_set_bitcoin_signature_2(uint32_t this_ptr, int8_tArray val) {
16659 LDKChannelAnnouncement this_ptr_conv;
16660 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16661 this_ptr_conv.is_owned = false;
16662 LDKSignature val_ref;
16663 CHECK(*((uint32_t*)val) == 64);
16664 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16665 ChannelAnnouncement_set_bitcoin_signature_2(&this_ptr_conv, val_ref);
16668 uint32_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_get_contents(uint32_t this_ptr) {
16669 LDKChannelAnnouncement this_ptr_conv;
16670 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16671 this_ptr_conv.is_owned = false;
16672 LDKUnsignedChannelAnnouncement ret_var = ChannelAnnouncement_get_contents(&this_ptr_conv);
16673 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16674 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16675 uint64_t ret_ref = (uint64_t)ret_var.inner;
16676 if (ret_var.is_owned) {
16682 void __attribute__((visibility("default"))) TS_ChannelAnnouncement_set_contents(uint32_t this_ptr, uint32_t val) {
16683 LDKChannelAnnouncement this_ptr_conv;
16684 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16685 this_ptr_conv.is_owned = false;
16686 LDKUnsignedChannelAnnouncement val_conv;
16687 val_conv.inner = (void*)(val & (~1));
16688 val_conv.is_owned = (val & 1) || (val == 0);
16689 val_conv = UnsignedChannelAnnouncement_clone(&val_conv);
16690 ChannelAnnouncement_set_contents(&this_ptr_conv, val_conv);
16693 uint32_t __attribute__((visibility("default"))) 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) {
16694 LDKSignature node_signature_1_arg_ref;
16695 CHECK(*((uint32_t*)node_signature_1_arg) == 64);
16696 memcpy(node_signature_1_arg_ref.compact_form, (uint8_t*)(node_signature_1_arg + 4), 64);
16697 LDKSignature node_signature_2_arg_ref;
16698 CHECK(*((uint32_t*)node_signature_2_arg) == 64);
16699 memcpy(node_signature_2_arg_ref.compact_form, (uint8_t*)(node_signature_2_arg + 4), 64);
16700 LDKSignature bitcoin_signature_1_arg_ref;
16701 CHECK(*((uint32_t*)bitcoin_signature_1_arg) == 64);
16702 memcpy(bitcoin_signature_1_arg_ref.compact_form, (uint8_t*)(bitcoin_signature_1_arg + 4), 64);
16703 LDKSignature bitcoin_signature_2_arg_ref;
16704 CHECK(*((uint32_t*)bitcoin_signature_2_arg) == 64);
16705 memcpy(bitcoin_signature_2_arg_ref.compact_form, (uint8_t*)(bitcoin_signature_2_arg + 4), 64);
16706 LDKUnsignedChannelAnnouncement contents_arg_conv;
16707 contents_arg_conv.inner = (void*)(contents_arg & (~1));
16708 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
16709 contents_arg_conv = UnsignedChannelAnnouncement_clone(&contents_arg_conv);
16710 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);
16711 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16712 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16713 uint64_t ret_ref = (uint64_t)ret_var.inner;
16714 if (ret_var.is_owned) {
16720 uint32_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_clone(uint32_t orig) {
16721 LDKChannelAnnouncement orig_conv;
16722 orig_conv.inner = (void*)(orig & (~1));
16723 orig_conv.is_owned = false;
16724 LDKChannelAnnouncement ret_var = ChannelAnnouncement_clone(&orig_conv);
16725 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16726 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16727 uint64_t ret_ref = (uint64_t)ret_var.inner;
16728 if (ret_var.is_owned) {
16734 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_free(uint32_t this_obj) {
16735 LDKUnsignedChannelUpdate this_obj_conv;
16736 this_obj_conv.inner = (void*)(this_obj & (~1));
16737 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16738 UnsignedChannelUpdate_free(this_obj_conv);
16741 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_chain_hash(uint32_t this_ptr) {
16742 LDKUnsignedChannelUpdate this_ptr_conv;
16743 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16744 this_ptr_conv.is_owned = false;
16745 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
16746 memcpy((uint8_t*)(ret_arr + 4), *UnsignedChannelUpdate_get_chain_hash(&this_ptr_conv), 32);
16750 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
16751 LDKUnsignedChannelUpdate this_ptr_conv;
16752 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16753 this_ptr_conv.is_owned = false;
16754 LDKThirtyTwoBytes val_ref;
16755 CHECK(*((uint32_t*)val) == 32);
16756 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16757 UnsignedChannelUpdate_set_chain_hash(&this_ptr_conv, val_ref);
16760 int64_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_short_channel_id(uint32_t this_ptr) {
16761 LDKUnsignedChannelUpdate this_ptr_conv;
16762 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16763 this_ptr_conv.is_owned = false;
16764 int64_t ret_val = UnsignedChannelUpdate_get_short_channel_id(&this_ptr_conv);
16768 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_short_channel_id(uint32_t this_ptr, int64_t val) {
16769 LDKUnsignedChannelUpdate this_ptr_conv;
16770 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16771 this_ptr_conv.is_owned = false;
16772 UnsignedChannelUpdate_set_short_channel_id(&this_ptr_conv, val);
16775 int32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_timestamp(uint32_t this_ptr) {
16776 LDKUnsignedChannelUpdate this_ptr_conv;
16777 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16778 this_ptr_conv.is_owned = false;
16779 int32_t ret_val = UnsignedChannelUpdate_get_timestamp(&this_ptr_conv);
16783 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_timestamp(uint32_t this_ptr, int32_t val) {
16784 LDKUnsignedChannelUpdate this_ptr_conv;
16785 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16786 this_ptr_conv.is_owned = false;
16787 UnsignedChannelUpdate_set_timestamp(&this_ptr_conv, val);
16790 int8_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_flags(uint32_t this_ptr) {
16791 LDKUnsignedChannelUpdate this_ptr_conv;
16792 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16793 this_ptr_conv.is_owned = false;
16794 int8_t ret_val = UnsignedChannelUpdate_get_flags(&this_ptr_conv);
16798 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_flags(uint32_t this_ptr, int8_t val) {
16799 LDKUnsignedChannelUpdate this_ptr_conv;
16800 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16801 this_ptr_conv.is_owned = false;
16802 UnsignedChannelUpdate_set_flags(&this_ptr_conv, val);
16805 int16_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_cltv_expiry_delta(uint32_t this_ptr) {
16806 LDKUnsignedChannelUpdate this_ptr_conv;
16807 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16808 this_ptr_conv.is_owned = false;
16809 int16_t ret_val = UnsignedChannelUpdate_get_cltv_expiry_delta(&this_ptr_conv);
16813 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
16814 LDKUnsignedChannelUpdate this_ptr_conv;
16815 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16816 this_ptr_conv.is_owned = false;
16817 UnsignedChannelUpdate_set_cltv_expiry_delta(&this_ptr_conv, val);
16820 int64_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_htlc_minimum_msat(uint32_t this_ptr) {
16821 LDKUnsignedChannelUpdate this_ptr_conv;
16822 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16823 this_ptr_conv.is_owned = false;
16824 int64_t ret_val = UnsignedChannelUpdate_get_htlc_minimum_msat(&this_ptr_conv);
16828 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
16829 LDKUnsignedChannelUpdate this_ptr_conv;
16830 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16831 this_ptr_conv.is_owned = false;
16832 UnsignedChannelUpdate_set_htlc_minimum_msat(&this_ptr_conv, val);
16835 int32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_fee_base_msat(uint32_t this_ptr) {
16836 LDKUnsignedChannelUpdate this_ptr_conv;
16837 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16838 this_ptr_conv.is_owned = false;
16839 int32_t ret_val = UnsignedChannelUpdate_get_fee_base_msat(&this_ptr_conv);
16843 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_fee_base_msat(uint32_t this_ptr, int32_t val) {
16844 LDKUnsignedChannelUpdate this_ptr_conv;
16845 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16846 this_ptr_conv.is_owned = false;
16847 UnsignedChannelUpdate_set_fee_base_msat(&this_ptr_conv, val);
16850 int32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_get_fee_proportional_millionths(uint32_t this_ptr) {
16851 LDKUnsignedChannelUpdate this_ptr_conv;
16852 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16853 this_ptr_conv.is_owned = false;
16854 int32_t ret_val = UnsignedChannelUpdate_get_fee_proportional_millionths(&this_ptr_conv);
16858 void __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_set_fee_proportional_millionths(uint32_t this_ptr, int32_t val) {
16859 LDKUnsignedChannelUpdate this_ptr_conv;
16860 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16861 this_ptr_conv.is_owned = false;
16862 UnsignedChannelUpdate_set_fee_proportional_millionths(&this_ptr_conv, val);
16865 uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_clone(uint32_t orig) {
16866 LDKUnsignedChannelUpdate orig_conv;
16867 orig_conv.inner = (void*)(orig & (~1));
16868 orig_conv.is_owned = false;
16869 LDKUnsignedChannelUpdate ret_var = UnsignedChannelUpdate_clone(&orig_conv);
16870 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16871 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16872 uint64_t ret_ref = (uint64_t)ret_var.inner;
16873 if (ret_var.is_owned) {
16879 void __attribute__((visibility("default"))) TS_ChannelUpdate_free(uint32_t this_obj) {
16880 LDKChannelUpdate this_obj_conv;
16881 this_obj_conv.inner = (void*)(this_obj & (~1));
16882 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16883 ChannelUpdate_free(this_obj_conv);
16886 int8_tArray __attribute__((visibility("default"))) TS_ChannelUpdate_get_signature(uint32_t this_ptr) {
16887 LDKChannelUpdate this_ptr_conv;
16888 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16889 this_ptr_conv.is_owned = false;
16890 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
16891 memcpy((uint8_t*)(ret_arr + 4), ChannelUpdate_get_signature(&this_ptr_conv).compact_form, 64);
16895 void __attribute__((visibility("default"))) TS_ChannelUpdate_set_signature(uint32_t this_ptr, int8_tArray val) {
16896 LDKChannelUpdate this_ptr_conv;
16897 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16898 this_ptr_conv.is_owned = false;
16899 LDKSignature val_ref;
16900 CHECK(*((uint32_t*)val) == 64);
16901 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
16902 ChannelUpdate_set_signature(&this_ptr_conv, val_ref);
16905 uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_get_contents(uint32_t this_ptr) {
16906 LDKChannelUpdate this_ptr_conv;
16907 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16908 this_ptr_conv.is_owned = false;
16909 LDKUnsignedChannelUpdate ret_var = ChannelUpdate_get_contents(&this_ptr_conv);
16910 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16911 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16912 uint64_t ret_ref = (uint64_t)ret_var.inner;
16913 if (ret_var.is_owned) {
16919 void __attribute__((visibility("default"))) TS_ChannelUpdate_set_contents(uint32_t this_ptr, uint32_t val) {
16920 LDKChannelUpdate this_ptr_conv;
16921 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16922 this_ptr_conv.is_owned = false;
16923 LDKUnsignedChannelUpdate val_conv;
16924 val_conv.inner = (void*)(val & (~1));
16925 val_conv.is_owned = (val & 1) || (val == 0);
16926 val_conv = UnsignedChannelUpdate_clone(&val_conv);
16927 ChannelUpdate_set_contents(&this_ptr_conv, val_conv);
16930 uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_new(int8_tArray signature_arg, uint32_t contents_arg) {
16931 LDKSignature signature_arg_ref;
16932 CHECK(*((uint32_t*)signature_arg) == 64);
16933 memcpy(signature_arg_ref.compact_form, (uint8_t*)(signature_arg + 4), 64);
16934 LDKUnsignedChannelUpdate contents_arg_conv;
16935 contents_arg_conv.inner = (void*)(contents_arg & (~1));
16936 contents_arg_conv.is_owned = (contents_arg & 1) || (contents_arg == 0);
16937 contents_arg_conv = UnsignedChannelUpdate_clone(&contents_arg_conv);
16938 LDKChannelUpdate ret_var = ChannelUpdate_new(signature_arg_ref, contents_arg_conv);
16939 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16940 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16941 uint64_t ret_ref = (uint64_t)ret_var.inner;
16942 if (ret_var.is_owned) {
16948 uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_clone(uint32_t orig) {
16949 LDKChannelUpdate orig_conv;
16950 orig_conv.inner = (void*)(orig & (~1));
16951 orig_conv.is_owned = false;
16952 LDKChannelUpdate ret_var = ChannelUpdate_clone(&orig_conv);
16953 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
16954 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
16955 uint64_t ret_ref = (uint64_t)ret_var.inner;
16956 if (ret_var.is_owned) {
16962 void __attribute__((visibility("default"))) TS_QueryChannelRange_free(uint32_t this_obj) {
16963 LDKQueryChannelRange this_obj_conv;
16964 this_obj_conv.inner = (void*)(this_obj & (~1));
16965 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
16966 QueryChannelRange_free(this_obj_conv);
16969 int8_tArray __attribute__((visibility("default"))) TS_QueryChannelRange_get_chain_hash(uint32_t this_ptr) {
16970 LDKQueryChannelRange this_ptr_conv;
16971 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16972 this_ptr_conv.is_owned = false;
16973 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
16974 memcpy((uint8_t*)(ret_arr + 4), *QueryChannelRange_get_chain_hash(&this_ptr_conv), 32);
16978 void __attribute__((visibility("default"))) TS_QueryChannelRange_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
16979 LDKQueryChannelRange this_ptr_conv;
16980 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16981 this_ptr_conv.is_owned = false;
16982 LDKThirtyTwoBytes val_ref;
16983 CHECK(*((uint32_t*)val) == 32);
16984 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
16985 QueryChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
16988 int32_t __attribute__((visibility("default"))) TS_QueryChannelRange_get_first_blocknum(uint32_t this_ptr) {
16989 LDKQueryChannelRange this_ptr_conv;
16990 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16991 this_ptr_conv.is_owned = false;
16992 int32_t ret_val = QueryChannelRange_get_first_blocknum(&this_ptr_conv);
16996 void __attribute__((visibility("default"))) TS_QueryChannelRange_set_first_blocknum(uint32_t this_ptr, int32_t val) {
16997 LDKQueryChannelRange this_ptr_conv;
16998 this_ptr_conv.inner = (void*)(this_ptr & (~1));
16999 this_ptr_conv.is_owned = false;
17000 QueryChannelRange_set_first_blocknum(&this_ptr_conv, val);
17003 int32_t __attribute__((visibility("default"))) TS_QueryChannelRange_get_number_of_blocks(uint32_t this_ptr) {
17004 LDKQueryChannelRange this_ptr_conv;
17005 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17006 this_ptr_conv.is_owned = false;
17007 int32_t ret_val = QueryChannelRange_get_number_of_blocks(&this_ptr_conv);
17011 void __attribute__((visibility("default"))) TS_QueryChannelRange_set_number_of_blocks(uint32_t this_ptr, int32_t val) {
17012 LDKQueryChannelRange this_ptr_conv;
17013 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17014 this_ptr_conv.is_owned = false;
17015 QueryChannelRange_set_number_of_blocks(&this_ptr_conv, val);
17018 uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_new(int8_tArray chain_hash_arg, int32_t first_blocknum_arg, int32_t number_of_blocks_arg) {
17019 LDKThirtyTwoBytes chain_hash_arg_ref;
17020 CHECK(*((uint32_t*)chain_hash_arg) == 32);
17021 memcpy(chain_hash_arg_ref.data, (uint8_t*)(chain_hash_arg + 4), 32);
17022 LDKQueryChannelRange ret_var = QueryChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg);
17023 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17024 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17025 uint64_t ret_ref = (uint64_t)ret_var.inner;
17026 if (ret_var.is_owned) {
17032 uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_clone(uint32_t orig) {
17033 LDKQueryChannelRange orig_conv;
17034 orig_conv.inner = (void*)(orig & (~1));
17035 orig_conv.is_owned = false;
17036 LDKQueryChannelRange ret_var = QueryChannelRange_clone(&orig_conv);
17037 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17038 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17039 uint64_t ret_ref = (uint64_t)ret_var.inner;
17040 if (ret_var.is_owned) {
17046 void __attribute__((visibility("default"))) TS_ReplyChannelRange_free(uint32_t this_obj) {
17047 LDKReplyChannelRange this_obj_conv;
17048 this_obj_conv.inner = (void*)(this_obj & (~1));
17049 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17050 ReplyChannelRange_free(this_obj_conv);
17053 int8_tArray __attribute__((visibility("default"))) TS_ReplyChannelRange_get_chain_hash(uint32_t this_ptr) {
17054 LDKReplyChannelRange this_ptr_conv;
17055 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17056 this_ptr_conv.is_owned = false;
17057 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
17058 memcpy((uint8_t*)(ret_arr + 4), *ReplyChannelRange_get_chain_hash(&this_ptr_conv), 32);
17062 void __attribute__((visibility("default"))) TS_ReplyChannelRange_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
17063 LDKReplyChannelRange this_ptr_conv;
17064 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17065 this_ptr_conv.is_owned = false;
17066 LDKThirtyTwoBytes val_ref;
17067 CHECK(*((uint32_t*)val) == 32);
17068 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
17069 ReplyChannelRange_set_chain_hash(&this_ptr_conv, val_ref);
17072 int32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_get_first_blocknum(uint32_t this_ptr) {
17073 LDKReplyChannelRange this_ptr_conv;
17074 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17075 this_ptr_conv.is_owned = false;
17076 int32_t ret_val = ReplyChannelRange_get_first_blocknum(&this_ptr_conv);
17080 void __attribute__((visibility("default"))) TS_ReplyChannelRange_set_first_blocknum(uint32_t this_ptr, int32_t val) {
17081 LDKReplyChannelRange this_ptr_conv;
17082 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17083 this_ptr_conv.is_owned = false;
17084 ReplyChannelRange_set_first_blocknum(&this_ptr_conv, val);
17087 int32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_get_number_of_blocks(uint32_t this_ptr) {
17088 LDKReplyChannelRange this_ptr_conv;
17089 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17090 this_ptr_conv.is_owned = false;
17091 int32_t ret_val = ReplyChannelRange_get_number_of_blocks(&this_ptr_conv);
17095 void __attribute__((visibility("default"))) TS_ReplyChannelRange_set_number_of_blocks(uint32_t this_ptr, int32_t val) {
17096 LDKReplyChannelRange this_ptr_conv;
17097 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17098 this_ptr_conv.is_owned = false;
17099 ReplyChannelRange_set_number_of_blocks(&this_ptr_conv, val);
17102 jboolean __attribute__((visibility("default"))) TS_ReplyChannelRange_get_sync_complete(uint32_t this_ptr) {
17103 LDKReplyChannelRange this_ptr_conv;
17104 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17105 this_ptr_conv.is_owned = false;
17106 jboolean ret_val = ReplyChannelRange_get_sync_complete(&this_ptr_conv);
17110 void __attribute__((visibility("default"))) TS_ReplyChannelRange_set_sync_complete(uint32_t this_ptr, jboolean val) {
17111 LDKReplyChannelRange this_ptr_conv;
17112 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17113 this_ptr_conv.is_owned = false;
17114 ReplyChannelRange_set_sync_complete(&this_ptr_conv, val);
17117 void __attribute__((visibility("default"))) TS_ReplyChannelRange_set_short_channel_ids(uint32_t this_ptr, int64_tArray val) {
17118 LDKReplyChannelRange this_ptr_conv;
17119 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17120 this_ptr_conv.is_owned = false;
17121 LDKCVec_u64Z val_constr;
17122 val_constr.datalen = *((uint32_t*)val);
17123 if (val_constr.datalen > 0)
17124 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
17126 val_constr.data = NULL;
17127 int64_t* val_vals = (int64_t*)(val + 4);
17128 for (size_t i = 0; i < val_constr.datalen; i++) {
17129 int64_t val_conv_8 = val_vals[i];
17130 val_constr.data[i] = val_conv_8;
17132 ReplyChannelRange_set_short_channel_ids(&this_ptr_conv, val_constr);
17135 uint32_t __attribute__((visibility("default"))) 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) {
17136 LDKThirtyTwoBytes chain_hash_arg_ref;
17137 CHECK(*((uint32_t*)chain_hash_arg) == 32);
17138 memcpy(chain_hash_arg_ref.data, (uint8_t*)(chain_hash_arg + 4), 32);
17139 LDKCVec_u64Z short_channel_ids_arg_constr;
17140 short_channel_ids_arg_constr.datalen = *((uint32_t*)short_channel_ids_arg);
17141 if (short_channel_ids_arg_constr.datalen > 0)
17142 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
17144 short_channel_ids_arg_constr.data = NULL;
17145 int64_t* short_channel_ids_arg_vals = (int64_t*)(short_channel_ids_arg + 4);
17146 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
17147 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
17148 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
17150 LDKReplyChannelRange ret_var = ReplyChannelRange_new(chain_hash_arg_ref, first_blocknum_arg, number_of_blocks_arg, sync_complete_arg, short_channel_ids_arg_constr);
17151 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17152 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17153 uint64_t ret_ref = (uint64_t)ret_var.inner;
17154 if (ret_var.is_owned) {
17160 uint32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_clone(uint32_t orig) {
17161 LDKReplyChannelRange orig_conv;
17162 orig_conv.inner = (void*)(orig & (~1));
17163 orig_conv.is_owned = false;
17164 LDKReplyChannelRange ret_var = ReplyChannelRange_clone(&orig_conv);
17165 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17166 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17167 uint64_t ret_ref = (uint64_t)ret_var.inner;
17168 if (ret_var.is_owned) {
17174 void __attribute__((visibility("default"))) TS_QueryShortChannelIds_free(uint32_t this_obj) {
17175 LDKQueryShortChannelIds this_obj_conv;
17176 this_obj_conv.inner = (void*)(this_obj & (~1));
17177 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17178 QueryShortChannelIds_free(this_obj_conv);
17181 int8_tArray __attribute__((visibility("default"))) TS_QueryShortChannelIds_get_chain_hash(uint32_t this_ptr) {
17182 LDKQueryShortChannelIds this_ptr_conv;
17183 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17184 this_ptr_conv.is_owned = false;
17185 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
17186 memcpy((uint8_t*)(ret_arr + 4), *QueryShortChannelIds_get_chain_hash(&this_ptr_conv), 32);
17190 void __attribute__((visibility("default"))) TS_QueryShortChannelIds_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
17191 LDKQueryShortChannelIds this_ptr_conv;
17192 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17193 this_ptr_conv.is_owned = false;
17194 LDKThirtyTwoBytes val_ref;
17195 CHECK(*((uint32_t*)val) == 32);
17196 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
17197 QueryShortChannelIds_set_chain_hash(&this_ptr_conv, val_ref);
17200 void __attribute__((visibility("default"))) TS_QueryShortChannelIds_set_short_channel_ids(uint32_t this_ptr, int64_tArray val) {
17201 LDKQueryShortChannelIds this_ptr_conv;
17202 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17203 this_ptr_conv.is_owned = false;
17204 LDKCVec_u64Z val_constr;
17205 val_constr.datalen = *((uint32_t*)val);
17206 if (val_constr.datalen > 0)
17207 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
17209 val_constr.data = NULL;
17210 int64_t* val_vals = (int64_t*)(val + 4);
17211 for (size_t i = 0; i < val_constr.datalen; i++) {
17212 int64_t val_conv_8 = val_vals[i];
17213 val_constr.data[i] = val_conv_8;
17215 QueryShortChannelIds_set_short_channel_ids(&this_ptr_conv, val_constr);
17218 uint32_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_new(int8_tArray chain_hash_arg, int64_tArray short_channel_ids_arg) {
17219 LDKThirtyTwoBytes chain_hash_arg_ref;
17220 CHECK(*((uint32_t*)chain_hash_arg) == 32);
17221 memcpy(chain_hash_arg_ref.data, (uint8_t*)(chain_hash_arg + 4), 32);
17222 LDKCVec_u64Z short_channel_ids_arg_constr;
17223 short_channel_ids_arg_constr.datalen = *((uint32_t*)short_channel_ids_arg);
17224 if (short_channel_ids_arg_constr.datalen > 0)
17225 short_channel_ids_arg_constr.data = MALLOC(short_channel_ids_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
17227 short_channel_ids_arg_constr.data = NULL;
17228 int64_t* short_channel_ids_arg_vals = (int64_t*)(short_channel_ids_arg + 4);
17229 for (size_t i = 0; i < short_channel_ids_arg_constr.datalen; i++) {
17230 int64_t short_channel_ids_arg_conv_8 = short_channel_ids_arg_vals[i];
17231 short_channel_ids_arg_constr.data[i] = short_channel_ids_arg_conv_8;
17233 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_new(chain_hash_arg_ref, short_channel_ids_arg_constr);
17234 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17235 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17236 uint64_t ret_ref = (uint64_t)ret_var.inner;
17237 if (ret_var.is_owned) {
17243 uint32_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_clone(uint32_t orig) {
17244 LDKQueryShortChannelIds orig_conv;
17245 orig_conv.inner = (void*)(orig & (~1));
17246 orig_conv.is_owned = false;
17247 LDKQueryShortChannelIds ret_var = QueryShortChannelIds_clone(&orig_conv);
17248 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17249 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17250 uint64_t ret_ref = (uint64_t)ret_var.inner;
17251 if (ret_var.is_owned) {
17257 void __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_free(uint32_t this_obj) {
17258 LDKReplyShortChannelIdsEnd this_obj_conv;
17259 this_obj_conv.inner = (void*)(this_obj & (~1));
17260 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17261 ReplyShortChannelIdsEnd_free(this_obj_conv);
17264 int8_tArray __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_get_chain_hash(uint32_t this_ptr) {
17265 LDKReplyShortChannelIdsEnd this_ptr_conv;
17266 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17267 this_ptr_conv.is_owned = false;
17268 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
17269 memcpy((uint8_t*)(ret_arr + 4), *ReplyShortChannelIdsEnd_get_chain_hash(&this_ptr_conv), 32);
17273 void __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
17274 LDKReplyShortChannelIdsEnd this_ptr_conv;
17275 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17276 this_ptr_conv.is_owned = false;
17277 LDKThirtyTwoBytes val_ref;
17278 CHECK(*((uint32_t*)val) == 32);
17279 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
17280 ReplyShortChannelIdsEnd_set_chain_hash(&this_ptr_conv, val_ref);
17283 jboolean __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_get_full_information(uint32_t this_ptr) {
17284 LDKReplyShortChannelIdsEnd this_ptr_conv;
17285 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17286 this_ptr_conv.is_owned = false;
17287 jboolean ret_val = ReplyShortChannelIdsEnd_get_full_information(&this_ptr_conv);
17291 void __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_set_full_information(uint32_t this_ptr, jboolean val) {
17292 LDKReplyShortChannelIdsEnd this_ptr_conv;
17293 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17294 this_ptr_conv.is_owned = false;
17295 ReplyShortChannelIdsEnd_set_full_information(&this_ptr_conv, val);
17298 uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_new(int8_tArray chain_hash_arg, jboolean full_information_arg) {
17299 LDKThirtyTwoBytes chain_hash_arg_ref;
17300 CHECK(*((uint32_t*)chain_hash_arg) == 32);
17301 memcpy(chain_hash_arg_ref.data, (uint8_t*)(chain_hash_arg + 4), 32);
17302 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_new(chain_hash_arg_ref, full_information_arg);
17303 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17304 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17305 uint64_t ret_ref = (uint64_t)ret_var.inner;
17306 if (ret_var.is_owned) {
17312 uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_clone(uint32_t orig) {
17313 LDKReplyShortChannelIdsEnd orig_conv;
17314 orig_conv.inner = (void*)(orig & (~1));
17315 orig_conv.is_owned = false;
17316 LDKReplyShortChannelIdsEnd ret_var = ReplyShortChannelIdsEnd_clone(&orig_conv);
17317 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17318 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17319 uint64_t ret_ref = (uint64_t)ret_var.inner;
17320 if (ret_var.is_owned) {
17326 void __attribute__((visibility("default"))) TS_GossipTimestampFilter_free(uint32_t this_obj) {
17327 LDKGossipTimestampFilter this_obj_conv;
17328 this_obj_conv.inner = (void*)(this_obj & (~1));
17329 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17330 GossipTimestampFilter_free(this_obj_conv);
17333 int8_tArray __attribute__((visibility("default"))) TS_GossipTimestampFilter_get_chain_hash(uint32_t this_ptr) {
17334 LDKGossipTimestampFilter this_ptr_conv;
17335 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17336 this_ptr_conv.is_owned = false;
17337 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
17338 memcpy((uint8_t*)(ret_arr + 4), *GossipTimestampFilter_get_chain_hash(&this_ptr_conv), 32);
17342 void __attribute__((visibility("default"))) TS_GossipTimestampFilter_set_chain_hash(uint32_t this_ptr, int8_tArray val) {
17343 LDKGossipTimestampFilter this_ptr_conv;
17344 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17345 this_ptr_conv.is_owned = false;
17346 LDKThirtyTwoBytes val_ref;
17347 CHECK(*((uint32_t*)val) == 32);
17348 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
17349 GossipTimestampFilter_set_chain_hash(&this_ptr_conv, val_ref);
17352 int32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_get_first_timestamp(uint32_t this_ptr) {
17353 LDKGossipTimestampFilter this_ptr_conv;
17354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17355 this_ptr_conv.is_owned = false;
17356 int32_t ret_val = GossipTimestampFilter_get_first_timestamp(&this_ptr_conv);
17360 void __attribute__((visibility("default"))) TS_GossipTimestampFilter_set_first_timestamp(uint32_t this_ptr, int32_t val) {
17361 LDKGossipTimestampFilter this_ptr_conv;
17362 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17363 this_ptr_conv.is_owned = false;
17364 GossipTimestampFilter_set_first_timestamp(&this_ptr_conv, val);
17367 int32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_get_timestamp_range(uint32_t this_ptr) {
17368 LDKGossipTimestampFilter this_ptr_conv;
17369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17370 this_ptr_conv.is_owned = false;
17371 int32_t ret_val = GossipTimestampFilter_get_timestamp_range(&this_ptr_conv);
17375 void __attribute__((visibility("default"))) TS_GossipTimestampFilter_set_timestamp_range(uint32_t this_ptr, int32_t val) {
17376 LDKGossipTimestampFilter this_ptr_conv;
17377 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17378 this_ptr_conv.is_owned = false;
17379 GossipTimestampFilter_set_timestamp_range(&this_ptr_conv, val);
17382 uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_new(int8_tArray chain_hash_arg, int32_t first_timestamp_arg, int32_t timestamp_range_arg) {
17383 LDKThirtyTwoBytes chain_hash_arg_ref;
17384 CHECK(*((uint32_t*)chain_hash_arg) == 32);
17385 memcpy(chain_hash_arg_ref.data, (uint8_t*)(chain_hash_arg + 4), 32);
17386 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_new(chain_hash_arg_ref, first_timestamp_arg, timestamp_range_arg);
17387 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17388 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17389 uint64_t ret_ref = (uint64_t)ret_var.inner;
17390 if (ret_var.is_owned) {
17396 uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_clone(uint32_t orig) {
17397 LDKGossipTimestampFilter orig_conv;
17398 orig_conv.inner = (void*)(orig & (~1));
17399 orig_conv.is_owned = false;
17400 LDKGossipTimestampFilter ret_var = GossipTimestampFilter_clone(&orig_conv);
17401 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17402 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17403 uint64_t ret_ref = (uint64_t)ret_var.inner;
17404 if (ret_var.is_owned) {
17410 void __attribute__((visibility("default"))) TS_ErrorAction_free(uint32_t this_ptr) {
17411 if ((this_ptr & 1) != 0) return;
17412 LDKErrorAction this_ptr_conv = *(LDKErrorAction*)(((uint64_t)this_ptr) & ~1);
17413 FREE((void*)this_ptr);
17414 ErrorAction_free(this_ptr_conv);
17417 uint32_t __attribute__((visibility("default"))) TS_ErrorAction_clone(uint32_t orig) {
17418 LDKErrorAction* orig_conv = (LDKErrorAction*)orig;
17419 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
17420 *ret_copy = ErrorAction_clone(orig_conv);
17421 uint64_t ret_ref = (uint64_t)ret_copy;
17425 void __attribute__((visibility("default"))) TS_LightningError_free(uint32_t this_obj) {
17426 LDKLightningError this_obj_conv;
17427 this_obj_conv.inner = (void*)(this_obj & (~1));
17428 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17429 LightningError_free(this_obj_conv);
17432 jstring __attribute__((visibility("default"))) TS_LightningError_get_err(uint32_t this_ptr) {
17433 LDKLightningError this_ptr_conv;
17434 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17435 this_ptr_conv.is_owned = false;
17436 LDKStr ret_str = LightningError_get_err(&this_ptr_conv);
17437 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
17441 void __attribute__((visibility("default"))) TS_LightningError_set_err(uint32_t this_ptr, jstring val) {
17442 LDKLightningError this_ptr_conv;
17443 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17444 this_ptr_conv.is_owned = false;
17445 LDKStr val_conv = str_ref_to_owned_c(val);
17446 LightningError_set_err(&this_ptr_conv, val_conv);
17449 uint32_t __attribute__((visibility("default"))) TS_LightningError_get_action(uint32_t this_ptr) {
17450 LDKLightningError this_ptr_conv;
17451 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17452 this_ptr_conv.is_owned = false;
17453 LDKErrorAction *ret_copy = MALLOC(sizeof(LDKErrorAction), "LDKErrorAction");
17454 *ret_copy = LightningError_get_action(&this_ptr_conv);
17455 uint64_t ret_ref = (uint64_t)ret_copy;
17459 void __attribute__((visibility("default"))) TS_LightningError_set_action(uint32_t this_ptr, uint32_t val) {
17460 LDKLightningError this_ptr_conv;
17461 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17462 this_ptr_conv.is_owned = false;
17463 LDKErrorAction val_conv = *(LDKErrorAction*)(((uint64_t)val) & ~1);
17464 LightningError_set_action(&this_ptr_conv, val_conv);
17467 uint32_t __attribute__((visibility("default"))) TS_LightningError_new(jstring err_arg, uint32_t action_arg) {
17468 LDKStr err_arg_conv = str_ref_to_owned_c(err_arg);
17469 LDKErrorAction action_arg_conv = *(LDKErrorAction*)(((uint64_t)action_arg) & ~1);
17470 LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_conv);
17471 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17472 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17473 uint64_t ret_ref = (uint64_t)ret_var.inner;
17474 if (ret_var.is_owned) {
17480 uint32_t __attribute__((visibility("default"))) TS_LightningError_clone(uint32_t orig) {
17481 LDKLightningError orig_conv;
17482 orig_conv.inner = (void*)(orig & (~1));
17483 orig_conv.is_owned = false;
17484 LDKLightningError ret_var = LightningError_clone(&orig_conv);
17485 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17486 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17487 uint64_t ret_ref = (uint64_t)ret_var.inner;
17488 if (ret_var.is_owned) {
17494 void __attribute__((visibility("default"))) TS_CommitmentUpdate_free(uint32_t this_obj) {
17495 LDKCommitmentUpdate this_obj_conv;
17496 this_obj_conv.inner = (void*)(this_obj & (~1));
17497 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
17498 CommitmentUpdate_free(this_obj_conv);
17501 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_add_htlcs(uint32_t this_ptr, uint32_tArray val) {
17502 LDKCommitmentUpdate this_ptr_conv;
17503 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17504 this_ptr_conv.is_owned = false;
17505 LDKCVec_UpdateAddHTLCZ val_constr;
17506 val_constr.datalen = *((uint32_t*)val);
17507 if (val_constr.datalen > 0)
17508 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
17510 val_constr.data = NULL;
17511 uint32_t* val_vals = (uint32_t*)(val + 4);
17512 for (size_t p = 0; p < val_constr.datalen; p++) {
17513 uint32_t val_conv_15 = val_vals[p];
17514 LDKUpdateAddHTLC val_conv_15_conv;
17515 val_conv_15_conv.inner = (void*)(val_conv_15 & (~1));
17516 val_conv_15_conv.is_owned = (val_conv_15 & 1) || (val_conv_15 == 0);
17517 val_conv_15_conv = UpdateAddHTLC_clone(&val_conv_15_conv);
17518 val_constr.data[p] = val_conv_15_conv;
17520 CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr);
17523 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint32_t this_ptr, uint32_tArray val) {
17524 LDKCommitmentUpdate this_ptr_conv;
17525 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17526 this_ptr_conv.is_owned = false;
17527 LDKCVec_UpdateFulfillHTLCZ val_constr;
17528 val_constr.datalen = *((uint32_t*)val);
17529 if (val_constr.datalen > 0)
17530 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
17532 val_constr.data = NULL;
17533 uint32_t* val_vals = (uint32_t*)(val + 4);
17534 for (size_t t = 0; t < val_constr.datalen; t++) {
17535 uint32_t val_conv_19 = val_vals[t];
17536 LDKUpdateFulfillHTLC val_conv_19_conv;
17537 val_conv_19_conv.inner = (void*)(val_conv_19 & (~1));
17538 val_conv_19_conv.is_owned = (val_conv_19 & 1) || (val_conv_19 == 0);
17539 val_conv_19_conv = UpdateFulfillHTLC_clone(&val_conv_19_conv);
17540 val_constr.data[t] = val_conv_19_conv;
17542 CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr);
17545 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint32_t this_ptr, uint32_tArray val) {
17546 LDKCommitmentUpdate this_ptr_conv;
17547 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17548 this_ptr_conv.is_owned = false;
17549 LDKCVec_UpdateFailHTLCZ val_constr;
17550 val_constr.datalen = *((uint32_t*)val);
17551 if (val_constr.datalen > 0)
17552 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
17554 val_constr.data = NULL;
17555 uint32_t* val_vals = (uint32_t*)(val + 4);
17556 for (size_t q = 0; q < val_constr.datalen; q++) {
17557 uint32_t val_conv_16 = val_vals[q];
17558 LDKUpdateFailHTLC val_conv_16_conv;
17559 val_conv_16_conv.inner = (void*)(val_conv_16 & (~1));
17560 val_conv_16_conv.is_owned = (val_conv_16 & 1) || (val_conv_16 == 0);
17561 val_conv_16_conv = UpdateFailHTLC_clone(&val_conv_16_conv);
17562 val_constr.data[q] = val_conv_16_conv;
17564 CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr);
17567 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fail_malformed_htlcs(uint32_t this_ptr, uint32_tArray val) {
17568 LDKCommitmentUpdate this_ptr_conv;
17569 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17570 this_ptr_conv.is_owned = false;
17571 LDKCVec_UpdateFailMalformedHTLCZ val_constr;
17572 val_constr.datalen = *((uint32_t*)val);
17573 if (val_constr.datalen > 0)
17574 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
17576 val_constr.data = NULL;
17577 uint32_t* val_vals = (uint32_t*)(val + 4);
17578 for (size_t z = 0; z < val_constr.datalen; z++) {
17579 uint32_t val_conv_25 = val_vals[z];
17580 LDKUpdateFailMalformedHTLC val_conv_25_conv;
17581 val_conv_25_conv.inner = (void*)(val_conv_25 & (~1));
17582 val_conv_25_conv.is_owned = (val_conv_25 & 1) || (val_conv_25 == 0);
17583 val_conv_25_conv = UpdateFailMalformedHTLC_clone(&val_conv_25_conv);
17584 val_constr.data[z] = val_conv_25_conv;
17586 CommitmentUpdate_set_update_fail_malformed_htlcs(&this_ptr_conv, val_constr);
17589 uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_get_update_fee(uint32_t this_ptr) {
17590 LDKCommitmentUpdate this_ptr_conv;
17591 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17592 this_ptr_conv.is_owned = false;
17593 LDKUpdateFee ret_var = CommitmentUpdate_get_update_fee(&this_ptr_conv);
17594 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17595 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17596 uint64_t ret_ref = (uint64_t)ret_var.inner;
17597 if (ret_var.is_owned) {
17603 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fee(uint32_t this_ptr, uint32_t val) {
17604 LDKCommitmentUpdate this_ptr_conv;
17605 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17606 this_ptr_conv.is_owned = false;
17607 LDKUpdateFee val_conv;
17608 val_conv.inner = (void*)(val & (~1));
17609 val_conv.is_owned = (val & 1) || (val == 0);
17610 val_conv = UpdateFee_clone(&val_conv);
17611 CommitmentUpdate_set_update_fee(&this_ptr_conv, val_conv);
17614 uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_get_commitment_signed(uint32_t this_ptr) {
17615 LDKCommitmentUpdate this_ptr_conv;
17616 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17617 this_ptr_conv.is_owned = false;
17618 LDKCommitmentSigned ret_var = CommitmentUpdate_get_commitment_signed(&this_ptr_conv);
17619 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17620 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17621 uint64_t ret_ref = (uint64_t)ret_var.inner;
17622 if (ret_var.is_owned) {
17628 void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_commitment_signed(uint32_t this_ptr, uint32_t val) {
17629 LDKCommitmentUpdate this_ptr_conv;
17630 this_ptr_conv.inner = (void*)(this_ptr & (~1));
17631 this_ptr_conv.is_owned = false;
17632 LDKCommitmentSigned val_conv;
17633 val_conv.inner = (void*)(val & (~1));
17634 val_conv.is_owned = (val & 1) || (val == 0);
17635 val_conv = CommitmentSigned_clone(&val_conv);
17636 CommitmentUpdate_set_commitment_signed(&this_ptr_conv, val_conv);
17639 uint32_t __attribute__((visibility("default"))) 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) {
17640 LDKCVec_UpdateAddHTLCZ update_add_htlcs_arg_constr;
17641 update_add_htlcs_arg_constr.datalen = *((uint32_t*)update_add_htlcs_arg);
17642 if (update_add_htlcs_arg_constr.datalen > 0)
17643 update_add_htlcs_arg_constr.data = MALLOC(update_add_htlcs_arg_constr.datalen * sizeof(LDKUpdateAddHTLC), "LDKCVec_UpdateAddHTLCZ Elements");
17645 update_add_htlcs_arg_constr.data = NULL;
17646 uint32_t* update_add_htlcs_arg_vals = (uint32_t*)(update_add_htlcs_arg + 4);
17647 for (size_t p = 0; p < update_add_htlcs_arg_constr.datalen; p++) {
17648 uint32_t update_add_htlcs_arg_conv_15 = update_add_htlcs_arg_vals[p];
17649 LDKUpdateAddHTLC update_add_htlcs_arg_conv_15_conv;
17650 update_add_htlcs_arg_conv_15_conv.inner = (void*)(update_add_htlcs_arg_conv_15 & (~1));
17651 update_add_htlcs_arg_conv_15_conv.is_owned = (update_add_htlcs_arg_conv_15 & 1) || (update_add_htlcs_arg_conv_15 == 0);
17652 update_add_htlcs_arg_conv_15_conv = UpdateAddHTLC_clone(&update_add_htlcs_arg_conv_15_conv);
17653 update_add_htlcs_arg_constr.data[p] = update_add_htlcs_arg_conv_15_conv;
17655 LDKCVec_UpdateFulfillHTLCZ update_fulfill_htlcs_arg_constr;
17656 update_fulfill_htlcs_arg_constr.datalen = *((uint32_t*)update_fulfill_htlcs_arg);
17657 if (update_fulfill_htlcs_arg_constr.datalen > 0)
17658 update_fulfill_htlcs_arg_constr.data = MALLOC(update_fulfill_htlcs_arg_constr.datalen * sizeof(LDKUpdateFulfillHTLC), "LDKCVec_UpdateFulfillHTLCZ Elements");
17660 update_fulfill_htlcs_arg_constr.data = NULL;
17661 uint32_t* update_fulfill_htlcs_arg_vals = (uint32_t*)(update_fulfill_htlcs_arg + 4);
17662 for (size_t t = 0; t < update_fulfill_htlcs_arg_constr.datalen; t++) {
17663 uint32_t update_fulfill_htlcs_arg_conv_19 = update_fulfill_htlcs_arg_vals[t];
17664 LDKUpdateFulfillHTLC update_fulfill_htlcs_arg_conv_19_conv;
17665 update_fulfill_htlcs_arg_conv_19_conv.inner = (void*)(update_fulfill_htlcs_arg_conv_19 & (~1));
17666 update_fulfill_htlcs_arg_conv_19_conv.is_owned = (update_fulfill_htlcs_arg_conv_19 & 1) || (update_fulfill_htlcs_arg_conv_19 == 0);
17667 update_fulfill_htlcs_arg_conv_19_conv = UpdateFulfillHTLC_clone(&update_fulfill_htlcs_arg_conv_19_conv);
17668 update_fulfill_htlcs_arg_constr.data[t] = update_fulfill_htlcs_arg_conv_19_conv;
17670 LDKCVec_UpdateFailHTLCZ update_fail_htlcs_arg_constr;
17671 update_fail_htlcs_arg_constr.datalen = *((uint32_t*)update_fail_htlcs_arg);
17672 if (update_fail_htlcs_arg_constr.datalen > 0)
17673 update_fail_htlcs_arg_constr.data = MALLOC(update_fail_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailHTLC), "LDKCVec_UpdateFailHTLCZ Elements");
17675 update_fail_htlcs_arg_constr.data = NULL;
17676 uint32_t* update_fail_htlcs_arg_vals = (uint32_t*)(update_fail_htlcs_arg + 4);
17677 for (size_t q = 0; q < update_fail_htlcs_arg_constr.datalen; q++) {
17678 uint32_t update_fail_htlcs_arg_conv_16 = update_fail_htlcs_arg_vals[q];
17679 LDKUpdateFailHTLC update_fail_htlcs_arg_conv_16_conv;
17680 update_fail_htlcs_arg_conv_16_conv.inner = (void*)(update_fail_htlcs_arg_conv_16 & (~1));
17681 update_fail_htlcs_arg_conv_16_conv.is_owned = (update_fail_htlcs_arg_conv_16 & 1) || (update_fail_htlcs_arg_conv_16 == 0);
17682 update_fail_htlcs_arg_conv_16_conv = UpdateFailHTLC_clone(&update_fail_htlcs_arg_conv_16_conv);
17683 update_fail_htlcs_arg_constr.data[q] = update_fail_htlcs_arg_conv_16_conv;
17685 LDKCVec_UpdateFailMalformedHTLCZ update_fail_malformed_htlcs_arg_constr;
17686 update_fail_malformed_htlcs_arg_constr.datalen = *((uint32_t*)update_fail_malformed_htlcs_arg);
17687 if (update_fail_malformed_htlcs_arg_constr.datalen > 0)
17688 update_fail_malformed_htlcs_arg_constr.data = MALLOC(update_fail_malformed_htlcs_arg_constr.datalen * sizeof(LDKUpdateFailMalformedHTLC), "LDKCVec_UpdateFailMalformedHTLCZ Elements");
17690 update_fail_malformed_htlcs_arg_constr.data = NULL;
17691 uint32_t* update_fail_malformed_htlcs_arg_vals = (uint32_t*)(update_fail_malformed_htlcs_arg + 4);
17692 for (size_t z = 0; z < update_fail_malformed_htlcs_arg_constr.datalen; z++) {
17693 uint32_t update_fail_malformed_htlcs_arg_conv_25 = update_fail_malformed_htlcs_arg_vals[z];
17694 LDKUpdateFailMalformedHTLC update_fail_malformed_htlcs_arg_conv_25_conv;
17695 update_fail_malformed_htlcs_arg_conv_25_conv.inner = (void*)(update_fail_malformed_htlcs_arg_conv_25 & (~1));
17696 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);
17697 update_fail_malformed_htlcs_arg_conv_25_conv = UpdateFailMalformedHTLC_clone(&update_fail_malformed_htlcs_arg_conv_25_conv);
17698 update_fail_malformed_htlcs_arg_constr.data[z] = update_fail_malformed_htlcs_arg_conv_25_conv;
17700 LDKUpdateFee update_fee_arg_conv;
17701 update_fee_arg_conv.inner = (void*)(update_fee_arg & (~1));
17702 update_fee_arg_conv.is_owned = (update_fee_arg & 1) || (update_fee_arg == 0);
17703 update_fee_arg_conv = UpdateFee_clone(&update_fee_arg_conv);
17704 LDKCommitmentSigned commitment_signed_arg_conv;
17705 commitment_signed_arg_conv.inner = (void*)(commitment_signed_arg & (~1));
17706 commitment_signed_arg_conv.is_owned = (commitment_signed_arg & 1) || (commitment_signed_arg == 0);
17707 commitment_signed_arg_conv = CommitmentSigned_clone(&commitment_signed_arg_conv);
17708 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);
17709 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17710 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17711 uint64_t ret_ref = (uint64_t)ret_var.inner;
17712 if (ret_var.is_owned) {
17718 uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone(uint32_t orig) {
17719 LDKCommitmentUpdate orig_conv;
17720 orig_conv.inner = (void*)(orig & (~1));
17721 orig_conv.is_owned = false;
17722 LDKCommitmentUpdate ret_var = CommitmentUpdate_clone(&orig_conv);
17723 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
17724 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
17725 uint64_t ret_ref = (uint64_t)ret_var.inner;
17726 if (ret_var.is_owned) {
17732 void __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_free(uint32_t this_ptr) {
17733 if ((this_ptr & 1) != 0) return;
17734 LDKHTLCFailChannelUpdate this_ptr_conv = *(LDKHTLCFailChannelUpdate*)(((uint64_t)this_ptr) & ~1);
17735 FREE((void*)this_ptr);
17736 HTLCFailChannelUpdate_free(this_ptr_conv);
17739 uint32_t __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_clone(uint32_t orig) {
17740 LDKHTLCFailChannelUpdate* orig_conv = (LDKHTLCFailChannelUpdate*)orig;
17741 LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate");
17742 *ret_copy = HTLCFailChannelUpdate_clone(orig_conv);
17743 uint64_t ret_ref = (uint64_t)ret_copy;
17747 void __attribute__((visibility("default"))) TS_ChannelMessageHandler_free(uint32_t this_ptr) {
17748 if ((this_ptr & 1) != 0) return;
17749 LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(((uint64_t)this_ptr) & ~1);
17750 FREE((void*)this_ptr);
17751 ChannelMessageHandler_free(this_ptr_conv);
17754 void __attribute__((visibility("default"))) TS_RoutingMessageHandler_free(uint32_t this_ptr) {
17755 if ((this_ptr & 1) != 0) return;
17756 LDKRoutingMessageHandler this_ptr_conv = *(LDKRoutingMessageHandler*)(((uint64_t)this_ptr) & ~1);
17757 FREE((void*)this_ptr);
17758 RoutingMessageHandler_free(this_ptr_conv);
17761 int8_tArray __attribute__((visibility("default"))) TS_AcceptChannel_write(uint32_t obj) {
17762 LDKAcceptChannel obj_conv;
17763 obj_conv.inner = (void*)(obj & (~1));
17764 obj_conv.is_owned = false;
17765 LDKCVec_u8Z ret_var = AcceptChannel_write(&obj_conv);
17766 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17767 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17768 CVec_u8Z_free(ret_var);
17772 uint32_t __attribute__((visibility("default"))) TS_AcceptChannel_read(int8_tArray ser) {
17773 LDKu8slice ser_ref;
17774 ser_ref.datalen = *((uint32_t*)ser);
17775 ser_ref.data = (int8_t*)(ser + 4);
17776 LDKCResult_AcceptChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AcceptChannelDecodeErrorZ), "LDKCResult_AcceptChannelDecodeErrorZ");
17777 *ret_conv = AcceptChannel_read(ser_ref);
17778 return (uint64_t)ret_conv;
17781 int8_tArray __attribute__((visibility("default"))) TS_AnnouncementSignatures_write(uint32_t obj) {
17782 LDKAnnouncementSignatures obj_conv;
17783 obj_conv.inner = (void*)(obj & (~1));
17784 obj_conv.is_owned = false;
17785 LDKCVec_u8Z ret_var = AnnouncementSignatures_write(&obj_conv);
17786 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17787 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17788 CVec_u8Z_free(ret_var);
17792 uint32_t __attribute__((visibility("default"))) TS_AnnouncementSignatures_read(int8_tArray ser) {
17793 LDKu8slice ser_ref;
17794 ser_ref.datalen = *((uint32_t*)ser);
17795 ser_ref.data = (int8_t*)(ser + 4);
17796 LDKCResult_AnnouncementSignaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_AnnouncementSignaturesDecodeErrorZ), "LDKCResult_AnnouncementSignaturesDecodeErrorZ");
17797 *ret_conv = AnnouncementSignatures_read(ser_ref);
17798 return (uint64_t)ret_conv;
17801 int8_tArray __attribute__((visibility("default"))) TS_ChannelReestablish_write(uint32_t obj) {
17802 LDKChannelReestablish obj_conv;
17803 obj_conv.inner = (void*)(obj & (~1));
17804 obj_conv.is_owned = false;
17805 LDKCVec_u8Z ret_var = ChannelReestablish_write(&obj_conv);
17806 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17807 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17808 CVec_u8Z_free(ret_var);
17812 uint32_t __attribute__((visibility("default"))) TS_ChannelReestablish_read(int8_tArray ser) {
17813 LDKu8slice ser_ref;
17814 ser_ref.datalen = *((uint32_t*)ser);
17815 ser_ref.data = (int8_t*)(ser + 4);
17816 LDKCResult_ChannelReestablishDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelReestablishDecodeErrorZ), "LDKCResult_ChannelReestablishDecodeErrorZ");
17817 *ret_conv = ChannelReestablish_read(ser_ref);
17818 return (uint64_t)ret_conv;
17821 int8_tArray __attribute__((visibility("default"))) TS_ClosingSigned_write(uint32_t obj) {
17822 LDKClosingSigned obj_conv;
17823 obj_conv.inner = (void*)(obj & (~1));
17824 obj_conv.is_owned = false;
17825 LDKCVec_u8Z ret_var = ClosingSigned_write(&obj_conv);
17826 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17827 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17828 CVec_u8Z_free(ret_var);
17832 uint32_t __attribute__((visibility("default"))) TS_ClosingSigned_read(int8_tArray ser) {
17833 LDKu8slice ser_ref;
17834 ser_ref.datalen = *((uint32_t*)ser);
17835 ser_ref.data = (int8_t*)(ser + 4);
17836 LDKCResult_ClosingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ClosingSignedDecodeErrorZ), "LDKCResult_ClosingSignedDecodeErrorZ");
17837 *ret_conv = ClosingSigned_read(ser_ref);
17838 return (uint64_t)ret_conv;
17841 int8_tArray __attribute__((visibility("default"))) TS_CommitmentSigned_write(uint32_t obj) {
17842 LDKCommitmentSigned obj_conv;
17843 obj_conv.inner = (void*)(obj & (~1));
17844 obj_conv.is_owned = false;
17845 LDKCVec_u8Z ret_var = CommitmentSigned_write(&obj_conv);
17846 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17847 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17848 CVec_u8Z_free(ret_var);
17852 uint32_t __attribute__((visibility("default"))) TS_CommitmentSigned_read(int8_tArray ser) {
17853 LDKu8slice ser_ref;
17854 ser_ref.datalen = *((uint32_t*)ser);
17855 ser_ref.data = (int8_t*)(ser + 4);
17856 LDKCResult_CommitmentSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentSignedDecodeErrorZ), "LDKCResult_CommitmentSignedDecodeErrorZ");
17857 *ret_conv = CommitmentSigned_read(ser_ref);
17858 return (uint64_t)ret_conv;
17861 int8_tArray __attribute__((visibility("default"))) TS_FundingCreated_write(uint32_t obj) {
17862 LDKFundingCreated obj_conv;
17863 obj_conv.inner = (void*)(obj & (~1));
17864 obj_conv.is_owned = false;
17865 LDKCVec_u8Z ret_var = FundingCreated_write(&obj_conv);
17866 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17867 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17868 CVec_u8Z_free(ret_var);
17872 uint32_t __attribute__((visibility("default"))) TS_FundingCreated_read(int8_tArray ser) {
17873 LDKu8slice ser_ref;
17874 ser_ref.datalen = *((uint32_t*)ser);
17875 ser_ref.data = (int8_t*)(ser + 4);
17876 LDKCResult_FundingCreatedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingCreatedDecodeErrorZ), "LDKCResult_FundingCreatedDecodeErrorZ");
17877 *ret_conv = FundingCreated_read(ser_ref);
17878 return (uint64_t)ret_conv;
17881 int8_tArray __attribute__((visibility("default"))) TS_FundingSigned_write(uint32_t obj) {
17882 LDKFundingSigned obj_conv;
17883 obj_conv.inner = (void*)(obj & (~1));
17884 obj_conv.is_owned = false;
17885 LDKCVec_u8Z ret_var = FundingSigned_write(&obj_conv);
17886 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17887 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17888 CVec_u8Z_free(ret_var);
17892 uint32_t __attribute__((visibility("default"))) TS_FundingSigned_read(int8_tArray ser) {
17893 LDKu8slice ser_ref;
17894 ser_ref.datalen = *((uint32_t*)ser);
17895 ser_ref.data = (int8_t*)(ser + 4);
17896 LDKCResult_FundingSignedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingSignedDecodeErrorZ), "LDKCResult_FundingSignedDecodeErrorZ");
17897 *ret_conv = FundingSigned_read(ser_ref);
17898 return (uint64_t)ret_conv;
17901 int8_tArray __attribute__((visibility("default"))) TS_FundingLocked_write(uint32_t obj) {
17902 LDKFundingLocked obj_conv;
17903 obj_conv.inner = (void*)(obj & (~1));
17904 obj_conv.is_owned = false;
17905 LDKCVec_u8Z ret_var = FundingLocked_write(&obj_conv);
17906 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17907 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17908 CVec_u8Z_free(ret_var);
17912 uint32_t __attribute__((visibility("default"))) TS_FundingLocked_read(int8_tArray ser) {
17913 LDKu8slice ser_ref;
17914 ser_ref.datalen = *((uint32_t*)ser);
17915 ser_ref.data = (int8_t*)(ser + 4);
17916 LDKCResult_FundingLockedDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_FundingLockedDecodeErrorZ), "LDKCResult_FundingLockedDecodeErrorZ");
17917 *ret_conv = FundingLocked_read(ser_ref);
17918 return (uint64_t)ret_conv;
17921 int8_tArray __attribute__((visibility("default"))) TS_Init_write(uint32_t obj) {
17923 obj_conv.inner = (void*)(obj & (~1));
17924 obj_conv.is_owned = false;
17925 LDKCVec_u8Z ret_var = Init_write(&obj_conv);
17926 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17927 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17928 CVec_u8Z_free(ret_var);
17932 uint32_t __attribute__((visibility("default"))) TS_Init_read(int8_tArray ser) {
17933 LDKu8slice ser_ref;
17934 ser_ref.datalen = *((uint32_t*)ser);
17935 ser_ref.data = (int8_t*)(ser + 4);
17936 LDKCResult_InitDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitDecodeErrorZ), "LDKCResult_InitDecodeErrorZ");
17937 *ret_conv = Init_read(ser_ref);
17938 return (uint64_t)ret_conv;
17941 int8_tArray __attribute__((visibility("default"))) TS_OpenChannel_write(uint32_t obj) {
17942 LDKOpenChannel obj_conv;
17943 obj_conv.inner = (void*)(obj & (~1));
17944 obj_conv.is_owned = false;
17945 LDKCVec_u8Z ret_var = OpenChannel_write(&obj_conv);
17946 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17947 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17948 CVec_u8Z_free(ret_var);
17952 uint32_t __attribute__((visibility("default"))) TS_OpenChannel_read(int8_tArray ser) {
17953 LDKu8slice ser_ref;
17954 ser_ref.datalen = *((uint32_t*)ser);
17955 ser_ref.data = (int8_t*)(ser + 4);
17956 LDKCResult_OpenChannelDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_OpenChannelDecodeErrorZ), "LDKCResult_OpenChannelDecodeErrorZ");
17957 *ret_conv = OpenChannel_read(ser_ref);
17958 return (uint64_t)ret_conv;
17961 int8_tArray __attribute__((visibility("default"))) TS_RevokeAndACK_write(uint32_t obj) {
17962 LDKRevokeAndACK obj_conv;
17963 obj_conv.inner = (void*)(obj & (~1));
17964 obj_conv.is_owned = false;
17965 LDKCVec_u8Z ret_var = RevokeAndACK_write(&obj_conv);
17966 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17967 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17968 CVec_u8Z_free(ret_var);
17972 uint32_t __attribute__((visibility("default"))) TS_RevokeAndACK_read(int8_tArray ser) {
17973 LDKu8slice ser_ref;
17974 ser_ref.datalen = *((uint32_t*)ser);
17975 ser_ref.data = (int8_t*)(ser + 4);
17976 LDKCResult_RevokeAndACKDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RevokeAndACKDecodeErrorZ), "LDKCResult_RevokeAndACKDecodeErrorZ");
17977 *ret_conv = RevokeAndACK_read(ser_ref);
17978 return (uint64_t)ret_conv;
17981 int8_tArray __attribute__((visibility("default"))) TS_Shutdown_write(uint32_t obj) {
17982 LDKShutdown obj_conv;
17983 obj_conv.inner = (void*)(obj & (~1));
17984 obj_conv.is_owned = false;
17985 LDKCVec_u8Z ret_var = Shutdown_write(&obj_conv);
17986 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
17987 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
17988 CVec_u8Z_free(ret_var);
17992 uint32_t __attribute__((visibility("default"))) TS_Shutdown_read(int8_tArray ser) {
17993 LDKu8slice ser_ref;
17994 ser_ref.datalen = *((uint32_t*)ser);
17995 ser_ref.data = (int8_t*)(ser + 4);
17996 LDKCResult_ShutdownDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ShutdownDecodeErrorZ), "LDKCResult_ShutdownDecodeErrorZ");
17997 *ret_conv = Shutdown_read(ser_ref);
17998 return (uint64_t)ret_conv;
18001 int8_tArray __attribute__((visibility("default"))) TS_UpdateFailHTLC_write(uint32_t obj) {
18002 LDKUpdateFailHTLC obj_conv;
18003 obj_conv.inner = (void*)(obj & (~1));
18004 obj_conv.is_owned = false;
18005 LDKCVec_u8Z ret_var = UpdateFailHTLC_write(&obj_conv);
18006 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18007 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18008 CVec_u8Z_free(ret_var);
18012 uint32_t __attribute__((visibility("default"))) TS_UpdateFailHTLC_read(int8_tArray ser) {
18013 LDKu8slice ser_ref;
18014 ser_ref.datalen = *((uint32_t*)ser);
18015 ser_ref.data = (int8_t*)(ser + 4);
18016 LDKCResult_UpdateFailHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailHTLCDecodeErrorZ), "LDKCResult_UpdateFailHTLCDecodeErrorZ");
18017 *ret_conv = UpdateFailHTLC_read(ser_ref);
18018 return (uint64_t)ret_conv;
18021 int8_tArray __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_write(uint32_t obj) {
18022 LDKUpdateFailMalformedHTLC obj_conv;
18023 obj_conv.inner = (void*)(obj & (~1));
18024 obj_conv.is_owned = false;
18025 LDKCVec_u8Z ret_var = UpdateFailMalformedHTLC_write(&obj_conv);
18026 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18027 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18028 CVec_u8Z_free(ret_var);
18032 uint32_t __attribute__((visibility("default"))) TS_UpdateFailMalformedHTLC_read(int8_tArray ser) {
18033 LDKu8slice ser_ref;
18034 ser_ref.datalen = *((uint32_t*)ser);
18035 ser_ref.data = (int8_t*)(ser + 4);
18036 LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ), "LDKCResult_UpdateFailMalformedHTLCDecodeErrorZ");
18037 *ret_conv = UpdateFailMalformedHTLC_read(ser_ref);
18038 return (uint64_t)ret_conv;
18041 int8_tArray __attribute__((visibility("default"))) TS_UpdateFee_write(uint32_t obj) {
18042 LDKUpdateFee obj_conv;
18043 obj_conv.inner = (void*)(obj & (~1));
18044 obj_conv.is_owned = false;
18045 LDKCVec_u8Z ret_var = UpdateFee_write(&obj_conv);
18046 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18047 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18048 CVec_u8Z_free(ret_var);
18052 uint32_t __attribute__((visibility("default"))) TS_UpdateFee_read(int8_tArray ser) {
18053 LDKu8slice ser_ref;
18054 ser_ref.datalen = *((uint32_t*)ser);
18055 ser_ref.data = (int8_t*)(ser + 4);
18056 LDKCResult_UpdateFeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFeeDecodeErrorZ), "LDKCResult_UpdateFeeDecodeErrorZ");
18057 *ret_conv = UpdateFee_read(ser_ref);
18058 return (uint64_t)ret_conv;
18061 int8_tArray __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_write(uint32_t obj) {
18062 LDKUpdateFulfillHTLC obj_conv;
18063 obj_conv.inner = (void*)(obj & (~1));
18064 obj_conv.is_owned = false;
18065 LDKCVec_u8Z ret_var = UpdateFulfillHTLC_write(&obj_conv);
18066 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18067 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18068 CVec_u8Z_free(ret_var);
18072 uint32_t __attribute__((visibility("default"))) TS_UpdateFulfillHTLC_read(int8_tArray ser) {
18073 LDKu8slice ser_ref;
18074 ser_ref.datalen = *((uint32_t*)ser);
18075 ser_ref.data = (int8_t*)(ser + 4);
18076 LDKCResult_UpdateFulfillHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateFulfillHTLCDecodeErrorZ), "LDKCResult_UpdateFulfillHTLCDecodeErrorZ");
18077 *ret_conv = UpdateFulfillHTLC_read(ser_ref);
18078 return (uint64_t)ret_conv;
18081 int8_tArray __attribute__((visibility("default"))) TS_UpdateAddHTLC_write(uint32_t obj) {
18082 LDKUpdateAddHTLC obj_conv;
18083 obj_conv.inner = (void*)(obj & (~1));
18084 obj_conv.is_owned = false;
18085 LDKCVec_u8Z ret_var = UpdateAddHTLC_write(&obj_conv);
18086 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18087 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18088 CVec_u8Z_free(ret_var);
18092 uint32_t __attribute__((visibility("default"))) TS_UpdateAddHTLC_read(int8_tArray ser) {
18093 LDKu8slice ser_ref;
18094 ser_ref.datalen = *((uint32_t*)ser);
18095 ser_ref.data = (int8_t*)(ser + 4);
18096 LDKCResult_UpdateAddHTLCDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UpdateAddHTLCDecodeErrorZ), "LDKCResult_UpdateAddHTLCDecodeErrorZ");
18097 *ret_conv = UpdateAddHTLC_read(ser_ref);
18098 return (uint64_t)ret_conv;
18101 int8_tArray __attribute__((visibility("default"))) TS_Ping_write(uint32_t obj) {
18103 obj_conv.inner = (void*)(obj & (~1));
18104 obj_conv.is_owned = false;
18105 LDKCVec_u8Z ret_var = Ping_write(&obj_conv);
18106 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18107 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18108 CVec_u8Z_free(ret_var);
18112 uint32_t __attribute__((visibility("default"))) TS_Ping_read(int8_tArray ser) {
18113 LDKu8slice ser_ref;
18114 ser_ref.datalen = *((uint32_t*)ser);
18115 ser_ref.data = (int8_t*)(ser + 4);
18116 LDKCResult_PingDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PingDecodeErrorZ), "LDKCResult_PingDecodeErrorZ");
18117 *ret_conv = Ping_read(ser_ref);
18118 return (uint64_t)ret_conv;
18121 int8_tArray __attribute__((visibility("default"))) TS_Pong_write(uint32_t obj) {
18123 obj_conv.inner = (void*)(obj & (~1));
18124 obj_conv.is_owned = false;
18125 LDKCVec_u8Z ret_var = Pong_write(&obj_conv);
18126 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18127 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18128 CVec_u8Z_free(ret_var);
18132 uint32_t __attribute__((visibility("default"))) TS_Pong_read(int8_tArray ser) {
18133 LDKu8slice ser_ref;
18134 ser_ref.datalen = *((uint32_t*)ser);
18135 ser_ref.data = (int8_t*)(ser + 4);
18136 LDKCResult_PongDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PongDecodeErrorZ), "LDKCResult_PongDecodeErrorZ");
18137 *ret_conv = Pong_read(ser_ref);
18138 return (uint64_t)ret_conv;
18141 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_write(uint32_t obj) {
18142 LDKUnsignedChannelAnnouncement obj_conv;
18143 obj_conv.inner = (void*)(obj & (~1));
18144 obj_conv.is_owned = false;
18145 LDKCVec_u8Z ret_var = UnsignedChannelAnnouncement_write(&obj_conv);
18146 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18147 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18148 CVec_u8Z_free(ret_var);
18152 uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelAnnouncement_read(int8_tArray ser) {
18153 LDKu8slice ser_ref;
18154 ser_ref.datalen = *((uint32_t*)ser);
18155 ser_ref.data = (int8_t*)(ser + 4);
18156 LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ), "LDKCResult_UnsignedChannelAnnouncementDecodeErrorZ");
18157 *ret_conv = UnsignedChannelAnnouncement_read(ser_ref);
18158 return (uint64_t)ret_conv;
18161 int8_tArray __attribute__((visibility("default"))) TS_ChannelAnnouncement_write(uint32_t obj) {
18162 LDKChannelAnnouncement obj_conv;
18163 obj_conv.inner = (void*)(obj & (~1));
18164 obj_conv.is_owned = false;
18165 LDKCVec_u8Z ret_var = ChannelAnnouncement_write(&obj_conv);
18166 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18167 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18168 CVec_u8Z_free(ret_var);
18172 uint32_t __attribute__((visibility("default"))) TS_ChannelAnnouncement_read(int8_tArray ser) {
18173 LDKu8slice ser_ref;
18174 ser_ref.datalen = *((uint32_t*)ser);
18175 ser_ref.data = (int8_t*)(ser + 4);
18176 LDKCResult_ChannelAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelAnnouncementDecodeErrorZ), "LDKCResult_ChannelAnnouncementDecodeErrorZ");
18177 *ret_conv = ChannelAnnouncement_read(ser_ref);
18178 return (uint64_t)ret_conv;
18181 int8_tArray __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_write(uint32_t obj) {
18182 LDKUnsignedChannelUpdate obj_conv;
18183 obj_conv.inner = (void*)(obj & (~1));
18184 obj_conv.is_owned = false;
18185 LDKCVec_u8Z ret_var = UnsignedChannelUpdate_write(&obj_conv);
18186 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18187 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18188 CVec_u8Z_free(ret_var);
18192 uint32_t __attribute__((visibility("default"))) TS_UnsignedChannelUpdate_read(int8_tArray ser) {
18193 LDKu8slice ser_ref;
18194 ser_ref.datalen = *((uint32_t*)ser);
18195 ser_ref.data = (int8_t*)(ser + 4);
18196 LDKCResult_UnsignedChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedChannelUpdateDecodeErrorZ), "LDKCResult_UnsignedChannelUpdateDecodeErrorZ");
18197 *ret_conv = UnsignedChannelUpdate_read(ser_ref);
18198 return (uint64_t)ret_conv;
18201 int8_tArray __attribute__((visibility("default"))) TS_ChannelUpdate_write(uint32_t obj) {
18202 LDKChannelUpdate obj_conv;
18203 obj_conv.inner = (void*)(obj & (~1));
18204 obj_conv.is_owned = false;
18205 LDKCVec_u8Z ret_var = ChannelUpdate_write(&obj_conv);
18206 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18207 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18208 CVec_u8Z_free(ret_var);
18212 uint32_t __attribute__((visibility("default"))) TS_ChannelUpdate_read(int8_tArray ser) {
18213 LDKu8slice ser_ref;
18214 ser_ref.datalen = *((uint32_t*)ser);
18215 ser_ref.data = (int8_t*)(ser + 4);
18216 LDKCResult_ChannelUpdateDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelUpdateDecodeErrorZ), "LDKCResult_ChannelUpdateDecodeErrorZ");
18217 *ret_conv = ChannelUpdate_read(ser_ref);
18218 return (uint64_t)ret_conv;
18221 int8_tArray __attribute__((visibility("default"))) TS_ErrorMessage_write(uint32_t obj) {
18222 LDKErrorMessage obj_conv;
18223 obj_conv.inner = (void*)(obj & (~1));
18224 obj_conv.is_owned = false;
18225 LDKCVec_u8Z ret_var = ErrorMessage_write(&obj_conv);
18226 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18227 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18228 CVec_u8Z_free(ret_var);
18232 uint32_t __attribute__((visibility("default"))) TS_ErrorMessage_read(int8_tArray ser) {
18233 LDKu8slice ser_ref;
18234 ser_ref.datalen = *((uint32_t*)ser);
18235 ser_ref.data = (int8_t*)(ser + 4);
18236 LDKCResult_ErrorMessageDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ErrorMessageDecodeErrorZ), "LDKCResult_ErrorMessageDecodeErrorZ");
18237 *ret_conv = ErrorMessage_read(ser_ref);
18238 return (uint64_t)ret_conv;
18241 int8_tArray __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_write(uint32_t obj) {
18242 LDKUnsignedNodeAnnouncement obj_conv;
18243 obj_conv.inner = (void*)(obj & (~1));
18244 obj_conv.is_owned = false;
18245 LDKCVec_u8Z ret_var = UnsignedNodeAnnouncement_write(&obj_conv);
18246 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18247 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18248 CVec_u8Z_free(ret_var);
18252 uint32_t __attribute__((visibility("default"))) TS_UnsignedNodeAnnouncement_read(int8_tArray ser) {
18253 LDKu8slice ser_ref;
18254 ser_ref.datalen = *((uint32_t*)ser);
18255 ser_ref.data = (int8_t*)(ser + 4);
18256 LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ), "LDKCResult_UnsignedNodeAnnouncementDecodeErrorZ");
18257 *ret_conv = UnsignedNodeAnnouncement_read(ser_ref);
18258 return (uint64_t)ret_conv;
18261 int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncement_write(uint32_t obj) {
18262 LDKNodeAnnouncement obj_conv;
18263 obj_conv.inner = (void*)(obj & (~1));
18264 obj_conv.is_owned = false;
18265 LDKCVec_u8Z ret_var = NodeAnnouncement_write(&obj_conv);
18266 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18267 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18268 CVec_u8Z_free(ret_var);
18272 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncement_read(int8_tArray ser) {
18273 LDKu8slice ser_ref;
18274 ser_ref.datalen = *((uint32_t*)ser);
18275 ser_ref.data = (int8_t*)(ser + 4);
18276 LDKCResult_NodeAnnouncementDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementDecodeErrorZ), "LDKCResult_NodeAnnouncementDecodeErrorZ");
18277 *ret_conv = NodeAnnouncement_read(ser_ref);
18278 return (uint64_t)ret_conv;
18281 uint32_t __attribute__((visibility("default"))) TS_QueryShortChannelIds_read(int8_tArray ser) {
18282 LDKu8slice ser_ref;
18283 ser_ref.datalen = *((uint32_t*)ser);
18284 ser_ref.data = (int8_t*)(ser + 4);
18285 LDKCResult_QueryShortChannelIdsDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryShortChannelIdsDecodeErrorZ), "LDKCResult_QueryShortChannelIdsDecodeErrorZ");
18286 *ret_conv = QueryShortChannelIds_read(ser_ref);
18287 return (uint64_t)ret_conv;
18290 int8_tArray __attribute__((visibility("default"))) TS_QueryShortChannelIds_write(uint32_t obj) {
18291 LDKQueryShortChannelIds obj_conv;
18292 obj_conv.inner = (void*)(obj & (~1));
18293 obj_conv.is_owned = false;
18294 LDKCVec_u8Z ret_var = QueryShortChannelIds_write(&obj_conv);
18295 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18296 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18297 CVec_u8Z_free(ret_var);
18301 uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) {
18302 LDKu8slice ser_ref;
18303 ser_ref.datalen = *((uint32_t*)ser);
18304 ser_ref.data = (int8_t*)(ser + 4);
18305 LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ");
18306 *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref);
18307 return (uint64_t)ret_conv;
18310 int8_tArray __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_write(uint32_t obj) {
18311 LDKReplyShortChannelIdsEnd obj_conv;
18312 obj_conv.inner = (void*)(obj & (~1));
18313 obj_conv.is_owned = false;
18314 LDKCVec_u8Z ret_var = ReplyShortChannelIdsEnd_write(&obj_conv);
18315 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18316 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18317 CVec_u8Z_free(ret_var);
18321 int32_t __attribute__((visibility("default"))) TS_QueryChannelRange_end_blocknum(uint32_t this_arg) {
18322 LDKQueryChannelRange this_arg_conv;
18323 this_arg_conv.inner = (void*)(this_arg & (~1));
18324 this_arg_conv.is_owned = false;
18325 int32_t ret_val = QueryChannelRange_end_blocknum(&this_arg_conv);
18329 uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_read(int8_tArray ser) {
18330 LDKu8slice ser_ref;
18331 ser_ref.datalen = *((uint32_t*)ser);
18332 ser_ref.data = (int8_t*)(ser + 4);
18333 LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ");
18334 *ret_conv = QueryChannelRange_read(ser_ref);
18335 return (uint64_t)ret_conv;
18338 int8_tArray __attribute__((visibility("default"))) TS_QueryChannelRange_write(uint32_t obj) {
18339 LDKQueryChannelRange obj_conv;
18340 obj_conv.inner = (void*)(obj & (~1));
18341 obj_conv.is_owned = false;
18342 LDKCVec_u8Z ret_var = QueryChannelRange_write(&obj_conv);
18343 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18344 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18345 CVec_u8Z_free(ret_var);
18349 uint32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_read(int8_tArray ser) {
18350 LDKu8slice ser_ref;
18351 ser_ref.datalen = *((uint32_t*)ser);
18352 ser_ref.data = (int8_t*)(ser + 4);
18353 LDKCResult_ReplyChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyChannelRangeDecodeErrorZ), "LDKCResult_ReplyChannelRangeDecodeErrorZ");
18354 *ret_conv = ReplyChannelRange_read(ser_ref);
18355 return (uint64_t)ret_conv;
18358 int8_tArray __attribute__((visibility("default"))) TS_ReplyChannelRange_write(uint32_t obj) {
18359 LDKReplyChannelRange obj_conv;
18360 obj_conv.inner = (void*)(obj & (~1));
18361 obj_conv.is_owned = false;
18362 LDKCVec_u8Z ret_var = ReplyChannelRange_write(&obj_conv);
18363 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18364 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18365 CVec_u8Z_free(ret_var);
18369 uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_read(int8_tArray ser) {
18370 LDKu8slice ser_ref;
18371 ser_ref.datalen = *((uint32_t*)ser);
18372 ser_ref.data = (int8_t*)(ser + 4);
18373 LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ");
18374 *ret_conv = GossipTimestampFilter_read(ser_ref);
18375 return (uint64_t)ret_conv;
18378 int8_tArray __attribute__((visibility("default"))) TS_GossipTimestampFilter_write(uint32_t obj) {
18379 LDKGossipTimestampFilter obj_conv;
18380 obj_conv.inner = (void*)(obj & (~1));
18381 obj_conv.is_owned = false;
18382 LDKCVec_u8Z ret_var = GossipTimestampFilter_write(&obj_conv);
18383 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18384 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18385 CVec_u8Z_free(ret_var);
18389 void __attribute__((visibility("default"))) TS_IgnoringMessageHandler_free(uint32_t this_obj) {
18390 LDKIgnoringMessageHandler this_obj_conv;
18391 this_obj_conv.inner = (void*)(this_obj & (~1));
18392 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18393 IgnoringMessageHandler_free(this_obj_conv);
18396 uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_new() {
18397 LDKIgnoringMessageHandler ret_var = IgnoringMessageHandler_new();
18398 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18399 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18400 uint64_t ret_ref = (uint64_t)ret_var.inner;
18401 if (ret_var.is_owned) {
18407 uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
18408 LDKIgnoringMessageHandler this_arg_conv;
18409 this_arg_conv.inner = (void*)(this_arg & (~1));
18410 this_arg_conv.is_owned = false;
18411 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
18412 *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
18413 return (uint64_t)ret;
18416 uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint32_t this_arg) {
18417 LDKIgnoringMessageHandler this_arg_conv;
18418 this_arg_conv.inner = (void*)(this_arg & (~1));
18419 this_arg_conv.is_owned = false;
18420 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
18421 *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv);
18422 return (uint64_t)ret;
18425 void __attribute__((visibility("default"))) TS_ErroringMessageHandler_free(uint32_t this_obj) {
18426 LDKErroringMessageHandler this_obj_conv;
18427 this_obj_conv.inner = (void*)(this_obj & (~1));
18428 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18429 ErroringMessageHandler_free(this_obj_conv);
18432 uint32_t __attribute__((visibility("default"))) TS_ErroringMessageHandler_new() {
18433 LDKErroringMessageHandler ret_var = ErroringMessageHandler_new();
18434 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18435 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18436 uint64_t ret_ref = (uint64_t)ret_var.inner;
18437 if (ret_var.is_owned) {
18443 uint32_t __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
18444 LDKErroringMessageHandler this_arg_conv;
18445 this_arg_conv.inner = (void*)(this_arg & (~1));
18446 this_arg_conv.is_owned = false;
18447 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
18448 *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv);
18449 return (uint64_t)ret;
18452 uint32_t __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint32_t this_arg) {
18453 LDKErroringMessageHandler this_arg_conv;
18454 this_arg_conv.inner = (void*)(this_arg & (~1));
18455 this_arg_conv.is_owned = false;
18456 LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler");
18457 *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv);
18458 return (uint64_t)ret;
18461 void __attribute__((visibility("default"))) TS_MessageHandler_free(uint32_t this_obj) {
18462 LDKMessageHandler this_obj_conv;
18463 this_obj_conv.inner = (void*)(this_obj & (~1));
18464 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18465 MessageHandler_free(this_obj_conv);
18468 uint32_t __attribute__((visibility("default"))) TS_MessageHandler_get_chan_handler(uint32_t this_ptr) {
18469 LDKMessageHandler this_ptr_conv;
18470 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18471 this_ptr_conv.is_owned = false;
18472 uint64_t ret_ret = (uint64_t)MessageHandler_get_chan_handler(&this_ptr_conv);
18476 void __attribute__((visibility("default"))) TS_MessageHandler_set_chan_handler(uint32_t this_ptr, uint32_t val) {
18477 LDKMessageHandler this_ptr_conv;
18478 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18479 this_ptr_conv.is_owned = false;
18480 LDKChannelMessageHandler val_conv = *(LDKChannelMessageHandler*)(((uint64_t)val) & ~1);
18481 MessageHandler_set_chan_handler(&this_ptr_conv, val_conv);
18484 uint32_t __attribute__((visibility("default"))) TS_MessageHandler_get_route_handler(uint32_t this_ptr) {
18485 LDKMessageHandler this_ptr_conv;
18486 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18487 this_ptr_conv.is_owned = false;
18488 uint64_t ret_ret = (uint64_t)MessageHandler_get_route_handler(&this_ptr_conv);
18492 void __attribute__((visibility("default"))) TS_MessageHandler_set_route_handler(uint32_t this_ptr, uint32_t val) {
18493 LDKMessageHandler this_ptr_conv;
18494 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18495 this_ptr_conv.is_owned = false;
18496 LDKRoutingMessageHandler val_conv = *(LDKRoutingMessageHandler*)(((uint64_t)val) & ~1);
18497 MessageHandler_set_route_handler(&this_ptr_conv, val_conv);
18500 uint32_t __attribute__((visibility("default"))) TS_MessageHandler_new(uint32_t chan_handler_arg, uint32_t route_handler_arg) {
18501 LDKChannelMessageHandler chan_handler_arg_conv = *(LDKChannelMessageHandler*)(((uint64_t)chan_handler_arg) & ~1);
18502 LDKRoutingMessageHandler route_handler_arg_conv = *(LDKRoutingMessageHandler*)(((uint64_t)route_handler_arg) & ~1);
18503 LDKMessageHandler ret_var = MessageHandler_new(chan_handler_arg_conv, route_handler_arg_conv);
18504 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18505 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18506 uint64_t ret_ref = (uint64_t)ret_var.inner;
18507 if (ret_var.is_owned) {
18513 uint32_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone(uint32_t orig) {
18514 LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)(((uint64_t)orig) & ~1);
18515 LDKSocketDescriptor* ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor");
18516 *ret = SocketDescriptor_clone(orig_conv);
18517 return (uint64_t)ret;
18520 void __attribute__((visibility("default"))) TS_SocketDescriptor_free(uint32_t this_ptr) {
18521 if ((this_ptr & 1) != 0) return;
18522 LDKSocketDescriptor this_ptr_conv = *(LDKSocketDescriptor*)(((uint64_t)this_ptr) & ~1);
18523 FREE((void*)this_ptr);
18524 SocketDescriptor_free(this_ptr_conv);
18527 void __attribute__((visibility("default"))) TS_PeerHandleError_free(uint32_t this_obj) {
18528 LDKPeerHandleError this_obj_conv;
18529 this_obj_conv.inner = (void*)(this_obj & (~1));
18530 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18531 PeerHandleError_free(this_obj_conv);
18534 jboolean __attribute__((visibility("default"))) TS_PeerHandleError_get_no_connection_possible(uint32_t this_ptr) {
18535 LDKPeerHandleError this_ptr_conv;
18536 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18537 this_ptr_conv.is_owned = false;
18538 jboolean ret_val = PeerHandleError_get_no_connection_possible(&this_ptr_conv);
18542 void __attribute__((visibility("default"))) TS_PeerHandleError_set_no_connection_possible(uint32_t this_ptr, jboolean val) {
18543 LDKPeerHandleError this_ptr_conv;
18544 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18545 this_ptr_conv.is_owned = false;
18546 PeerHandleError_set_no_connection_possible(&this_ptr_conv, val);
18549 uint32_t __attribute__((visibility("default"))) TS_PeerHandleError_new(jboolean no_connection_possible_arg) {
18550 LDKPeerHandleError ret_var = PeerHandleError_new(no_connection_possible_arg);
18551 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18552 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18553 uint64_t ret_ref = (uint64_t)ret_var.inner;
18554 if (ret_var.is_owned) {
18560 uint32_t __attribute__((visibility("default"))) TS_PeerHandleError_clone(uint32_t orig) {
18561 LDKPeerHandleError orig_conv;
18562 orig_conv.inner = (void*)(orig & (~1));
18563 orig_conv.is_owned = false;
18564 LDKPeerHandleError ret_var = PeerHandleError_clone(&orig_conv);
18565 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18566 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18567 uint64_t ret_ref = (uint64_t)ret_var.inner;
18568 if (ret_var.is_owned) {
18574 void __attribute__((visibility("default"))) TS_PeerManager_free(uint32_t this_obj) {
18575 LDKPeerManager this_obj_conv;
18576 this_obj_conv.inner = (void*)(this_obj & (~1));
18577 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18578 PeerManager_free(this_obj_conv);
18581 uint32_t __attribute__((visibility("default"))) TS_PeerManager_new(uint32_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, uint32_t logger) {
18582 LDKMessageHandler message_handler_conv;
18583 message_handler_conv.inner = (void*)(message_handler & (~1));
18584 message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0);
18585 // Warning: we need a move here but no clone is available for LDKMessageHandler
18586 LDKSecretKey our_node_secret_ref;
18587 CHECK(*((uint32_t*)our_node_secret) == 32);
18588 memcpy(our_node_secret_ref.bytes, (uint8_t*)(our_node_secret + 4), 32);
18589 unsigned char ephemeral_random_data_arr[32];
18590 CHECK(*((uint32_t*)ephemeral_random_data) == 32);
18591 memcpy(ephemeral_random_data_arr, (uint8_t*)(ephemeral_random_data + 4), 32);
18592 unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr;
18593 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
18594 LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv);
18595 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18596 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18597 uint64_t ret_ref = (uint64_t)ret_var.inner;
18598 if (ret_var.is_owned) {
18604 ptrArray __attribute__((visibility("default"))) TS_PeerManager_get_peer_node_ids(uint32_t this_arg) {
18605 LDKPeerManager this_arg_conv;
18606 this_arg_conv.inner = (void*)(this_arg & (~1));
18607 this_arg_conv.is_owned = false;
18608 LDKCVec_PublicKeyZ ret_var = PeerManager_get_peer_node_ids(&this_arg_conv);
18609 ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes");
18610 int8_tArray *ret_arr_ptr = (int8_tArray*)(ret_arr + 4);
18611 for (size_t m = 0; m < ret_var.datalen; m++) {
18612 int8_tArray ret_conv_12_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18613 memcpy((uint8_t*)(ret_conv_12_arr + 4), ret_var.data[m].compressed_form, 33);
18614 ret_arr_ptr[m] = ret_conv_12_arr;
18616 FREE(ret_var.data);
18620 uint32_t __attribute__((visibility("default"))) TS_PeerManager_new_outbound_connection(uint32_t this_arg, int8_tArray their_node_id, uint32_t descriptor) {
18621 LDKPeerManager this_arg_conv;
18622 this_arg_conv.inner = (void*)(this_arg & (~1));
18623 this_arg_conv.is_owned = false;
18624 LDKPublicKey their_node_id_ref;
18625 CHECK(*((uint32_t*)their_node_id) == 33);
18626 memcpy(their_node_id_ref.compressed_form, (uint8_t*)(their_node_id + 4), 33);
18627 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
18628 LDKCResult_CVec_u8ZPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_u8ZPeerHandleErrorZ), "LDKCResult_CVec_u8ZPeerHandleErrorZ");
18629 *ret_conv = PeerManager_new_outbound_connection(&this_arg_conv, their_node_id_ref, descriptor_conv);
18630 return (uint64_t)ret_conv;
18633 uint32_t __attribute__((visibility("default"))) TS_PeerManager_new_inbound_connection(uint32_t this_arg, uint32_t descriptor) {
18634 LDKPeerManager this_arg_conv;
18635 this_arg_conv.inner = (void*)(this_arg & (~1));
18636 this_arg_conv.is_owned = false;
18637 LDKSocketDescriptor descriptor_conv = *(LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
18638 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18639 *ret_conv = PeerManager_new_inbound_connection(&this_arg_conv, descriptor_conv);
18640 return (uint64_t)ret_conv;
18643 uint32_t __attribute__((visibility("default"))) TS_PeerManager_write_buffer_space_avail(uint32_t this_arg, uint32_t descriptor) {
18644 LDKPeerManager this_arg_conv;
18645 this_arg_conv.inner = (void*)(this_arg & (~1));
18646 this_arg_conv.is_owned = false;
18647 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
18648 LDKCResult_NonePeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePeerHandleErrorZ), "LDKCResult_NonePeerHandleErrorZ");
18649 *ret_conv = PeerManager_write_buffer_space_avail(&this_arg_conv, descriptor_conv);
18650 return (uint64_t)ret_conv;
18653 uint32_t __attribute__((visibility("default"))) TS_PeerManager_read_event(uint32_t this_arg, uint32_t peer_descriptor, int8_tArray data) {
18654 LDKPeerManager this_arg_conv;
18655 this_arg_conv.inner = (void*)(this_arg & (~1));
18656 this_arg_conv.is_owned = false;
18657 LDKSocketDescriptor* peer_descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)peer_descriptor) & ~1);
18658 LDKu8slice data_ref;
18659 data_ref.datalen = *((uint32_t*)data);
18660 data_ref.data = (int8_t*)(data + 4);
18661 LDKCResult_boolPeerHandleErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolPeerHandleErrorZ), "LDKCResult_boolPeerHandleErrorZ");
18662 *ret_conv = PeerManager_read_event(&this_arg_conv, peer_descriptor_conv, data_ref);
18663 return (uint64_t)ret_conv;
18666 void __attribute__((visibility("default"))) TS_PeerManager_process_events(uint32_t this_arg) {
18667 LDKPeerManager this_arg_conv;
18668 this_arg_conv.inner = (void*)(this_arg & (~1));
18669 this_arg_conv.is_owned = false;
18670 PeerManager_process_events(&this_arg_conv);
18673 void __attribute__((visibility("default"))) TS_PeerManager_socket_disconnected(uint32_t this_arg, uint32_t descriptor) {
18674 LDKPeerManager this_arg_conv;
18675 this_arg_conv.inner = (void*)(this_arg & (~1));
18676 this_arg_conv.is_owned = false;
18677 LDKSocketDescriptor* descriptor_conv = (LDKSocketDescriptor*)(((uint64_t)descriptor) & ~1);
18678 PeerManager_socket_disconnected(&this_arg_conv, descriptor_conv);
18681 void __attribute__((visibility("default"))) TS_PeerManager_disconnect_by_node_id(uint32_t this_arg, int8_tArray node_id, jboolean no_connection_possible) {
18682 LDKPeerManager this_arg_conv;
18683 this_arg_conv.inner = (void*)(this_arg & (~1));
18684 this_arg_conv.is_owned = false;
18685 LDKPublicKey node_id_ref;
18686 CHECK(*((uint32_t*)node_id) == 33);
18687 memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33);
18688 PeerManager_disconnect_by_node_id(&this_arg_conv, node_id_ref, no_connection_possible);
18691 void __attribute__((visibility("default"))) TS_PeerManager_timer_tick_occurred(uint32_t this_arg) {
18692 LDKPeerManager this_arg_conv;
18693 this_arg_conv.inner = (void*)(this_arg & (~1));
18694 this_arg_conv.is_owned = false;
18695 PeerManager_timer_tick_occurred(&this_arg_conv);
18698 int8_tArray __attribute__((visibility("default"))) TS_build_commitment_secret(int8_tArray commitment_seed, int64_t idx) {
18699 unsigned char commitment_seed_arr[32];
18700 CHECK(*((uint32_t*)commitment_seed) == 32);
18701 memcpy(commitment_seed_arr, (uint8_t*)(commitment_seed + 4), 32);
18702 unsigned char (*commitment_seed_ref)[32] = &commitment_seed_arr;
18703 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
18704 memcpy((uint8_t*)(ret_arr + 4), build_commitment_secret(commitment_seed_ref, idx).data, 32);
18708 uint32_t __attribute__((visibility("default"))) TS_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) {
18709 LDKPublicKey per_commitment_point_ref;
18710 CHECK(*((uint32_t*)per_commitment_point) == 33);
18711 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
18712 unsigned char base_secret_arr[32];
18713 CHECK(*((uint32_t*)base_secret) == 32);
18714 memcpy(base_secret_arr, (uint8_t*)(base_secret + 4), 32);
18715 unsigned char (*base_secret_ref)[32] = &base_secret_arr;
18716 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
18717 *ret_conv = derive_private_key(per_commitment_point_ref, base_secret_ref);
18718 return (uint64_t)ret_conv;
18721 uint32_t __attribute__((visibility("default"))) TS_derive_public_key(int8_tArray per_commitment_point, int8_tArray base_point) {
18722 LDKPublicKey per_commitment_point_ref;
18723 CHECK(*((uint32_t*)per_commitment_point) == 33);
18724 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
18725 LDKPublicKey base_point_ref;
18726 CHECK(*((uint32_t*)base_point) == 33);
18727 memcpy(base_point_ref.compressed_form, (uint8_t*)(base_point + 4), 33);
18728 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
18729 *ret_conv = derive_public_key(per_commitment_point_ref, base_point_ref);
18730 return (uint64_t)ret_conv;
18733 uint32_t __attribute__((visibility("default"))) TS_derive_private_revocation_key(int8_tArray per_commitment_secret, int8_tArray countersignatory_revocation_base_secret) {
18734 unsigned char per_commitment_secret_arr[32];
18735 CHECK(*((uint32_t*)per_commitment_secret) == 32);
18736 memcpy(per_commitment_secret_arr, (uint8_t*)(per_commitment_secret + 4), 32);
18737 unsigned char (*per_commitment_secret_ref)[32] = &per_commitment_secret_arr;
18738 unsigned char countersignatory_revocation_base_secret_arr[32];
18739 CHECK(*((uint32_t*)countersignatory_revocation_base_secret) == 32);
18740 memcpy(countersignatory_revocation_base_secret_arr, (uint8_t*)(countersignatory_revocation_base_secret + 4), 32);
18741 unsigned char (*countersignatory_revocation_base_secret_ref)[32] = &countersignatory_revocation_base_secret_arr;
18742 LDKCResult_SecretKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SecretKeyErrorZ), "LDKCResult_SecretKeyErrorZ");
18743 *ret_conv = derive_private_revocation_key(per_commitment_secret_ref, countersignatory_revocation_base_secret_ref);
18744 return (uint64_t)ret_conv;
18747 uint32_t __attribute__((visibility("default"))) TS_derive_public_revocation_key(int8_tArray per_commitment_point, int8_tArray countersignatory_revocation_base_point) {
18748 LDKPublicKey per_commitment_point_ref;
18749 CHECK(*((uint32_t*)per_commitment_point) == 33);
18750 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
18751 LDKPublicKey countersignatory_revocation_base_point_ref;
18752 CHECK(*((uint32_t*)countersignatory_revocation_base_point) == 33);
18753 memcpy(countersignatory_revocation_base_point_ref.compressed_form, (uint8_t*)(countersignatory_revocation_base_point + 4), 33);
18754 LDKCResult_PublicKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PublicKeyErrorZ), "LDKCResult_PublicKeyErrorZ");
18755 *ret_conv = derive_public_revocation_key(per_commitment_point_ref, countersignatory_revocation_base_point_ref);
18756 return (uint64_t)ret_conv;
18759 void __attribute__((visibility("default"))) TS_TxCreationKeys_free(uint32_t this_obj) {
18760 LDKTxCreationKeys this_obj_conv;
18761 this_obj_conv.inner = (void*)(this_obj & (~1));
18762 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18763 TxCreationKeys_free(this_obj_conv);
18766 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_get_per_commitment_point(uint32_t this_ptr) {
18767 LDKTxCreationKeys this_ptr_conv;
18768 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18769 this_ptr_conv.is_owned = false;
18770 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18771 memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_per_commitment_point(&this_ptr_conv).compressed_form, 33);
18775 void __attribute__((visibility("default"))) TS_TxCreationKeys_set_per_commitment_point(uint32_t this_ptr, int8_tArray val) {
18776 LDKTxCreationKeys this_ptr_conv;
18777 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18778 this_ptr_conv.is_owned = false;
18779 LDKPublicKey val_ref;
18780 CHECK(*((uint32_t*)val) == 33);
18781 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18782 TxCreationKeys_set_per_commitment_point(&this_ptr_conv, val_ref);
18785 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_get_revocation_key(uint32_t this_ptr) {
18786 LDKTxCreationKeys this_ptr_conv;
18787 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18788 this_ptr_conv.is_owned = false;
18789 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18790 memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_revocation_key(&this_ptr_conv).compressed_form, 33);
18794 void __attribute__((visibility("default"))) TS_TxCreationKeys_set_revocation_key(uint32_t this_ptr, int8_tArray val) {
18795 LDKTxCreationKeys this_ptr_conv;
18796 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18797 this_ptr_conv.is_owned = false;
18798 LDKPublicKey val_ref;
18799 CHECK(*((uint32_t*)val) == 33);
18800 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18801 TxCreationKeys_set_revocation_key(&this_ptr_conv, val_ref);
18804 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_get_broadcaster_htlc_key(uint32_t this_ptr) {
18805 LDKTxCreationKeys this_ptr_conv;
18806 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18807 this_ptr_conv.is_owned = false;
18808 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18809 memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_htlc_key(&this_ptr_conv).compressed_form, 33);
18813 void __attribute__((visibility("default"))) TS_TxCreationKeys_set_broadcaster_htlc_key(uint32_t this_ptr, int8_tArray val) {
18814 LDKTxCreationKeys this_ptr_conv;
18815 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18816 this_ptr_conv.is_owned = false;
18817 LDKPublicKey val_ref;
18818 CHECK(*((uint32_t*)val) == 33);
18819 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18820 TxCreationKeys_set_broadcaster_htlc_key(&this_ptr_conv, val_ref);
18823 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_get_countersignatory_htlc_key(uint32_t this_ptr) {
18824 LDKTxCreationKeys this_ptr_conv;
18825 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18826 this_ptr_conv.is_owned = false;
18827 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18828 memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_countersignatory_htlc_key(&this_ptr_conv).compressed_form, 33);
18832 void __attribute__((visibility("default"))) TS_TxCreationKeys_set_countersignatory_htlc_key(uint32_t this_ptr, int8_tArray val) {
18833 LDKTxCreationKeys this_ptr_conv;
18834 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18835 this_ptr_conv.is_owned = false;
18836 LDKPublicKey val_ref;
18837 CHECK(*((uint32_t*)val) == 33);
18838 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18839 TxCreationKeys_set_countersignatory_htlc_key(&this_ptr_conv, val_ref);
18842 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_get_broadcaster_delayed_payment_key(uint32_t this_ptr) {
18843 LDKTxCreationKeys this_ptr_conv;
18844 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18845 this_ptr_conv.is_owned = false;
18846 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18847 memcpy((uint8_t*)(ret_arr + 4), TxCreationKeys_get_broadcaster_delayed_payment_key(&this_ptr_conv).compressed_form, 33);
18851 void __attribute__((visibility("default"))) TS_TxCreationKeys_set_broadcaster_delayed_payment_key(uint32_t this_ptr, int8_tArray val) {
18852 LDKTxCreationKeys this_ptr_conv;
18853 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18854 this_ptr_conv.is_owned = false;
18855 LDKPublicKey val_ref;
18856 CHECK(*((uint32_t*)val) == 33);
18857 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18858 TxCreationKeys_set_broadcaster_delayed_payment_key(&this_ptr_conv, val_ref);
18861 uint32_t __attribute__((visibility("default"))) 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) {
18862 LDKPublicKey per_commitment_point_arg_ref;
18863 CHECK(*((uint32_t*)per_commitment_point_arg) == 33);
18864 memcpy(per_commitment_point_arg_ref.compressed_form, (uint8_t*)(per_commitment_point_arg + 4), 33);
18865 LDKPublicKey revocation_key_arg_ref;
18866 CHECK(*((uint32_t*)revocation_key_arg) == 33);
18867 memcpy(revocation_key_arg_ref.compressed_form, (uint8_t*)(revocation_key_arg + 4), 33);
18868 LDKPublicKey broadcaster_htlc_key_arg_ref;
18869 CHECK(*((uint32_t*)broadcaster_htlc_key_arg) == 33);
18870 memcpy(broadcaster_htlc_key_arg_ref.compressed_form, (uint8_t*)(broadcaster_htlc_key_arg + 4), 33);
18871 LDKPublicKey countersignatory_htlc_key_arg_ref;
18872 CHECK(*((uint32_t*)countersignatory_htlc_key_arg) == 33);
18873 memcpy(countersignatory_htlc_key_arg_ref.compressed_form, (uint8_t*)(countersignatory_htlc_key_arg + 4), 33);
18874 LDKPublicKey broadcaster_delayed_payment_key_arg_ref;
18875 CHECK(*((uint32_t*)broadcaster_delayed_payment_key_arg) == 33);
18876 memcpy(broadcaster_delayed_payment_key_arg_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_key_arg + 4), 33);
18877 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);
18878 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18879 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18880 uint64_t ret_ref = (uint64_t)ret_var.inner;
18881 if (ret_var.is_owned) {
18887 uint32_t __attribute__((visibility("default"))) TS_TxCreationKeys_clone(uint32_t orig) {
18888 LDKTxCreationKeys orig_conv;
18889 orig_conv.inner = (void*)(orig & (~1));
18890 orig_conv.is_owned = false;
18891 LDKTxCreationKeys ret_var = TxCreationKeys_clone(&orig_conv);
18892 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
18893 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
18894 uint64_t ret_ref = (uint64_t)ret_var.inner;
18895 if (ret_var.is_owned) {
18901 int8_tArray __attribute__((visibility("default"))) TS_TxCreationKeys_write(uint32_t obj) {
18902 LDKTxCreationKeys obj_conv;
18903 obj_conv.inner = (void*)(obj & (~1));
18904 obj_conv.is_owned = false;
18905 LDKCVec_u8Z ret_var = TxCreationKeys_write(&obj_conv);
18906 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
18907 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
18908 CVec_u8Z_free(ret_var);
18912 uint32_t __attribute__((visibility("default"))) TS_TxCreationKeys_read(int8_tArray ser) {
18913 LDKu8slice ser_ref;
18914 ser_ref.datalen = *((uint32_t*)ser);
18915 ser_ref.data = (int8_t*)(ser + 4);
18916 LDKCResult_TxCreationKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysDecodeErrorZ), "LDKCResult_TxCreationKeysDecodeErrorZ");
18917 *ret_conv = TxCreationKeys_read(ser_ref);
18918 return (uint64_t)ret_conv;
18921 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_free(uint32_t this_obj) {
18922 LDKChannelPublicKeys this_obj_conv;
18923 this_obj_conv.inner = (void*)(this_obj & (~1));
18924 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
18925 ChannelPublicKeys_free(this_obj_conv);
18928 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_get_funding_pubkey(uint32_t this_ptr) {
18929 LDKChannelPublicKeys this_ptr_conv;
18930 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18931 this_ptr_conv.is_owned = false;
18932 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18933 memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_funding_pubkey(&this_ptr_conv).compressed_form, 33);
18937 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_set_funding_pubkey(uint32_t this_ptr, int8_tArray val) {
18938 LDKChannelPublicKeys this_ptr_conv;
18939 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18940 this_ptr_conv.is_owned = false;
18941 LDKPublicKey val_ref;
18942 CHECK(*((uint32_t*)val) == 33);
18943 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18944 ChannelPublicKeys_set_funding_pubkey(&this_ptr_conv, val_ref);
18947 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_get_revocation_basepoint(uint32_t this_ptr) {
18948 LDKChannelPublicKeys this_ptr_conv;
18949 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18950 this_ptr_conv.is_owned = false;
18951 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18952 memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_revocation_basepoint(&this_ptr_conv).compressed_form, 33);
18956 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_set_revocation_basepoint(uint32_t this_ptr, int8_tArray val) {
18957 LDKChannelPublicKeys this_ptr_conv;
18958 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18959 this_ptr_conv.is_owned = false;
18960 LDKPublicKey val_ref;
18961 CHECK(*((uint32_t*)val) == 33);
18962 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18963 ChannelPublicKeys_set_revocation_basepoint(&this_ptr_conv, val_ref);
18966 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_get_payment_point(uint32_t this_ptr) {
18967 LDKChannelPublicKeys this_ptr_conv;
18968 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18969 this_ptr_conv.is_owned = false;
18970 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18971 memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_payment_point(&this_ptr_conv).compressed_form, 33);
18975 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_set_payment_point(uint32_t this_ptr, int8_tArray val) {
18976 LDKChannelPublicKeys this_ptr_conv;
18977 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18978 this_ptr_conv.is_owned = false;
18979 LDKPublicKey val_ref;
18980 CHECK(*((uint32_t*)val) == 33);
18981 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
18982 ChannelPublicKeys_set_payment_point(&this_ptr_conv, val_ref);
18985 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_get_delayed_payment_basepoint(uint32_t this_ptr) {
18986 LDKChannelPublicKeys this_ptr_conv;
18987 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18988 this_ptr_conv.is_owned = false;
18989 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
18990 memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_delayed_payment_basepoint(&this_ptr_conv).compressed_form, 33);
18994 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_set_delayed_payment_basepoint(uint32_t this_ptr, int8_tArray val) {
18995 LDKChannelPublicKeys this_ptr_conv;
18996 this_ptr_conv.inner = (void*)(this_ptr & (~1));
18997 this_ptr_conv.is_owned = false;
18998 LDKPublicKey val_ref;
18999 CHECK(*((uint32_t*)val) == 33);
19000 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
19001 ChannelPublicKeys_set_delayed_payment_basepoint(&this_ptr_conv, val_ref);
19004 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_get_htlc_basepoint(uint32_t this_ptr) {
19005 LDKChannelPublicKeys this_ptr_conv;
19006 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19007 this_ptr_conv.is_owned = false;
19008 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
19009 memcpy((uint8_t*)(ret_arr + 4), ChannelPublicKeys_get_htlc_basepoint(&this_ptr_conv).compressed_form, 33);
19013 void __attribute__((visibility("default"))) TS_ChannelPublicKeys_set_htlc_basepoint(uint32_t this_ptr, int8_tArray val) {
19014 LDKChannelPublicKeys this_ptr_conv;
19015 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19016 this_ptr_conv.is_owned = false;
19017 LDKPublicKey val_ref;
19018 CHECK(*((uint32_t*)val) == 33);
19019 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
19020 ChannelPublicKeys_set_htlc_basepoint(&this_ptr_conv, val_ref);
19023 uint32_t __attribute__((visibility("default"))) 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) {
19024 LDKPublicKey funding_pubkey_arg_ref;
19025 CHECK(*((uint32_t*)funding_pubkey_arg) == 33);
19026 memcpy(funding_pubkey_arg_ref.compressed_form, (uint8_t*)(funding_pubkey_arg + 4), 33);
19027 LDKPublicKey revocation_basepoint_arg_ref;
19028 CHECK(*((uint32_t*)revocation_basepoint_arg) == 33);
19029 memcpy(revocation_basepoint_arg_ref.compressed_form, (uint8_t*)(revocation_basepoint_arg + 4), 33);
19030 LDKPublicKey payment_point_arg_ref;
19031 CHECK(*((uint32_t*)payment_point_arg) == 33);
19032 memcpy(payment_point_arg_ref.compressed_form, (uint8_t*)(payment_point_arg + 4), 33);
19033 LDKPublicKey delayed_payment_basepoint_arg_ref;
19034 CHECK(*((uint32_t*)delayed_payment_basepoint_arg) == 33);
19035 memcpy(delayed_payment_basepoint_arg_ref.compressed_form, (uint8_t*)(delayed_payment_basepoint_arg + 4), 33);
19036 LDKPublicKey htlc_basepoint_arg_ref;
19037 CHECK(*((uint32_t*)htlc_basepoint_arg) == 33);
19038 memcpy(htlc_basepoint_arg_ref.compressed_form, (uint8_t*)(htlc_basepoint_arg + 4), 33);
19039 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);
19040 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19041 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19042 uint64_t ret_ref = (uint64_t)ret_var.inner;
19043 if (ret_var.is_owned) {
19049 uint32_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_clone(uint32_t orig) {
19050 LDKChannelPublicKeys orig_conv;
19051 orig_conv.inner = (void*)(orig & (~1));
19052 orig_conv.is_owned = false;
19053 LDKChannelPublicKeys ret_var = ChannelPublicKeys_clone(&orig_conv);
19054 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19055 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19056 uint64_t ret_ref = (uint64_t)ret_var.inner;
19057 if (ret_var.is_owned) {
19063 int8_tArray __attribute__((visibility("default"))) TS_ChannelPublicKeys_write(uint32_t obj) {
19064 LDKChannelPublicKeys obj_conv;
19065 obj_conv.inner = (void*)(obj & (~1));
19066 obj_conv.is_owned = false;
19067 LDKCVec_u8Z ret_var = ChannelPublicKeys_write(&obj_conv);
19068 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19069 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19070 CVec_u8Z_free(ret_var);
19074 uint32_t __attribute__((visibility("default"))) TS_ChannelPublicKeys_read(int8_tArray ser) {
19075 LDKu8slice ser_ref;
19076 ser_ref.datalen = *((uint32_t*)ser);
19077 ser_ref.data = (int8_t*)(ser + 4);
19078 LDKCResult_ChannelPublicKeysDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelPublicKeysDecodeErrorZ), "LDKCResult_ChannelPublicKeysDecodeErrorZ");
19079 *ret_conv = ChannelPublicKeys_read(ser_ref);
19080 return (uint64_t)ret_conv;
19083 uint32_t __attribute__((visibility("default"))) 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) {
19084 LDKPublicKey per_commitment_point_ref;
19085 CHECK(*((uint32_t*)per_commitment_point) == 33);
19086 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
19087 LDKPublicKey broadcaster_delayed_payment_base_ref;
19088 CHECK(*((uint32_t*)broadcaster_delayed_payment_base) == 33);
19089 memcpy(broadcaster_delayed_payment_base_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_base + 4), 33);
19090 LDKPublicKey broadcaster_htlc_base_ref;
19091 CHECK(*((uint32_t*)broadcaster_htlc_base) == 33);
19092 memcpy(broadcaster_htlc_base_ref.compressed_form, (uint8_t*)(broadcaster_htlc_base + 4), 33);
19093 LDKPublicKey countersignatory_revocation_base_ref;
19094 CHECK(*((uint32_t*)countersignatory_revocation_base) == 33);
19095 memcpy(countersignatory_revocation_base_ref.compressed_form, (uint8_t*)(countersignatory_revocation_base + 4), 33);
19096 LDKPublicKey countersignatory_htlc_base_ref;
19097 CHECK(*((uint32_t*)countersignatory_htlc_base) == 33);
19098 memcpy(countersignatory_htlc_base_ref.compressed_form, (uint8_t*)(countersignatory_htlc_base + 4), 33);
19099 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
19100 *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);
19101 return (uint64_t)ret_conv;
19104 uint32_t __attribute__((visibility("default"))) TS_TxCreationKeys_from_channel_static_keys(int8_tArray per_commitment_point, uint32_t broadcaster_keys, uint32_t countersignatory_keys) {
19105 LDKPublicKey per_commitment_point_ref;
19106 CHECK(*((uint32_t*)per_commitment_point) == 33);
19107 memcpy(per_commitment_point_ref.compressed_form, (uint8_t*)(per_commitment_point + 4), 33);
19108 LDKChannelPublicKeys broadcaster_keys_conv;
19109 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
19110 broadcaster_keys_conv.is_owned = false;
19111 LDKChannelPublicKeys countersignatory_keys_conv;
19112 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
19113 countersignatory_keys_conv.is_owned = false;
19114 LDKCResult_TxCreationKeysErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxCreationKeysErrorZ), "LDKCResult_TxCreationKeysErrorZ");
19115 *ret_conv = TxCreationKeys_from_channel_static_keys(per_commitment_point_ref, &broadcaster_keys_conv, &countersignatory_keys_conv);
19116 return (uint64_t)ret_conv;
19119 int8_tArray __attribute__((visibility("default"))) TS_get_revokeable_redeemscript(int8_tArray revocation_key, int16_t contest_delay, int8_tArray broadcaster_delayed_payment_key) {
19120 LDKPublicKey revocation_key_ref;
19121 CHECK(*((uint32_t*)revocation_key) == 33);
19122 memcpy(revocation_key_ref.compressed_form, (uint8_t*)(revocation_key + 4), 33);
19123 LDKPublicKey broadcaster_delayed_payment_key_ref;
19124 CHECK(*((uint32_t*)broadcaster_delayed_payment_key) == 33);
19125 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_key + 4), 33);
19126 LDKCVec_u8Z ret_var = get_revokeable_redeemscript(revocation_key_ref, contest_delay, broadcaster_delayed_payment_key_ref);
19127 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19128 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19129 CVec_u8Z_free(ret_var);
19133 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_free(uint32_t this_obj) {
19134 LDKHTLCOutputInCommitment this_obj_conv;
19135 this_obj_conv.inner = (void*)(this_obj & (~1));
19136 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19137 HTLCOutputInCommitment_free(this_obj_conv);
19140 jboolean __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_get_offered(uint32_t this_ptr) {
19141 LDKHTLCOutputInCommitment this_ptr_conv;
19142 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19143 this_ptr_conv.is_owned = false;
19144 jboolean ret_val = HTLCOutputInCommitment_get_offered(&this_ptr_conv);
19148 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_offered(uint32_t this_ptr, jboolean val) {
19149 LDKHTLCOutputInCommitment this_ptr_conv;
19150 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19151 this_ptr_conv.is_owned = false;
19152 HTLCOutputInCommitment_set_offered(&this_ptr_conv, val);
19155 int64_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_get_amount_msat(uint32_t this_ptr) {
19156 LDKHTLCOutputInCommitment this_ptr_conv;
19157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19158 this_ptr_conv.is_owned = false;
19159 int64_t ret_val = HTLCOutputInCommitment_get_amount_msat(&this_ptr_conv);
19163 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_amount_msat(uint32_t this_ptr, int64_t val) {
19164 LDKHTLCOutputInCommitment this_ptr_conv;
19165 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19166 this_ptr_conv.is_owned = false;
19167 HTLCOutputInCommitment_set_amount_msat(&this_ptr_conv, val);
19170 int32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_get_cltv_expiry(uint32_t this_ptr) {
19171 LDKHTLCOutputInCommitment this_ptr_conv;
19172 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19173 this_ptr_conv.is_owned = false;
19174 int32_t ret_val = HTLCOutputInCommitment_get_cltv_expiry(&this_ptr_conv);
19178 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_cltv_expiry(uint32_t this_ptr, int32_t val) {
19179 LDKHTLCOutputInCommitment this_ptr_conv;
19180 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19181 this_ptr_conv.is_owned = false;
19182 HTLCOutputInCommitment_set_cltv_expiry(&this_ptr_conv, val);
19185 int8_tArray __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_get_payment_hash(uint32_t this_ptr) {
19186 LDKHTLCOutputInCommitment this_ptr_conv;
19187 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19188 this_ptr_conv.is_owned = false;
19189 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
19190 memcpy((uint8_t*)(ret_arr + 4), *HTLCOutputInCommitment_get_payment_hash(&this_ptr_conv), 32);
19194 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_payment_hash(uint32_t this_ptr, int8_tArray val) {
19195 LDKHTLCOutputInCommitment this_ptr_conv;
19196 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19197 this_ptr_conv.is_owned = false;
19198 LDKThirtyTwoBytes val_ref;
19199 CHECK(*((uint32_t*)val) == 32);
19200 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
19201 HTLCOutputInCommitment_set_payment_hash(&this_ptr_conv, val_ref);
19204 uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_get_transaction_output_index(uint32_t this_ptr) {
19205 LDKHTLCOutputInCommitment this_ptr_conv;
19206 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19207 this_ptr_conv.is_owned = false;
19208 LDKCOption_u32Z *ret_copy = MALLOC(sizeof(LDKCOption_u32Z), "LDKCOption_u32Z");
19209 *ret_copy = HTLCOutputInCommitment_get_transaction_output_index(&this_ptr_conv);
19210 uint64_t ret_ref = (uint64_t)ret_copy;
19214 void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_transaction_output_index(uint32_t this_ptr, uint32_t val) {
19215 LDKHTLCOutputInCommitment this_ptr_conv;
19216 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19217 this_ptr_conv.is_owned = false;
19218 LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1);
19219 HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv);
19222 uint32_t __attribute__((visibility("default"))) 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) {
19223 LDKThirtyTwoBytes payment_hash_arg_ref;
19224 CHECK(*((uint32_t*)payment_hash_arg) == 32);
19225 memcpy(payment_hash_arg_ref.data, (uint8_t*)(payment_hash_arg + 4), 32);
19226 LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)transaction_output_index_arg) & ~1);
19227 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_conv);
19228 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19229 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19230 uint64_t ret_ref = (uint64_t)ret_var.inner;
19231 if (ret_var.is_owned) {
19237 uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_clone(uint32_t orig) {
19238 LDKHTLCOutputInCommitment orig_conv;
19239 orig_conv.inner = (void*)(orig & (~1));
19240 orig_conv.is_owned = false;
19241 LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_clone(&orig_conv);
19242 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19243 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19244 uint64_t ret_ref = (uint64_t)ret_var.inner;
19245 if (ret_var.is_owned) {
19251 int8_tArray __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_write(uint32_t obj) {
19252 LDKHTLCOutputInCommitment obj_conv;
19253 obj_conv.inner = (void*)(obj & (~1));
19254 obj_conv.is_owned = false;
19255 LDKCVec_u8Z ret_var = HTLCOutputInCommitment_write(&obj_conv);
19256 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19257 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19258 CVec_u8Z_free(ret_var);
19262 uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_read(int8_tArray ser) {
19263 LDKu8slice ser_ref;
19264 ser_ref.datalen = *((uint32_t*)ser);
19265 ser_ref.data = (int8_t*)(ser + 4);
19266 LDKCResult_HTLCOutputInCommitmentDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HTLCOutputInCommitmentDecodeErrorZ), "LDKCResult_HTLCOutputInCommitmentDecodeErrorZ");
19267 *ret_conv = HTLCOutputInCommitment_read(ser_ref);
19268 return (uint64_t)ret_conv;
19271 int8_tArray __attribute__((visibility("default"))) TS_get_htlc_redeemscript(uint32_t htlc, uint32_t keys) {
19272 LDKHTLCOutputInCommitment htlc_conv;
19273 htlc_conv.inner = (void*)(htlc & (~1));
19274 htlc_conv.is_owned = false;
19275 LDKTxCreationKeys keys_conv;
19276 keys_conv.inner = (void*)(keys & (~1));
19277 keys_conv.is_owned = false;
19278 LDKCVec_u8Z ret_var = get_htlc_redeemscript(&htlc_conv, &keys_conv);
19279 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19280 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19281 CVec_u8Z_free(ret_var);
19285 int8_tArray __attribute__((visibility("default"))) TS_make_funding_redeemscript(int8_tArray broadcaster, int8_tArray countersignatory) {
19286 LDKPublicKey broadcaster_ref;
19287 CHECK(*((uint32_t*)broadcaster) == 33);
19288 memcpy(broadcaster_ref.compressed_form, (uint8_t*)(broadcaster + 4), 33);
19289 LDKPublicKey countersignatory_ref;
19290 CHECK(*((uint32_t*)countersignatory) == 33);
19291 memcpy(countersignatory_ref.compressed_form, (uint8_t*)(countersignatory + 4), 33);
19292 LDKCVec_u8Z ret_var = make_funding_redeemscript(broadcaster_ref, countersignatory_ref);
19293 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19294 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19295 CVec_u8Z_free(ret_var);
19299 int8_tArray __attribute__((visibility("default"))) TS_build_htlc_transaction(int8_tArray commitment_txid, int32_t feerate_per_kw, int16_t contest_delay, uint32_t htlc, int8_tArray broadcaster_delayed_payment_key, int8_tArray revocation_key) {
19300 unsigned char commitment_txid_arr[32];
19301 CHECK(*((uint32_t*)commitment_txid) == 32);
19302 memcpy(commitment_txid_arr, (uint8_t*)(commitment_txid + 4), 32);
19303 unsigned char (*commitment_txid_ref)[32] = &commitment_txid_arr;
19304 LDKHTLCOutputInCommitment htlc_conv;
19305 htlc_conv.inner = (void*)(htlc & (~1));
19306 htlc_conv.is_owned = false;
19307 LDKPublicKey broadcaster_delayed_payment_key_ref;
19308 CHECK(*((uint32_t*)broadcaster_delayed_payment_key) == 33);
19309 memcpy(broadcaster_delayed_payment_key_ref.compressed_form, (uint8_t*)(broadcaster_delayed_payment_key + 4), 33);
19310 LDKPublicKey revocation_key_ref;
19311 CHECK(*((uint32_t*)revocation_key) == 33);
19312 memcpy(revocation_key_ref.compressed_form, (uint8_t*)(revocation_key + 4), 33);
19313 LDKTransaction ret_var = build_htlc_transaction(commitment_txid_ref, feerate_per_kw, contest_delay, &htlc_conv, broadcaster_delayed_payment_key_ref, revocation_key_ref);
19314 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19315 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19316 Transaction_free(ret_var);
19320 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_free(uint32_t this_obj) {
19321 LDKChannelTransactionParameters this_obj_conv;
19322 this_obj_conv.inner = (void*)(this_obj & (~1));
19323 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19324 ChannelTransactionParameters_free(this_obj_conv);
19327 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_get_holder_pubkeys(uint32_t this_ptr) {
19328 LDKChannelTransactionParameters this_ptr_conv;
19329 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19330 this_ptr_conv.is_owned = false;
19331 LDKChannelPublicKeys ret_var = ChannelTransactionParameters_get_holder_pubkeys(&this_ptr_conv);
19332 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19333 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19334 uint64_t ret_ref = (uint64_t)ret_var.inner;
19335 if (ret_var.is_owned) {
19341 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_set_holder_pubkeys(uint32_t this_ptr, uint32_t val) {
19342 LDKChannelTransactionParameters this_ptr_conv;
19343 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19344 this_ptr_conv.is_owned = false;
19345 LDKChannelPublicKeys val_conv;
19346 val_conv.inner = (void*)(val & (~1));
19347 val_conv.is_owned = (val & 1) || (val == 0);
19348 val_conv = ChannelPublicKeys_clone(&val_conv);
19349 ChannelTransactionParameters_set_holder_pubkeys(&this_ptr_conv, val_conv);
19352 int16_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_get_holder_selected_contest_delay(uint32_t this_ptr) {
19353 LDKChannelTransactionParameters this_ptr_conv;
19354 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19355 this_ptr_conv.is_owned = false;
19356 int16_t ret_val = ChannelTransactionParameters_get_holder_selected_contest_delay(&this_ptr_conv);
19360 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_set_holder_selected_contest_delay(uint32_t this_ptr, int16_t val) {
19361 LDKChannelTransactionParameters this_ptr_conv;
19362 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19363 this_ptr_conv.is_owned = false;
19364 ChannelTransactionParameters_set_holder_selected_contest_delay(&this_ptr_conv, val);
19367 jboolean __attribute__((visibility("default"))) TS_ChannelTransactionParameters_get_is_outbound_from_holder(uint32_t this_ptr) {
19368 LDKChannelTransactionParameters this_ptr_conv;
19369 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19370 this_ptr_conv.is_owned = false;
19371 jboolean ret_val = ChannelTransactionParameters_get_is_outbound_from_holder(&this_ptr_conv);
19375 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_set_is_outbound_from_holder(uint32_t this_ptr, jboolean val) {
19376 LDKChannelTransactionParameters this_ptr_conv;
19377 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19378 this_ptr_conv.is_owned = false;
19379 ChannelTransactionParameters_set_is_outbound_from_holder(&this_ptr_conv, val);
19382 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_get_counterparty_parameters(uint32_t this_ptr) {
19383 LDKChannelTransactionParameters this_ptr_conv;
19384 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19385 this_ptr_conv.is_owned = false;
19386 LDKCounterpartyChannelTransactionParameters ret_var = ChannelTransactionParameters_get_counterparty_parameters(&this_ptr_conv);
19387 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19388 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19389 uint64_t ret_ref = (uint64_t)ret_var.inner;
19390 if (ret_var.is_owned) {
19396 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_set_counterparty_parameters(uint32_t this_ptr, uint32_t val) {
19397 LDKChannelTransactionParameters this_ptr_conv;
19398 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19399 this_ptr_conv.is_owned = false;
19400 LDKCounterpartyChannelTransactionParameters val_conv;
19401 val_conv.inner = (void*)(val & (~1));
19402 val_conv.is_owned = (val & 1) || (val == 0);
19403 val_conv = CounterpartyChannelTransactionParameters_clone(&val_conv);
19404 ChannelTransactionParameters_set_counterparty_parameters(&this_ptr_conv, val_conv);
19407 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_get_funding_outpoint(uint32_t this_ptr) {
19408 LDKChannelTransactionParameters this_ptr_conv;
19409 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19410 this_ptr_conv.is_owned = false;
19411 LDKOutPoint ret_var = ChannelTransactionParameters_get_funding_outpoint(&this_ptr_conv);
19412 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19413 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19414 uint64_t ret_ref = (uint64_t)ret_var.inner;
19415 if (ret_var.is_owned) {
19421 void __attribute__((visibility("default"))) TS_ChannelTransactionParameters_set_funding_outpoint(uint32_t this_ptr, uint32_t val) {
19422 LDKChannelTransactionParameters this_ptr_conv;
19423 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19424 this_ptr_conv.is_owned = false;
19425 LDKOutPoint val_conv;
19426 val_conv.inner = (void*)(val & (~1));
19427 val_conv.is_owned = (val & 1) || (val == 0);
19428 val_conv = OutPoint_clone(&val_conv);
19429 ChannelTransactionParameters_set_funding_outpoint(&this_ptr_conv, val_conv);
19432 uint32_t __attribute__((visibility("default"))) 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) {
19433 LDKChannelPublicKeys holder_pubkeys_arg_conv;
19434 holder_pubkeys_arg_conv.inner = (void*)(holder_pubkeys_arg & (~1));
19435 holder_pubkeys_arg_conv.is_owned = (holder_pubkeys_arg & 1) || (holder_pubkeys_arg == 0);
19436 holder_pubkeys_arg_conv = ChannelPublicKeys_clone(&holder_pubkeys_arg_conv);
19437 LDKCounterpartyChannelTransactionParameters counterparty_parameters_arg_conv;
19438 counterparty_parameters_arg_conv.inner = (void*)(counterparty_parameters_arg & (~1));
19439 counterparty_parameters_arg_conv.is_owned = (counterparty_parameters_arg & 1) || (counterparty_parameters_arg == 0);
19440 counterparty_parameters_arg_conv = CounterpartyChannelTransactionParameters_clone(&counterparty_parameters_arg_conv);
19441 LDKOutPoint funding_outpoint_arg_conv;
19442 funding_outpoint_arg_conv.inner = (void*)(funding_outpoint_arg & (~1));
19443 funding_outpoint_arg_conv.is_owned = (funding_outpoint_arg & 1) || (funding_outpoint_arg == 0);
19444 funding_outpoint_arg_conv = OutPoint_clone(&funding_outpoint_arg_conv);
19445 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);
19446 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19447 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19448 uint64_t ret_ref = (uint64_t)ret_var.inner;
19449 if (ret_var.is_owned) {
19455 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_clone(uint32_t orig) {
19456 LDKChannelTransactionParameters orig_conv;
19457 orig_conv.inner = (void*)(orig & (~1));
19458 orig_conv.is_owned = false;
19459 LDKChannelTransactionParameters ret_var = ChannelTransactionParameters_clone(&orig_conv);
19460 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19461 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19462 uint64_t ret_ref = (uint64_t)ret_var.inner;
19463 if (ret_var.is_owned) {
19469 void __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_free(uint32_t this_obj) {
19470 LDKCounterpartyChannelTransactionParameters this_obj_conv;
19471 this_obj_conv.inner = (void*)(this_obj & (~1));
19472 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19473 CounterpartyChannelTransactionParameters_free(this_obj_conv);
19476 uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_get_pubkeys(uint32_t this_ptr) {
19477 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
19478 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19479 this_ptr_conv.is_owned = false;
19480 LDKChannelPublicKeys ret_var = CounterpartyChannelTransactionParameters_get_pubkeys(&this_ptr_conv);
19481 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19482 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19483 uint64_t ret_ref = (uint64_t)ret_var.inner;
19484 if (ret_var.is_owned) {
19490 void __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_set_pubkeys(uint32_t this_ptr, uint32_t val) {
19491 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
19492 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19493 this_ptr_conv.is_owned = false;
19494 LDKChannelPublicKeys val_conv;
19495 val_conv.inner = (void*)(val & (~1));
19496 val_conv.is_owned = (val & 1) || (val == 0);
19497 val_conv = ChannelPublicKeys_clone(&val_conv);
19498 CounterpartyChannelTransactionParameters_set_pubkeys(&this_ptr_conv, val_conv);
19501 int16_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_get_selected_contest_delay(uint32_t this_ptr) {
19502 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
19503 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19504 this_ptr_conv.is_owned = false;
19505 int16_t ret_val = CounterpartyChannelTransactionParameters_get_selected_contest_delay(&this_ptr_conv);
19509 void __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_set_selected_contest_delay(uint32_t this_ptr, int16_t val) {
19510 LDKCounterpartyChannelTransactionParameters this_ptr_conv;
19511 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19512 this_ptr_conv.is_owned = false;
19513 CounterpartyChannelTransactionParameters_set_selected_contest_delay(&this_ptr_conv, val);
19516 uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_new(uint32_t pubkeys_arg, int16_t selected_contest_delay_arg) {
19517 LDKChannelPublicKeys pubkeys_arg_conv;
19518 pubkeys_arg_conv.inner = (void*)(pubkeys_arg & (~1));
19519 pubkeys_arg_conv.is_owned = (pubkeys_arg & 1) || (pubkeys_arg == 0);
19520 pubkeys_arg_conv = ChannelPublicKeys_clone(&pubkeys_arg_conv);
19521 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_new(pubkeys_arg_conv, selected_contest_delay_arg);
19522 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19523 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19524 uint64_t ret_ref = (uint64_t)ret_var.inner;
19525 if (ret_var.is_owned) {
19531 uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_clone(uint32_t orig) {
19532 LDKCounterpartyChannelTransactionParameters orig_conv;
19533 orig_conv.inner = (void*)(orig & (~1));
19534 orig_conv.is_owned = false;
19535 LDKCounterpartyChannelTransactionParameters ret_var = CounterpartyChannelTransactionParameters_clone(&orig_conv);
19536 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19537 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19538 uint64_t ret_ref = (uint64_t)ret_var.inner;
19539 if (ret_var.is_owned) {
19545 jboolean __attribute__((visibility("default"))) TS_ChannelTransactionParameters_is_populated(uint32_t this_arg) {
19546 LDKChannelTransactionParameters this_arg_conv;
19547 this_arg_conv.inner = (void*)(this_arg & (~1));
19548 this_arg_conv.is_owned = false;
19549 jboolean ret_val = ChannelTransactionParameters_is_populated(&this_arg_conv);
19553 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_as_holder_broadcastable(uint32_t this_arg) {
19554 LDKChannelTransactionParameters this_arg_conv;
19555 this_arg_conv.inner = (void*)(this_arg & (~1));
19556 this_arg_conv.is_owned = false;
19557 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_holder_broadcastable(&this_arg_conv);
19558 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19559 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19560 uint64_t ret_ref = (uint64_t)ret_var.inner;
19561 if (ret_var.is_owned) {
19567 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_as_counterparty_broadcastable(uint32_t this_arg) {
19568 LDKChannelTransactionParameters this_arg_conv;
19569 this_arg_conv.inner = (void*)(this_arg & (~1));
19570 this_arg_conv.is_owned = false;
19571 LDKDirectedChannelTransactionParameters ret_var = ChannelTransactionParameters_as_counterparty_broadcastable(&this_arg_conv);
19572 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19573 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19574 uint64_t ret_ref = (uint64_t)ret_var.inner;
19575 if (ret_var.is_owned) {
19581 int8_tArray __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_write(uint32_t obj) {
19582 LDKCounterpartyChannelTransactionParameters obj_conv;
19583 obj_conv.inner = (void*)(obj & (~1));
19584 obj_conv.is_owned = false;
19585 LDKCVec_u8Z ret_var = CounterpartyChannelTransactionParameters_write(&obj_conv);
19586 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19587 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19588 CVec_u8Z_free(ret_var);
19592 uint32_t __attribute__((visibility("default"))) TS_CounterpartyChannelTransactionParameters_read(int8_tArray ser) {
19593 LDKu8slice ser_ref;
19594 ser_ref.datalen = *((uint32_t*)ser);
19595 ser_ref.data = (int8_t*)(ser + 4);
19596 LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ), "LDKCResult_CounterpartyChannelTransactionParametersDecodeErrorZ");
19597 *ret_conv = CounterpartyChannelTransactionParameters_read(ser_ref);
19598 return (uint64_t)ret_conv;
19601 int8_tArray __attribute__((visibility("default"))) TS_ChannelTransactionParameters_write(uint32_t obj) {
19602 LDKChannelTransactionParameters obj_conv;
19603 obj_conv.inner = (void*)(obj & (~1));
19604 obj_conv.is_owned = false;
19605 LDKCVec_u8Z ret_var = ChannelTransactionParameters_write(&obj_conv);
19606 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19607 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19608 CVec_u8Z_free(ret_var);
19612 uint32_t __attribute__((visibility("default"))) TS_ChannelTransactionParameters_read(int8_tArray ser) {
19613 LDKu8slice ser_ref;
19614 ser_ref.datalen = *((uint32_t*)ser);
19615 ser_ref.data = (int8_t*)(ser + 4);
19616 LDKCResult_ChannelTransactionParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelTransactionParametersDecodeErrorZ), "LDKCResult_ChannelTransactionParametersDecodeErrorZ");
19617 *ret_conv = ChannelTransactionParameters_read(ser_ref);
19618 return (uint64_t)ret_conv;
19621 void __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_free(uint32_t this_obj) {
19622 LDKDirectedChannelTransactionParameters this_obj_conv;
19623 this_obj_conv.inner = (void*)(this_obj & (~1));
19624 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19625 DirectedChannelTransactionParameters_free(this_obj_conv);
19628 uint32_t __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_broadcaster_pubkeys(uint32_t this_arg) {
19629 LDKDirectedChannelTransactionParameters this_arg_conv;
19630 this_arg_conv.inner = (void*)(this_arg & (~1));
19631 this_arg_conv.is_owned = false;
19632 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_broadcaster_pubkeys(&this_arg_conv);
19633 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19634 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19635 uint64_t ret_ref = (uint64_t)ret_var.inner;
19636 if (ret_var.is_owned) {
19642 uint32_t __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_countersignatory_pubkeys(uint32_t this_arg) {
19643 LDKDirectedChannelTransactionParameters this_arg_conv;
19644 this_arg_conv.inner = (void*)(this_arg & (~1));
19645 this_arg_conv.is_owned = false;
19646 LDKChannelPublicKeys ret_var = DirectedChannelTransactionParameters_countersignatory_pubkeys(&this_arg_conv);
19647 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19648 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19649 uint64_t ret_ref = (uint64_t)ret_var.inner;
19650 if (ret_var.is_owned) {
19656 int16_t __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_contest_delay(uint32_t this_arg) {
19657 LDKDirectedChannelTransactionParameters this_arg_conv;
19658 this_arg_conv.inner = (void*)(this_arg & (~1));
19659 this_arg_conv.is_owned = false;
19660 int16_t ret_val = DirectedChannelTransactionParameters_contest_delay(&this_arg_conv);
19664 jboolean __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_is_outbound(uint32_t this_arg) {
19665 LDKDirectedChannelTransactionParameters this_arg_conv;
19666 this_arg_conv.inner = (void*)(this_arg & (~1));
19667 this_arg_conv.is_owned = false;
19668 jboolean ret_val = DirectedChannelTransactionParameters_is_outbound(&this_arg_conv);
19672 uint32_t __attribute__((visibility("default"))) TS_DirectedChannelTransactionParameters_funding_outpoint(uint32_t this_arg) {
19673 LDKDirectedChannelTransactionParameters this_arg_conv;
19674 this_arg_conv.inner = (void*)(this_arg & (~1));
19675 this_arg_conv.is_owned = false;
19676 LDKOutPoint ret_var = DirectedChannelTransactionParameters_funding_outpoint(&this_arg_conv);
19677 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19678 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19679 uint64_t ret_ref = (uint64_t)ret_var.inner;
19680 if (ret_var.is_owned) {
19686 void __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_free(uint32_t this_obj) {
19687 LDKHolderCommitmentTransaction this_obj_conv;
19688 this_obj_conv.inner = (void*)(this_obj & (~1));
19689 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19690 HolderCommitmentTransaction_free(this_obj_conv);
19693 int8_tArray __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_get_counterparty_sig(uint32_t this_ptr) {
19694 LDKHolderCommitmentTransaction this_ptr_conv;
19695 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19696 this_ptr_conv.is_owned = false;
19697 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
19698 memcpy((uint8_t*)(ret_arr + 4), HolderCommitmentTransaction_get_counterparty_sig(&this_ptr_conv).compact_form, 64);
19702 void __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_set_counterparty_sig(uint32_t this_ptr, int8_tArray val) {
19703 LDKHolderCommitmentTransaction this_ptr_conv;
19704 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19705 this_ptr_conv.is_owned = false;
19706 LDKSignature val_ref;
19707 CHECK(*((uint32_t*)val) == 64);
19708 memcpy(val_ref.compact_form, (uint8_t*)(val + 4), 64);
19709 HolderCommitmentTransaction_set_counterparty_sig(&this_ptr_conv, val_ref);
19712 void __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_set_counterparty_htlc_sigs(uint32_t this_ptr, ptrArray val) {
19713 LDKHolderCommitmentTransaction this_ptr_conv;
19714 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19715 this_ptr_conv.is_owned = false;
19716 LDKCVec_SignatureZ val_constr;
19717 val_constr.datalen = *((uint32_t*)val);
19718 if (val_constr.datalen > 0)
19719 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
19721 val_constr.data = NULL;
19722 int8_tArray* val_vals = (int8_tArray*)(val + 4);
19723 for (size_t m = 0; m < val_constr.datalen; m++) {
19724 int8_tArray val_conv_12 = val_vals[m];
19725 LDKSignature val_conv_12_ref;
19726 CHECK(*((uint32_t*)val_conv_12) == 64);
19727 memcpy(val_conv_12_ref.compact_form, (uint8_t*)(val_conv_12 + 4), 64);
19728 val_constr.data[m] = val_conv_12_ref;
19730 HolderCommitmentTransaction_set_counterparty_htlc_sigs(&this_ptr_conv, val_constr);
19733 uint32_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_clone(uint32_t orig) {
19734 LDKHolderCommitmentTransaction orig_conv;
19735 orig_conv.inner = (void*)(orig & (~1));
19736 orig_conv.is_owned = false;
19737 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_clone(&orig_conv);
19738 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19739 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19740 uint64_t ret_ref = (uint64_t)ret_var.inner;
19741 if (ret_var.is_owned) {
19747 int8_tArray __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_write(uint32_t obj) {
19748 LDKHolderCommitmentTransaction obj_conv;
19749 obj_conv.inner = (void*)(obj & (~1));
19750 obj_conv.is_owned = false;
19751 LDKCVec_u8Z ret_var = HolderCommitmentTransaction_write(&obj_conv);
19752 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19753 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19754 CVec_u8Z_free(ret_var);
19758 uint32_t __attribute__((visibility("default"))) TS_HolderCommitmentTransaction_read(int8_tArray ser) {
19759 LDKu8slice ser_ref;
19760 ser_ref.datalen = *((uint32_t*)ser);
19761 ser_ref.data = (int8_t*)(ser + 4);
19762 LDKCResult_HolderCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_HolderCommitmentTransactionDecodeErrorZ), "LDKCResult_HolderCommitmentTransactionDecodeErrorZ");
19763 *ret_conv = HolderCommitmentTransaction_read(ser_ref);
19764 return (uint64_t)ret_conv;
19767 uint32_t __attribute__((visibility("default"))) 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) {
19768 LDKCommitmentTransaction commitment_tx_conv;
19769 commitment_tx_conv.inner = (void*)(commitment_tx & (~1));
19770 commitment_tx_conv.is_owned = (commitment_tx & 1) || (commitment_tx == 0);
19771 commitment_tx_conv = CommitmentTransaction_clone(&commitment_tx_conv);
19772 LDKSignature counterparty_sig_ref;
19773 CHECK(*((uint32_t*)counterparty_sig) == 64);
19774 memcpy(counterparty_sig_ref.compact_form, (uint8_t*)(counterparty_sig + 4), 64);
19775 LDKCVec_SignatureZ counterparty_htlc_sigs_constr;
19776 counterparty_htlc_sigs_constr.datalen = *((uint32_t*)counterparty_htlc_sigs);
19777 if (counterparty_htlc_sigs_constr.datalen > 0)
19778 counterparty_htlc_sigs_constr.data = MALLOC(counterparty_htlc_sigs_constr.datalen * sizeof(LDKSignature), "LDKCVec_SignatureZ Elements");
19780 counterparty_htlc_sigs_constr.data = NULL;
19781 int8_tArray* counterparty_htlc_sigs_vals = (int8_tArray*)(counterparty_htlc_sigs + 4);
19782 for (size_t m = 0; m < counterparty_htlc_sigs_constr.datalen; m++) {
19783 int8_tArray counterparty_htlc_sigs_conv_12 = counterparty_htlc_sigs_vals[m];
19784 LDKSignature counterparty_htlc_sigs_conv_12_ref;
19785 CHECK(*((uint32_t*)counterparty_htlc_sigs_conv_12) == 64);
19786 memcpy(counterparty_htlc_sigs_conv_12_ref.compact_form, (uint8_t*)(counterparty_htlc_sigs_conv_12 + 4), 64);
19787 counterparty_htlc_sigs_constr.data[m] = counterparty_htlc_sigs_conv_12_ref;
19789 LDKPublicKey holder_funding_key_ref;
19790 CHECK(*((uint32_t*)holder_funding_key) == 33);
19791 memcpy(holder_funding_key_ref.compressed_form, (uint8_t*)(holder_funding_key + 4), 33);
19792 LDKPublicKey counterparty_funding_key_ref;
19793 CHECK(*((uint32_t*)counterparty_funding_key) == 33);
19794 memcpy(counterparty_funding_key_ref.compressed_form, (uint8_t*)(counterparty_funding_key + 4), 33);
19795 LDKHolderCommitmentTransaction ret_var = HolderCommitmentTransaction_new(commitment_tx_conv, counterparty_sig_ref, counterparty_htlc_sigs_constr, holder_funding_key_ref, counterparty_funding_key_ref);
19796 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19797 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19798 uint64_t ret_ref = (uint64_t)ret_var.inner;
19799 if (ret_var.is_owned) {
19805 void __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_free(uint32_t this_obj) {
19806 LDKBuiltCommitmentTransaction this_obj_conv;
19807 this_obj_conv.inner = (void*)(this_obj & (~1));
19808 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19809 BuiltCommitmentTransaction_free(this_obj_conv);
19812 int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_get_transaction(uint32_t this_ptr) {
19813 LDKBuiltCommitmentTransaction this_ptr_conv;
19814 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19815 this_ptr_conv.is_owned = false;
19816 LDKTransaction ret_var = BuiltCommitmentTransaction_get_transaction(&this_ptr_conv);
19817 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19818 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19819 Transaction_free(ret_var);
19823 void __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_set_transaction(uint32_t this_ptr, int8_tArray val) {
19824 LDKBuiltCommitmentTransaction this_ptr_conv;
19825 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19826 this_ptr_conv.is_owned = false;
19827 LDKTransaction val_ref;
19828 val_ref.datalen = *((uint32_t*)val);
19829 val_ref.data = MALLOC(val_ref.datalen, "LDKTransaction Bytes");
19830 memcpy(val_ref.data, (uint8_t*)(val + 4), val_ref.datalen);
19831 val_ref.data_is_owned = true;
19832 BuiltCommitmentTransaction_set_transaction(&this_ptr_conv, val_ref);
19835 int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_get_txid(uint32_t this_ptr) {
19836 LDKBuiltCommitmentTransaction this_ptr_conv;
19837 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19838 this_ptr_conv.is_owned = false;
19839 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
19840 memcpy((uint8_t*)(ret_arr + 4), *BuiltCommitmentTransaction_get_txid(&this_ptr_conv), 32);
19844 void __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_set_txid(uint32_t this_ptr, int8_tArray val) {
19845 LDKBuiltCommitmentTransaction this_ptr_conv;
19846 this_ptr_conv.inner = (void*)(this_ptr & (~1));
19847 this_ptr_conv.is_owned = false;
19848 LDKThirtyTwoBytes val_ref;
19849 CHECK(*((uint32_t*)val) == 32);
19850 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
19851 BuiltCommitmentTransaction_set_txid(&this_ptr_conv, val_ref);
19854 uint32_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_new(int8_tArray transaction_arg, int8_tArray txid_arg) {
19855 LDKTransaction transaction_arg_ref;
19856 transaction_arg_ref.datalen = *((uint32_t*)transaction_arg);
19857 transaction_arg_ref.data = MALLOC(transaction_arg_ref.datalen, "LDKTransaction Bytes");
19858 memcpy(transaction_arg_ref.data, (uint8_t*)(transaction_arg + 4), transaction_arg_ref.datalen);
19859 transaction_arg_ref.data_is_owned = true;
19860 LDKThirtyTwoBytes txid_arg_ref;
19861 CHECK(*((uint32_t*)txid_arg) == 32);
19862 memcpy(txid_arg_ref.data, (uint8_t*)(txid_arg + 4), 32);
19863 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_new(transaction_arg_ref, txid_arg_ref);
19864 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19865 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19866 uint64_t ret_ref = (uint64_t)ret_var.inner;
19867 if (ret_var.is_owned) {
19873 uint32_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_clone(uint32_t orig) {
19874 LDKBuiltCommitmentTransaction orig_conv;
19875 orig_conv.inner = (void*)(orig & (~1));
19876 orig_conv.is_owned = false;
19877 LDKBuiltCommitmentTransaction ret_var = BuiltCommitmentTransaction_clone(&orig_conv);
19878 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19879 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19880 uint64_t ret_ref = (uint64_t)ret_var.inner;
19881 if (ret_var.is_owned) {
19887 int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_write(uint32_t obj) {
19888 LDKBuiltCommitmentTransaction obj_conv;
19889 obj_conv.inner = (void*)(obj & (~1));
19890 obj_conv.is_owned = false;
19891 LDKCVec_u8Z ret_var = BuiltCommitmentTransaction_write(&obj_conv);
19892 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19893 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19894 CVec_u8Z_free(ret_var);
19898 uint32_t __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_read(int8_tArray ser) {
19899 LDKu8slice ser_ref;
19900 ser_ref.datalen = *((uint32_t*)ser);
19901 ser_ref.data = (int8_t*)(ser + 4);
19902 LDKCResult_BuiltCommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_BuiltCommitmentTransactionDecodeErrorZ), "LDKCResult_BuiltCommitmentTransactionDecodeErrorZ");
19903 *ret_conv = BuiltCommitmentTransaction_read(ser_ref);
19904 return (uint64_t)ret_conv;
19907 int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_get_sighash_all(uint32_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
19908 LDKBuiltCommitmentTransaction this_arg_conv;
19909 this_arg_conv.inner = (void*)(this_arg & (~1));
19910 this_arg_conv.is_owned = false;
19911 LDKu8slice funding_redeemscript_ref;
19912 funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
19913 funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
19914 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
19915 memcpy((uint8_t*)(ret_arr + 4), BuiltCommitmentTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32);
19919 int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransaction_sign(uint32_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) {
19920 LDKBuiltCommitmentTransaction this_arg_conv;
19921 this_arg_conv.inner = (void*)(this_arg & (~1));
19922 this_arg_conv.is_owned = false;
19923 unsigned char funding_key_arr[32];
19924 CHECK(*((uint32_t*)funding_key) == 32);
19925 memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32);
19926 unsigned char (*funding_key_ref)[32] = &funding_key_arr;
19927 LDKu8slice funding_redeemscript_ref;
19928 funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript);
19929 funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4);
19930 int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes");
19931 memcpy((uint8_t*)(ret_arr + 4), BuiltCommitmentTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64);
19935 void __attribute__((visibility("default"))) TS_CommitmentTransaction_free(uint32_t this_obj) {
19936 LDKCommitmentTransaction this_obj_conv;
19937 this_obj_conv.inner = (void*)(this_obj & (~1));
19938 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
19939 CommitmentTransaction_free(this_obj_conv);
19942 uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_clone(uint32_t orig) {
19943 LDKCommitmentTransaction orig_conv;
19944 orig_conv.inner = (void*)(orig & (~1));
19945 orig_conv.is_owned = false;
19946 LDKCommitmentTransaction ret_var = CommitmentTransaction_clone(&orig_conv);
19947 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
19948 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
19949 uint64_t ret_ref = (uint64_t)ret_var.inner;
19950 if (ret_var.is_owned) {
19956 int8_tArray __attribute__((visibility("default"))) TS_CommitmentTransaction_write(uint32_t obj) {
19957 LDKCommitmentTransaction obj_conv;
19958 obj_conv.inner = (void*)(obj & (~1));
19959 obj_conv.is_owned = false;
19960 LDKCVec_u8Z ret_var = CommitmentTransaction_write(&obj_conv);
19961 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
19962 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
19963 CVec_u8Z_free(ret_var);
19967 uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_read(int8_tArray ser) {
19968 LDKu8slice ser_ref;
19969 ser_ref.datalen = *((uint32_t*)ser);
19970 ser_ref.data = (int8_t*)(ser + 4);
19971 LDKCResult_CommitmentTransactionDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CommitmentTransactionDecodeErrorZ), "LDKCResult_CommitmentTransactionDecodeErrorZ");
19972 *ret_conv = CommitmentTransaction_read(ser_ref);
19973 return (uint64_t)ret_conv;
19976 int64_t __attribute__((visibility("default"))) TS_CommitmentTransaction_commitment_number(uint32_t this_arg) {
19977 LDKCommitmentTransaction this_arg_conv;
19978 this_arg_conv.inner = (void*)(this_arg & (~1));
19979 this_arg_conv.is_owned = false;
19980 int64_t ret_val = CommitmentTransaction_commitment_number(&this_arg_conv);
19984 int64_t __attribute__((visibility("default"))) TS_CommitmentTransaction_to_broadcaster_value_sat(uint32_t this_arg) {
19985 LDKCommitmentTransaction this_arg_conv;
19986 this_arg_conv.inner = (void*)(this_arg & (~1));
19987 this_arg_conv.is_owned = false;
19988 int64_t ret_val = CommitmentTransaction_to_broadcaster_value_sat(&this_arg_conv);
19992 int64_t __attribute__((visibility("default"))) TS_CommitmentTransaction_to_countersignatory_value_sat(uint32_t this_arg) {
19993 LDKCommitmentTransaction this_arg_conv;
19994 this_arg_conv.inner = (void*)(this_arg & (~1));
19995 this_arg_conv.is_owned = false;
19996 int64_t ret_val = CommitmentTransaction_to_countersignatory_value_sat(&this_arg_conv);
20000 int32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_feerate_per_kw(uint32_t this_arg) {
20001 LDKCommitmentTransaction this_arg_conv;
20002 this_arg_conv.inner = (void*)(this_arg & (~1));
20003 this_arg_conv.is_owned = false;
20004 int32_t ret_val = CommitmentTransaction_feerate_per_kw(&this_arg_conv);
20008 uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_trust(uint32_t this_arg) {
20009 LDKCommitmentTransaction this_arg_conv;
20010 this_arg_conv.inner = (void*)(this_arg & (~1));
20011 this_arg_conv.is_owned = false;
20012 LDKTrustedCommitmentTransaction ret_var = CommitmentTransaction_trust(&this_arg_conv);
20013 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20014 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20015 uint64_t ret_ref = (uint64_t)ret_var.inner;
20016 if (ret_var.is_owned) {
20022 uint32_t __attribute__((visibility("default"))) TS_CommitmentTransaction_verify(uint32_t this_arg, uint32_t channel_parameters, uint32_t broadcaster_keys, uint32_t countersignatory_keys) {
20023 LDKCommitmentTransaction this_arg_conv;
20024 this_arg_conv.inner = (void*)(this_arg & (~1));
20025 this_arg_conv.is_owned = false;
20026 LDKDirectedChannelTransactionParameters channel_parameters_conv;
20027 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
20028 channel_parameters_conv.is_owned = false;
20029 LDKChannelPublicKeys broadcaster_keys_conv;
20030 broadcaster_keys_conv.inner = (void*)(broadcaster_keys & (~1));
20031 broadcaster_keys_conv.is_owned = false;
20032 LDKChannelPublicKeys countersignatory_keys_conv;
20033 countersignatory_keys_conv.inner = (void*)(countersignatory_keys & (~1));
20034 countersignatory_keys_conv.is_owned = false;
20035 LDKCResult_TrustedCommitmentTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedCommitmentTransactionNoneZ), "LDKCResult_TrustedCommitmentTransactionNoneZ");
20036 *ret_conv = CommitmentTransaction_verify(&this_arg_conv, &channel_parameters_conv, &broadcaster_keys_conv, &countersignatory_keys_conv);
20037 return (uint64_t)ret_conv;
20040 void __attribute__((visibility("default"))) TS_TrustedCommitmentTransaction_free(uint32_t this_obj) {
20041 LDKTrustedCommitmentTransaction this_obj_conv;
20042 this_obj_conv.inner = (void*)(this_obj & (~1));
20043 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20044 TrustedCommitmentTransaction_free(this_obj_conv);
20047 int8_tArray __attribute__((visibility("default"))) TS_TrustedCommitmentTransaction_txid(uint32_t this_arg) {
20048 LDKTrustedCommitmentTransaction this_arg_conv;
20049 this_arg_conv.inner = (void*)(this_arg & (~1));
20050 this_arg_conv.is_owned = false;
20051 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
20052 memcpy((uint8_t*)(ret_arr + 4), TrustedCommitmentTransaction_txid(&this_arg_conv).data, 32);
20056 uint32_t __attribute__((visibility("default"))) TS_TrustedCommitmentTransaction_built_transaction(uint32_t this_arg) {
20057 LDKTrustedCommitmentTransaction this_arg_conv;
20058 this_arg_conv.inner = (void*)(this_arg & (~1));
20059 this_arg_conv.is_owned = false;
20060 LDKBuiltCommitmentTransaction ret_var = TrustedCommitmentTransaction_built_transaction(&this_arg_conv);
20061 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20062 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20063 uint64_t ret_ref = (uint64_t)ret_var.inner;
20064 if (ret_var.is_owned) {
20070 uint32_t __attribute__((visibility("default"))) TS_TrustedCommitmentTransaction_keys(uint32_t this_arg) {
20071 LDKTrustedCommitmentTransaction this_arg_conv;
20072 this_arg_conv.inner = (void*)(this_arg & (~1));
20073 this_arg_conv.is_owned = false;
20074 LDKTxCreationKeys ret_var = TrustedCommitmentTransaction_keys(&this_arg_conv);
20075 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20076 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20077 uint64_t ret_ref = (uint64_t)ret_var.inner;
20078 if (ret_var.is_owned) {
20084 uint32_t __attribute__((visibility("default"))) TS_TrustedCommitmentTransaction_get_htlc_sigs(uint32_t this_arg, int8_tArray htlc_base_key, uint32_t channel_parameters) {
20085 LDKTrustedCommitmentTransaction this_arg_conv;
20086 this_arg_conv.inner = (void*)(this_arg & (~1));
20087 this_arg_conv.is_owned = false;
20088 unsigned char htlc_base_key_arr[32];
20089 CHECK(*((uint32_t*)htlc_base_key) == 32);
20090 memcpy(htlc_base_key_arr, (uint8_t*)(htlc_base_key + 4), 32);
20091 unsigned char (*htlc_base_key_ref)[32] = &htlc_base_key_arr;
20092 LDKDirectedChannelTransactionParameters channel_parameters_conv;
20093 channel_parameters_conv.inner = (void*)(channel_parameters & (~1));
20094 channel_parameters_conv.is_owned = false;
20095 LDKCResult_CVec_SignatureZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_SignatureZNoneZ), "LDKCResult_CVec_SignatureZNoneZ");
20096 *ret_conv = TrustedCommitmentTransaction_get_htlc_sigs(&this_arg_conv, htlc_base_key_ref, &channel_parameters_conv);
20097 return (uint64_t)ret_conv;
20100 int64_t __attribute__((visibility("default"))) TS_get_commitment_transaction_number_obscure_factor(int8_tArray broadcaster_payment_basepoint, int8_tArray countersignatory_payment_basepoint, jboolean outbound_from_broadcaster) {
20101 LDKPublicKey broadcaster_payment_basepoint_ref;
20102 CHECK(*((uint32_t*)broadcaster_payment_basepoint) == 33);
20103 memcpy(broadcaster_payment_basepoint_ref.compressed_form, (uint8_t*)(broadcaster_payment_basepoint + 4), 33);
20104 LDKPublicKey countersignatory_payment_basepoint_ref;
20105 CHECK(*((uint32_t*)countersignatory_payment_basepoint) == 33);
20106 memcpy(countersignatory_payment_basepoint_ref.compressed_form, (uint8_t*)(countersignatory_payment_basepoint + 4), 33);
20107 int64_t ret_val = get_commitment_transaction_number_obscure_factor(broadcaster_payment_basepoint_ref, countersignatory_payment_basepoint_ref, outbound_from_broadcaster);
20111 jboolean __attribute__((visibility("default"))) TS_InitFeatures_eq(uint32_t a, uint32_t b) {
20112 LDKInitFeatures a_conv;
20113 a_conv.inner = (void*)(a & (~1));
20114 a_conv.is_owned = false;
20115 LDKInitFeatures b_conv;
20116 b_conv.inner = (void*)(b & (~1));
20117 b_conv.is_owned = false;
20118 jboolean ret_val = InitFeatures_eq(&a_conv, &b_conv);
20122 jboolean __attribute__((visibility("default"))) TS_NodeFeatures_eq(uint32_t a, uint32_t b) {
20123 LDKNodeFeatures a_conv;
20124 a_conv.inner = (void*)(a & (~1));
20125 a_conv.is_owned = false;
20126 LDKNodeFeatures b_conv;
20127 b_conv.inner = (void*)(b & (~1));
20128 b_conv.is_owned = false;
20129 jboolean ret_val = NodeFeatures_eq(&a_conv, &b_conv);
20133 jboolean __attribute__((visibility("default"))) TS_ChannelFeatures_eq(uint32_t a, uint32_t b) {
20134 LDKChannelFeatures a_conv;
20135 a_conv.inner = (void*)(a & (~1));
20136 a_conv.is_owned = false;
20137 LDKChannelFeatures b_conv;
20138 b_conv.inner = (void*)(b & (~1));
20139 b_conv.is_owned = false;
20140 jboolean ret_val = ChannelFeatures_eq(&a_conv, &b_conv);
20144 jboolean __attribute__((visibility("default"))) TS_InvoiceFeatures_eq(uint32_t a, uint32_t b) {
20145 LDKInvoiceFeatures a_conv;
20146 a_conv.inner = (void*)(a & (~1));
20147 a_conv.is_owned = false;
20148 LDKInvoiceFeatures b_conv;
20149 b_conv.inner = (void*)(b & (~1));
20150 b_conv.is_owned = false;
20151 jboolean ret_val = InvoiceFeatures_eq(&a_conv, &b_conv);
20155 uint32_t __attribute__((visibility("default"))) TS_InitFeatures_clone(uint32_t orig) {
20156 LDKInitFeatures orig_conv;
20157 orig_conv.inner = (void*)(orig & (~1));
20158 orig_conv.is_owned = false;
20159 LDKInitFeatures ret_var = InitFeatures_clone(&orig_conv);
20160 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20161 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20162 uint64_t ret_ref = (uint64_t)ret_var.inner;
20163 if (ret_var.is_owned) {
20169 uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_clone(uint32_t orig) {
20170 LDKNodeFeatures orig_conv;
20171 orig_conv.inner = (void*)(orig & (~1));
20172 orig_conv.is_owned = false;
20173 LDKNodeFeatures ret_var = NodeFeatures_clone(&orig_conv);
20174 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20175 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20176 uint64_t ret_ref = (uint64_t)ret_var.inner;
20177 if (ret_var.is_owned) {
20183 uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_clone(uint32_t orig) {
20184 LDKChannelFeatures orig_conv;
20185 orig_conv.inner = (void*)(orig & (~1));
20186 orig_conv.is_owned = false;
20187 LDKChannelFeatures ret_var = ChannelFeatures_clone(&orig_conv);
20188 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20189 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20190 uint64_t ret_ref = (uint64_t)ret_var.inner;
20191 if (ret_var.is_owned) {
20197 uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_clone(uint32_t orig) {
20198 LDKInvoiceFeatures orig_conv;
20199 orig_conv.inner = (void*)(orig & (~1));
20200 orig_conv.is_owned = false;
20201 LDKInvoiceFeatures ret_var = InvoiceFeatures_clone(&orig_conv);
20202 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20203 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20204 uint64_t ret_ref = (uint64_t)ret_var.inner;
20205 if (ret_var.is_owned) {
20211 void __attribute__((visibility("default"))) TS_InitFeatures_free(uint32_t this_obj) {
20212 LDKInitFeatures this_obj_conv;
20213 this_obj_conv.inner = (void*)(this_obj & (~1));
20214 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20215 InitFeatures_free(this_obj_conv);
20218 void __attribute__((visibility("default"))) TS_NodeFeatures_free(uint32_t this_obj) {
20219 LDKNodeFeatures this_obj_conv;
20220 this_obj_conv.inner = (void*)(this_obj & (~1));
20221 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20222 NodeFeatures_free(this_obj_conv);
20225 void __attribute__((visibility("default"))) TS_ChannelFeatures_free(uint32_t this_obj) {
20226 LDKChannelFeatures this_obj_conv;
20227 this_obj_conv.inner = (void*)(this_obj & (~1));
20228 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20229 ChannelFeatures_free(this_obj_conv);
20232 void __attribute__((visibility("default"))) TS_InvoiceFeatures_free(uint32_t this_obj) {
20233 LDKInvoiceFeatures this_obj_conv;
20234 this_obj_conv.inner = (void*)(this_obj & (~1));
20235 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20236 InvoiceFeatures_free(this_obj_conv);
20239 uint32_t __attribute__((visibility("default"))) TS_InitFeatures_empty() {
20240 LDKInitFeatures ret_var = InitFeatures_empty();
20241 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20242 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20243 uint64_t ret_ref = (uint64_t)ret_var.inner;
20244 if (ret_var.is_owned) {
20250 uint32_t __attribute__((visibility("default"))) TS_InitFeatures_known() {
20251 LDKInitFeatures ret_var = InitFeatures_known();
20252 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20253 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20254 uint64_t ret_ref = (uint64_t)ret_var.inner;
20255 if (ret_var.is_owned) {
20261 uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_empty() {
20262 LDKNodeFeatures ret_var = NodeFeatures_empty();
20263 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20264 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20265 uint64_t ret_ref = (uint64_t)ret_var.inner;
20266 if (ret_var.is_owned) {
20272 uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_known() {
20273 LDKNodeFeatures ret_var = NodeFeatures_known();
20274 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20275 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20276 uint64_t ret_ref = (uint64_t)ret_var.inner;
20277 if (ret_var.is_owned) {
20283 uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_empty() {
20284 LDKChannelFeatures ret_var = ChannelFeatures_empty();
20285 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20286 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20287 uint64_t ret_ref = (uint64_t)ret_var.inner;
20288 if (ret_var.is_owned) {
20294 uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_known() {
20295 LDKChannelFeatures ret_var = ChannelFeatures_known();
20296 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20297 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20298 uint64_t ret_ref = (uint64_t)ret_var.inner;
20299 if (ret_var.is_owned) {
20305 uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_empty() {
20306 LDKInvoiceFeatures ret_var = InvoiceFeatures_empty();
20307 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20308 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20309 uint64_t ret_ref = (uint64_t)ret_var.inner;
20310 if (ret_var.is_owned) {
20316 uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_known() {
20317 LDKInvoiceFeatures ret_var = InvoiceFeatures_known();
20318 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20319 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20320 uint64_t ret_ref = (uint64_t)ret_var.inner;
20321 if (ret_var.is_owned) {
20327 jboolean __attribute__((visibility("default"))) TS_InitFeatures_supports_payment_secret(uint32_t this_arg) {
20328 LDKInitFeatures this_arg_conv;
20329 this_arg_conv.inner = (void*)(this_arg & (~1));
20330 this_arg_conv.is_owned = false;
20331 jboolean ret_val = InitFeatures_supports_payment_secret(&this_arg_conv);
20335 jboolean __attribute__((visibility("default"))) TS_NodeFeatures_supports_payment_secret(uint32_t this_arg) {
20336 LDKNodeFeatures this_arg_conv;
20337 this_arg_conv.inner = (void*)(this_arg & (~1));
20338 this_arg_conv.is_owned = false;
20339 jboolean ret_val = NodeFeatures_supports_payment_secret(&this_arg_conv);
20343 jboolean __attribute__((visibility("default"))) TS_InvoiceFeatures_supports_payment_secret(uint32_t this_arg) {
20344 LDKInvoiceFeatures this_arg_conv;
20345 this_arg_conv.inner = (void*)(this_arg & (~1));
20346 this_arg_conv.is_owned = false;
20347 jboolean ret_val = InvoiceFeatures_supports_payment_secret(&this_arg_conv);
20351 int8_tArray __attribute__((visibility("default"))) TS_InitFeatures_write(uint32_t obj) {
20352 LDKInitFeatures obj_conv;
20353 obj_conv.inner = (void*)(obj & (~1));
20354 obj_conv.is_owned = false;
20355 LDKCVec_u8Z ret_var = InitFeatures_write(&obj_conv);
20356 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20357 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20358 CVec_u8Z_free(ret_var);
20362 int8_tArray __attribute__((visibility("default"))) TS_NodeFeatures_write(uint32_t obj) {
20363 LDKNodeFeatures obj_conv;
20364 obj_conv.inner = (void*)(obj & (~1));
20365 obj_conv.is_owned = false;
20366 LDKCVec_u8Z ret_var = NodeFeatures_write(&obj_conv);
20367 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20368 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20369 CVec_u8Z_free(ret_var);
20373 int8_tArray __attribute__((visibility("default"))) TS_ChannelFeatures_write(uint32_t obj) {
20374 LDKChannelFeatures obj_conv;
20375 obj_conv.inner = (void*)(obj & (~1));
20376 obj_conv.is_owned = false;
20377 LDKCVec_u8Z ret_var = ChannelFeatures_write(&obj_conv);
20378 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20379 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20380 CVec_u8Z_free(ret_var);
20384 int8_tArray __attribute__((visibility("default"))) TS_InvoiceFeatures_write(uint32_t obj) {
20385 LDKInvoiceFeatures obj_conv;
20386 obj_conv.inner = (void*)(obj & (~1));
20387 obj_conv.is_owned = false;
20388 LDKCVec_u8Z ret_var = InvoiceFeatures_write(&obj_conv);
20389 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20390 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20391 CVec_u8Z_free(ret_var);
20395 uint32_t __attribute__((visibility("default"))) TS_InitFeatures_read(int8_tArray ser) {
20396 LDKu8slice ser_ref;
20397 ser_ref.datalen = *((uint32_t*)ser);
20398 ser_ref.data = (int8_t*)(ser + 4);
20399 LDKCResult_InitFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InitFeaturesDecodeErrorZ), "LDKCResult_InitFeaturesDecodeErrorZ");
20400 *ret_conv = InitFeatures_read(ser_ref);
20401 return (uint64_t)ret_conv;
20404 uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_read(int8_tArray ser) {
20405 LDKu8slice ser_ref;
20406 ser_ref.datalen = *((uint32_t*)ser);
20407 ser_ref.data = (int8_t*)(ser + 4);
20408 LDKCResult_NodeFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeFeaturesDecodeErrorZ), "LDKCResult_NodeFeaturesDecodeErrorZ");
20409 *ret_conv = NodeFeatures_read(ser_ref);
20410 return (uint64_t)ret_conv;
20413 uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_read(int8_tArray ser) {
20414 LDKu8slice ser_ref;
20415 ser_ref.datalen = *((uint32_t*)ser);
20416 ser_ref.data = (int8_t*)(ser + 4);
20417 LDKCResult_ChannelFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelFeaturesDecodeErrorZ), "LDKCResult_ChannelFeaturesDecodeErrorZ");
20418 *ret_conv = ChannelFeatures_read(ser_ref);
20419 return (uint64_t)ret_conv;
20422 uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_read(int8_tArray ser) {
20423 LDKu8slice ser_ref;
20424 ser_ref.datalen = *((uint32_t*)ser);
20425 ser_ref.data = (int8_t*)(ser + 4);
20426 LDKCResult_InvoiceFeaturesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceFeaturesDecodeErrorZ), "LDKCResult_InvoiceFeaturesDecodeErrorZ");
20427 *ret_conv = InvoiceFeatures_read(ser_ref);
20428 return (uint64_t)ret_conv;
20431 void __attribute__((visibility("default"))) TS_RouteHop_free(uint32_t this_obj) {
20432 LDKRouteHop this_obj_conv;
20433 this_obj_conv.inner = (void*)(this_obj & (~1));
20434 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20435 RouteHop_free(this_obj_conv);
20438 int8_tArray __attribute__((visibility("default"))) TS_RouteHop_get_pubkey(uint32_t this_ptr) {
20439 LDKRouteHop this_ptr_conv;
20440 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20441 this_ptr_conv.is_owned = false;
20442 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
20443 memcpy((uint8_t*)(ret_arr + 4), RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33);
20447 void __attribute__((visibility("default"))) TS_RouteHop_set_pubkey(uint32_t this_ptr, int8_tArray val) {
20448 LDKRouteHop this_ptr_conv;
20449 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20450 this_ptr_conv.is_owned = false;
20451 LDKPublicKey val_ref;
20452 CHECK(*((uint32_t*)val) == 33);
20453 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
20454 RouteHop_set_pubkey(&this_ptr_conv, val_ref);
20457 uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_node_features(uint32_t this_ptr) {
20458 LDKRouteHop this_ptr_conv;
20459 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20460 this_ptr_conv.is_owned = false;
20461 LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv);
20462 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20463 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20464 uint64_t ret_ref = (uint64_t)ret_var.inner;
20465 if (ret_var.is_owned) {
20471 void __attribute__((visibility("default"))) TS_RouteHop_set_node_features(uint32_t this_ptr, uint32_t val) {
20472 LDKRouteHop this_ptr_conv;
20473 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20474 this_ptr_conv.is_owned = false;
20475 LDKNodeFeatures val_conv;
20476 val_conv.inner = (void*)(val & (~1));
20477 val_conv.is_owned = (val & 1) || (val == 0);
20478 val_conv = NodeFeatures_clone(&val_conv);
20479 RouteHop_set_node_features(&this_ptr_conv, val_conv);
20482 int64_t __attribute__((visibility("default"))) TS_RouteHop_get_short_channel_id(uint32_t this_ptr) {
20483 LDKRouteHop this_ptr_conv;
20484 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20485 this_ptr_conv.is_owned = false;
20486 int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv);
20490 void __attribute__((visibility("default"))) TS_RouteHop_set_short_channel_id(uint32_t this_ptr, int64_t val) {
20491 LDKRouteHop this_ptr_conv;
20492 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20493 this_ptr_conv.is_owned = false;
20494 RouteHop_set_short_channel_id(&this_ptr_conv, val);
20497 uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_channel_features(uint32_t this_ptr) {
20498 LDKRouteHop this_ptr_conv;
20499 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20500 this_ptr_conv.is_owned = false;
20501 LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv);
20502 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20503 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20504 uint64_t ret_ref = (uint64_t)ret_var.inner;
20505 if (ret_var.is_owned) {
20511 void __attribute__((visibility("default"))) TS_RouteHop_set_channel_features(uint32_t this_ptr, uint32_t val) {
20512 LDKRouteHop this_ptr_conv;
20513 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20514 this_ptr_conv.is_owned = false;
20515 LDKChannelFeatures val_conv;
20516 val_conv.inner = (void*)(val & (~1));
20517 val_conv.is_owned = (val & 1) || (val == 0);
20518 val_conv = ChannelFeatures_clone(&val_conv);
20519 RouteHop_set_channel_features(&this_ptr_conv, val_conv);
20522 int64_t __attribute__((visibility("default"))) TS_RouteHop_get_fee_msat(uint32_t this_ptr) {
20523 LDKRouteHop this_ptr_conv;
20524 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20525 this_ptr_conv.is_owned = false;
20526 int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv);
20530 void __attribute__((visibility("default"))) TS_RouteHop_set_fee_msat(uint32_t this_ptr, int64_t val) {
20531 LDKRouteHop this_ptr_conv;
20532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20533 this_ptr_conv.is_owned = false;
20534 RouteHop_set_fee_msat(&this_ptr_conv, val);
20537 int32_t __attribute__((visibility("default"))) TS_RouteHop_get_cltv_expiry_delta(uint32_t this_ptr) {
20538 LDKRouteHop this_ptr_conv;
20539 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20540 this_ptr_conv.is_owned = false;
20541 int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv);
20545 void __attribute__((visibility("default"))) TS_RouteHop_set_cltv_expiry_delta(uint32_t this_ptr, int32_t val) {
20546 LDKRouteHop this_ptr_conv;
20547 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20548 this_ptr_conv.is_owned = false;
20549 RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val);
20552 uint32_t __attribute__((visibility("default"))) 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) {
20553 LDKPublicKey pubkey_arg_ref;
20554 CHECK(*((uint32_t*)pubkey_arg) == 33);
20555 memcpy(pubkey_arg_ref.compressed_form, (uint8_t*)(pubkey_arg + 4), 33);
20556 LDKNodeFeatures node_features_arg_conv;
20557 node_features_arg_conv.inner = (void*)(node_features_arg & (~1));
20558 node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0);
20559 node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv);
20560 LDKChannelFeatures channel_features_arg_conv;
20561 channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1));
20562 channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0);
20563 channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv);
20564 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);
20565 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20566 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20567 uint64_t ret_ref = (uint64_t)ret_var.inner;
20568 if (ret_var.is_owned) {
20574 uint32_t __attribute__((visibility("default"))) TS_RouteHop_clone(uint32_t orig) {
20575 LDKRouteHop orig_conv;
20576 orig_conv.inner = (void*)(orig & (~1));
20577 orig_conv.is_owned = false;
20578 LDKRouteHop ret_var = RouteHop_clone(&orig_conv);
20579 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20580 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20581 uint64_t ret_ref = (uint64_t)ret_var.inner;
20582 if (ret_var.is_owned) {
20588 int8_tArray __attribute__((visibility("default"))) TS_RouteHop_write(uint32_t obj) {
20589 LDKRouteHop obj_conv;
20590 obj_conv.inner = (void*)(obj & (~1));
20591 obj_conv.is_owned = false;
20592 LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv);
20593 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20594 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20595 CVec_u8Z_free(ret_var);
20599 uint32_t __attribute__((visibility("default"))) TS_RouteHop_read(int8_tArray ser) {
20600 LDKu8slice ser_ref;
20601 ser_ref.datalen = *((uint32_t*)ser);
20602 ser_ref.data = (int8_t*)(ser + 4);
20603 LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ");
20604 *ret_conv = RouteHop_read(ser_ref);
20605 return (uint64_t)ret_conv;
20608 void __attribute__((visibility("default"))) TS_Route_free(uint32_t this_obj) {
20609 LDKRoute this_obj_conv;
20610 this_obj_conv.inner = (void*)(this_obj & (~1));
20611 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20612 Route_free(this_obj_conv);
20615 void __attribute__((visibility("default"))) TS_Route_set_paths(uint32_t this_ptr, ptrArray val) {
20616 LDKRoute this_ptr_conv;
20617 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20618 this_ptr_conv.is_owned = false;
20619 LDKCVec_CVec_RouteHopZZ val_constr;
20620 val_constr.datalen = *((uint32_t*)val);
20621 if (val_constr.datalen > 0)
20622 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
20624 val_constr.data = NULL;
20625 uint32_tArray* val_vals = (uint32_tArray*)(val + 4);
20626 for (size_t m = 0; m < val_constr.datalen; m++) {
20627 uint32_tArray val_conv_12 = val_vals[m];
20628 LDKCVec_RouteHopZ val_conv_12_constr;
20629 val_conv_12_constr.datalen = *((uint32_t*)val_conv_12);
20630 if (val_conv_12_constr.datalen > 0)
20631 val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
20633 val_conv_12_constr.data = NULL;
20634 uint32_t* val_conv_12_vals = (uint32_t*)(val_conv_12 + 4);
20635 for (size_t k = 0; k < val_conv_12_constr.datalen; k++) {
20636 uint32_t val_conv_12_conv_10 = val_conv_12_vals[k];
20637 LDKRouteHop val_conv_12_conv_10_conv;
20638 val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1));
20639 val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0);
20640 val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv);
20641 val_conv_12_constr.data[k] = val_conv_12_conv_10_conv;
20643 val_constr.data[m] = val_conv_12_constr;
20645 Route_set_paths(&this_ptr_conv, val_constr);
20648 uint32_t __attribute__((visibility("default"))) TS_Route_new(ptrArray paths_arg) {
20649 LDKCVec_CVec_RouteHopZZ paths_arg_constr;
20650 paths_arg_constr.datalen = *((uint32_t*)paths_arg);
20651 if (paths_arg_constr.datalen > 0)
20652 paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements");
20654 paths_arg_constr.data = NULL;
20655 uint32_tArray* paths_arg_vals = (uint32_tArray*)(paths_arg + 4);
20656 for (size_t m = 0; m < paths_arg_constr.datalen; m++) {
20657 uint32_tArray paths_arg_conv_12 = paths_arg_vals[m];
20658 LDKCVec_RouteHopZ paths_arg_conv_12_constr;
20659 paths_arg_conv_12_constr.datalen = *((uint32_t*)paths_arg_conv_12);
20660 if (paths_arg_conv_12_constr.datalen > 0)
20661 paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements");
20663 paths_arg_conv_12_constr.data = NULL;
20664 uint32_t* paths_arg_conv_12_vals = (uint32_t*)(paths_arg_conv_12 + 4);
20665 for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) {
20666 uint32_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k];
20667 LDKRouteHop paths_arg_conv_12_conv_10_conv;
20668 paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1));
20669 paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0);
20670 paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv);
20671 paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv;
20673 paths_arg_constr.data[m] = paths_arg_conv_12_constr;
20675 LDKRoute ret_var = Route_new(paths_arg_constr);
20676 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20677 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20678 uint64_t ret_ref = (uint64_t)ret_var.inner;
20679 if (ret_var.is_owned) {
20685 uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) {
20686 LDKRoute orig_conv;
20687 orig_conv.inner = (void*)(orig & (~1));
20688 orig_conv.is_owned = false;
20689 LDKRoute ret_var = Route_clone(&orig_conv);
20690 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20691 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20692 uint64_t ret_ref = (uint64_t)ret_var.inner;
20693 if (ret_var.is_owned) {
20699 int8_tArray __attribute__((visibility("default"))) TS_Route_write(uint32_t obj) {
20701 obj_conv.inner = (void*)(obj & (~1));
20702 obj_conv.is_owned = false;
20703 LDKCVec_u8Z ret_var = Route_write(&obj_conv);
20704 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
20705 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
20706 CVec_u8Z_free(ret_var);
20710 uint32_t __attribute__((visibility("default"))) TS_Route_read(int8_tArray ser) {
20711 LDKu8slice ser_ref;
20712 ser_ref.datalen = *((uint32_t*)ser);
20713 ser_ref.data = (int8_t*)(ser + 4);
20714 LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ");
20715 *ret_conv = Route_read(ser_ref);
20716 return (uint64_t)ret_conv;
20719 void __attribute__((visibility("default"))) TS_RouteHint_free(uint32_t this_obj) {
20720 LDKRouteHint this_obj_conv;
20721 this_obj_conv.inner = (void*)(this_obj & (~1));
20722 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20723 RouteHint_free(this_obj_conv);
20726 jboolean __attribute__((visibility("default"))) TS_RouteHint_eq(uint32_t a, uint32_t b) {
20727 LDKRouteHint a_conv;
20728 a_conv.inner = (void*)(a & (~1));
20729 a_conv.is_owned = false;
20730 LDKRouteHint b_conv;
20731 b_conv.inner = (void*)(b & (~1));
20732 b_conv.is_owned = false;
20733 jboolean ret_val = RouteHint_eq(&a_conv, &b_conv);
20737 uint32_t __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) {
20738 LDKRouteHint orig_conv;
20739 orig_conv.inner = (void*)(orig & (~1));
20740 orig_conv.is_owned = false;
20741 LDKRouteHint ret_var = RouteHint_clone(&orig_conv);
20742 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20743 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20744 uint64_t ret_ref = (uint64_t)ret_var.inner;
20745 if (ret_var.is_owned) {
20751 void __attribute__((visibility("default"))) TS_RouteHintHop_free(uint32_t this_obj) {
20752 LDKRouteHintHop this_obj_conv;
20753 this_obj_conv.inner = (void*)(this_obj & (~1));
20754 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20755 RouteHintHop_free(this_obj_conv);
20758 int8_tArray __attribute__((visibility("default"))) TS_RouteHintHop_get_src_node_id(uint32_t this_ptr) {
20759 LDKRouteHintHop this_ptr_conv;
20760 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20761 this_ptr_conv.is_owned = false;
20762 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
20763 memcpy((uint8_t*)(ret_arr + 4), RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33);
20767 void __attribute__((visibility("default"))) TS_RouteHintHop_set_src_node_id(uint32_t this_ptr, int8_tArray val) {
20768 LDKRouteHintHop this_ptr_conv;
20769 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20770 this_ptr_conv.is_owned = false;
20771 LDKPublicKey val_ref;
20772 CHECK(*((uint32_t*)val) == 33);
20773 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
20774 RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref);
20777 int64_t __attribute__((visibility("default"))) TS_RouteHintHop_get_short_channel_id(uint32_t this_ptr) {
20778 LDKRouteHintHop this_ptr_conv;
20779 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20780 this_ptr_conv.is_owned = false;
20781 int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv);
20785 void __attribute__((visibility("default"))) TS_RouteHintHop_set_short_channel_id(uint32_t this_ptr, int64_t val) {
20786 LDKRouteHintHop this_ptr_conv;
20787 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20788 this_ptr_conv.is_owned = false;
20789 RouteHintHop_set_short_channel_id(&this_ptr_conv, val);
20792 uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_fees(uint32_t this_ptr) {
20793 LDKRouteHintHop this_ptr_conv;
20794 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20795 this_ptr_conv.is_owned = false;
20796 LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv);
20797 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20798 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20799 uint64_t ret_ref = (uint64_t)ret_var.inner;
20800 if (ret_var.is_owned) {
20806 void __attribute__((visibility("default"))) TS_RouteHintHop_set_fees(uint32_t this_ptr, uint32_t val) {
20807 LDKRouteHintHop this_ptr_conv;
20808 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20809 this_ptr_conv.is_owned = false;
20810 LDKRoutingFees val_conv;
20811 val_conv.inner = (void*)(val & (~1));
20812 val_conv.is_owned = (val & 1) || (val == 0);
20813 val_conv = RoutingFees_clone(&val_conv);
20814 RouteHintHop_set_fees(&this_ptr_conv, val_conv);
20817 int16_t __attribute__((visibility("default"))) TS_RouteHintHop_get_cltv_expiry_delta(uint32_t this_ptr) {
20818 LDKRouteHintHop this_ptr_conv;
20819 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20820 this_ptr_conv.is_owned = false;
20821 int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv);
20825 void __attribute__((visibility("default"))) TS_RouteHintHop_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
20826 LDKRouteHintHop this_ptr_conv;
20827 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20828 this_ptr_conv.is_owned = false;
20829 RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val);
20832 uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_minimum_msat(uint32_t this_ptr) {
20833 LDKRouteHintHop this_ptr_conv;
20834 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20835 this_ptr_conv.is_owned = false;
20836 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
20837 *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv);
20838 uint64_t ret_ref = (uint64_t)ret_copy;
20842 void __attribute__((visibility("default"))) TS_RouteHintHop_set_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) {
20843 LDKRouteHintHop this_ptr_conv;
20844 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20845 this_ptr_conv.is_owned = false;
20846 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
20847 RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv);
20850 uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_maximum_msat(uint32_t this_ptr) {
20851 LDKRouteHintHop this_ptr_conv;
20852 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20853 this_ptr_conv.is_owned = false;
20854 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
20855 *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv);
20856 uint64_t ret_ref = (uint64_t)ret_copy;
20860 void __attribute__((visibility("default"))) TS_RouteHintHop_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) {
20861 LDKRouteHintHop this_ptr_conv;
20862 this_ptr_conv.inner = (void*)(this_ptr & (~1));
20863 this_ptr_conv.is_owned = false;
20864 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
20865 RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
20868 uint32_t __attribute__((visibility("default"))) 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) {
20869 LDKPublicKey src_node_id_arg_ref;
20870 CHECK(*((uint32_t*)src_node_id_arg) == 33);
20871 memcpy(src_node_id_arg_ref.compressed_form, (uint8_t*)(src_node_id_arg + 4), 33);
20872 LDKRoutingFees fees_arg_conv;
20873 fees_arg_conv.inner = (void*)(fees_arg & (~1));
20874 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
20875 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
20876 LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_minimum_msat_arg) & ~1);
20877 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1);
20878 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);
20879 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20880 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20881 uint64_t ret_ref = (uint64_t)ret_var.inner;
20882 if (ret_var.is_owned) {
20888 jboolean __attribute__((visibility("default"))) TS_RouteHintHop_eq(uint32_t a, uint32_t b) {
20889 LDKRouteHintHop a_conv;
20890 a_conv.inner = (void*)(a & (~1));
20891 a_conv.is_owned = false;
20892 LDKRouteHintHop b_conv;
20893 b_conv.inner = (void*)(b & (~1));
20894 b_conv.is_owned = false;
20895 jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv);
20899 uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t orig) {
20900 LDKRouteHintHop orig_conv;
20901 orig_conv.inner = (void*)(orig & (~1));
20902 orig_conv.is_owned = false;
20903 LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv);
20904 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20905 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20906 uint64_t ret_ref = (uint64_t)ret_var.inner;
20907 if (ret_var.is_owned) {
20913 uint32_t __attribute__((visibility("default"))) TS_get_route(int8_tArray our_node_id, uint32_t network, int8_tArray payee, uint32_t payee_features, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger) {
20914 LDKPublicKey our_node_id_ref;
20915 CHECK(*((uint32_t*)our_node_id) == 33);
20916 memcpy(our_node_id_ref.compressed_form, (uint8_t*)(our_node_id + 4), 33);
20917 LDKNetworkGraph network_conv;
20918 network_conv.inner = (void*)(network & (~1));
20919 network_conv.is_owned = false;
20920 LDKPublicKey payee_ref;
20921 CHECK(*((uint32_t*)payee) == 33);
20922 memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33);
20923 LDKInvoiceFeatures payee_features_conv;
20924 payee_features_conv.inner = (void*)(payee_features & (~1));
20925 payee_features_conv.is_owned = (payee_features & 1) || (payee_features == 0);
20926 payee_features_conv = InvoiceFeatures_clone(&payee_features_conv);
20927 LDKCVec_ChannelDetailsZ first_hops_constr;
20928 first_hops_constr.datalen = *((uint32_t*)first_hops);
20929 if (first_hops_constr.datalen > 0)
20930 first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements");
20932 first_hops_constr.data = NULL;
20933 uint32_t* first_hops_vals = (uint32_t*)(first_hops + 4);
20934 for (size_t q = 0; q < first_hops_constr.datalen; q++) {
20935 uint32_t first_hops_conv_16 = first_hops_vals[q];
20936 LDKChannelDetails first_hops_conv_16_conv;
20937 first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1));
20938 first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0);
20939 first_hops_constr.data[q] = first_hops_conv_16_conv;
20941 LDKCVec_RouteHintZ last_hops_constr;
20942 last_hops_constr.datalen = *((uint32_t*)last_hops);
20943 if (last_hops_constr.datalen > 0)
20944 last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
20946 last_hops_constr.data = NULL;
20947 uint32_t* last_hops_vals = (uint32_t*)(last_hops + 4);
20948 for (size_t l = 0; l < last_hops_constr.datalen; l++) {
20949 uint32_t last_hops_conv_11 = last_hops_vals[l];
20950 LDKRouteHint last_hops_conv_11_conv;
20951 last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1));
20952 last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0);
20953 last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv);
20954 last_hops_constr.data[l] = last_hops_conv_11_conv;
20956 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
20957 LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ");
20958 *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, payee_features_conv, &first_hops_constr, last_hops_constr, final_value_msat, final_cltv, logger_conv);
20959 FREE(first_hops_constr.data);
20960 return (uint64_t)ret_conv;
20963 void __attribute__((visibility("default"))) TS_NetworkGraph_free(uint32_t this_obj) {
20964 LDKNetworkGraph this_obj_conv;
20965 this_obj_conv.inner = (void*)(this_obj & (~1));
20966 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20967 NetworkGraph_free(this_obj_conv);
20970 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_clone(uint32_t orig) {
20971 LDKNetworkGraph orig_conv;
20972 orig_conv.inner = (void*)(orig & (~1));
20973 orig_conv.is_owned = false;
20974 LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv);
20975 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
20976 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
20977 uint64_t ret_ref = (uint64_t)ret_var.inner;
20978 if (ret_var.is_owned) {
20984 void __attribute__((visibility("default"))) TS_LockedNetworkGraph_free(uint32_t this_obj) {
20985 LDKLockedNetworkGraph this_obj_conv;
20986 this_obj_conv.inner = (void*)(this_obj & (~1));
20987 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20988 LockedNetworkGraph_free(this_obj_conv);
20991 void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_free(uint32_t this_obj) {
20992 LDKNetGraphMsgHandler this_obj_conv;
20993 this_obj_conv.inner = (void*)(this_obj & (~1));
20994 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
20995 NetGraphMsgHandler_free(this_obj_conv);
20998 uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_new(int8_tArray genesis_hash, uint32_t chain_access, uint32_t logger) {
20999 LDKThirtyTwoBytes genesis_hash_ref;
21000 CHECK(*((uint32_t*)genesis_hash) == 32);
21001 memcpy(genesis_hash_ref.data, (uint8_t*)(genesis_hash + 4), 32);
21002 LDKAccess *chain_access_conv_ptr = NULL;
21003 if (chain_access != 0) {
21004 LDKAccess chain_access_conv;
21005 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
21006 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
21007 *chain_access_conv_ptr = chain_access_conv;
21009 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
21010 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_new(genesis_hash_ref, chain_access_conv_ptr, logger_conv);
21011 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21012 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21013 uint64_t ret_ref = (uint64_t)ret_var.inner;
21014 if (ret_var.is_owned) {
21020 uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_from_net_graph(uint32_t chain_access, uint32_t logger, uint32_t network_graph) {
21021 LDKAccess *chain_access_conv_ptr = NULL;
21022 if (chain_access != 0) {
21023 LDKAccess chain_access_conv;
21024 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
21025 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
21026 *chain_access_conv_ptr = chain_access_conv;
21028 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
21029 LDKNetworkGraph network_graph_conv;
21030 network_graph_conv.inner = (void*)(network_graph & (~1));
21031 network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0);
21032 network_graph_conv = NetworkGraph_clone(&network_graph_conv);
21033 LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_from_net_graph(chain_access_conv_ptr, logger_conv, network_graph_conv);
21034 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21035 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21036 uint64_t ret_ref = (uint64_t)ret_var.inner;
21037 if (ret_var.is_owned) {
21043 void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_add_chain_access(uint32_t this_arg, uint32_t chain_access) {
21044 LDKNetGraphMsgHandler this_arg_conv;
21045 this_arg_conv.inner = (void*)(this_arg & (~1));
21046 this_arg_conv.is_owned = false;
21047 LDKAccess *chain_access_conv_ptr = NULL;
21048 if (chain_access != 0) {
21049 LDKAccess chain_access_conv;
21050 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
21051 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
21052 *chain_access_conv_ptr = chain_access_conv;
21054 NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv_ptr);
21057 uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_read_locked_graph(uint32_t this_arg) {
21058 LDKNetGraphMsgHandler this_arg_conv;
21059 this_arg_conv.inner = (void*)(this_arg & (~1));
21060 this_arg_conv.is_owned = false;
21061 LDKLockedNetworkGraph ret_var = NetGraphMsgHandler_read_locked_graph(&this_arg_conv);
21062 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21063 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21064 uint64_t ret_ref = (uint64_t)ret_var.inner;
21065 if (ret_var.is_owned) {
21071 uint32_t __attribute__((visibility("default"))) TS_LockedNetworkGraph_graph(uint32_t this_arg) {
21072 LDKLockedNetworkGraph this_arg_conv;
21073 this_arg_conv.inner = (void*)(this_arg & (~1));
21074 this_arg_conv.is_owned = false;
21075 LDKNetworkGraph ret_var = LockedNetworkGraph_graph(&this_arg_conv);
21076 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21077 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21078 uint64_t ret_ref = (uint64_t)ret_var.inner;
21079 if (ret_var.is_owned) {
21085 uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_RoutingMessageHandler(uint32_t this_arg) {
21086 LDKNetGraphMsgHandler this_arg_conv;
21087 this_arg_conv.inner = (void*)(this_arg & (~1));
21088 this_arg_conv.is_owned = false;
21089 LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler");
21090 *ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv);
21091 return (uint64_t)ret;
21094 uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_MessageSendEventsProvider(uint32_t this_arg) {
21095 LDKNetGraphMsgHandler this_arg_conv;
21096 this_arg_conv.inner = (void*)(this_arg & (~1));
21097 this_arg_conv.is_owned = false;
21098 LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider");
21099 *ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv);
21100 return (uint64_t)ret;
21103 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_free(uint32_t this_obj) {
21104 LDKDirectionalChannelInfo this_obj_conv;
21105 this_obj_conv.inner = (void*)(this_obj & (~1));
21106 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21107 DirectionalChannelInfo_free(this_obj_conv);
21110 int32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update(uint32_t this_ptr) {
21111 LDKDirectionalChannelInfo this_ptr_conv;
21112 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21113 this_ptr_conv.is_owned = false;
21114 int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv);
21118 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_last_update(uint32_t this_ptr, int32_t val) {
21119 LDKDirectionalChannelInfo this_ptr_conv;
21120 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21121 this_ptr_conv.is_owned = false;
21122 DirectionalChannelInfo_set_last_update(&this_ptr_conv, val);
21125 jboolean __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_enabled(uint32_t this_ptr) {
21126 LDKDirectionalChannelInfo this_ptr_conv;
21127 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21128 this_ptr_conv.is_owned = false;
21129 jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv);
21133 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_enabled(uint32_t this_ptr, jboolean val) {
21134 LDKDirectionalChannelInfo this_ptr_conv;
21135 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21136 this_ptr_conv.is_owned = false;
21137 DirectionalChannelInfo_set_enabled(&this_ptr_conv, val);
21140 int16_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_cltv_expiry_delta(uint32_t this_ptr) {
21141 LDKDirectionalChannelInfo this_ptr_conv;
21142 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21143 this_ptr_conv.is_owned = false;
21144 int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv);
21148 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) {
21149 LDKDirectionalChannelInfo this_ptr_conv;
21150 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21151 this_ptr_conv.is_owned = false;
21152 DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val);
21155 int64_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_minimum_msat(uint32_t this_ptr) {
21156 LDKDirectionalChannelInfo this_ptr_conv;
21157 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21158 this_ptr_conv.is_owned = false;
21159 int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv);
21163 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) {
21164 LDKDirectionalChannelInfo this_ptr_conv;
21165 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21166 this_ptr_conv.is_owned = false;
21167 DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val);
21170 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_maximum_msat(uint32_t this_ptr) {
21171 LDKDirectionalChannelInfo this_ptr_conv;
21172 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21173 this_ptr_conv.is_owned = false;
21174 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
21175 *ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv);
21176 uint64_t ret_ref = (uint64_t)ret_copy;
21180 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) {
21181 LDKDirectionalChannelInfo this_ptr_conv;
21182 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21183 this_ptr_conv.is_owned = false;
21184 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
21185 DirectionalChannelInfo_set_htlc_maximum_msat(&this_ptr_conv, val_conv);
21188 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_fees(uint32_t this_ptr) {
21189 LDKDirectionalChannelInfo this_ptr_conv;
21190 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21191 this_ptr_conv.is_owned = false;
21192 LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_conv);
21193 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21194 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21195 uint64_t ret_ref = (uint64_t)ret_var.inner;
21196 if (ret_var.is_owned) {
21202 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_fees(uint32_t this_ptr, uint32_t val) {
21203 LDKDirectionalChannelInfo this_ptr_conv;
21204 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21205 this_ptr_conv.is_owned = false;
21206 LDKRoutingFees val_conv;
21207 val_conv.inner = (void*)(val & (~1));
21208 val_conv.is_owned = (val & 1) || (val == 0);
21209 val_conv = RoutingFees_clone(&val_conv);
21210 DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv);
21213 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update_message(uint32_t this_ptr) {
21214 LDKDirectionalChannelInfo this_ptr_conv;
21215 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21216 this_ptr_conv.is_owned = false;
21217 LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv);
21218 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21219 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21220 uint64_t ret_ref = (uint64_t)ret_var.inner;
21221 if (ret_var.is_owned) {
21227 void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_last_update_message(uint32_t this_ptr, uint32_t val) {
21228 LDKDirectionalChannelInfo this_ptr_conv;
21229 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21230 this_ptr_conv.is_owned = false;
21231 LDKChannelUpdate val_conv;
21232 val_conv.inner = (void*)(val & (~1));
21233 val_conv.is_owned = (val & 1) || (val == 0);
21234 val_conv = ChannelUpdate_clone(&val_conv);
21235 DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv);
21238 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_new(int32_t last_update_arg, jboolean enabled_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg, uint32_t fees_arg, uint32_t last_update_message_arg) {
21239 LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1);
21240 LDKRoutingFees fees_arg_conv;
21241 fees_arg_conv.inner = (void*)(fees_arg & (~1));
21242 fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0);
21243 fees_arg_conv = RoutingFees_clone(&fees_arg_conv);
21244 LDKChannelUpdate last_update_message_arg_conv;
21245 last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1));
21246 last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0);
21247 last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv);
21248 LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv);
21249 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21250 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21251 uint64_t ret_ref = (uint64_t)ret_var.inner;
21252 if (ret_var.is_owned) {
21258 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone(uint32_t orig) {
21259 LDKDirectionalChannelInfo orig_conv;
21260 orig_conv.inner = (void*)(orig & (~1));
21261 orig_conv.is_owned = false;
21262 LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv);
21263 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21264 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21265 uint64_t ret_ref = (uint64_t)ret_var.inner;
21266 if (ret_var.is_owned) {
21272 int8_tArray __attribute__((visibility("default"))) TS_DirectionalChannelInfo_write(uint32_t obj) {
21273 LDKDirectionalChannelInfo obj_conv;
21274 obj_conv.inner = (void*)(obj & (~1));
21275 obj_conv.is_owned = false;
21276 LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv);
21277 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21278 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21279 CVec_u8Z_free(ret_var);
21283 uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_read(int8_tArray ser) {
21284 LDKu8slice ser_ref;
21285 ser_ref.datalen = *((uint32_t*)ser);
21286 ser_ref.data = (int8_t*)(ser + 4);
21287 LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ");
21288 *ret_conv = DirectionalChannelInfo_read(ser_ref);
21289 return (uint64_t)ret_conv;
21292 void __attribute__((visibility("default"))) TS_ChannelInfo_free(uint32_t this_obj) {
21293 LDKChannelInfo this_obj_conv;
21294 this_obj_conv.inner = (void*)(this_obj & (~1));
21295 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21296 ChannelInfo_free(this_obj_conv);
21299 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_features(uint32_t this_ptr) {
21300 LDKChannelInfo this_ptr_conv;
21301 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21302 this_ptr_conv.is_owned = false;
21303 LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv);
21304 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21305 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21306 uint64_t ret_ref = (uint64_t)ret_var.inner;
21307 if (ret_var.is_owned) {
21313 void __attribute__((visibility("default"))) TS_ChannelInfo_set_features(uint32_t this_ptr, uint32_t val) {
21314 LDKChannelInfo this_ptr_conv;
21315 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21316 this_ptr_conv.is_owned = false;
21317 LDKChannelFeatures val_conv;
21318 val_conv.inner = (void*)(val & (~1));
21319 val_conv.is_owned = (val & 1) || (val == 0);
21320 val_conv = ChannelFeatures_clone(&val_conv);
21321 ChannelInfo_set_features(&this_ptr_conv, val_conv);
21324 int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_get_node_one(uint32_t this_ptr) {
21325 LDKChannelInfo this_ptr_conv;
21326 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21327 this_ptr_conv.is_owned = false;
21328 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
21329 memcpy((uint8_t*)(ret_arr + 4), ChannelInfo_get_node_one(&this_ptr_conv).compressed_form, 33);
21333 void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_one(uint32_t this_ptr, int8_tArray val) {
21334 LDKChannelInfo this_ptr_conv;
21335 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21336 this_ptr_conv.is_owned = false;
21337 LDKPublicKey val_ref;
21338 CHECK(*((uint32_t*)val) == 33);
21339 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
21340 ChannelInfo_set_node_one(&this_ptr_conv, val_ref);
21343 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_one_to_two(uint32_t this_ptr) {
21344 LDKChannelInfo this_ptr_conv;
21345 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21346 this_ptr_conv.is_owned = false;
21347 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_conv);
21348 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21349 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21350 uint64_t ret_ref = (uint64_t)ret_var.inner;
21351 if (ret_var.is_owned) {
21357 void __attribute__((visibility("default"))) TS_ChannelInfo_set_one_to_two(uint32_t this_ptr, uint32_t val) {
21358 LDKChannelInfo this_ptr_conv;
21359 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21360 this_ptr_conv.is_owned = false;
21361 LDKDirectionalChannelInfo val_conv;
21362 val_conv.inner = (void*)(val & (~1));
21363 val_conv.is_owned = (val & 1) || (val == 0);
21364 val_conv = DirectionalChannelInfo_clone(&val_conv);
21365 ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv);
21368 int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_get_node_two(uint32_t this_ptr) {
21369 LDKChannelInfo this_ptr_conv;
21370 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21371 this_ptr_conv.is_owned = false;
21372 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
21373 memcpy((uint8_t*)(ret_arr + 4), ChannelInfo_get_node_two(&this_ptr_conv).compressed_form, 33);
21377 void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_two(uint32_t this_ptr, int8_tArray val) {
21378 LDKChannelInfo this_ptr_conv;
21379 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21380 this_ptr_conv.is_owned = false;
21381 LDKPublicKey val_ref;
21382 CHECK(*((uint32_t*)val) == 33);
21383 memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
21384 ChannelInfo_set_node_two(&this_ptr_conv, val_ref);
21387 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_two_to_one(uint32_t this_ptr) {
21388 LDKChannelInfo this_ptr_conv;
21389 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21390 this_ptr_conv.is_owned = false;
21391 LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_conv);
21392 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21393 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21394 uint64_t ret_ref = (uint64_t)ret_var.inner;
21395 if (ret_var.is_owned) {
21401 void __attribute__((visibility("default"))) TS_ChannelInfo_set_two_to_one(uint32_t this_ptr, uint32_t val) {
21402 LDKChannelInfo this_ptr_conv;
21403 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21404 this_ptr_conv.is_owned = false;
21405 LDKDirectionalChannelInfo val_conv;
21406 val_conv.inner = (void*)(val & (~1));
21407 val_conv.is_owned = (val & 1) || (val == 0);
21408 val_conv = DirectionalChannelInfo_clone(&val_conv);
21409 ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv);
21412 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_capacity_sats(uint32_t this_ptr) {
21413 LDKChannelInfo this_ptr_conv;
21414 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21415 this_ptr_conv.is_owned = false;
21416 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
21417 *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv);
21418 uint64_t ret_ref = (uint64_t)ret_copy;
21422 void __attribute__((visibility("default"))) TS_ChannelInfo_set_capacity_sats(uint32_t this_ptr, uint32_t val) {
21423 LDKChannelInfo this_ptr_conv;
21424 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21425 this_ptr_conv.is_owned = false;
21426 LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1);
21427 ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv);
21430 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_announcement_message(uint32_t this_ptr) {
21431 LDKChannelInfo this_ptr_conv;
21432 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21433 this_ptr_conv.is_owned = false;
21434 LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv);
21435 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21436 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21437 uint64_t ret_ref = (uint64_t)ret_var.inner;
21438 if (ret_var.is_owned) {
21444 void __attribute__((visibility("default"))) TS_ChannelInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) {
21445 LDKChannelInfo this_ptr_conv;
21446 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21447 this_ptr_conv.is_owned = false;
21448 LDKChannelAnnouncement val_conv;
21449 val_conv.inner = (void*)(val & (~1));
21450 val_conv.is_owned = (val & 1) || (val == 0);
21451 val_conv = ChannelAnnouncement_clone(&val_conv);
21452 ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv);
21455 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_new(uint32_t features_arg, int8_tArray node_one_arg, uint32_t one_to_two_arg, int8_tArray node_two_arg, uint32_t two_to_one_arg, uint32_t capacity_sats_arg, uint32_t announcement_message_arg) {
21456 LDKChannelFeatures features_arg_conv;
21457 features_arg_conv.inner = (void*)(features_arg & (~1));
21458 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
21459 features_arg_conv = ChannelFeatures_clone(&features_arg_conv);
21460 LDKPublicKey node_one_arg_ref;
21461 CHECK(*((uint32_t*)node_one_arg) == 33);
21462 memcpy(node_one_arg_ref.compressed_form, (uint8_t*)(node_one_arg + 4), 33);
21463 LDKDirectionalChannelInfo one_to_two_arg_conv;
21464 one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1));
21465 one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0);
21466 one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv);
21467 LDKPublicKey node_two_arg_ref;
21468 CHECK(*((uint32_t*)node_two_arg) == 33);
21469 memcpy(node_two_arg_ref.compressed_form, (uint8_t*)(node_two_arg + 4), 33);
21470 LDKDirectionalChannelInfo two_to_one_arg_conv;
21471 two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1));
21472 two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0);
21473 two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv);
21474 LDKCOption_u64Z capacity_sats_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)capacity_sats_arg) & ~1);
21475 LDKChannelAnnouncement announcement_message_arg_conv;
21476 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
21477 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
21478 announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv);
21479 LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_ref, one_to_two_arg_conv, node_two_arg_ref, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv);
21480 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21481 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21482 uint64_t ret_ref = (uint64_t)ret_var.inner;
21483 if (ret_var.is_owned) {
21489 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t orig) {
21490 LDKChannelInfo orig_conv;
21491 orig_conv.inner = (void*)(orig & (~1));
21492 orig_conv.is_owned = false;
21493 LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv);
21494 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21495 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21496 uint64_t ret_ref = (uint64_t)ret_var.inner;
21497 if (ret_var.is_owned) {
21503 int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_write(uint32_t obj) {
21504 LDKChannelInfo obj_conv;
21505 obj_conv.inner = (void*)(obj & (~1));
21506 obj_conv.is_owned = false;
21507 LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv);
21508 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21509 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21510 CVec_u8Z_free(ret_var);
21514 uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_read(int8_tArray ser) {
21515 LDKu8slice ser_ref;
21516 ser_ref.datalen = *((uint32_t*)ser);
21517 ser_ref.data = (int8_t*)(ser + 4);
21518 LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ");
21519 *ret_conv = ChannelInfo_read(ser_ref);
21520 return (uint64_t)ret_conv;
21523 void __attribute__((visibility("default"))) TS_RoutingFees_free(uint32_t this_obj) {
21524 LDKRoutingFees this_obj_conv;
21525 this_obj_conv.inner = (void*)(this_obj & (~1));
21526 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21527 RoutingFees_free(this_obj_conv);
21530 int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_base_msat(uint32_t this_ptr) {
21531 LDKRoutingFees this_ptr_conv;
21532 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21533 this_ptr_conv.is_owned = false;
21534 int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv);
21538 void __attribute__((visibility("default"))) TS_RoutingFees_set_base_msat(uint32_t this_ptr, int32_t val) {
21539 LDKRoutingFees this_ptr_conv;
21540 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21541 this_ptr_conv.is_owned = false;
21542 RoutingFees_set_base_msat(&this_ptr_conv, val);
21545 int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_proportional_millionths(uint32_t this_ptr) {
21546 LDKRoutingFees this_ptr_conv;
21547 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21548 this_ptr_conv.is_owned = false;
21549 int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv);
21553 void __attribute__((visibility("default"))) TS_RoutingFees_set_proportional_millionths(uint32_t this_ptr, int32_t val) {
21554 LDKRoutingFees this_ptr_conv;
21555 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21556 this_ptr_conv.is_owned = false;
21557 RoutingFees_set_proportional_millionths(&this_ptr_conv, val);
21560 uint32_t __attribute__((visibility("default"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) {
21561 LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg);
21562 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21563 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21564 uint64_t ret_ref = (uint64_t)ret_var.inner;
21565 if (ret_var.is_owned) {
21571 jboolean __attribute__((visibility("default"))) TS_RoutingFees_eq(uint32_t a, uint32_t b) {
21572 LDKRoutingFees a_conv;
21573 a_conv.inner = (void*)(a & (~1));
21574 a_conv.is_owned = false;
21575 LDKRoutingFees b_conv;
21576 b_conv.inner = (void*)(b & (~1));
21577 b_conv.is_owned = false;
21578 jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv);
21582 uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t orig) {
21583 LDKRoutingFees orig_conv;
21584 orig_conv.inner = (void*)(orig & (~1));
21585 orig_conv.is_owned = false;
21586 LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv);
21587 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21588 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21589 uint64_t ret_ref = (uint64_t)ret_var.inner;
21590 if (ret_var.is_owned) {
21596 int8_tArray __attribute__((visibility("default"))) TS_RoutingFees_write(uint32_t obj) {
21597 LDKRoutingFees obj_conv;
21598 obj_conv.inner = (void*)(obj & (~1));
21599 obj_conv.is_owned = false;
21600 LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv);
21601 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21602 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21603 CVec_u8Z_free(ret_var);
21607 uint32_t __attribute__((visibility("default"))) TS_RoutingFees_read(int8_tArray ser) {
21608 LDKu8slice ser_ref;
21609 ser_ref.datalen = *((uint32_t*)ser);
21610 ser_ref.data = (int8_t*)(ser + 4);
21611 LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ");
21612 *ret_conv = RoutingFees_read(ser_ref);
21613 return (uint64_t)ret_conv;
21616 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_free(uint32_t this_obj) {
21617 LDKNodeAnnouncementInfo this_obj_conv;
21618 this_obj_conv.inner = (void*)(this_obj & (~1));
21619 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21620 NodeAnnouncementInfo_free(this_obj_conv);
21623 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_features(uint32_t this_ptr) {
21624 LDKNodeAnnouncementInfo this_ptr_conv;
21625 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21626 this_ptr_conv.is_owned = false;
21627 LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_conv);
21628 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21629 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21630 uint64_t ret_ref = (uint64_t)ret_var.inner;
21631 if (ret_var.is_owned) {
21637 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_features(uint32_t this_ptr, uint32_t val) {
21638 LDKNodeAnnouncementInfo this_ptr_conv;
21639 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21640 this_ptr_conv.is_owned = false;
21641 LDKNodeFeatures val_conv;
21642 val_conv.inner = (void*)(val & (~1));
21643 val_conv.is_owned = (val & 1) || (val == 0);
21644 val_conv = NodeFeatures_clone(&val_conv);
21645 NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv);
21648 int32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_last_update(uint32_t this_ptr) {
21649 LDKNodeAnnouncementInfo this_ptr_conv;
21650 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21651 this_ptr_conv.is_owned = false;
21652 int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv);
21656 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_last_update(uint32_t this_ptr, int32_t val) {
21657 LDKNodeAnnouncementInfo this_ptr_conv;
21658 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21659 this_ptr_conv.is_owned = false;
21660 NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val);
21663 int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_rgb(uint32_t this_ptr) {
21664 LDKNodeAnnouncementInfo this_ptr_conv;
21665 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21666 this_ptr_conv.is_owned = false;
21667 int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes");
21668 memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3);
21672 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_rgb(uint32_t this_ptr, int8_tArray val) {
21673 LDKNodeAnnouncementInfo this_ptr_conv;
21674 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21675 this_ptr_conv.is_owned = false;
21676 LDKThreeBytes val_ref;
21677 CHECK(*((uint32_t*)val) == 3);
21678 memcpy(val_ref.data, (uint8_t*)(val + 4), 3);
21679 NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref);
21682 int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_alias(uint32_t this_ptr) {
21683 LDKNodeAnnouncementInfo this_ptr_conv;
21684 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21685 this_ptr_conv.is_owned = false;
21686 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
21687 memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_alias(&this_ptr_conv), 32);
21691 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_alias(uint32_t this_ptr, int8_tArray val) {
21692 LDKNodeAnnouncementInfo this_ptr_conv;
21693 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21694 this_ptr_conv.is_owned = false;
21695 LDKThirtyTwoBytes val_ref;
21696 CHECK(*((uint32_t*)val) == 32);
21697 memcpy(val_ref.data, (uint8_t*)(val + 4), 32);
21698 NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_ref);
21701 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_addresses(uint32_t this_ptr, uint32_tArray val) {
21702 LDKNodeAnnouncementInfo this_ptr_conv;
21703 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21704 this_ptr_conv.is_owned = false;
21705 LDKCVec_NetAddressZ val_constr;
21706 val_constr.datalen = *((uint32_t*)val);
21707 if (val_constr.datalen > 0)
21708 val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
21710 val_constr.data = NULL;
21711 uint32_t* val_vals = (uint32_t*)(val + 4);
21712 for (size_t m = 0; m < val_constr.datalen; m++) {
21713 uint32_t val_conv_12 = val_vals[m];
21714 LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1);
21715 val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1));
21716 val_constr.data[m] = val_conv_12_conv;
21718 NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr);
21721 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_announcement_message(uint32_t this_ptr) {
21722 LDKNodeAnnouncementInfo this_ptr_conv;
21723 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21724 this_ptr_conv.is_owned = false;
21725 LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_conv);
21726 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21727 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21728 uint64_t ret_ref = (uint64_t)ret_var.inner;
21729 if (ret_var.is_owned) {
21735 void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) {
21736 LDKNodeAnnouncementInfo this_ptr_conv;
21737 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21738 this_ptr_conv.is_owned = false;
21739 LDKNodeAnnouncement val_conv;
21740 val_conv.inner = (void*)(val & (~1));
21741 val_conv.is_owned = (val & 1) || (val == 0);
21742 val_conv = NodeAnnouncement_clone(&val_conv);
21743 NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv);
21746 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_new(uint32_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, int8_tArray alias_arg, uint32_tArray addresses_arg, uint32_t announcement_message_arg) {
21747 LDKNodeFeatures features_arg_conv;
21748 features_arg_conv.inner = (void*)(features_arg & (~1));
21749 features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
21750 features_arg_conv = NodeFeatures_clone(&features_arg_conv);
21751 LDKThreeBytes rgb_arg_ref;
21752 CHECK(*((uint32_t*)rgb_arg) == 3);
21753 memcpy(rgb_arg_ref.data, (uint8_t*)(rgb_arg + 4), 3);
21754 LDKThirtyTwoBytes alias_arg_ref;
21755 CHECK(*((uint32_t*)alias_arg) == 32);
21756 memcpy(alias_arg_ref.data, (uint8_t*)(alias_arg + 4), 32);
21757 LDKCVec_NetAddressZ addresses_arg_constr;
21758 addresses_arg_constr.datalen = *((uint32_t*)addresses_arg);
21759 if (addresses_arg_constr.datalen > 0)
21760 addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements");
21762 addresses_arg_constr.data = NULL;
21763 uint32_t* addresses_arg_vals = (uint32_t*)(addresses_arg + 4);
21764 for (size_t m = 0; m < addresses_arg_constr.datalen; m++) {
21765 uint32_t addresses_arg_conv_12 = addresses_arg_vals[m];
21766 LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_arg_conv_12) & ~1);
21767 addresses_arg_constr.data[m] = addresses_arg_conv_12_conv;
21769 LDKNodeAnnouncement announcement_message_arg_conv;
21770 announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1));
21771 announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0);
21772 announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv);
21773 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv);
21774 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21775 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21776 uint64_t ret_ref = (uint64_t)ret_var.inner;
21777 if (ret_var.is_owned) {
21783 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) {
21784 LDKNodeAnnouncementInfo orig_conv;
21785 orig_conv.inner = (void*)(orig & (~1));
21786 orig_conv.is_owned = false;
21787 LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv);
21788 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21789 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21790 uint64_t ret_ref = (uint64_t)ret_var.inner;
21791 if (ret_var.is_owned) {
21797 int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_write(uint32_t obj) {
21798 LDKNodeAnnouncementInfo obj_conv;
21799 obj_conv.inner = (void*)(obj & (~1));
21800 obj_conv.is_owned = false;
21801 LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv);
21802 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21803 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21804 CVec_u8Z_free(ret_var);
21808 uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) {
21809 LDKu8slice ser_ref;
21810 ser_ref.datalen = *((uint32_t*)ser);
21811 ser_ref.data = (int8_t*)(ser + 4);
21812 LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ");
21813 *ret_conv = NodeAnnouncementInfo_read(ser_ref);
21814 return (uint64_t)ret_conv;
21817 void __attribute__((visibility("default"))) TS_NodeInfo_free(uint32_t this_obj) {
21818 LDKNodeInfo this_obj_conv;
21819 this_obj_conv.inner = (void*)(this_obj & (~1));
21820 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
21821 NodeInfo_free(this_obj_conv);
21824 void __attribute__((visibility("default"))) TS_NodeInfo_set_channels(uint32_t this_ptr, int64_tArray val) {
21825 LDKNodeInfo this_ptr_conv;
21826 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21827 this_ptr_conv.is_owned = false;
21828 LDKCVec_u64Z val_constr;
21829 val_constr.datalen = *((uint32_t*)val);
21830 if (val_constr.datalen > 0)
21831 val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
21833 val_constr.data = NULL;
21834 int64_t* val_vals = (int64_t*)(val + 4);
21835 for (size_t i = 0; i < val_constr.datalen; i++) {
21836 int64_t val_conv_8 = val_vals[i];
21837 val_constr.data[i] = val_conv_8;
21839 NodeInfo_set_channels(&this_ptr_conv, val_constr);
21842 uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_lowest_inbound_channel_fees(uint32_t this_ptr) {
21843 LDKNodeInfo this_ptr_conv;
21844 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21845 this_ptr_conv.is_owned = false;
21846 LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv);
21847 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21848 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21849 uint64_t ret_ref = (uint64_t)ret_var.inner;
21850 if (ret_var.is_owned) {
21856 void __attribute__((visibility("default"))) TS_NodeInfo_set_lowest_inbound_channel_fees(uint32_t this_ptr, uint32_t val) {
21857 LDKNodeInfo this_ptr_conv;
21858 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21859 this_ptr_conv.is_owned = false;
21860 LDKRoutingFees val_conv;
21861 val_conv.inner = (void*)(val & (~1));
21862 val_conv.is_owned = (val & 1) || (val == 0);
21863 val_conv = RoutingFees_clone(&val_conv);
21864 NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv);
21867 uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_announcement_info(uint32_t this_ptr) {
21868 LDKNodeInfo this_ptr_conv;
21869 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21870 this_ptr_conv.is_owned = false;
21871 LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_conv);
21872 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21873 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21874 uint64_t ret_ref = (uint64_t)ret_var.inner;
21875 if (ret_var.is_owned) {
21881 void __attribute__((visibility("default"))) TS_NodeInfo_set_announcement_info(uint32_t this_ptr, uint32_t val) {
21882 LDKNodeInfo this_ptr_conv;
21883 this_ptr_conv.inner = (void*)(this_ptr & (~1));
21884 this_ptr_conv.is_owned = false;
21885 LDKNodeAnnouncementInfo val_conv;
21886 val_conv.inner = (void*)(val & (~1));
21887 val_conv.is_owned = (val & 1) || (val == 0);
21888 val_conv = NodeAnnouncementInfo_clone(&val_conv);
21889 NodeInfo_set_announcement_info(&this_ptr_conv, val_conv);
21892 uint32_t __attribute__((visibility("default"))) TS_NodeInfo_new(int64_tArray channels_arg, uint32_t lowest_inbound_channel_fees_arg, uint32_t announcement_info_arg) {
21893 LDKCVec_u64Z channels_arg_constr;
21894 channels_arg_constr.datalen = *((uint32_t*)channels_arg);
21895 if (channels_arg_constr.datalen > 0)
21896 channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements");
21898 channels_arg_constr.data = NULL;
21899 int64_t* channels_arg_vals = (int64_t*)(channels_arg + 4);
21900 for (size_t i = 0; i < channels_arg_constr.datalen; i++) {
21901 int64_t channels_arg_conv_8 = channels_arg_vals[i];
21902 channels_arg_constr.data[i] = channels_arg_conv_8;
21904 LDKRoutingFees lowest_inbound_channel_fees_arg_conv;
21905 lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1));
21906 lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0);
21907 lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv);
21908 LDKNodeAnnouncementInfo announcement_info_arg_conv;
21909 announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1));
21910 announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0);
21911 announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv);
21912 LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv);
21913 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21914 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21915 uint64_t ret_ref = (uint64_t)ret_var.inner;
21916 if (ret_var.is_owned) {
21922 uint32_t __attribute__((visibility("default"))) TS_NodeInfo_clone(uint32_t orig) {
21923 LDKNodeInfo orig_conv;
21924 orig_conv.inner = (void*)(orig & (~1));
21925 orig_conv.is_owned = false;
21926 LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv);
21927 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21928 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21929 uint64_t ret_ref = (uint64_t)ret_var.inner;
21930 if (ret_var.is_owned) {
21936 int8_tArray __attribute__((visibility("default"))) TS_NodeInfo_write(uint32_t obj) {
21937 LDKNodeInfo obj_conv;
21938 obj_conv.inner = (void*)(obj & (~1));
21939 obj_conv.is_owned = false;
21940 LDKCVec_u8Z ret_var = NodeInfo_write(&obj_conv);
21941 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21942 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21943 CVec_u8Z_free(ret_var);
21947 uint32_t __attribute__((visibility("default"))) TS_NodeInfo_read(int8_tArray ser) {
21948 LDKu8slice ser_ref;
21949 ser_ref.datalen = *((uint32_t*)ser);
21950 ser_ref.data = (int8_t*)(ser + 4);
21951 LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ");
21952 *ret_conv = NodeInfo_read(ser_ref);
21953 return (uint64_t)ret_conv;
21956 int8_tArray __attribute__((visibility("default"))) TS_NetworkGraph_write(uint32_t obj) {
21957 LDKNetworkGraph obj_conv;
21958 obj_conv.inner = (void*)(obj & (~1));
21959 obj_conv.is_owned = false;
21960 LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_conv);
21961 int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes");
21962 memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen);
21963 CVec_u8Z_free(ret_var);
21967 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_read(int8_tArray ser) {
21968 LDKu8slice ser_ref;
21969 ser_ref.datalen = *((uint32_t*)ser);
21970 ser_ref.data = (int8_t*)(ser + 4);
21971 LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ");
21972 *ret_conv = NetworkGraph_read(ser_ref);
21973 return (uint64_t)ret_conv;
21976 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_new(int8_tArray genesis_hash) {
21977 LDKThirtyTwoBytes genesis_hash_ref;
21978 CHECK(*((uint32_t*)genesis_hash) == 32);
21979 memcpy(genesis_hash_ref.data, (uint8_t*)(genesis_hash + 4), 32);
21980 LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref);
21981 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
21982 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
21983 uint64_t ret_ref = (uint64_t)ret_var.inner;
21984 if (ret_var.is_owned) {
21990 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_node_from_announcement(uint32_t this_arg, uint32_t msg) {
21991 LDKNetworkGraph this_arg_conv;
21992 this_arg_conv.inner = (void*)(this_arg & (~1));
21993 this_arg_conv.is_owned = false;
21994 LDKNodeAnnouncement msg_conv;
21995 msg_conv.inner = (void*)(msg & (~1));
21996 msg_conv.is_owned = false;
21997 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
21998 *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv);
21999 return (uint64_t)ret_conv;
22002 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_node_from_unsigned_announcement(uint32_t this_arg, uint32_t msg) {
22003 LDKNetworkGraph this_arg_conv;
22004 this_arg_conv.inner = (void*)(this_arg & (~1));
22005 this_arg_conv.is_owned = false;
22006 LDKUnsignedNodeAnnouncement msg_conv;
22007 msg_conv.inner = (void*)(msg & (~1));
22008 msg_conv.is_owned = false;
22009 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
22010 *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv);
22011 return (uint64_t)ret_conv;
22014 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) {
22015 LDKNetworkGraph this_arg_conv;
22016 this_arg_conv.inner = (void*)(this_arg & (~1));
22017 this_arg_conv.is_owned = false;
22018 LDKChannelAnnouncement msg_conv;
22019 msg_conv.inner = (void*)(msg & (~1));
22020 msg_conv.is_owned = false;
22021 LDKAccess *chain_access_conv_ptr = NULL;
22022 if (chain_access != 0) {
22023 LDKAccess chain_access_conv;
22024 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
22025 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
22026 *chain_access_conv_ptr = chain_access_conv;
22028 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
22029 *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
22030 return (uint64_t)ret_conv;
22033 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_unsigned_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) {
22034 LDKNetworkGraph this_arg_conv;
22035 this_arg_conv.inner = (void*)(this_arg & (~1));
22036 this_arg_conv.is_owned = false;
22037 LDKUnsignedChannelAnnouncement msg_conv;
22038 msg_conv.inner = (void*)(msg & (~1));
22039 msg_conv.is_owned = false;
22040 LDKAccess *chain_access_conv_ptr = NULL;
22041 if (chain_access != 0) {
22042 LDKAccess chain_access_conv;
22043 chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1);
22044 chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess");
22045 *chain_access_conv_ptr = chain_access_conv;
22047 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
22048 *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr);
22049 return (uint64_t)ret_conv;
22052 void __attribute__((visibility("default"))) TS_NetworkGraph_close_channel_from_update(uint32_t this_arg, int64_t short_channel_id, jboolean is_permanent) {
22053 LDKNetworkGraph this_arg_conv;
22054 this_arg_conv.inner = (void*)(this_arg & (~1));
22055 this_arg_conv.is_owned = false;
22056 NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent);
22059 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel(uint32_t this_arg, uint32_t msg) {
22060 LDKNetworkGraph this_arg_conv;
22061 this_arg_conv.inner = (void*)(this_arg & (~1));
22062 this_arg_conv.is_owned = false;
22063 LDKChannelUpdate msg_conv;
22064 msg_conv.inner = (void*)(msg & (~1));
22065 msg_conv.is_owned = false;
22066 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
22067 *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv);
22068 return (uint64_t)ret_conv;
22071 uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_unsigned(uint32_t this_arg, uint32_t msg) {
22072 LDKNetworkGraph this_arg_conv;
22073 this_arg_conv.inner = (void*)(this_arg & (~1));
22074 this_arg_conv.is_owned = false;
22075 LDKUnsignedChannelUpdate msg_conv;
22076 msg_conv.inner = (void*)(msg & (~1));
22077 msg_conv.is_owned = false;
22078 LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ");
22079 *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv);
22080 return (uint64_t)ret_conv;
22083 void __attribute__((visibility("default"))) TS_FilesystemPersister_free(uint32_t this_obj) {
22084 LDKFilesystemPersister this_obj_conv;
22085 this_obj_conv.inner = (void*)(this_obj & (~1));
22086 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22087 FilesystemPersister_free(this_obj_conv);
22090 uint32_t __attribute__((visibility("default"))) TS_FilesystemPersister_new(jstring path_to_channel_data) {
22091 LDKStr path_to_channel_data_conv = str_ref_to_owned_c(path_to_channel_data);
22092 LDKFilesystemPersister ret_var = FilesystemPersister_new(path_to_channel_data_conv);
22093 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22094 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22095 uint64_t ret_ref = (uint64_t)ret_var.inner;
22096 if (ret_var.is_owned) {
22102 jstring __attribute__((visibility("default"))) TS_FilesystemPersister_get_data_dir(uint32_t this_arg) {
22103 LDKFilesystemPersister this_arg_conv;
22104 this_arg_conv.inner = (void*)(this_arg & (~1));
22105 this_arg_conv.is_owned = false;
22106 LDKStr ret_str = FilesystemPersister_get_data_dir(&this_arg_conv);
22107 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
22111 uint32_t __attribute__((visibility("default"))) TS_FilesystemPersister_persist_manager(jstring data_dir, uint32_t manager) {
22112 LDKStr data_dir_conv = str_ref_to_owned_c(data_dir);
22113 LDKChannelManager manager_conv;
22114 manager_conv.inner = (void*)(manager & (~1));
22115 manager_conv.is_owned = false;
22116 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
22117 *ret_conv = FilesystemPersister_persist_manager(data_dir_conv, &manager_conv);
22118 return (uint64_t)ret_conv;
22121 uint32_t __attribute__((visibility("default"))) TS_FilesystemPersister_read_channelmonitors(uint32_t this_arg, uint32_t keys_manager) {
22122 LDKFilesystemPersister this_arg_conv;
22123 this_arg_conv.inner = (void*)(this_arg & (~1));
22124 this_arg_conv.is_owned = false;
22125 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
22126 LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ");
22127 *ret_conv = FilesystemPersister_read_channelmonitors(&this_arg_conv, keys_manager_conv);
22128 return (uint64_t)ret_conv;
22131 uint32_t __attribute__((visibility("default"))) TS_FilesystemPersister_as_Persist(uint32_t this_arg) {
22132 LDKFilesystemPersister this_arg_conv;
22133 this_arg_conv.inner = (void*)(this_arg & (~1));
22134 this_arg_conv.is_owned = false;
22135 LDKPersist* ret = MALLOC(sizeof(LDKPersist), "LDKPersist");
22136 *ret = FilesystemPersister_as_Persist(&this_arg_conv);
22137 return (uint64_t)ret;
22140 void __attribute__((visibility("default"))) TS_BackgroundProcessor_free(uint32_t this_obj) {
22141 LDKBackgroundProcessor this_obj_conv;
22142 this_obj_conv.inner = (void*)(this_obj & (~1));
22143 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22144 BackgroundProcessor_free(this_obj_conv);
22147 void __attribute__((visibility("default"))) TS_ChannelManagerPersister_free(uint32_t this_ptr) {
22148 if ((this_ptr & 1) != 0) return;
22149 LDKChannelManagerPersister this_ptr_conv = *(LDKChannelManagerPersister*)(((uint64_t)this_ptr) & ~1);
22150 FREE((void*)this_ptr);
22151 ChannelManagerPersister_free(this_ptr_conv);
22154 uint32_t __attribute__((visibility("default"))) TS_BackgroundProcessor_start(uint32_t persister, uint32_t event_handler, uint32_t chain_monitor, uint32_t channel_manager, uint32_t peer_manager, uint32_t logger) {
22155 LDKChannelManagerPersister persister_conv = *(LDKChannelManagerPersister*)(((uint64_t)persister) & ~1);
22156 LDKEventHandler event_handler_conv = *(LDKEventHandler*)(((uint64_t)event_handler) & ~1);
22157 LDKChainMonitor chain_monitor_conv;
22158 chain_monitor_conv.inner = (void*)(chain_monitor & (~1));
22159 chain_monitor_conv.is_owned = false;
22160 LDKChannelManager channel_manager_conv;
22161 channel_manager_conv.inner = (void*)(channel_manager & (~1));
22162 channel_manager_conv.is_owned = false;
22163 LDKPeerManager peer_manager_conv;
22164 peer_manager_conv.inner = (void*)(peer_manager & (~1));
22165 peer_manager_conv.is_owned = false;
22166 LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1);
22167 LDKBackgroundProcessor ret_var = BackgroundProcessor_start(persister_conv, event_handler_conv, &chain_monitor_conv, &channel_manager_conv, &peer_manager_conv, logger_conv);
22168 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22169 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22170 uint64_t ret_ref = (uint64_t)ret_var.inner;
22171 if (ret_var.is_owned) {
22177 uint32_t __attribute__((visibility("default"))) TS_BackgroundProcessor_stop(uint32_t this_arg) {
22178 LDKBackgroundProcessor this_arg_conv;
22179 this_arg_conv.inner = (void*)(this_arg & (~1));
22180 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
22181 // Warning: we need a move here but no clone is available for LDKBackgroundProcessor
22182 LDKCResult_NoneErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneErrorZ), "LDKCResult_NoneErrorZ");
22183 *ret_conv = BackgroundProcessor_stop(this_arg_conv);
22184 return (uint64_t)ret_conv;
22187 void __attribute__((visibility("default"))) TS_check_platform() {
22191 void __attribute__((visibility("default"))) TS_Invoice_free(uint32_t this_obj) {
22192 LDKInvoice this_obj_conv;
22193 this_obj_conv.inner = (void*)(this_obj & (~1));
22194 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22195 Invoice_free(this_obj_conv);
22198 jboolean __attribute__((visibility("default"))) TS_Invoice_eq(uint32_t a, uint32_t b) {
22200 a_conv.inner = (void*)(a & (~1));
22201 a_conv.is_owned = false;
22203 b_conv.inner = (void*)(b & (~1));
22204 b_conv.is_owned = false;
22205 jboolean ret_val = Invoice_eq(&a_conv, &b_conv);
22209 uint32_t __attribute__((visibility("default"))) TS_Invoice_clone(uint32_t orig) {
22210 LDKInvoice orig_conv;
22211 orig_conv.inner = (void*)(orig & (~1));
22212 orig_conv.is_owned = false;
22213 LDKInvoice ret_var = Invoice_clone(&orig_conv);
22214 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22215 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22216 uint64_t ret_ref = (uint64_t)ret_var.inner;
22217 if (ret_var.is_owned) {
22223 void __attribute__((visibility("default"))) TS_SignedRawInvoice_free(uint32_t this_obj) {
22224 LDKSignedRawInvoice this_obj_conv;
22225 this_obj_conv.inner = (void*)(this_obj & (~1));
22226 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22227 SignedRawInvoice_free(this_obj_conv);
22230 jboolean __attribute__((visibility("default"))) TS_SignedRawInvoice_eq(uint32_t a, uint32_t b) {
22231 LDKSignedRawInvoice a_conv;
22232 a_conv.inner = (void*)(a & (~1));
22233 a_conv.is_owned = false;
22234 LDKSignedRawInvoice b_conv;
22235 b_conv.inner = (void*)(b & (~1));
22236 b_conv.is_owned = false;
22237 jboolean ret_val = SignedRawInvoice_eq(&a_conv, &b_conv);
22241 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_clone(uint32_t orig) {
22242 LDKSignedRawInvoice orig_conv;
22243 orig_conv.inner = (void*)(orig & (~1));
22244 orig_conv.is_owned = false;
22245 LDKSignedRawInvoice ret_var = SignedRawInvoice_clone(&orig_conv);
22246 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22247 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22248 uint64_t ret_ref = (uint64_t)ret_var.inner;
22249 if (ret_var.is_owned) {
22255 void __attribute__((visibility("default"))) TS_RawInvoice_free(uint32_t this_obj) {
22256 LDKRawInvoice this_obj_conv;
22257 this_obj_conv.inner = (void*)(this_obj & (~1));
22258 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22259 RawInvoice_free(this_obj_conv);
22262 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_get_data(uint32_t this_ptr) {
22263 LDKRawInvoice this_ptr_conv;
22264 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22265 this_ptr_conv.is_owned = false;
22266 LDKRawDataPart ret_var = RawInvoice_get_data(&this_ptr_conv);
22267 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22268 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22269 uint64_t ret_ref = (uint64_t)ret_var.inner;
22270 if (ret_var.is_owned) {
22276 void __attribute__((visibility("default"))) TS_RawInvoice_set_data(uint32_t this_ptr, uint32_t val) {
22277 LDKRawInvoice this_ptr_conv;
22278 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22279 this_ptr_conv.is_owned = false;
22280 LDKRawDataPart val_conv;
22281 val_conv.inner = (void*)(val & (~1));
22282 val_conv.is_owned = (val & 1) || (val == 0);
22283 val_conv = RawDataPart_clone(&val_conv);
22284 RawInvoice_set_data(&this_ptr_conv, val_conv);
22287 jboolean __attribute__((visibility("default"))) TS_RawInvoice_eq(uint32_t a, uint32_t b) {
22288 LDKRawInvoice a_conv;
22289 a_conv.inner = (void*)(a & (~1));
22290 a_conv.is_owned = false;
22291 LDKRawInvoice b_conv;
22292 b_conv.inner = (void*)(b & (~1));
22293 b_conv.is_owned = false;
22294 jboolean ret_val = RawInvoice_eq(&a_conv, &b_conv);
22298 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_clone(uint32_t orig) {
22299 LDKRawInvoice orig_conv;
22300 orig_conv.inner = (void*)(orig & (~1));
22301 orig_conv.is_owned = false;
22302 LDKRawInvoice ret_var = RawInvoice_clone(&orig_conv);
22303 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22304 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22305 uint64_t ret_ref = (uint64_t)ret_var.inner;
22306 if (ret_var.is_owned) {
22312 void __attribute__((visibility("default"))) TS_RawDataPart_free(uint32_t this_obj) {
22313 LDKRawDataPart this_obj_conv;
22314 this_obj_conv.inner = (void*)(this_obj & (~1));
22315 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22316 RawDataPart_free(this_obj_conv);
22319 uint32_t __attribute__((visibility("default"))) TS_RawDataPart_get_timestamp(uint32_t this_ptr) {
22320 LDKRawDataPart this_ptr_conv;
22321 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22322 this_ptr_conv.is_owned = false;
22323 LDKPositiveTimestamp ret_var = RawDataPart_get_timestamp(&this_ptr_conv);
22324 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22325 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22326 uint64_t ret_ref = (uint64_t)ret_var.inner;
22327 if (ret_var.is_owned) {
22333 void __attribute__((visibility("default"))) TS_RawDataPart_set_timestamp(uint32_t this_ptr, uint32_t val) {
22334 LDKRawDataPart this_ptr_conv;
22335 this_ptr_conv.inner = (void*)(this_ptr & (~1));
22336 this_ptr_conv.is_owned = false;
22337 LDKPositiveTimestamp val_conv;
22338 val_conv.inner = (void*)(val & (~1));
22339 val_conv.is_owned = (val & 1) || (val == 0);
22340 val_conv = PositiveTimestamp_clone(&val_conv);
22341 RawDataPart_set_timestamp(&this_ptr_conv, val_conv);
22344 jboolean __attribute__((visibility("default"))) TS_RawDataPart_eq(uint32_t a, uint32_t b) {
22345 LDKRawDataPart a_conv;
22346 a_conv.inner = (void*)(a & (~1));
22347 a_conv.is_owned = false;
22348 LDKRawDataPart b_conv;
22349 b_conv.inner = (void*)(b & (~1));
22350 b_conv.is_owned = false;
22351 jboolean ret_val = RawDataPart_eq(&a_conv, &b_conv);
22355 uint32_t __attribute__((visibility("default"))) TS_RawDataPart_clone(uint32_t orig) {
22356 LDKRawDataPart orig_conv;
22357 orig_conv.inner = (void*)(orig & (~1));
22358 orig_conv.is_owned = false;
22359 LDKRawDataPart ret_var = RawDataPart_clone(&orig_conv);
22360 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22361 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22362 uint64_t ret_ref = (uint64_t)ret_var.inner;
22363 if (ret_var.is_owned) {
22369 void __attribute__((visibility("default"))) TS_PositiveTimestamp_free(uint32_t this_obj) {
22370 LDKPositiveTimestamp this_obj_conv;
22371 this_obj_conv.inner = (void*)(this_obj & (~1));
22372 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22373 PositiveTimestamp_free(this_obj_conv);
22376 jboolean __attribute__((visibility("default"))) TS_PositiveTimestamp_eq(uint32_t a, uint32_t b) {
22377 LDKPositiveTimestamp a_conv;
22378 a_conv.inner = (void*)(a & (~1));
22379 a_conv.is_owned = false;
22380 LDKPositiveTimestamp b_conv;
22381 b_conv.inner = (void*)(b & (~1));
22382 b_conv.is_owned = false;
22383 jboolean ret_val = PositiveTimestamp_eq(&a_conv, &b_conv);
22387 uint32_t __attribute__((visibility("default"))) TS_PositiveTimestamp_clone(uint32_t orig) {
22388 LDKPositiveTimestamp orig_conv;
22389 orig_conv.inner = (void*)(orig & (~1));
22390 orig_conv.is_owned = false;
22391 LDKPositiveTimestamp ret_var = PositiveTimestamp_clone(&orig_conv);
22392 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22393 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22394 uint64_t ret_ref = (uint64_t)ret_var.inner;
22395 if (ret_var.is_owned) {
22401 uint32_t __attribute__((visibility("default"))) TS_SiPrefix_clone(uint32_t orig) {
22402 LDKSiPrefix* orig_conv = (LDKSiPrefix*)(orig & ~1);
22403 uint32_t ret_conv = LDKSiPrefix_to_js(SiPrefix_clone(orig_conv));
22407 jboolean __attribute__((visibility("default"))) TS_SiPrefix_eq(uint32_t a, uint32_t b) {
22408 LDKSiPrefix* a_conv = (LDKSiPrefix*)(a & ~1);
22409 LDKSiPrefix* b_conv = (LDKSiPrefix*)(b & ~1);
22410 jboolean ret_val = SiPrefix_eq(a_conv, b_conv);
22414 int64_t __attribute__((visibility("default"))) TS_SiPrefix_multiplier(uint32_t this_arg) {
22415 LDKSiPrefix* this_arg_conv = (LDKSiPrefix*)(this_arg & ~1);
22416 int64_t ret_val = SiPrefix_multiplier(this_arg_conv);
22420 uint32_t __attribute__((visibility("default"))) TS_Currency_clone(uint32_t orig) {
22421 LDKCurrency* orig_conv = (LDKCurrency*)(orig & ~1);
22422 uint32_t ret_conv = LDKCurrency_to_js(Currency_clone(orig_conv));
22426 jboolean __attribute__((visibility("default"))) TS_Currency_eq(uint32_t a, uint32_t b) {
22427 LDKCurrency* a_conv = (LDKCurrency*)(a & ~1);
22428 LDKCurrency* b_conv = (LDKCurrency*)(b & ~1);
22429 jboolean ret_val = Currency_eq(a_conv, b_conv);
22433 void __attribute__((visibility("default"))) TS_Sha256_free(uint32_t this_obj) {
22434 LDKSha256 this_obj_conv;
22435 this_obj_conv.inner = (void*)(this_obj & (~1));
22436 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22437 Sha256_free(this_obj_conv);
22440 jboolean __attribute__((visibility("default"))) TS_Sha256_eq(uint32_t a, uint32_t b) {
22442 a_conv.inner = (void*)(a & (~1));
22443 a_conv.is_owned = false;
22445 b_conv.inner = (void*)(b & (~1));
22446 b_conv.is_owned = false;
22447 jboolean ret_val = Sha256_eq(&a_conv, &b_conv);
22451 uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) {
22452 LDKSha256 orig_conv;
22453 orig_conv.inner = (void*)(orig & (~1));
22454 orig_conv.is_owned = false;
22455 LDKSha256 ret_var = Sha256_clone(&orig_conv);
22456 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22457 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22458 uint64_t ret_ref = (uint64_t)ret_var.inner;
22459 if (ret_var.is_owned) {
22465 void __attribute__((visibility("default"))) TS_Description_free(uint32_t this_obj) {
22466 LDKDescription this_obj_conv;
22467 this_obj_conv.inner = (void*)(this_obj & (~1));
22468 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22469 Description_free(this_obj_conv);
22472 jboolean __attribute__((visibility("default"))) TS_Description_eq(uint32_t a, uint32_t b) {
22473 LDKDescription a_conv;
22474 a_conv.inner = (void*)(a & (~1));
22475 a_conv.is_owned = false;
22476 LDKDescription b_conv;
22477 b_conv.inner = (void*)(b & (~1));
22478 b_conv.is_owned = false;
22479 jboolean ret_val = Description_eq(&a_conv, &b_conv);
22483 uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t orig) {
22484 LDKDescription orig_conv;
22485 orig_conv.inner = (void*)(orig & (~1));
22486 orig_conv.is_owned = false;
22487 LDKDescription ret_var = Description_clone(&orig_conv);
22488 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22489 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22490 uint64_t ret_ref = (uint64_t)ret_var.inner;
22491 if (ret_var.is_owned) {
22497 void __attribute__((visibility("default"))) TS_PayeePubKey_free(uint32_t this_obj) {
22498 LDKPayeePubKey this_obj_conv;
22499 this_obj_conv.inner = (void*)(this_obj & (~1));
22500 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22501 PayeePubKey_free(this_obj_conv);
22504 jboolean __attribute__((visibility("default"))) TS_PayeePubKey_eq(uint32_t a, uint32_t b) {
22505 LDKPayeePubKey a_conv;
22506 a_conv.inner = (void*)(a & (~1));
22507 a_conv.is_owned = false;
22508 LDKPayeePubKey b_conv;
22509 b_conv.inner = (void*)(b & (~1));
22510 b_conv.is_owned = false;
22511 jboolean ret_val = PayeePubKey_eq(&a_conv, &b_conv);
22515 uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t orig) {
22516 LDKPayeePubKey orig_conv;
22517 orig_conv.inner = (void*)(orig & (~1));
22518 orig_conv.is_owned = false;
22519 LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv);
22520 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22521 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22522 uint64_t ret_ref = (uint64_t)ret_var.inner;
22523 if (ret_var.is_owned) {
22529 void __attribute__((visibility("default"))) TS_ExpiryTime_free(uint32_t this_obj) {
22530 LDKExpiryTime this_obj_conv;
22531 this_obj_conv.inner = (void*)(this_obj & (~1));
22532 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22533 ExpiryTime_free(this_obj_conv);
22536 jboolean __attribute__((visibility("default"))) TS_ExpiryTime_eq(uint32_t a, uint32_t b) {
22537 LDKExpiryTime a_conv;
22538 a_conv.inner = (void*)(a & (~1));
22539 a_conv.is_owned = false;
22540 LDKExpiryTime b_conv;
22541 b_conv.inner = (void*)(b & (~1));
22542 b_conv.is_owned = false;
22543 jboolean ret_val = ExpiryTime_eq(&a_conv, &b_conv);
22547 uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t orig) {
22548 LDKExpiryTime orig_conv;
22549 orig_conv.inner = (void*)(orig & (~1));
22550 orig_conv.is_owned = false;
22551 LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv);
22552 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22553 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22554 uint64_t ret_ref = (uint64_t)ret_var.inner;
22555 if (ret_var.is_owned) {
22561 void __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_free(uint32_t this_obj) {
22562 LDKMinFinalCltvExpiry this_obj_conv;
22563 this_obj_conv.inner = (void*)(this_obj & (~1));
22564 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22565 MinFinalCltvExpiry_free(this_obj_conv);
22568 jboolean __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_eq(uint32_t a, uint32_t b) {
22569 LDKMinFinalCltvExpiry a_conv;
22570 a_conv.inner = (void*)(a & (~1));
22571 a_conv.is_owned = false;
22572 LDKMinFinalCltvExpiry b_conv;
22573 b_conv.inner = (void*)(b & (~1));
22574 b_conv.is_owned = false;
22575 jboolean ret_val = MinFinalCltvExpiry_eq(&a_conv, &b_conv);
22579 uint32_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) {
22580 LDKMinFinalCltvExpiry orig_conv;
22581 orig_conv.inner = (void*)(orig & (~1));
22582 orig_conv.is_owned = false;
22583 LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_clone(&orig_conv);
22584 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22585 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22586 uint64_t ret_ref = (uint64_t)ret_var.inner;
22587 if (ret_var.is_owned) {
22593 void __attribute__((visibility("default"))) TS_Fallback_free(uint32_t this_ptr) {
22594 if ((this_ptr & 1) != 0) return;
22595 LDKFallback this_ptr_conv = *(LDKFallback*)(((uint64_t)this_ptr) & ~1);
22596 FREE((void*)this_ptr);
22597 Fallback_free(this_ptr_conv);
22600 uint32_t __attribute__((visibility("default"))) TS_Fallback_clone(uint32_t orig) {
22601 LDKFallback* orig_conv = (LDKFallback*)orig;
22602 LDKFallback *ret_copy = MALLOC(sizeof(LDKFallback), "LDKFallback");
22603 *ret_copy = Fallback_clone(orig_conv);
22604 uint64_t ret_ref = (uint64_t)ret_copy;
22608 jboolean __attribute__((visibility("default"))) TS_Fallback_eq(uint32_t a, uint32_t b) {
22609 LDKFallback* a_conv = (LDKFallback*)a;
22610 LDKFallback* b_conv = (LDKFallback*)b;
22611 jboolean ret_val = Fallback_eq(a_conv, b_conv);
22615 void __attribute__((visibility("default"))) TS_InvoiceSignature_free(uint32_t this_obj) {
22616 LDKInvoiceSignature this_obj_conv;
22617 this_obj_conv.inner = (void*)(this_obj & (~1));
22618 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22619 InvoiceSignature_free(this_obj_conv);
22622 jboolean __attribute__((visibility("default"))) TS_InvoiceSignature_eq(uint32_t a, uint32_t b) {
22623 LDKInvoiceSignature a_conv;
22624 a_conv.inner = (void*)(a & (~1));
22625 a_conv.is_owned = false;
22626 LDKInvoiceSignature b_conv;
22627 b_conv.inner = (void*)(b & (~1));
22628 b_conv.is_owned = false;
22629 jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv);
22633 uint32_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone(uint32_t orig) {
22634 LDKInvoiceSignature orig_conv;
22635 orig_conv.inner = (void*)(orig & (~1));
22636 orig_conv.is_owned = false;
22637 LDKInvoiceSignature ret_var = InvoiceSignature_clone(&orig_conv);
22638 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22639 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22640 uint64_t ret_ref = (uint64_t)ret_var.inner;
22641 if (ret_var.is_owned) {
22647 void __attribute__((visibility("default"))) TS_PrivateRoute_free(uint32_t this_obj) {
22648 LDKPrivateRoute this_obj_conv;
22649 this_obj_conv.inner = (void*)(this_obj & (~1));
22650 this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
22651 PrivateRoute_free(this_obj_conv);
22654 jboolean __attribute__((visibility("default"))) TS_PrivateRoute_eq(uint32_t a, uint32_t b) {
22655 LDKPrivateRoute a_conv;
22656 a_conv.inner = (void*)(a & (~1));
22657 a_conv.is_owned = false;
22658 LDKPrivateRoute b_conv;
22659 b_conv.inner = (void*)(b & (~1));
22660 b_conv.is_owned = false;
22661 jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv);
22665 uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_clone(uint32_t orig) {
22666 LDKPrivateRoute orig_conv;
22667 orig_conv.inner = (void*)(orig & (~1));
22668 orig_conv.is_owned = false;
22669 LDKPrivateRoute ret_var = PrivateRoute_clone(&orig_conv);
22670 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22671 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22672 uint64_t ret_ref = (uint64_t)ret_var.inner;
22673 if (ret_var.is_owned) {
22679 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_into_parts(uint32_t this_arg) {
22680 LDKSignedRawInvoice this_arg_conv;
22681 this_arg_conv.inner = (void*)(this_arg & (~1));
22682 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
22683 this_arg_conv = SignedRawInvoice_clone(&this_arg_conv);
22684 LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ");
22685 *ret_ref = SignedRawInvoice_into_parts(this_arg_conv);
22686 return (uint64_t)ret_ref;
22689 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_raw_invoice(uint32_t this_arg) {
22690 LDKSignedRawInvoice this_arg_conv;
22691 this_arg_conv.inner = (void*)(this_arg & (~1));
22692 this_arg_conv.is_owned = false;
22693 LDKRawInvoice ret_var = SignedRawInvoice_raw_invoice(&this_arg_conv);
22694 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22695 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22696 uint64_t ret_ref = (uint64_t)ret_var.inner;
22697 if (ret_var.is_owned) {
22703 int8_tArray __attribute__((visibility("default"))) TS_SignedRawInvoice_hash(uint32_t this_arg) {
22704 LDKSignedRawInvoice this_arg_conv;
22705 this_arg_conv.inner = (void*)(this_arg & (~1));
22706 this_arg_conv.is_owned = false;
22707 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
22708 memcpy((uint8_t*)(ret_arr + 4), *SignedRawInvoice_hash(&this_arg_conv), 32);
22712 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_signature(uint32_t this_arg) {
22713 LDKSignedRawInvoice this_arg_conv;
22714 this_arg_conv.inner = (void*)(this_arg & (~1));
22715 this_arg_conv.is_owned = false;
22716 LDKInvoiceSignature ret_var = SignedRawInvoice_signature(&this_arg_conv);
22717 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22718 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22719 uint64_t ret_ref = (uint64_t)ret_var.inner;
22720 if (ret_var.is_owned) {
22726 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_recover_payee_pub_key(uint32_t this_arg) {
22727 LDKSignedRawInvoice this_arg_conv;
22728 this_arg_conv.inner = (void*)(this_arg & (~1));
22729 this_arg_conv.is_owned = false;
22730 LDKCResult_PayeePubKeyErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeePubKeyErrorZ), "LDKCResult_PayeePubKeyErrorZ");
22731 *ret_conv = SignedRawInvoice_recover_payee_pub_key(&this_arg_conv);
22732 return (uint64_t)ret_conv;
22735 jboolean __attribute__((visibility("default"))) TS_SignedRawInvoice_check_signature(uint32_t this_arg) {
22736 LDKSignedRawInvoice this_arg_conv;
22737 this_arg_conv.inner = (void*)(this_arg & (~1));
22738 this_arg_conv.is_owned = false;
22739 jboolean ret_val = SignedRawInvoice_check_signature(&this_arg_conv);
22743 int8_tArray __attribute__((visibility("default"))) TS_RawInvoice_hash(uint32_t this_arg) {
22744 LDKRawInvoice this_arg_conv;
22745 this_arg_conv.inner = (void*)(this_arg & (~1));
22746 this_arg_conv.is_owned = false;
22747 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
22748 memcpy((uint8_t*)(ret_arr + 4), RawInvoice_hash(&this_arg_conv).data, 32);
22752 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_payment_hash(uint32_t this_arg) {
22753 LDKRawInvoice this_arg_conv;
22754 this_arg_conv.inner = (void*)(this_arg & (~1));
22755 this_arg_conv.is_owned = false;
22756 LDKSha256 ret_var = RawInvoice_payment_hash(&this_arg_conv);
22757 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22758 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22759 uint64_t ret_ref = (uint64_t)ret_var.inner;
22760 if (ret_var.is_owned) {
22766 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_description(uint32_t this_arg) {
22767 LDKRawInvoice this_arg_conv;
22768 this_arg_conv.inner = (void*)(this_arg & (~1));
22769 this_arg_conv.is_owned = false;
22770 LDKDescription ret_var = RawInvoice_description(&this_arg_conv);
22771 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22772 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22773 uint64_t ret_ref = (uint64_t)ret_var.inner;
22774 if (ret_var.is_owned) {
22780 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_payee_pub_key(uint32_t this_arg) {
22781 LDKRawInvoice this_arg_conv;
22782 this_arg_conv.inner = (void*)(this_arg & (~1));
22783 this_arg_conv.is_owned = false;
22784 LDKPayeePubKey ret_var = RawInvoice_payee_pub_key(&this_arg_conv);
22785 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22786 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22787 uint64_t ret_ref = (uint64_t)ret_var.inner;
22788 if (ret_var.is_owned) {
22794 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_description_hash(uint32_t this_arg) {
22795 LDKRawInvoice this_arg_conv;
22796 this_arg_conv.inner = (void*)(this_arg & (~1));
22797 this_arg_conv.is_owned = false;
22798 LDKSha256 ret_var = RawInvoice_description_hash(&this_arg_conv);
22799 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22800 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22801 uint64_t ret_ref = (uint64_t)ret_var.inner;
22802 if (ret_var.is_owned) {
22808 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_expiry_time(uint32_t this_arg) {
22809 LDKRawInvoice this_arg_conv;
22810 this_arg_conv.inner = (void*)(this_arg & (~1));
22811 this_arg_conv.is_owned = false;
22812 LDKExpiryTime ret_var = RawInvoice_expiry_time(&this_arg_conv);
22813 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22814 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22815 uint64_t ret_ref = (uint64_t)ret_var.inner;
22816 if (ret_var.is_owned) {
22822 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_min_final_cltv_expiry(uint32_t this_arg) {
22823 LDKRawInvoice this_arg_conv;
22824 this_arg_conv.inner = (void*)(this_arg & (~1));
22825 this_arg_conv.is_owned = false;
22826 LDKMinFinalCltvExpiry ret_var = RawInvoice_min_final_cltv_expiry(&this_arg_conv);
22827 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22828 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22829 uint64_t ret_ref = (uint64_t)ret_var.inner;
22830 if (ret_var.is_owned) {
22836 int8_tArray __attribute__((visibility("default"))) TS_RawInvoice_payment_secret(uint32_t this_arg) {
22837 LDKRawInvoice this_arg_conv;
22838 this_arg_conv.inner = (void*)(this_arg & (~1));
22839 this_arg_conv.is_owned = false;
22840 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
22841 memcpy((uint8_t*)(ret_arr + 4), RawInvoice_payment_secret(&this_arg_conv).data, 32);
22845 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_features(uint32_t this_arg) {
22846 LDKRawInvoice this_arg_conv;
22847 this_arg_conv.inner = (void*)(this_arg & (~1));
22848 this_arg_conv.is_owned = false;
22849 LDKInvoiceFeatures ret_var = RawInvoice_features(&this_arg_conv);
22850 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22851 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22852 uint64_t ret_ref = (uint64_t)ret_var.inner;
22853 if (ret_var.is_owned) {
22859 uint32_tArray __attribute__((visibility("default"))) TS_RawInvoice_private_routes(uint32_t this_arg) {
22860 LDKRawInvoice this_arg_conv;
22861 this_arg_conv.inner = (void*)(this_arg & (~1));
22862 this_arg_conv.is_owned = false;
22863 LDKCVec_PrivateRouteZ ret_var = RawInvoice_private_routes(&this_arg_conv);
22864 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
22865 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
22866 for (size_t o = 0; o < ret_var.datalen; o++) {
22867 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
22868 CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22869 CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22870 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
22871 if (ret_conv_14_var.is_owned) {
22872 ret_conv_14_ref |= 1;
22874 ret_arr_ptr[o] = ret_conv_14_ref;
22876 FREE(ret_var.data);
22880 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_amount_pico_btc(uint32_t this_arg) {
22881 LDKRawInvoice this_arg_conv;
22882 this_arg_conv.inner = (void*)(this_arg & (~1));
22883 this_arg_conv.is_owned = false;
22884 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
22885 *ret_copy = RawInvoice_amount_pico_btc(&this_arg_conv);
22886 uint64_t ret_ref = (uint64_t)ret_copy;
22890 uint32_t __attribute__((visibility("default"))) TS_RawInvoice_currency(uint32_t this_arg) {
22891 LDKRawInvoice this_arg_conv;
22892 this_arg_conv.inner = (void*)(this_arg & (~1));
22893 this_arg_conv.is_owned = false;
22894 uint32_t ret_conv = LDKCurrency_to_js(RawInvoice_currency(&this_arg_conv));
22898 uint32_t __attribute__((visibility("default"))) TS_PositiveTimestamp_from_unix_timestamp(int64_t unix_seconds) {
22899 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22900 *ret_conv = PositiveTimestamp_from_unix_timestamp(unix_seconds);
22901 return (uint64_t)ret_conv;
22904 uint32_t __attribute__((visibility("default"))) TS_PositiveTimestamp_from_system_time(int64_t time) {
22905 LDKCResult_PositiveTimestampCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PositiveTimestampCreationErrorZ), "LDKCResult_PositiveTimestampCreationErrorZ");
22906 *ret_conv = PositiveTimestamp_from_system_time(time);
22907 return (uint64_t)ret_conv;
22910 int64_t __attribute__((visibility("default"))) TS_PositiveTimestamp_as_unix_timestamp(uint32_t this_arg) {
22911 LDKPositiveTimestamp this_arg_conv;
22912 this_arg_conv.inner = (void*)(this_arg & (~1));
22913 this_arg_conv.is_owned = false;
22914 int64_t ret_val = PositiveTimestamp_as_unix_timestamp(&this_arg_conv);
22918 int64_t __attribute__((visibility("default"))) TS_PositiveTimestamp_as_time(uint32_t this_arg) {
22919 LDKPositiveTimestamp this_arg_conv;
22920 this_arg_conv.inner = (void*)(this_arg & (~1));
22921 this_arg_conv.is_owned = false;
22922 int64_t ret_val = PositiveTimestamp_as_time(&this_arg_conv);
22926 uint32_t __attribute__((visibility("default"))) TS_Invoice_into_signed_raw(uint32_t this_arg) {
22927 LDKInvoice this_arg_conv;
22928 this_arg_conv.inner = (void*)(this_arg & (~1));
22929 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
22930 this_arg_conv = Invoice_clone(&this_arg_conv);
22931 LDKSignedRawInvoice ret_var = Invoice_into_signed_raw(this_arg_conv);
22932 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
22933 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
22934 uint64_t ret_ref = (uint64_t)ret_var.inner;
22935 if (ret_var.is_owned) {
22941 uint32_t __attribute__((visibility("default"))) TS_Invoice_check_signature(uint32_t this_arg) {
22942 LDKInvoice this_arg_conv;
22943 this_arg_conv.inner = (void*)(this_arg & (~1));
22944 this_arg_conv.is_owned = false;
22945 LDKCResult_NoneSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneSemanticErrorZ), "LDKCResult_NoneSemanticErrorZ");
22946 *ret_conv = Invoice_check_signature(&this_arg_conv);
22947 return (uint64_t)ret_conv;
22950 uint32_t __attribute__((visibility("default"))) TS_Invoice_from_signed(uint32_t signed_invoice) {
22951 LDKSignedRawInvoice signed_invoice_conv;
22952 signed_invoice_conv.inner = (void*)(signed_invoice & (~1));
22953 signed_invoice_conv.is_owned = (signed_invoice & 1) || (signed_invoice == 0);
22954 signed_invoice_conv = SignedRawInvoice_clone(&signed_invoice_conv);
22955 LDKCResult_InvoiceSemanticErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSemanticErrorZ), "LDKCResult_InvoiceSemanticErrorZ");
22956 *ret_conv = Invoice_from_signed(signed_invoice_conv);
22957 return (uint64_t)ret_conv;
22960 int64_t __attribute__((visibility("default"))) TS_Invoice_timestamp(uint32_t this_arg) {
22961 LDKInvoice this_arg_conv;
22962 this_arg_conv.inner = (void*)(this_arg & (~1));
22963 this_arg_conv.is_owned = false;
22964 int64_t ret_val = Invoice_timestamp(&this_arg_conv);
22968 int8_tArray __attribute__((visibility("default"))) TS_Invoice_payment_hash(uint32_t this_arg) {
22969 LDKInvoice this_arg_conv;
22970 this_arg_conv.inner = (void*)(this_arg & (~1));
22971 this_arg_conv.is_owned = false;
22972 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
22973 memcpy((uint8_t*)(ret_arr + 4), *Invoice_payment_hash(&this_arg_conv), 32);
22977 int8_tArray __attribute__((visibility("default"))) TS_Invoice_payee_pub_key(uint32_t this_arg) {
22978 LDKInvoice this_arg_conv;
22979 this_arg_conv.inner = (void*)(this_arg & (~1));
22980 this_arg_conv.is_owned = false;
22981 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
22982 memcpy((uint8_t*)(ret_arr + 4), Invoice_payee_pub_key(&this_arg_conv).compressed_form, 33);
22986 int8_tArray __attribute__((visibility("default"))) TS_Invoice_payment_secret(uint32_t this_arg) {
22987 LDKInvoice this_arg_conv;
22988 this_arg_conv.inner = (void*)(this_arg & (~1));
22989 this_arg_conv.is_owned = false;
22990 int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes");
22991 memcpy((uint8_t*)(ret_arr + 4), Invoice_payment_secret(&this_arg_conv).data, 32);
22995 uint32_t __attribute__((visibility("default"))) TS_Invoice_features(uint32_t this_arg) {
22996 LDKInvoice this_arg_conv;
22997 this_arg_conv.inner = (void*)(this_arg & (~1));
22998 this_arg_conv.is_owned = false;
22999 LDKInvoiceFeatures ret_var = Invoice_features(&this_arg_conv);
23000 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23001 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23002 uint64_t ret_ref = (uint64_t)ret_var.inner;
23003 if (ret_var.is_owned) {
23009 int8_tArray __attribute__((visibility("default"))) TS_Invoice_recover_payee_pub_key(uint32_t this_arg) {
23010 LDKInvoice this_arg_conv;
23011 this_arg_conv.inner = (void*)(this_arg & (~1));
23012 this_arg_conv.is_owned = false;
23013 int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
23014 memcpy((uint8_t*)(ret_arr + 4), Invoice_recover_payee_pub_key(&this_arg_conv).compressed_form, 33);
23018 int64_t __attribute__((visibility("default"))) TS_Invoice_expiry_time(uint32_t this_arg) {
23019 LDKInvoice this_arg_conv;
23020 this_arg_conv.inner = (void*)(this_arg & (~1));
23021 this_arg_conv.is_owned = false;
23022 int64_t ret_val = Invoice_expiry_time(&this_arg_conv);
23026 int64_t __attribute__((visibility("default"))) TS_Invoice_min_final_cltv_expiry(uint32_t this_arg) {
23027 LDKInvoice this_arg_conv;
23028 this_arg_conv.inner = (void*)(this_arg & (~1));
23029 this_arg_conv.is_owned = false;
23030 int64_t ret_val = Invoice_min_final_cltv_expiry(&this_arg_conv);
23034 uint32_tArray __attribute__((visibility("default"))) TS_Invoice_private_routes(uint32_t this_arg) {
23035 LDKInvoice this_arg_conv;
23036 this_arg_conv.inner = (void*)(this_arg & (~1));
23037 this_arg_conv.is_owned = false;
23038 LDKCVec_PrivateRouteZ ret_var = Invoice_private_routes(&this_arg_conv);
23039 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
23040 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
23041 for (size_t o = 0; o < ret_var.datalen; o++) {
23042 LDKPrivateRoute ret_conv_14_var = ret_var.data[o];
23043 CHECK((((uint64_t)ret_conv_14_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23044 CHECK((((uint64_t)&ret_conv_14_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23045 uint64_t ret_conv_14_ref = (uint64_t)ret_conv_14_var.inner;
23046 if (ret_conv_14_var.is_owned) {
23047 ret_conv_14_ref |= 1;
23049 ret_arr_ptr[o] = ret_conv_14_ref;
23051 FREE(ret_var.data);
23055 uint32_tArray __attribute__((visibility("default"))) TS_Invoice_route_hints(uint32_t this_arg) {
23056 LDKInvoice this_arg_conv;
23057 this_arg_conv.inner = (void*)(this_arg & (~1));
23058 this_arg_conv.is_owned = false;
23059 LDKCVec_RouteHintZ ret_var = Invoice_route_hints(&this_arg_conv);
23060 uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes");
23061 uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4);
23062 for (size_t l = 0; l < ret_var.datalen; l++) {
23063 LDKRouteHint ret_conv_11_var = ret_var.data[l];
23064 CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23065 CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23066 uint64_t ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
23067 if (ret_conv_11_var.is_owned) {
23068 ret_conv_11_ref |= 1;
23070 ret_arr_ptr[l] = ret_conv_11_ref;
23072 FREE(ret_var.data);
23076 uint32_t __attribute__((visibility("default"))) TS_Invoice_currency(uint32_t this_arg) {
23077 LDKInvoice this_arg_conv;
23078 this_arg_conv.inner = (void*)(this_arg & (~1));
23079 this_arg_conv.is_owned = false;
23080 uint32_t ret_conv = LDKCurrency_to_js(Invoice_currency(&this_arg_conv));
23084 uint32_t __attribute__((visibility("default"))) TS_Invoice_amount_pico_btc(uint32_t this_arg) {
23085 LDKInvoice this_arg_conv;
23086 this_arg_conv.inner = (void*)(this_arg & (~1));
23087 this_arg_conv.is_owned = false;
23088 LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
23089 *ret_copy = Invoice_amount_pico_btc(&this_arg_conv);
23090 uint64_t ret_ref = (uint64_t)ret_copy;
23094 uint32_t __attribute__((visibility("default"))) TS_Description_new(jstring description) {
23095 LDKStr description_conv = str_ref_to_owned_c(description);
23096 LDKCResult_DescriptionCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DescriptionCreationErrorZ), "LDKCResult_DescriptionCreationErrorZ");
23097 *ret_conv = Description_new(description_conv);
23098 return (uint64_t)ret_conv;
23101 jstring __attribute__((visibility("default"))) TS_Description_into_inner(uint32_t this_arg) {
23102 LDKDescription this_arg_conv;
23103 this_arg_conv.inner = (void*)(this_arg & (~1));
23104 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
23105 this_arg_conv = Description_clone(&this_arg_conv);
23106 LDKStr ret_str = Description_into_inner(this_arg_conv);
23107 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23111 uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_from_seconds(int64_t seconds) {
23112 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
23113 *ret_conv = ExpiryTime_from_seconds(seconds);
23114 return (uint64_t)ret_conv;
23117 uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_from_duration(int64_t duration) {
23118 LDKCResult_ExpiryTimeCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ExpiryTimeCreationErrorZ), "LDKCResult_ExpiryTimeCreationErrorZ");
23119 *ret_conv = ExpiryTime_from_duration(duration);
23120 return (uint64_t)ret_conv;
23123 int64_t __attribute__((visibility("default"))) TS_ExpiryTime_as_seconds(uint32_t this_arg) {
23124 LDKExpiryTime this_arg_conv;
23125 this_arg_conv.inner = (void*)(this_arg & (~1));
23126 this_arg_conv.is_owned = false;
23127 int64_t ret_val = ExpiryTime_as_seconds(&this_arg_conv);
23131 int64_t __attribute__((visibility("default"))) TS_ExpiryTime_as_duration(uint32_t this_arg) {
23132 LDKExpiryTime this_arg_conv;
23133 this_arg_conv.inner = (void*)(this_arg & (~1));
23134 this_arg_conv.is_owned = false;
23135 int64_t ret_val = ExpiryTime_as_duration(&this_arg_conv);
23139 uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_new(uint32_t hops) {
23140 LDKRouteHint hops_conv;
23141 hops_conv.inner = (void*)(hops & (~1));
23142 hops_conv.is_owned = (hops & 1) || (hops == 0);
23143 hops_conv = RouteHint_clone(&hops_conv);
23144 LDKCResult_PrivateRouteCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PrivateRouteCreationErrorZ), "LDKCResult_PrivateRouteCreationErrorZ");
23145 *ret_conv = PrivateRoute_new(hops_conv);
23146 return (uint64_t)ret_conv;
23149 uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_into_inner(uint32_t this_arg) {
23150 LDKPrivateRoute this_arg_conv;
23151 this_arg_conv.inner = (void*)(this_arg & (~1));
23152 this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0);
23153 this_arg_conv = PrivateRoute_clone(&this_arg_conv);
23154 LDKRouteHint ret_var = PrivateRoute_into_inner(this_arg_conv);
23155 CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
23156 CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
23157 uint64_t ret_ref = (uint64_t)ret_var.inner;
23158 if (ret_var.is_owned) {
23164 uint32_t __attribute__((visibility("default"))) TS_CreationError_clone(uint32_t orig) {
23165 LDKCreationError* orig_conv = (LDKCreationError*)(orig & ~1);
23166 uint32_t ret_conv = LDKCreationError_to_js(CreationError_clone(orig_conv));
23170 jboolean __attribute__((visibility("default"))) TS_CreationError_eq(uint32_t a, uint32_t b) {
23171 LDKCreationError* a_conv = (LDKCreationError*)(a & ~1);
23172 LDKCreationError* b_conv = (LDKCreationError*)(b & ~1);
23173 jboolean ret_val = CreationError_eq(a_conv, b_conv);
23177 jstring __attribute__((visibility("default"))) TS_CreationError_to_str(uint32_t o) {
23178 LDKCreationError* o_conv = (LDKCreationError*)(o & ~1);
23179 LDKStr ret_str = CreationError_to_str(o_conv);
23180 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23184 uint32_t __attribute__((visibility("default"))) TS_SemanticError_clone(uint32_t orig) {
23185 LDKSemanticError* orig_conv = (LDKSemanticError*)(orig & ~1);
23186 uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_clone(orig_conv));
23190 jboolean __attribute__((visibility("default"))) TS_SemanticError_eq(uint32_t a, uint32_t b) {
23191 LDKSemanticError* a_conv = (LDKSemanticError*)(a & ~1);
23192 LDKSemanticError* b_conv = (LDKSemanticError*)(b & ~1);
23193 jboolean ret_val = SemanticError_eq(a_conv, b_conv);
23197 jstring __attribute__((visibility("default"))) TS_SemanticError_to_str(uint32_t o) {
23198 LDKSemanticError* o_conv = (LDKSemanticError*)(o & ~1);
23199 LDKStr ret_str = SemanticError_to_str(o_conv);
23200 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23204 void __attribute__((visibility("default"))) TS_SignOrCreationError_free(uint32_t this_ptr) {
23205 if ((this_ptr & 1) != 0) return;
23206 LDKSignOrCreationError this_ptr_conv = *(LDKSignOrCreationError*)(((uint64_t)this_ptr) & ~1);
23207 FREE((void*)this_ptr);
23208 SignOrCreationError_free(this_ptr_conv);
23211 uint32_t __attribute__((visibility("default"))) TS_SignOrCreationError_clone(uint32_t orig) {
23212 LDKSignOrCreationError* orig_conv = (LDKSignOrCreationError*)orig;
23213 LDKSignOrCreationError *ret_copy = MALLOC(sizeof(LDKSignOrCreationError), "LDKSignOrCreationError");
23214 *ret_copy = SignOrCreationError_clone(orig_conv);
23215 uint64_t ret_ref = (uint64_t)ret_copy;
23219 jboolean __attribute__((visibility("default"))) TS_SignOrCreationError_eq(uint32_t a, uint32_t b) {
23220 LDKSignOrCreationError* a_conv = (LDKSignOrCreationError*)a;
23221 LDKSignOrCreationError* b_conv = (LDKSignOrCreationError*)b;
23222 jboolean ret_val = SignOrCreationError_eq(a_conv, b_conv);
23226 jstring __attribute__((visibility("default"))) TS_SignOrCreationError_to_str(uint32_t o) {
23227 LDKSignOrCreationError* o_conv = (LDKSignOrCreationError*)o;
23228 LDKStr ret_str = SignOrCreationError_to_str(o_conv);
23229 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23233 uint32_t __attribute__((visibility("default"))) TS_create_invoice_from_channelmanager(uint32_t channelmanager, uint32_t keys_manager, uint32_t network, uint32_t amt_msat, jstring description) {
23234 LDKChannelManager channelmanager_conv;
23235 channelmanager_conv.inner = (void*)(channelmanager & (~1));
23236 channelmanager_conv.is_owned = false;
23237 LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1);
23238 LDKCurrency network_conv = LDKCurrency_from_js(network);
23239 LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)amt_msat) & ~1);
23240 LDKStr description_conv = str_ref_to_owned_c(description);
23241 LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ");
23242 *ret_conv = create_invoice_from_channelmanager(&channelmanager_conv, keys_manager_conv, network_conv, amt_msat_conv, description_conv);
23243 return (uint64_t)ret_conv;
23246 uint32_t __attribute__((visibility("default"))) TS_SiPrefix_from_str(jstring s) {
23247 LDKStr s_conv = str_ref_to_owned_c(s);
23248 LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ");
23249 *ret_conv = SiPrefix_from_str(s_conv);
23250 return (uint64_t)ret_conv;
23253 uint32_t __attribute__((visibility("default"))) TS_Invoice_from_str(jstring s) {
23254 LDKStr s_conv = str_ref_to_owned_c(s);
23255 LDKCResult_InvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceNoneZ), "LDKCResult_InvoiceNoneZ");
23256 *ret_conv = Invoice_from_str(s_conv);
23257 return (uint64_t)ret_conv;
23260 uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_from_str(jstring s) {
23261 LDKStr s_conv = str_ref_to_owned_c(s);
23262 LDKCResult_SignedRawInvoiceNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignedRawInvoiceNoneZ), "LDKCResult_SignedRawInvoiceNoneZ");
23263 *ret_conv = SignedRawInvoice_from_str(s_conv);
23264 return (uint64_t)ret_conv;
23267 jstring __attribute__((visibility("default"))) TS_Invoice_to_str(uint32_t o) {
23269 o_conv.inner = (void*)(o & (~1));
23270 o_conv.is_owned = false;
23271 LDKStr ret_str = Invoice_to_str(&o_conv);
23272 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23276 jstring __attribute__((visibility("default"))) TS_SignedRawInvoice_to_str(uint32_t o) {
23277 LDKSignedRawInvoice o_conv;
23278 o_conv.inner = (void*)(o & (~1));
23279 o_conv.is_owned = false;
23280 LDKStr ret_str = SignedRawInvoice_to_str(&o_conv);
23281 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23285 jstring __attribute__((visibility("default"))) TS_Currency_to_str(uint32_t o) {
23286 LDKCurrency* o_conv = (LDKCurrency*)(o & ~1);
23287 LDKStr ret_str = Currency_to_str(o_conv);
23288 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);
23292 jstring __attribute__((visibility("default"))) TS_SiPrefix_to_str(uint32_t o) {
23293 LDKSiPrefix* o_conv = (LDKSiPrefix*)(o & ~1);
23294 LDKStr ret_str = SiPrefix_to_str(o_conv);
23295 jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len);