X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=ts%2Fbindings.c.body;h=066ba66dcbf0cf7a9df08d3e0fbd36c3bcd8bd61;hb=f6c75b182a7786062a4966e8939701ef59092509;hp=5661316a1c4733fa26f4e93a4c1d7fe34ba9fb1a;hpb=9da1fb892048ce2faddd35e930619fd1a16c0137;p=ldk-java diff --git a/ts/bindings.c.body b/ts/bindings.c.body index 5661316a..066ba66d 100644 --- a/ts/bindings.c.body +++ b/ts/bindings.c.body @@ -870,17 +870,27 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ ret->b = b_ref; return (uint64_t)ret; } -int64_t __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ_get_a(uint32_t ptr) { - LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1); +static inline uintptr_t C2Tuple_usizeTransactionZ_get_a(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple){ return tuple->a; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_usizeTransactionZ_get_b(uint32_t ptr) { - LDKC2Tuple_usizeTransactionZ *tuple = (LDKC2Tuple_usizeTransactionZ*)(ptr & ~1); - LDKTransaction b_var = tuple->b; - int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen); - return b_arr; +int64_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_get_a(uint32_t tuple) { + LDKC2Tuple_usizeTransactionZ* tuple_conv = (LDKC2Tuple_usizeTransactionZ*)(tuple & ~1); + int64_t ret_val = C2Tuple_usizeTransactionZ_get_a(tuple_conv); + return ret_val; +} + +static inline struct LDKTransaction C2Tuple_usizeTransactionZ_get_b(LDKC2Tuple_usizeTransactionZ *NONNULL_PTR tuple){ + return tuple->b; } +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_get_b(uint32_t tuple) { + LDKC2Tuple_usizeTransactionZ* tuple_conv = (LDKC2Tuple_usizeTransactionZ*)(tuple & ~1); + LDKTransaction ret_var = C2Tuple_usizeTransactionZ_get_b(tuple_conv); + int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen); + Transaction_free(ret_var); + return ret_arr; +} + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_usizeTransactionZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_usizeTransactionZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_usizeTransactionZZ), "LDKCVec_C2Tuple_usizeTransactionZZ"); ret->datalen = *((uint32_t*)elems); @@ -974,8 +984,10 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCOption_C2Tuple_usizeTrans LDKCOption_C2Tuple_usizeTransactionZZ *obj = (LDKCOption_C2Tuple_usizeTransactionZZ*)(ptr & ~1); switch(obj->tag) { case LDKCOption_C2Tuple_usizeTransactionZZ_Some: { - uint64_t some_ref = (uint64_t)(&obj->some) | 1; - return 0 /* LDKCOption_C2Tuple_usizeTransactionZZ - Some */; (void) some_ref; + LDKC2Tuple_usizeTransactionZ* some_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); + *some_conv = obj->some; + *some_conv = C2Tuple_usizeTransactionZ_clone(some_conv); + return 0 /* LDKCOption_C2Tuple_usizeTransactionZZ - Some */; (void) ((uint64_t)some_conv); } case LDKCOption_C2Tuple_usizeTransactionZZ_None: { return 0 /* LDKCOption_C2Tuple_usizeTransactionZZ - None */; @@ -1472,32 +1484,43 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_Sig ret->b = b_constr; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_get_a(uint32_t ptr) { - LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.compact_form, 64); - return a_arr; +static inline struct LDKSignature C2Tuple_SignatureCVec_SignatureZZ_get_a(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple){ + return tuple->a; +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_a(uint32_t tuple) { + LDKC2Tuple_SignatureCVec_SignatureZZ* tuple_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_SignatureCVec_SignatureZZ_get_a(tuple_conv).compact_form, 64); + return ret_arr; } -ptrArray __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_get_b(uint32_t ptr) { - LDKC2Tuple_SignatureCVec_SignatureZZ *tuple = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(ptr & ~1); - LDKCVec_SignatureZ b_var = tuple->b; - ptrArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes"); - int8_tArray *b_arr_ptr = (int8_tArray*)(b_arr + 4); - for (size_t m = 0; m < b_var.datalen; m++) { - int8_tArray b_conv_12_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_conv_12_arr + 4), b_var.data[m].compact_form, 64); - b_arr_ptr[m] = b_conv_12_arr; + +static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple){ + return tuple->b; +} +ptrArray __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_get_b(uint32_t tuple) { + LDKC2Tuple_SignatureCVec_SignatureZZ* tuple_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(tuple & ~1); + LDKCVec_SignatureZ ret_var = C2Tuple_SignatureCVec_SignatureZZ_get_b(tuple_conv); + ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes"); + int8_tArray *ret_arr_ptr = (int8_tArray*)(ret_arr + 4); + for (size_t m = 0; m < ret_var.datalen; m++) { + int8_tArray ret_conv_12_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_conv_12_arr + 4), ret_var.data[m].compact_form, 64); + ret_arr_ptr[m] = ret_conv_12_arr; } - return b_arr; + FREE(ret_var.data); + return ret_arr; } + jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_result_ok(uint32_t arg) { return ((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)arg)->result_ok; } uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_ok(uint32_t arg) { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1); CHECK(val->result_ok); - uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1; - return res_ref; + LDKC2Tuple_SignatureCVec_SignatureZZ* res_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); + *res_conv = (*val->contents.result); + *res_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(res_conv); + return ((uint64_t)res_conv); } void __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_get_err(uint32_t arg) { LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ *val = (LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(arg & ~1); @@ -2126,20 +2149,31 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelM ret->b = b_conv; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelMonitorZ_get_a(uint32_t ptr) { - LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32); - return a_arr; +static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelMonitorZ_get_a(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_a(uint32_t tuple) { + LDKC2Tuple_BlockHashChannelMonitorZ* tuple_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_BlockHashChannelMonitorZ_get_a(tuple_conv).data, 32); + return ret_arr; } -uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelMonitorZ_get_b(uint32_t ptr) { - LDKC2Tuple_BlockHashChannelMonitorZ *tuple = (LDKC2Tuple_BlockHashChannelMonitorZ*)(ptr & ~1); - LDKChannelMonitor b_var = tuple->b; - CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t b_ref = (uint64_t)b_var.inner & ~1; - return b_ref; + +static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple){ + return ChannelMonitor_clone(&tuple->b); } +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_get_b(uint32_t tuple) { + LDKC2Tuple_BlockHashChannelMonitorZ* tuple_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(tuple & ~1); + LDKChannelMonitor ret_var = C2Tuple_BlockHashChannelMonitorZ_get_b(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_BlockHashChannelMonitorZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_BlockHashChannelMonitorZZ), "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ"); ret->datalen = *((uint32_t*)elems); @@ -2151,12 +2185,19 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_BlockHashCha for (size_t i = 0; i < ret->datalen; i++) { uint32_t arr_elem = java_elems[i]; LDKC2Tuple_BlockHashChannelMonitorZ arr_elem_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1); - // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ + arr_elem_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)arr_elem) & ~1)); ret->data[i] = arr_elem_conv; } } return (uint64_t)ret; } +static inline LDKCVec_C2Tuple_BlockHashChannelMonitorZZ CVec_C2Tuple_BlockHashChannelMonitorZZ_clone(const LDKCVec_C2Tuple_BlockHashChannelMonitorZZ *orig) { + LDKCVec_C2Tuple_BlockHashChannelMonitorZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ) * orig->datalen, "LDKCVec_C2Tuple_BlockHashChannelMonitorZZ clone bytes"), .datalen = orig->datalen }; + for (size_t i = 0; i < ret.datalen; i++) { + ret.data[i] = C2Tuple_BlockHashChannelMonitorZ_clone(&orig->data[i]); + } + return ret; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)arg)->result_ok; } @@ -2166,9 +2207,11 @@ uint32_tArray __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple LDKCVec_C2Tuple_BlockHashChannelMonitorZZ res_var = (*val->contents.result); uint32_tArray res_arr = init_arr(res_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *res_arr_ptr = (uint32_t*)(res_arr + 4); - for (size_t m = 0; m < res_var.datalen; m++) { - uint64_t res_conv_38_ref = (uint64_t)(&res_var.data[m]) | 1; - res_arr_ptr[m] = res_conv_38_ref; + for (size_t j = 0; j < res_var.datalen; j++) { + LDKC2Tuple_BlockHashChannelMonitorZ* res_conv_35_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ"); + *res_conv_35_conv = res_var.data[j]; + *res_conv_35_conv = C2Tuple_BlockHashChannelMonitorZ_clone(res_conv_35_conv); + res_arr_ptr[j] = ((uint64_t)res_conv_35_conv); } return res_arr; } @@ -2424,18 +2467,26 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymen ret->b = b_ref; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentSecretZ_get_a(uint32_t ptr) { - LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32); - return a_arr; +static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_a(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_a(uint32_t tuple) { + LDKC2Tuple_PaymentHashPaymentSecretZ* tuple_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_PaymentHashPaymentSecretZ_get_a(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentSecretZ_get_b(LDKC2Tuple_PaymentHashPaymentSecretZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->b); } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentSecretZ_get_b(uint32_t ptr) { - LDKC2Tuple_PaymentHashPaymentSecretZ *tuple = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(ptr & ~1); - int8_tArray b_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_arr + 4), tuple->b.data, 32); - return b_arr; +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_get_b(uint32_t tuple) { + LDKC2Tuple_PaymentHashPaymentSecretZ* tuple_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_PaymentHashPaymentSecretZ_get_b(tuple_conv).data, 32); + return ret_arr; } + jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentSecretAPIErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_PaymentSecretAPIErrorZ*)arg)->result_ok; } @@ -2941,28 +2992,38 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelM ret->b = b_conv; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelManagerZ_get_a(uint32_t ptr) { - LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32); - return a_arr; +static inline struct LDKThirtyTwoBytes C2Tuple_BlockHashChannelManagerZ_get_a(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_get_a(uint32_t tuple) { + LDKC2Tuple_BlockHashChannelManagerZ* tuple_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_BlockHashChannelManagerZ_get_a(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKChannelManager *C2Tuple_BlockHashChannelManagerZ_get_b(LDKC2Tuple_BlockHashChannelManagerZ *NONNULL_PTR tuple){ + return &tuple->b; } -uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_BlockHashChannelManagerZ_get_b(uint32_t ptr) { - LDKC2Tuple_BlockHashChannelManagerZ *tuple = (LDKC2Tuple_BlockHashChannelManagerZ*)(ptr & ~1); - LDKChannelManager b_var = tuple->b; - CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t b_ref = (uint64_t)b_var.inner & ~1; - return b_ref; +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_get_b(uint32_t tuple) { + LDKC2Tuple_BlockHashChannelManagerZ* tuple_conv = (LDKC2Tuple_BlockHashChannelManagerZ*)(tuple & ~1); + LDKChannelManager ret_var = *C2Tuple_BlockHashChannelManagerZ_get_b(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner & ~1; + return ret_ref; } + jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)arg)->result_ok; } uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_ok(uint32_t arg) { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1); CHECK(val->result_ok); - uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1; - return res_ref; + LDKC2Tuple_BlockHashChannelManagerZ* res_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ"); + *res_conv = (*val->contents.result); + // Warning: we really need to clone here, but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ + return ((uint64_t)res_conv) | 1; } uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_get_err(uint32_t arg) { LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ*)(arg & ~1); @@ -3194,28 +3255,46 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832In ret->c = c_conv; return (uint64_t)ret; } -uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint32_t ptr) { - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1); - LDKRawInvoice a_var = tuple->a; - CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t a_ref = (uint64_t)a_var.inner & ~1; - return a_ref; -} -int8_tArray __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint32_t ptr) { - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1); - int8_tArray b_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_arr + 4), tuple->b.data, 32); - return b_arr; -} -uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint32_t ptr) { - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *tuple = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(ptr & ~1); - LDKInvoiceSignature c_var = tuple->c; - CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t c_ref = (uint64_t)c_var.inner & ~1; - return c_ref; +static inline struct LDKRawInvoice C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple){ + return RawInvoice_clone(&tuple->a); } +uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(uint32_t tuple) { + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* tuple_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(tuple & ~1); + LDKRawInvoice ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_a(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + +static inline struct LDKThirtyTwoBytes C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->b); +} +int8_tArray __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(uint32_t tuple) { + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* tuple_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_b(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKInvoiceSignature C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ *NONNULL_PTR tuple){ + return InvoiceSignature_clone(&tuple->c); +} +uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(uint32_t tuple) { + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* tuple_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(tuple & ~1); + LDKInvoiceSignature ret_var = C3Tuple_RawInvoice_u832InvoiceSignatureZ_get_c(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok; } @@ -3453,21 +3532,33 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_n ret->b = b_ref; return (uint64_t)ret; } -uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_get_a(uint32_t ptr) { - LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1); - LDKOutPoint a_var = tuple->a; - CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t a_ref = (uint64_t)a_var.inner & ~1; - return a_ref; -} -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_OutPointScriptZ_get_b(uint32_t ptr) { - LDKC2Tuple_OutPointScriptZ *tuple = (LDKC2Tuple_OutPointScriptZ*)(ptr & ~1); - LDKCVec_u8Z b_var = tuple->b; - int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen); - return b_arr; +static inline struct LDKOutPoint C2Tuple_OutPointScriptZ_get_a(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple){ + return OutPoint_clone(&tuple->a); +} +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_get_a(uint32_t tuple) { + LDKC2Tuple_OutPointScriptZ* tuple_conv = (LDKC2Tuple_OutPointScriptZ*)(tuple & ~1); + LDKOutPoint ret_var = C2Tuple_OutPointScriptZ_get_a(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + +static inline struct LDKCVec_u8Z C2Tuple_OutPointScriptZ_get_b(LDKC2Tuple_OutPointScriptZ *NONNULL_PTR tuple){ + return CVec_u8Z_clone(&tuple->b); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_get_b(uint32_t tuple) { + LDKC2Tuple_OutPointScriptZ* tuple_conv = (LDKC2Tuple_OutPointScriptZ*)(tuple & ~1); + LDKCVec_u8Z ret_var = C2Tuple_OutPointScriptZ_get_b(tuple_conv); + int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen); + CVec_u8Z_free(ret_var); + return ret_arr; } + uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) { LDKC2Tuple_u32ScriptZ* ret = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); ret->a = a; @@ -3478,17 +3569,27 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_new(in ret->b = b_ref; return (uint64_t)ret; } -int32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_get_a(uint32_t ptr) { - LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1); +static inline uint32_t C2Tuple_u32ScriptZ_get_a(LDKC2Tuple_u32ScriptZ *NONNULL_PTR tuple){ return tuple->a; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_u32ScriptZ_get_b(uint32_t ptr) { - LDKC2Tuple_u32ScriptZ *tuple = (LDKC2Tuple_u32ScriptZ*)(ptr & ~1); - LDKCVec_u8Z b_var = tuple->b; - int8_tArray b_arr = init_arr(b_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(b_arr + 4), b_var.data, b_var.datalen); - return b_arr; +int32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_get_a(uint32_t tuple) { + LDKC2Tuple_u32ScriptZ* tuple_conv = (LDKC2Tuple_u32ScriptZ*)(tuple & ~1); + int32_t ret_val = C2Tuple_u32ScriptZ_get_a(tuple_conv); + return ret_val; +} + +static inline struct LDKCVec_u8Z C2Tuple_u32ScriptZ_get_b(LDKC2Tuple_u32ScriptZ *NONNULL_PTR tuple){ + return CVec_u8Z_clone(&tuple->b); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_get_b(uint32_t tuple) { + LDKC2Tuple_u32ScriptZ* tuple_conv = (LDKC2Tuple_u32ScriptZ*)(tuple & ~1); + LDKCVec_u8Z ret_var = C2Tuple_u32ScriptZ_get_b(tuple_conv); + int8_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), ret_var.data, ret_var.datalen); + CVec_u8Z_free(ret_var); + return ret_arr; } + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32ScriptZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_u32ScriptZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32ScriptZZ), "LDKCVec_C2Tuple_u32ScriptZZ"); ret->datalen = *((uint32_t*)elems); @@ -3526,32 +3627,42 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_ else b_constr.data = NULL; uint32_t* b_vals = (uint32_t*)(b + 4); - for (size_t e = 0; e < b_constr.datalen; e++) { - uint32_t b_conv_30 = b_vals[e]; - LDKC2Tuple_u32ScriptZ b_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1); - b_conv_30_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1)); - b_constr.data[e] = b_conv_30_conv; + for (size_t v = 0; v < b_constr.datalen; v++) { + uint32_t b_conv_21 = b_vals[v]; + LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_21) & ~1); + b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_21) & ~1)); + b_constr.data[v] = b_conv_21_conv; } ret->b = b_constr; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint32_t ptr) { - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32); - return a_arr; +static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(uint32_t tuple) { + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* tuple_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_a(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKCVec_C2Tuple_u32ScriptZZ C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *NONNULL_PTR tuple){ + return CVec_C2Tuple_u32ScriptZZ_clone(&tuple->b); } -uint32_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint32_t ptr) { - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(ptr & ~1); - LDKCVec_C2Tuple_u32ScriptZZ b_var = tuple->b; - uint32_tArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); - uint32_t *b_arr_ptr = (uint32_t*)(b_arr + 4); - for (size_t e = 0; e < b_var.datalen; e++) { - uint64_t b_conv_30_ref = (uint64_t)(&b_var.data[e]) | 1; - b_arr_ptr[e] = b_conv_30_ref; +uint32_tArray __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(uint32_t tuple) { + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* tuple_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(tuple & ~1); + LDKCVec_C2Tuple_u32ScriptZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_get_b(tuple_conv); + uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); + uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); + for (size_t v = 0; v < ret_var.datalen; v++) { + LDKC2Tuple_u32ScriptZ* ret_conv_21_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); + *ret_conv_21_conv = ret_var.data[v]; + ret_arr_ptr[v] = ((uint64_t)ret_conv_21_conv); } - return b_arr; + FREE(ret_var.data); + return ret_arr; } + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ"); ret->datalen = *((uint32_t*)elems); @@ -3721,15 +3832,25 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_new(int ret->b = b_conv; return (uint64_t)ret; } -int32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_get_a(uint32_t ptr) { - LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1); +static inline uint32_t C2Tuple_u32TxOutZ_get_a(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple){ return tuple->a; } -uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_u32TxOutZ_get_b(uint32_t ptr) { - LDKC2Tuple_u32TxOutZ *tuple = (LDKC2Tuple_u32TxOutZ*)(ptr & ~1); - uint64_t b_ref = ((uint64_t)&tuple->b) | 1; - return (uint64_t)b_ref; +int32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_get_a(uint32_t tuple) { + LDKC2Tuple_u32TxOutZ* tuple_conv = (LDKC2Tuple_u32TxOutZ*)(tuple & ~1); + int32_t ret_val = C2Tuple_u32TxOutZ_get_a(tuple_conv); + return ret_val; +} + +static inline struct LDKTxOut C2Tuple_u32TxOutZ_get_b(LDKC2Tuple_u32TxOutZ *NONNULL_PTR tuple){ + return TxOut_clone(&tuple->b); +} +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_get_b(uint32_t tuple) { + LDKC2Tuple_u32TxOutZ* tuple_conv = (LDKC2Tuple_u32TxOutZ*)(tuple & ~1); + LDKTxOut* ret_ref = MALLOC(sizeof(LDKTxOut), "LDKTxOut"); + *ret_ref = C2Tuple_u32TxOutZ_get_b(tuple_conv); + return (uint64_t)ret_ref; } + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_u32TxOutZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_u32TxOutZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_u32TxOutZZ), "LDKCVec_C2Tuple_u32TxOutZZ"); ret->datalen = *((uint32_t*)elems); @@ -3767,32 +3888,42 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_ else b_constr.data = NULL; uint32_t* b_vals = (uint32_t*)(b + 4); - for (size_t z = 0; z < b_constr.datalen; z++) { - uint32_t b_conv_25 = b_vals[z]; - LDKC2Tuple_u32TxOutZ b_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1); - b_conv_25_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1)); - b_constr.data[z] = b_conv_25_conv; + for (size_t u = 0; u < b_constr.datalen; u++) { + uint32_t b_conv_20 = b_vals[u]; + LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_20) & ~1); + b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_20) & ~1)); + b_constr.data[u] = b_conv_20_conv; } ret->b = b_constr; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint32_t ptr) { - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.data, 32); - return a_arr; +static inline struct LDKThirtyTwoBytes C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(uint32_t tuple) { + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* tuple_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_a(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKCVec_C2Tuple_u32TxOutZZ C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *NONNULL_PTR tuple){ + return CVec_C2Tuple_u32TxOutZZ_clone(&tuple->b); } -uint32_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint32_t ptr) { - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ *tuple = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(ptr & ~1); - LDKCVec_C2Tuple_u32TxOutZZ b_var = tuple->b; - uint32_tArray b_arr = init_arr(b_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); - uint32_t *b_arr_ptr = (uint32_t*)(b_arr + 4); - for (size_t z = 0; z < b_var.datalen; z++) { - uint64_t b_conv_25_ref = (uint64_t)(&b_var.data[z]) | 1; - b_arr_ptr[z] = b_conv_25_ref; +uint32_tArray __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(uint32_t tuple) { + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* tuple_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(tuple & ~1); + LDKCVec_C2Tuple_u32TxOutZZ ret_var = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_get_b(tuple_conv); + uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); + uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); + for (size_t u = 0; u < ret_var.datalen; u++) { + LDKC2Tuple_u32TxOutZ* ret_conv_20_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); + *ret_conv_20_conv = ret_var.data[u]; + ret_arr_ptr[u] = ((uint64_t)ret_conv_20_conv); } - return b_arr; + FREE(ret_var.data); + return ret_arr; } + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ), "LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ"); ret->datalen = *((uint32_t*)elems); @@ -3865,8 +3996,10 @@ jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHash uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_ok(uint32_t arg) { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1); CHECK(val->result_ok); - uint64_t res_ref = (uint64_t)(&(*val->contents.result)) | 1; - return res_ref; + LDKC2Tuple_BlockHashChannelMonitorZ* res_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ"); + *res_conv = (*val->contents.result); + *res_conv = C2Tuple_BlockHashChannelMonitorZ_clone(res_conv); + return ((uint64_t)res_conv); } uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_get_err(uint32_t arg) { LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ *val = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(arg & ~1); @@ -3905,18 +4038,26 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PublicKeyTypeZ_ne ret->b = b_conv; return (uint64_t)ret; } -int8_tArray __attribute__((visibility("default"))) TS_LDKC2Tuple_PublicKeyTypeZ_get_a(uint32_t ptr) { - LDKC2Tuple_PublicKeyTypeZ *tuple = (LDKC2Tuple_PublicKeyTypeZ*)(ptr & ~1); - int8_tArray a_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(a_arr + 4), tuple->a.compressed_form, 33); - return a_arr; +static inline struct LDKPublicKey C2Tuple_PublicKeyTypeZ_get_a(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple){ + return tuple->a; +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_get_a(uint32_t tuple) { + LDKC2Tuple_PublicKeyTypeZ* tuple_conv = (LDKC2Tuple_PublicKeyTypeZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_PublicKeyTypeZ_get_a(tuple_conv).compressed_form, 33); + return ret_arr; } -uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PublicKeyTypeZ_get_b(uint32_t ptr) { - LDKC2Tuple_PublicKeyTypeZ *tuple = (LDKC2Tuple_PublicKeyTypeZ*)(ptr & ~1); - LDKType* b_ret =MALLOC(sizeof(LDKType), "LDKType"); - *b_ret = Type_clone(&tuple->b); - return (uint64_t)b_ret; + +static inline struct LDKType C2Tuple_PublicKeyTypeZ_get_b(LDKC2Tuple_PublicKeyTypeZ *NONNULL_PTR tuple){ + return Type_clone(&tuple->b); } +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_get_b(uint32_t tuple) { + LDKC2Tuple_PublicKeyTypeZ* tuple_conv = (LDKC2Tuple_PublicKeyTypeZ*)(tuple & ~1); + LDKType* ret_ret =MALLOC(sizeof(LDKType), "LDKType"); + *ret_ret = C2Tuple_PublicKeyTypeZ_get_b(tuple_conv); + return (uint64_t)ret_ret; +} + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C2Tuple_PublicKeyTypeZZ_new(uint32_tArray elems) { LDKCVec_C2Tuple_PublicKeyTypeZZ *ret = MALLOC(sizeof(LDKCVec_C2Tuple_PublicKeyTypeZZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ"); ret->datalen = *((uint32_t*)elems); @@ -3977,30 +4118,51 @@ uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnounceme ret->c = c_conv; return (uint64_t)ret; } -uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint32_t ptr) { - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1); - LDKChannelAnnouncement a_var = tuple->a; - CHECK((((uint64_t)a_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&a_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t a_ref = (uint64_t)a_var.inner & ~1; - return a_ref; -} -uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint32_t ptr) { - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1); - LDKChannelUpdate b_var = tuple->b; - CHECK((((uint64_t)b_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&b_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t b_ref = (uint64_t)b_var.inner & ~1; - return b_ref; -} -uint32_t __attribute__((visibility("default"))) TS_LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint32_t ptr) { - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *tuple = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(ptr & ~1); - LDKChannelUpdate c_var = tuple->c; - CHECK((((uint64_t)c_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&c_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t c_ref = (uint64_t)c_var.inner & ~1; - return c_ref; +static inline struct LDKChannelAnnouncement C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple){ + return ChannelAnnouncement_clone(&tuple->a); +} +uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(uint32_t tuple) { + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* tuple_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(tuple & ~1); + LDKChannelAnnouncement ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_a(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + +static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple){ + return ChannelUpdate_clone(&tuple->b); } +uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(uint32_t tuple) { + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* tuple_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(tuple & ~1); + LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_b(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + +static inline struct LDKChannelUpdate C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ *NONNULL_PTR tuple){ + return ChannelUpdate_clone(&tuple->c); +} +uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(uint32_t tuple) { + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* tuple_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(tuple & ~1); + LDKChannelUpdate ret_var = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_get_c(tuple_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + uint32_t __attribute__((visibility("default"))) TS_LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_new(uint32_tArray elems) { LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ *ret = MALLOC(sizeof(LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ), "LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ"); ret->datalen = *((uint32_t*)elems); @@ -5515,10 +5677,10 @@ void transactions_confirmed_LDKConfirm_jcall(const void* this_arg, const uint8_t LDKCVec_C2Tuple_usizeTransactionZZ txdata_var = txdata; uint32_tArray txdata_arr = init_arr(txdata_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *txdata_arr_ptr = (uint32_t*)(txdata_arr + 4); - for (size_t e = 0; e < txdata_var.datalen; e++) { - LDKC2Tuple_usizeTransactionZ* txdata_conv_30_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); - *txdata_conv_30_ref = txdata_var.data[e]; - txdata_arr_ptr[e] = (uint64_t)txdata_conv_30_ref; + for (size_t c = 0; c < txdata_var.datalen; c++) { + LDKC2Tuple_usizeTransactionZ* txdata_conv_28_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); + *txdata_conv_28_conv = txdata_var.data[c]; + txdata_arr_ptr[c] = ((uint64_t)txdata_conv_28_conv); } FREE(txdata_var.data); js_invoke_function_3(j_calls->transactions_confirmed_meth, header_arr, txdata_arr, height); @@ -5591,11 +5753,11 @@ void __attribute__((visibility("default"))) TS_Confirm_transactions_confirmed(u else txdata_constr.data = NULL; uint32_t* txdata_vals = (uint32_t*)(txdata + 4); - for (size_t e = 0; e < txdata_constr.datalen; e++) { - uint32_t txdata_conv_30 = txdata_vals[e]; - LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1); - txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1)); - txdata_constr.data[e] = txdata_conv_30_conv; + for (size_t c = 0; c < txdata_constr.datalen; c++) { + uint32_t txdata_conv_28 = txdata_vals[c]; + LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1); + txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1)); + txdata_constr.data[c] = txdata_conv_28_conv; } (this_arg_conv->transactions_confirmed)(this_arg_conv->this_arg, header_ref, txdata_constr, height); } @@ -6450,11 +6612,11 @@ LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel else ret_constr.data = NULL; uint32_t* ret_vals = (uint32_t*)(ret + 4); - for (size_t l = 0; l < ret_constr.datalen; l++) { - uint32_t ret_conv_63 = ret_vals[l]; - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1); - ret_conv_63_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_63) & ~1)); - ret_constr.data[l] = ret_conv_63_conv; + for (size_t h = 0; h < ret_constr.datalen; h++) { + uint32_t ret_conv_59 = ret_vals[h]; + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ ret_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1); + ret_conv_59_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone((LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)ret_conv_59) & ~1)); + ret_constr.data[h] = ret_conv_59_conv; } return ret_constr; } @@ -6626,10 +6788,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_RoutingMessageHandler_g LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ ret_var = (this_arg_conv->get_next_channel_announcements)(this_arg_conv->this_arg, starting_point, batch_amount); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t l = 0; l < ret_var.datalen; l++) { - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_63_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); - *ret_conv_63_ref = ret_var.data[l]; - ret_arr_ptr[l] = (uint64_t)ret_conv_63_ref; + for (size_t h = 0; h < ret_var.datalen; h++) { + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv_59_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); + *ret_conv_59_conv = ret_var.data[h]; + ret_arr_ptr[h] = ((uint64_t)ret_conv_59_conv); } FREE(ret_var.data); return ret_arr; @@ -6811,11 +6973,11 @@ LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandle else ret_constr.data = NULL; uint32_t* ret_vals = (uint32_t*)(ret + 4); - for (size_t c = 0; c < ret_constr.datalen; c++) { - uint32_t ret_conv_28 = ret_vals[c]; - LDKC2Tuple_PublicKeyTypeZ ret_conv_28_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_28) & ~1); - ret_conv_28_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_28) & ~1)); - ret_constr.data[c] = ret_conv_28_conv; + for (size_t z = 0; z < ret_constr.datalen; z++) { + uint32_t ret_conv_25 = ret_vals[z]; + LDKC2Tuple_PublicKeyTypeZ ret_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1); + ret_conv_25_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)ret_conv_25) & ~1)); + ret_constr.data[z] = ret_conv_25_conv; } return ret_constr; } @@ -6860,10 +7022,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_CustomMessageHandler_ge LDKCVec_C2Tuple_PublicKeyTypeZZ ret_var = (this_arg_conv->get_and_clear_pending_msg)(this_arg_conv->this_arg); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t c = 0; c < ret_var.datalen; c++) { - LDKC2Tuple_PublicKeyTypeZ* ret_conv_28_ref = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); - *ret_conv_28_ref = ret_var.data[c]; - ret_arr_ptr[c] = (uint64_t)ret_conv_28_ref; + for (size_t z = 0; z < ret_var.datalen; z++) { + LDKC2Tuple_PublicKeyTypeZ* ret_conv_25_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); + *ret_conv_25_conv = ret_var.data[z]; + ret_arr_ptr[z] = ((uint64_t)ret_conv_25_conv); } FREE(ret_var.data); return ret_arr; @@ -7906,9 +8068,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_cl uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_clone(uint32_t orig) { LDKC2Tuple_usizeTransactionZ* orig_conv = (LDKC2Tuple_usizeTransactionZ*)(orig & ~1); - LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); - *ret_ref = C2Tuple_usizeTransactionZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); + *ret_conv = C2Tuple_usizeTransactionZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_new(int64_t a, int8_tArray b) { @@ -7917,9 +8079,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_ne b_ref.data = MALLOC(b_ref.datalen, "LDKTransaction Bytes"); memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen); b_ref.data_is_owned = true; - LDKC2Tuple_usizeTransactionZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); - *ret_ref = C2Tuple_usizeTransactionZ_new(a, b_ref); - return (uint64_t)ret_ref; + LDKC2Tuple_usizeTransactionZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_usizeTransactionZ), "LDKC2Tuple_usizeTransactionZ"); + *ret_conv = C2Tuple_usizeTransactionZ_new(a, b_ref); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_usizeTransactionZ_free(uint32_t _res) { @@ -7937,11 +8099,11 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_usizeTransactionZZ_ else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t e = 0; e < _res_constr.datalen; e++) { - uint32_t _res_conv_30 = _res_vals[e]; - LDKC2Tuple_usizeTransactionZ _res_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res_conv_30) & ~1); - FREE((void*)_res_conv_30); - _res_constr.data[e] = _res_conv_30_conv; + for (size_t c = 0; c < _res_constr.datalen; c++) { + uint32_t _res_conv_28 = _res_vals[c]; + LDKC2Tuple_usizeTransactionZ _res_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)_res_conv_28) & ~1); + FREE((void*)_res_conv_28); + _res_constr.data[c] = _res_conv_28_conv; } CVec_C2Tuple_usizeTransactionZZ_free(_res_constr); } @@ -8340,9 +8502,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone(uint uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_clone(uint32_t orig) { LDKC2Tuple_SignatureCVec_SignatureZZ* orig_conv = (LDKC2Tuple_SignatureCVec_SignatureZZ*)(orig & ~1); - LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); - *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); + *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) { @@ -8363,9 +8525,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_Signat memcpy(b_conv_12_ref.compact_form, (uint8_t*)(b_conv_12 + 4), 64); b_constr.data[m] = b_conv_12_ref; } - LDKC2Tuple_SignatureCVec_SignatureZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); - *ret_ref = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr); - return (uint64_t)ret_ref; + LDKC2Tuple_SignatureCVec_SignatureZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); + *ret_conv = C2Tuple_SignatureCVec_SignatureZZ_new(a_ref, b_constr); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZZ_free(uint32_t _res) { @@ -8642,6 +8804,13 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_TransactionNoneZ_clo return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_clone(uint32_t orig) { + LDKC2Tuple_BlockHashChannelMonitorZ* orig_conv = (LDKC2Tuple_BlockHashChannelMonitorZ*)(orig & ~1); + LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ"); + *ret_conv = C2Tuple_BlockHashChannelMonitorZ_clone(orig_conv); + return ((uint64_t)ret_conv); +} + uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_new(int8_tArray a, uint32_t b) { LDKThirtyTwoBytes a_ref; CHECK(*((uint32_t*)a) == 32); @@ -8650,9 +8819,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMoni b_conv.inner = (void*)(b & (~1)); b_conv.is_owned = (b & 1) || (b == 0); b_conv = ChannelMonitor_clone(&b_conv); - LDKC2Tuple_BlockHashChannelMonitorZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ"); - *ret_ref = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_BlockHashChannelMonitorZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelMonitorZ), "LDKC2Tuple_BlockHashChannelMonitorZ"); + *ret_conv = C2Tuple_BlockHashChannelMonitorZ_new(a_ref, b_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_free(uint32_t _res) { @@ -8670,11 +8839,11 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_BlockHashChannelMon else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t m = 0; m < _res_constr.datalen; m++) { - uint32_t _res_conv_38 = _res_vals[m]; - LDKC2Tuple_BlockHashChannelMonitorZ _res_conv_38_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res_conv_38) & ~1); - FREE((void*)_res_conv_38); - _res_constr.data[m] = _res_conv_38_conv; + for (size_t j = 0; j < _res_constr.datalen; j++) { + uint32_t _res_conv_35 = _res_vals[j]; + LDKC2Tuple_BlockHashChannelMonitorZ _res_conv_35_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)_res_conv_35) & ~1); + FREE((void*)_res_conv_35); + _res_constr.data[j] = _res_conv_35_conv; } CVec_C2Tuple_BlockHashChannelMonitorZZ_free(_res_constr); } @@ -8687,11 +8856,11 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHa else o_constr.data = NULL; uint32_t* o_vals = (uint32_t*)(o + 4); - for (size_t m = 0; m < o_constr.datalen; m++) { - uint32_t o_conv_38 = o_vals[m]; - LDKC2Tuple_BlockHashChannelMonitorZ o_conv_38_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_38) & ~1); - // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ - o_constr.data[m] = o_conv_38_conv; + for (size_t j = 0; j < o_constr.datalen; j++) { + uint32_t o_conv_35 = o_vals[j]; + LDKC2Tuple_BlockHashChannelMonitorZ o_conv_35_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_35) & ~1); + o_conv_35_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o_conv_35) & ~1)); + o_constr.data[j] = o_conv_35_conv; } LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ"); *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_ok(o_constr); @@ -8712,6 +8881,13 @@ void __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashCh CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_free(_res_conv); } +uint32_t __attribute__((visibility("default"))) TS_CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(uint32_t orig) { + LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* orig_conv = (LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ*)(orig & ~1); + LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ), "LDKCResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ"); + *ret_conv = CResult_CVec_C2Tuple_BlockHashChannelMonitorZZErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_COption_u16Z_some(int16_t o) { LDKCOption_u16Z *ret_copy = MALLOC(sizeof(LDKCOption_u16Z), "LDKCOption_u16Z"); *ret_copy = COption_u16Z_some(o); @@ -8881,9 +9057,9 @@ void __attribute__((visibility("default"))) TS_CVec_NetAddressZ_free(uint32_tAr uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_clone(uint32_t orig) { LDKC2Tuple_PaymentHashPaymentSecretZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentSecretZ*)(orig & ~1); - LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); - *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); + *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_new(int8_tArray a, int8_tArray b) { @@ -8893,9 +9069,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSe LDKThirtyTwoBytes b_ref; CHECK(*((uint32_t*)b) == 32); memcpy(b_ref.data, (uint8_t*)(b + 4), 32); - LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); - *ret_ref = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref); - return (uint64_t)ret_ref; + LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); + *ret_conv = C2Tuple_PaymentHashPaymentSecretZ_new(a_ref, b_ref); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentSecretZ_free(uint32_t _res) { @@ -8962,9 +9138,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMana b_conv.inner = (void*)(b & (~1)); b_conv.is_owned = (b & 1) || (b == 0); // Warning: we need a move here but no clone is available for LDKChannelManager - LDKC2Tuple_BlockHashChannelManagerZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ"); - *ret_ref = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_BlockHashChannelManagerZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_BlockHashChannelManagerZ), "LDKC2Tuple_BlockHashChannelManagerZ"); + *ret_conv = C2Tuple_BlockHashChannelManagerZ_new(a_ref, b_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ_free(uint32_t _res) { @@ -9218,9 +9394,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_SignedRawInvoiceNone uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(uint32_t orig) { LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* orig_conv = (LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ*)(orig & ~1); - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); - *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); + *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(uint32_t a, int8_tArray b, uint32_t c) { @@ -9235,9 +9411,9 @@ uint32_t __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832Invoi c_conv.inner = (void*)(c & (~1)); c_conv.is_owned = (c & 1) || (c == 0); c_conv = InvoiceSignature_clone(&c_conv); - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); - *ret_ref = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv); - return (uint64_t)ret_ref; + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); + *ret_conv = C3Tuple_RawInvoice_u832InvoiceSignatureZ_new(a_conv, b_ref, c_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C3Tuple_RawInvoice_u832InvoiceSignatureZ_free(uint32_t _res) { @@ -9599,9 +9775,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NoneMonitorUpdateErr uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_clone(uint32_t orig) { LDKC2Tuple_OutPointScriptZ* orig_conv = (LDKC2Tuple_OutPointScriptZ*)(orig & ~1); - LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); - *ret_ref = C2Tuple_OutPointScriptZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); + *ret_conv = C2Tuple_OutPointScriptZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_new(uint32_t a, int8_tArray b) { @@ -9613,9 +9789,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_new( b_ref.datalen = *((uint32_t*)b); b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes"); memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen); - LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); - *ret_ref = C2Tuple_OutPointScriptZ_new(a_conv, b_ref); - return (uint64_t)ret_ref; + LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); + *ret_conv = C2Tuple_OutPointScriptZ_new(a_conv, b_ref); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_free(uint32_t _res) { @@ -9627,9 +9803,9 @@ void __attribute__((visibility("default"))) TS_C2Tuple_OutPointScriptZ_free(uin uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_clone(uint32_t orig) { LDKC2Tuple_u32ScriptZ* orig_conv = (LDKC2Tuple_u32ScriptZ*)(orig & ~1); - LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); - *ret_ref = C2Tuple_u32ScriptZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); + *ret_conv = C2Tuple_u32ScriptZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_new(int32_t a, int8_tArray b) { @@ -9637,9 +9813,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_new(int32 b_ref.datalen = *((uint32_t*)b); b_ref.data = MALLOC(b_ref.datalen, "LDKCVec_u8Z Bytes"); memcpy(b_ref.data, (uint8_t*)(b + 4), b_ref.datalen); - LDKC2Tuple_u32ScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); - *ret_ref = C2Tuple_u32ScriptZ_new(a, b_ref); - return (uint64_t)ret_ref; + LDKC2Tuple_u32ScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32ScriptZ), "LDKC2Tuple_u32ScriptZ"); + *ret_conv = C2Tuple_u32ScriptZ_new(a, b_ref); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_u32ScriptZ_free(uint32_t _res) { @@ -9657,20 +9833,20 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32ScriptZZ_free(ui else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t e = 0; e < _res_constr.datalen; e++) { - uint32_t _res_conv_30 = _res_vals[e]; - LDKC2Tuple_u32ScriptZ _res_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res_conv_30) & ~1); - FREE((void*)_res_conv_30); - _res_constr.data[e] = _res_conv_30_conv; + for (size_t v = 0; v < _res_constr.datalen; v++) { + uint32_t _res_conv_21 = _res_vals[v]; + LDKC2Tuple_u32ScriptZ _res_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)_res_conv_21) & ~1); + FREE((void*)_res_conv_21); + _res_constr.data[v] = _res_conv_21_conv; } CVec_C2Tuple_u32ScriptZZ_free(_res_constr); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(uint32_t orig) { LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(orig & ~1); - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); - *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); + *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(int8_tArray a, uint32_tArray b) { @@ -9684,15 +9860,15 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32 else b_constr.data = NULL; uint32_t* b_vals = (uint32_t*)(b + 4); - for (size_t e = 0; e < b_constr.datalen; e++) { - uint32_t b_conv_30 = b_vals[e]; - LDKC2Tuple_u32ScriptZ b_conv_30_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1); - b_conv_30_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_30) & ~1)); - b_constr.data[e] = b_conv_30_conv; - } - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); - *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr); - return (uint64_t)ret_ref; + for (size_t v = 0; v < b_constr.datalen; v++) { + uint32_t b_conv_21 = b_vals[v]; + LDKC2Tuple_u32ScriptZ b_conv_21_conv = *(LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_21) & ~1); + b_conv_21_conv = C2Tuple_u32ScriptZ_clone((LDKC2Tuple_u32ScriptZ*)(((uint64_t)b_conv_21) & ~1)); + b_constr.data[v] = b_conv_21_conv; + } + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); + *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_new(a_ref, b_constr); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ_free(uint32_t _res) { @@ -9710,11 +9886,11 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u3 else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t c = 0; c < _res_constr.datalen; c++) { - uint32_t _res_conv_54 = _res_vals[c]; - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_54_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res_conv_54) & ~1); - FREE((void*)_res_conv_54); - _res_constr.data[c] = _res_conv_54_conv; + for (size_t o = 0; o < _res_constr.datalen; o++) { + uint32_t _res_conv_40 = _res_vals[o]; + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ _res_conv_40_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ*)(((uint64_t)_res_conv_40) & ~1); + FREE((void*)_res_conv_40); + _res_constr.data[o] = _res_conv_40_conv; } CVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ_free(_res_constr); } @@ -9758,17 +9934,17 @@ void __attribute__((visibility("default"))) TS_CVec_TransactionZ_free(ptrArray uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_clone(uint32_t orig) { LDKC2Tuple_u32TxOutZ* orig_conv = (LDKC2Tuple_u32TxOutZ*)(orig & ~1); - LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); - *ret_ref = C2Tuple_u32TxOutZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); + *ret_conv = C2Tuple_u32TxOutZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_new(int32_t a, uint32_t b) { LDKTxOut b_conv = *(LDKTxOut*)(((uint64_t)b) & ~1); b_conv = TxOut_clone((LDKTxOut*)(((uint64_t)b) & ~1)); - LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); - *ret_ref = C2Tuple_u32TxOutZ_new(a, b_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_u32TxOutZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); + *ret_conv = C2Tuple_u32TxOutZ_new(a, b_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_u32TxOutZ_free(uint32_t _res) { @@ -9786,20 +9962,20 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_u32TxOutZZ_free(uin else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t z = 0; z < _res_constr.datalen; z++) { - uint32_t _res_conv_25 = _res_vals[z]; - LDKC2Tuple_u32TxOutZ _res_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res_conv_25) & ~1); - FREE((void*)_res_conv_25); - _res_constr.data[z] = _res_conv_25_conv; + for (size_t u = 0; u < _res_constr.datalen; u++) { + uint32_t _res_conv_20 = _res_vals[u]; + LDKC2Tuple_u32TxOutZ _res_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)_res_conv_20) & ~1); + FREE((void*)_res_conv_20); + _res_constr.data[u] = _res_conv_20_conv; } CVec_C2Tuple_u32TxOutZZ_free(_res_constr); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(uint32_t orig) { LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* orig_conv = (LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(orig & ~1); - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); - *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); + *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(int8_tArray a, uint32_tArray b) { @@ -9813,15 +9989,15 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32 else b_constr.data = NULL; uint32_t* b_vals = (uint32_t*)(b + 4); - for (size_t z = 0; z < b_constr.datalen; z++) { - uint32_t b_conv_25 = b_vals[z]; - LDKC2Tuple_u32TxOutZ b_conv_25_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1); - b_conv_25_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_25) & ~1)); - b_constr.data[z] = b_conv_25_conv; - } - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); - *ret_ref = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr); - return (uint64_t)ret_ref; + for (size_t u = 0; u < b_constr.datalen; u++) { + uint32_t b_conv_20 = b_vals[u]; + LDKC2Tuple_u32TxOutZ b_conv_20_conv = *(LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_20) & ~1); + b_conv_20_conv = C2Tuple_u32TxOutZ_clone((LDKC2Tuple_u32TxOutZ*)(((uint64_t)b_conv_20) & ~1)); + b_constr.data[u] = b_conv_20_conv; + } + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); + *ret_conv = C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_new(a_ref, b_constr); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ_free(uint32_t _res) { @@ -9839,11 +10015,11 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_TxidCVec_C2Tuple_u3 else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t x = 0; x < _res_constr.datalen; x++) { - uint32_t _res_conv_49 = _res_vals[x]; - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_49_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res_conv_49) & ~1); - FREE((void*)_res_conv_49); - _res_constr.data[x] = _res_conv_49_conv; + for (size_t n = 0; n < _res_constr.datalen; n++) { + uint32_t _res_conv_39 = _res_vals[n]; + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ _res_conv_39_conv = *(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ*)(((uint64_t)_res_conv_39) & ~1); + FREE((void*)_res_conv_39); + _res_constr.data[n] = _res_conv_39_conv; } CVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ_free(_res_constr); } @@ -9867,7 +10043,7 @@ void __attribute__((visibility("default"))) TS_CVec_BalanceZ_free(uint32_tArray uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint32_t o) { LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1); - // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelMonitorZ + o_conv = C2Tuple_BlockHashChannelMonitorZ_clone((LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1)); LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ"); *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -9890,6 +10066,13 @@ void __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannel CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_free(_res_conv); } +uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(uint32_t orig) { + LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* orig_conv = (LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)(orig & ~1); + LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ"); + *ret_conv = CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() { LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); *ret_conv = CResult_NoneLightningErrorZ_ok(); @@ -9922,9 +10105,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) { LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1); - LDKC2Tuple_PublicKeyTypeZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); - *ret_ref = C2Tuple_PublicKeyTypeZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); + *ret_conv = C2Tuple_PublicKeyTypeZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint32_t b) { @@ -9932,9 +10115,9 @@ uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_new(i CHECK(*((uint32_t*)a) == 33); memcpy(a_ref.compressed_form, (uint8_t*)(a + 4), 33); LDKType b_conv = *(LDKType*)(((uint64_t)b) & ~1); - LDKC2Tuple_PublicKeyTypeZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); - *ret_ref = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_PublicKeyTypeZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); + *ret_conv = C2Tuple_PublicKeyTypeZ_new(a_ref, b_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_free(uint32_t _res) { @@ -9952,11 +10135,11 @@ void __attribute__((visibility("default"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_fre else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t c = 0; c < _res_constr.datalen; c++) { - uint32_t _res_conv_28 = _res_vals[c]; - LDKC2Tuple_PublicKeyTypeZ _res_conv_28_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)_res_conv_28) & ~1); - FREE((void*)_res_conv_28); - _res_constr.data[c] = _res_conv_28_conv; + for (size_t z = 0; z < _res_constr.datalen; z++) { + uint32_t _res_conv_25 = _res_vals[z]; + LDKC2Tuple_PublicKeyTypeZ _res_conv_25_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)_res_conv_25) & ~1); + FREE((void*)_res_conv_25); + _res_constr.data[z] = _res_conv_25_conv; } CVec_C2Tuple_PublicKeyTypeZZ_free(_res_constr); } @@ -9993,9 +10176,9 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(uint32_t orig) { LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* orig_conv = (LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(orig & ~1); - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); - *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv); - return (uint64_t)ret_ref; + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); + *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_clone(orig_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(uint32_t a, uint32_t b, uint32_t c) { @@ -10011,9 +10194,9 @@ uint32_t __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementC c_conv.inner = (void*)(c & (~1)); c_conv.is_owned = (c & 1) || (c == 0); c_conv = ChannelUpdate_clone(&c_conv); - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); - *ret_ref = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv); - return (uint64_t)ret_ref; + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ), "LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ"); + *ret_conv = C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_new(a_conv, b_conv, c_conv); + return ((uint64_t)ret_conv); } void __attribute__((visibility("default"))) TS_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ_free(uint32_t _res) { @@ -10031,11 +10214,11 @@ void __attribute__((visibility("default"))) TS_CVec_C3Tuple_ChannelAnnouncement else _res_constr.data = NULL; uint32_t* _res_vals = (uint32_t*)(_res + 4); - for (size_t l = 0; l < _res_constr.datalen; l++) { - uint32_t _res_conv_63 = _res_vals[l]; - LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_63_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_63) & ~1); - FREE((void*)_res_conv_63); - _res_constr.data[l] = _res_conv_63_conv; + for (size_t h = 0; h < _res_constr.datalen; h++) { + uint32_t _res_conv_59 = _res_vals[h]; + LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ _res_conv_59_conv = *(LDKC3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZ*)(((uint64_t)_res_conv_59) & ~1); + FREE((void*)_res_conv_59); + _res_constr.data[h] = _res_conv_59_conv; } CVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ_free(_res_constr); } @@ -10381,7 +10564,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeEr LDKNetworkGraph o_conv; o_conv.inner = (void*)(o & (~1)); o_conv.is_owned = (o & 1) || (o == 0); - // Warning: we need a move here but no clone is available for LDKNetworkGraph + o_conv = NetworkGraph_clone(&o_conv); LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ"); *ret_conv = CResult_NetworkGraphDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -10404,6 +10587,13 @@ void __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ CResult_NetworkGraphDecodeErrorZ_free(_res_conv); } +uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeErrorZ_clone(uint32_t orig) { + LDKCResult_NetworkGraphDecodeErrorZ* orig_conv = (LDKCResult_NetworkGraphDecodeErrorZ*)(orig & ~1); + LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ"); + *ret_conv = CResult_NetworkGraphDecodeErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_ok(uint32_t o) { LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1); o_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)o) & ~1)); @@ -13621,9 +13811,9 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_get_funding_t LDKChannelMonitor this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKC2Tuple_OutPointScriptZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); - *ret_ref = ChannelMonitor_get_funding_txo(&this_arg_conv); - return (uint64_t)ret_ref; + LDKC2Tuple_OutPointScriptZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_OutPointScriptZ), "LDKC2Tuple_OutPointScriptZ"); + *ret_conv = ChannelMonitor_get_funding_txo(&this_arg_conv); + return ((uint64_t)ret_conv); } uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_outputs_to_watch(uint32_t this_arg) { @@ -13633,10 +13823,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_outp LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32ScriptZZZZ ret_var = ChannelMonitor_get_outputs_to_watch(&this_arg_conv); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t c = 0; c < ret_var.datalen; c++) { - LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_54_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); - *ret_conv_54_ref = ret_var.data[c]; - ret_arr_ptr[c] = (uint64_t)ret_conv_54_ref; + for (size_t o = 0; o < ret_var.datalen; o++) { + LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ* ret_conv_40_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32ScriptZZZ"); + *ret_conv_40_conv = ret_var.data[o]; + ret_arr_ptr[o] = ((uint64_t)ret_conv_40_conv); } FREE(ret_var.data); return ret_arr; @@ -13718,11 +13908,11 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_block_co else txdata_constr.data = NULL; uint32_t* txdata_vals = (uint32_t*)(txdata + 4); - for (size_t e = 0; e < txdata_constr.datalen; e++) { - uint32_t txdata_conv_30 = txdata_vals[e]; - LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1); - txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1)); - txdata_constr.data[e] = txdata_conv_30_conv; + for (size_t c = 0; c < txdata_constr.datalen; c++) { + uint32_t txdata_conv_28 = txdata_vals[c]; + LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1); + txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1)); + txdata_constr.data[c] = txdata_conv_28_conv; } LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1); LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1); @@ -13730,10 +13920,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_block_co 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); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t x = 0; x < ret_var.datalen; x++) { - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); - *ret_conv_49_ref = ret_var.data[x]; - ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref; + for (size_t n = 0; n < ret_var.datalen; n++) { + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); + *ret_conv_39_conv = ret_var.data[n]; + ret_arr_ptr[n] = ((uint64_t)ret_conv_39_conv); } FREE(ret_var.data); return ret_arr; @@ -13768,11 +13958,11 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_transact else txdata_constr.data = NULL; uint32_t* txdata_vals = (uint32_t*)(txdata + 4); - for (size_t e = 0; e < txdata_constr.datalen; e++) { - uint32_t txdata_conv_30 = txdata_vals[e]; - LDKC2Tuple_usizeTransactionZ txdata_conv_30_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1); - txdata_conv_30_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_30) & ~1)); - txdata_constr.data[e] = txdata_conv_30_conv; + for (size_t c = 0; c < txdata_constr.datalen; c++) { + uint32_t txdata_conv_28 = txdata_vals[c]; + LDKC2Tuple_usizeTransactionZ txdata_conv_28_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1); + txdata_conv_28_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)txdata_conv_28) & ~1)); + txdata_constr.data[c] = txdata_conv_28_conv; } LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1); LDKFeeEstimator fee_estimator_conv = *(LDKFeeEstimator*)(((uint64_t)fee_estimator) & ~1); @@ -13780,10 +13970,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_transact 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); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t x = 0; x < ret_var.datalen; x++) { - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); - *ret_conv_49_ref = ret_var.data[x]; - ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref; + for (size_t n = 0; n < ret_var.datalen; n++) { + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); + *ret_conv_39_conv = ret_var.data[n]; + ret_arr_ptr[n] = ((uint64_t)ret_conv_39_conv); } FREE(ret_var.data); return ret_arr; @@ -13817,10 +14007,10 @@ uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_best_blo LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ ret_var = ChannelMonitor_best_block_updated(&this_arg_conv, header_ref, height, broadcaster_conv, fee_estimator_conv, logger_conv); uint32_tArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); uint32_t *ret_arr_ptr = (uint32_t*)(ret_arr + 4); - for (size_t x = 0; x < ret_var.datalen; x++) { - LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_49_ref = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); - *ret_conv_49_ref = ret_var.data[x]; - ret_arr_ptr[x] = (uint64_t)ret_conv_49_ref; + for (size_t n = 0; n < ret_var.datalen; n++) { + LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ* ret_conv_39_conv = MALLOC(sizeof(LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ), "LDKC2Tuple_TxidCVec_C2Tuple_u32TxOutZZZ"); + *ret_conv_39_conv = ret_var.data[n]; + ret_arr_ptr[n] = ((uint64_t)ret_conv_39_conv); } FREE(ret_var.data); return ret_arr; @@ -15781,9 +15971,9 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_inboun this_arg_conv.is_owned = false; LDKCOption_u64Z min_value_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1); min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1)); - LDKC2Tuple_PaymentHashPaymentSecretZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); - *ret_ref = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id); - return (uint64_t)ret_ref; + LDKC2Tuple_PaymentHashPaymentSecretZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentSecretZ), "LDKC2Tuple_PaymentHashPaymentSecretZ"); + *ret_conv = ChannelManager_create_inbound_payment(&this_arg_conv, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id); + return ((uint64_t)ret_conv); } 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) { @@ -23827,6 +24017,20 @@ void __attribute__((visibility("default"))) TS_NetworkGraph_free(uint32_t this_ NetworkGraph_free(this_obj_conv); } +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_clone(uint32_t orig) { + LDKNetworkGraph orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKNetworkGraph ret_var = NetworkGraph_clone(&orig_conv); + CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_ref = (uint64_t)ret_var.inner; + if (ret_var.is_owned) { + ret_ref |= 1; + } + return ret_ref; +} + void __attribute__((visibility("default"))) TS_ReadOnlyNetworkGraph_free(uint32_t this_obj) { LDKReadOnlyNetworkGraph this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -23923,7 +24127,7 @@ void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_set_network_g LDKNetworkGraph val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); - // Warning: we need a move here but no clone is available for LDKNetworkGraph + val_conv = NetworkGraph_clone(&val_conv); NetGraphMsgHandler_set_network_graph(&this_ptr_conv, val_conv); } @@ -23931,7 +24135,7 @@ uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_new(uint3 LDKNetworkGraph network_graph_conv; network_graph_conv.inner = (void*)(network_graph & (~1)); network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0); - // Warning: we need a move here but no clone is available for LDKNetworkGraph + network_graph_conv = NetworkGraph_clone(&network_graph_conv); LDKCOption_AccessZ chain_access_conv = *(LDKCOption_AccessZ*)(((uint64_t)chain_access) & ~1); // Warning: we may need a move here but no clone is available for LDKCOption_AccessZ if (chain_access_conv.tag == LDKCOption_AccessZ_Some) { @@ -25742,9 +25946,9 @@ uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_into_parts( this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = (this_arg & 1) || (this_arg == 0); this_arg_conv = SignedRawInvoice_clone(&this_arg_conv); - LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_ref = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); - *ret_ref = SignedRawInvoice_into_parts(this_arg_conv); - return (uint64_t)ret_ref; + LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ* ret_conv = MALLOC(sizeof(LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ), "LDKC3Tuple_RawInvoice_u832InvoiceSignatureZ"); + *ret_conv = SignedRawInvoice_into_parts(this_arg_conv); + return ((uint64_t)ret_conv); } uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_raw_invoice(uint32_t this_arg) {