X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;ds=sidebyside;f=ts%2Fbindings.c.body;h=c2e953afa383a8063f52209afaf7b80f64050023;hb=db55d4ed1b9ee1b2712db1df0f9b0081a70e269b;hp=90ea56c0052200bbb6fb00dfd186eca908e03efa;hpb=d92b9f26eda1f6c1fbb970db797a03fac62c5606;p=ldk-java diff --git a/ts/bindings.c.body b/ts/bindings.c.body index 90ea56c0..c2e953af 100644 --- a/ts/bindings.c.body +++ b/ts/bindings.c.body @@ -16,7 +16,7 @@ void *malloc(size_t size); void free(void *ptr); #define MALLOC(a, _) malloc(a) -#define FREE(p) if ((long)(p) > 1024) { free(p); } +#define FREE(p) if ((unsigned long)(p) > 1024) { free(p); } #define DO_ASSERT(a) (void)(a) #define CHECK(a) @@ -267,10 +267,12 @@ static inline LDKSemanticError LDKSemanticError_from_js(int32_t ord) { case 1: return LDKSemanticError_MultiplePaymentHashes; case 2: return LDKSemanticError_NoDescription; case 3: return LDKSemanticError_MultipleDescriptions; - case 4: return LDKSemanticError_MultiplePaymentSecrets; - case 5: return LDKSemanticError_InvalidFeatures; - case 6: return LDKSemanticError_InvalidRecoveryId; - case 7: return LDKSemanticError_InvalidSignature; + case 4: return LDKSemanticError_NoPaymentSecret; + case 5: return LDKSemanticError_MultiplePaymentSecrets; + case 6: return LDKSemanticError_InvalidFeatures; + case 7: return LDKSemanticError_InvalidRecoveryId; + case 8: return LDKSemanticError_InvalidSignature; + case 9: return LDKSemanticError_ImpreciseAmount; } abort(); } @@ -280,10 +282,12 @@ static inline int32_t LDKSemanticError_to_js(LDKSemanticError val) { case LDKSemanticError_MultiplePaymentHashes: return 1; case LDKSemanticError_NoDescription: return 2; case LDKSemanticError_MultipleDescriptions: return 3; - case LDKSemanticError_MultiplePaymentSecrets: return 4; - case LDKSemanticError_InvalidFeatures: return 5; - case LDKSemanticError_InvalidRecoveryId: return 6; - case LDKSemanticError_InvalidSignature: return 7; + case LDKSemanticError_NoPaymentSecret: return 4; + case LDKSemanticError_MultiplePaymentSecrets: return 5; + case LDKSemanticError_InvalidFeatures: return 6; + case LDKSemanticError_InvalidRecoveryId: return 7; + case LDKSemanticError_InvalidSignature: return 8; + case LDKSemanticError_ImpreciseAmount: return 9; default: abort(); } } @@ -548,6 +552,23 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_BuiltCommitmentTr uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } +jboolean __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_result_ok(uint32_t arg) { + return ((LDKCResult_TrustedClosingTransactionNoneZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_get_ok(uint32_t arg) { + LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1); + CHECK(val->result_ok); + LDKTrustedClosingTransaction res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +void __attribute__((visibility("default"))) TS_LDKCResult_TrustedClosingTransactionNoneZ_get_err(uint32_t arg) { + LDKCResult_TrustedClosingTransactionNoneZ *val = (LDKCResult_TrustedClosingTransactionNoneZ*)(arg & ~1); + CHECK(!val->result_ok); + return *val->contents.err; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_CommitmentTransactionDecodeErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_CommitmentTransactionDecodeErrorZ*)arg)->result_ok; } @@ -849,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); @@ -915,12 +946,12 @@ uint32_t __attribute__((visibility("default"))) TS_LDKMonitorEvent_ref_from_ptr( uint64_t htlc_event_ref = (uint64_t)htlc_event_var.inner & ~1; return 0 /* LDKMonitorEvent - HTLCEvent */; (void) htlc_event_ref; } - case LDKMonitorEvent_CommitmentTxBroadcasted: { - LDKOutPoint commitment_tx_broadcasted_var = obj->commitment_tx_broadcasted; - CHECK((((uint64_t)commitment_tx_broadcasted_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&commitment_tx_broadcasted_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t commitment_tx_broadcasted_ref = (uint64_t)commitment_tx_broadcasted_var.inner & ~1; - return 0 /* LDKMonitorEvent - CommitmentTxBroadcasted */; (void) commitment_tx_broadcasted_ref; + case LDKMonitorEvent_CommitmentTxConfirmed: { + LDKOutPoint commitment_tx_confirmed_var = obj->commitment_tx_confirmed; + CHECK((((uint64_t)commitment_tx_confirmed_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&commitment_tx_confirmed_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t commitment_tx_confirmed_ref = (uint64_t)commitment_tx_confirmed_var.inner & ~1; + return 0 /* LDKMonitorEvent - CommitmentTxConfirmed */; (void) commitment_tx_confirmed_ref; } default: abort(); } @@ -953,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 */; @@ -962,6 +995,40 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCOption_C2Tuple_usizeTrans default: abort(); } } +uint32_t __attribute__((visibility("default"))) TS_LDKNetworkUpdate_ref_from_ptr(uint32_t ptr) { + LDKNetworkUpdate *obj = (LDKNetworkUpdate*)(ptr & ~1); + switch(obj->tag) { + case LDKNetworkUpdate_ChannelUpdateMessage: { + LDKChannelUpdate msg_var = obj->channel_update_message.msg; + CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t msg_ref = (uint64_t)msg_var.inner & ~1; + return 0 /* LDKNetworkUpdate - ChannelUpdateMessage */; (void) msg_ref; + } + case LDKNetworkUpdate_ChannelClosed: { + return 0 /* LDKNetworkUpdate - ChannelClosed */; (void) obj->channel_closed.short_channel_id; (void) obj->channel_closed.is_permanent; + } + case LDKNetworkUpdate_NodeFailure: { + int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(node_id_arr + 4), obj->node_failure.node_id.compressed_form, 33); + return 0 /* LDKNetworkUpdate - NodeFailure */; (void) node_id_arr; (void) obj->node_failure.is_permanent; + } + default: abort(); + } +} +uint32_t __attribute__((visibility("default"))) TS_LDKCOption_NetworkUpdateZ_ref_from_ptr(uint32_t ptr) { + LDKCOption_NetworkUpdateZ *obj = (LDKCOption_NetworkUpdateZ*)(ptr & ~1); + switch(obj->tag) { + case LDKCOption_NetworkUpdateZ_Some: { + uint64_t some_ref = ((uint64_t)&obj->some) | 1; + return 0 /* LDKCOption_NetworkUpdateZ - Some */; (void) some_ref; + } + case LDKCOption_NetworkUpdateZ_None: { + return 0 /* LDKCOption_NetworkUpdateZ - None */; + } + default: abort(); + } +} uint32_t __attribute__((visibility("default"))) TS_LDKSpendableOutputDescriptor_ref_from_ptr(uint32_t ptr) { LDKSpendableOutputDescriptor *obj = (LDKSpendableOutputDescriptor*)(ptr & ~1); switch(obj->tag) { @@ -1041,27 +1108,6 @@ uint32_t __attribute__((visibility("default"))) TS_LDKErrorAction_ref_from_ptr(u default: abort(); } } -uint32_t __attribute__((visibility("default"))) TS_LDKHTLCFailChannelUpdate_ref_from_ptr(uint32_t ptr) { - LDKHTLCFailChannelUpdate *obj = (LDKHTLCFailChannelUpdate*)(ptr & ~1); - switch(obj->tag) { - case LDKHTLCFailChannelUpdate_ChannelUpdateMessage: { - LDKChannelUpdate msg_var = obj->channel_update_message.msg; - CHECK((((uint64_t)msg_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&msg_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t msg_ref = (uint64_t)msg_var.inner & ~1; - return 0 /* LDKHTLCFailChannelUpdate - ChannelUpdateMessage */; (void) msg_ref; - } - case LDKHTLCFailChannelUpdate_ChannelClosed: { - return 0 /* LDKHTLCFailChannelUpdate - ChannelClosed */; (void) obj->channel_closed.short_channel_id; (void) obj->channel_closed.is_permanent; - } - case LDKHTLCFailChannelUpdate_NodeFailure: { - int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(node_id_arr + 4), obj->node_failure.node_id.compressed_form, 33); - return 0 /* LDKHTLCFailChannelUpdate - NodeFailure */; (void) node_id_arr; (void) obj->node_failure.is_permanent; - } - default: abort(); - } -} uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_ptr(uint32_t ptr) { LDKMessageSendEvent *obj = (LDKMessageSendEvent*)(ptr & ~1); switch(obj->tag) { @@ -1204,10 +1250,6 @@ uint32_t __attribute__((visibility("default"))) TS_LDKMessageSendEvent_ref_from_ uint64_t action_ref = ((uint64_t)&obj->handle_error.action) | 1; return 0 /* LDKMessageSendEvent - HandleError */; (void) node_id_arr; (void) action_ref; } - case LDKMessageSendEvent_PaymentFailureNetworkUpdate: { - uint64_t update_ref = ((uint64_t)&obj->payment_failure_network_update.update) | 1; - return 0 /* LDKMessageSendEvent - PaymentFailureNetworkUpdate */; (void) update_ref; - } case LDKMessageSendEvent_SendChannelRangeQuery: { int8_tArray node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); memcpy((uint8_t*)(node_id_arr + 4), obj->send_channel_range_query.node_id.compressed_form, 33); @@ -1406,6 +1448,19 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SpendableOutputDe uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } +jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_result_ok(uint32_t arg) { + return ((LDKCResult_NoneNoneZ*)arg)->result_ok; +} +void __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_get_ok(uint32_t arg) { + LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1); + CHECK(val->result_ok); + return *val->contents.result; +} +void __attribute__((visibility("default"))) TS_LDKCResult_NoneNoneZ_get_err(uint32_t arg) { + LDKCResult_NoneNoneZ *val = (LDKCResult_NoneNoneZ*)(arg & ~1); + CHECK(!val->result_ok); + return *val->contents.err; +} uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_SignatureCVec_SignatureZZ_new(int8_tArray a, ptrArray b) { LDKC2Tuple_SignatureCVec_SignatureZZ* ret = MALLOC(sizeof(LDKC2Tuple_SignatureCVec_SignatureZZ), "LDKC2Tuple_SignatureCVec_SignatureZZ"); LDKSignature a_ref; @@ -1429,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; +} + +static inline struct LDKCVec_SignatureZ C2Tuple_SignatureCVec_SignatureZZ_get_b(LDKC2Tuple_SignatureCVec_SignatureZZ *NONNULL_PTR tuple){ + return tuple->b; } -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; +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); @@ -1480,8 +1546,10 @@ typedef struct LDKBaseSign_JCalls { atomic_size_t refcnt; uint32_t get_per_commitment_point_meth; uint32_t release_commitment_secret_meth; + uint32_t validate_holder_commitment_meth; uint32_t channel_keys_id_meth; uint32_t sign_counterparty_commitment_meth; + uint32_t validate_counterparty_revocation_meth; uint32_t sign_holder_commitment_and_htlcs_meth; uint32_t sign_justice_revoked_output_meth; uint32_t sign_justice_revoked_htlc_meth; @@ -1495,8 +1563,10 @@ static void LDKBaseSign_JCalls_free(void* this_arg) { if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { js_free(j_calls->get_per_commitment_point_meth); js_free(j_calls->release_commitment_secret_meth); + js_free(j_calls->validate_holder_commitment_meth); js_free(j_calls->channel_keys_id_meth); js_free(j_calls->sign_counterparty_commitment_meth); + js_free(j_calls->validate_counterparty_revocation_meth); js_free(j_calls->sign_holder_commitment_and_htlcs_meth); js_free(j_calls->sign_justice_revoked_output_meth); js_free(j_calls->sign_justice_revoked_htlc_meth); @@ -1523,6 +1593,21 @@ LDKThirtyTwoBytes release_commitment_secret_LDKBaseSign_jcall(const void* this_a memcpy(ret_ref.data, (uint8_t*)(ret + 4), 32); return ret_ref; } +LDKCResult_NoneNoneZ validate_holder_commitment_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * holder_tx) { + LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg; + LDKHolderCommitmentTransaction holder_tx_var = *holder_tx; + holder_tx_var = HolderCommitmentTransaction_clone(holder_tx); + CHECK((((uint64_t)holder_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&holder_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t holder_tx_ref = (uint64_t)holder_tx_var.inner; + if (holder_tx_var.is_owned) { + holder_tx_ref |= 1; + } + uint32_t ret = js_invoke_function_1(j_calls->validate_holder_commitment_meth, holder_tx_ref); + LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1); + ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1)); + return ret_conv; +} LDKThirtyTwoBytes channel_keys_id_LDKBaseSign_jcall(const void* this_arg) { LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg; int8_tArray ret = js_invoke_function_0(j_calls->channel_keys_id_meth); @@ -1546,6 +1631,15 @@ LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_counterparty_commitment_L ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_clone((LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ*)(((uint64_t)ret) & ~1)); return ret_conv; } +LDKCResult_NoneNoneZ validate_counterparty_revocation_LDKBaseSign_jcall(const void* this_arg, uint64_t idx, const uint8_t (* secret)[32]) { + LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg; + int8_tArray secret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(secret_arr + 4), *secret, 32); + uint32_t ret = js_invoke_function_2(j_calls->validate_counterparty_revocation_meth, idx, secret_arr); + LDKCResult_NoneNoneZ ret_conv = *(LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1); + ret_conv = CResult_NoneNoneZ_clone((LDKCResult_NoneNoneZ*)(((uint64_t)ret) & ~1)); + return ret_conv; +} LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ sign_holder_commitment_and_htlcs_LDKBaseSign_jcall(const void* this_arg, const LDKHolderCommitmentTransaction * commitment_tx) { LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg; LDKHolderCommitmentTransaction commitment_tx_var = *commitment_tx; @@ -1616,13 +1710,17 @@ LDKCResult_SignatureNoneZ sign_counterparty_htlc_transaction_LDKBaseSign_jcall(c ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1)); return ret_conv; } -LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, LDKTransaction closing_tx) { +LDKCResult_SignatureNoneZ sign_closing_transaction_LDKBaseSign_jcall(const void* this_arg, const LDKClosingTransaction * closing_tx) { LDKBaseSign_JCalls *j_calls = (LDKBaseSign_JCalls*) this_arg; - LDKTransaction closing_tx_var = closing_tx; - int8_tArray closing_tx_arr = init_arr(closing_tx_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(closing_tx_arr + 4), closing_tx_var.data, closing_tx_var.datalen); - Transaction_free(closing_tx_var); - uint32_t ret = js_invoke_function_1(j_calls->sign_closing_transaction_meth, closing_tx_arr); + LDKClosingTransaction closing_tx_var = *closing_tx; + // Warning: we may need a move here but no clone is available for LDKClosingTransaction + CHECK((((uint64_t)closing_tx_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&closing_tx_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t closing_tx_ref = (uint64_t)closing_tx_var.inner; + if (closing_tx_var.is_owned) { + closing_tx_ref |= 1; + } + uint32_t ret = js_invoke_function_1(j_calls->sign_closing_transaction_meth, closing_tx_ref); LDKCResult_SignatureNoneZ ret_conv = *(LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1); ret_conv = CResult_SignatureNoneZ_clone((LDKCResult_SignatureNoneZ*)(((uint64_t)ret) & ~1)); return ret_conv; @@ -1672,8 +1770,10 @@ static inline LDKBaseSign LDKBaseSign_init (/*TODO: JS Object Reference */void* .this_arg = (void*) calls, .get_per_commitment_point = get_per_commitment_point_LDKBaseSign_jcall, .release_commitment_secret = release_commitment_secret_LDKBaseSign_jcall, + .validate_holder_commitment = validate_holder_commitment_LDKBaseSign_jcall, .channel_keys_id = channel_keys_id_LDKBaseSign_jcall, .sign_counterparty_commitment = sign_counterparty_commitment_LDKBaseSign_jcall, + .validate_counterparty_revocation = validate_counterparty_revocation_LDKBaseSign_jcall, .sign_holder_commitment_and_htlcs = sign_holder_commitment_and_htlcs_LDKBaseSign_jcall, .sign_justice_revoked_output = sign_justice_revoked_output_LDKBaseSign_jcall, .sign_justice_revoked_htlc = sign_justice_revoked_htlc_LDKBaseSign_jcall, @@ -1706,6 +1806,16 @@ int8_tArray __attribute__((visibility("default"))) TS_BaseSign_release_commitme return ret_arr; } +uint32_t __attribute__((visibility("default"))) TS_BaseSign_validate_holder_commitment(uint32_t this_arg, uint32_t holder_tx) { + LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1); + LDKHolderCommitmentTransaction holder_tx_conv; + holder_tx_conv.inner = (void*)(holder_tx & (~1)); + holder_tx_conv.is_owned = false; + LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ"); + *ret_conv = (this_arg_conv->validate_holder_commitment)(this_arg_conv->this_arg, &holder_tx_conv); + return (uint64_t)ret_conv; +} + int8_tArray __attribute__((visibility("default"))) TS_BaseSign_channel_keys_id(uint32_t this_arg) { LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1); int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); @@ -1723,6 +1833,17 @@ uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_counterparty_c return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_BaseSign_validate_counterparty_revocation(uint32_t this_arg, int64_t idx, int8_tArray secret) { + LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1); + unsigned char secret_arr[32]; + CHECK(*((uint32_t*)secret) == 32); + memcpy(secret_arr, (uint8_t*)(secret + 4), 32); + unsigned char (*secret_ref)[32] = &secret_arr; + LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ"); + *ret_conv = (this_arg_conv->validate_counterparty_revocation)(this_arg_conv->this_arg, idx, secret_ref); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_holder_commitment_and_htlcs(uint32_t this_arg, uint32_t commitment_tx) { LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1); LDKHolderCommitmentTransaction commitment_tx_conv; @@ -1786,15 +1907,13 @@ uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_counterparty_h return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_closing_transaction(uint32_t this_arg, int8_tArray closing_tx) { +uint32_t __attribute__((visibility("default"))) TS_BaseSign_sign_closing_transaction(uint32_t this_arg, uint32_t closing_tx) { LDKBaseSign* this_arg_conv = (LDKBaseSign*)(((uint64_t)this_arg) & ~1); - LDKTransaction closing_tx_ref; - closing_tx_ref.datalen = *((uint32_t*)closing_tx); - closing_tx_ref.data = MALLOC(closing_tx_ref.datalen, "LDKTransaction Bytes"); - memcpy(closing_tx_ref.data, (uint8_t*)(closing_tx + 4), closing_tx_ref.datalen); - closing_tx_ref.data_is_owned = true; + LDKClosingTransaction closing_tx_conv; + closing_tx_conv.inner = (void*)(closing_tx & (~1)); + closing_tx_conv.is_owned = false; LDKCResult_SignatureNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SignatureNoneZ), "LDKCResult_SignatureNoneZ"); - *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, closing_tx_ref); + *ret_conv = (this_arg_conv->sign_closing_transaction)(this_arg_conv->this_arg, &closing_tx_conv); return (uint64_t)ret_conv; } @@ -1899,9 +2018,9 @@ jboolean __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_ok(uint32_t arg) { LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1); CHECK(val->result_ok); - LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign"); - *ret = Sign_clone(&(*val->contents.result)); - return (uint64_t)ret; + LDKSign* res_ret =MALLOC(sizeof(LDKSign), "LDKSign"); + *res_ret = Sign_clone(&(*val->contents.result)); + return (uint64_t)res_ret; } uint32_t __attribute__((visibility("default"))) TS_LDKCResult_SignDecodeErrorZ_get_err(uint32_t arg) { LDKCResult_SignDecodeErrorZ *val = (LDKCResult_SignDecodeErrorZ*)(arg & ~1); @@ -2030,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; +} + +static inline struct LDKChannelMonitor C2Tuple_BlockHashChannelMonitorZ_get_b(LDKC2Tuple_BlockHashChannelMonitorZ *NONNULL_PTR tuple){ + return ChannelMonitor_clone(&tuple->b); } -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; +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); @@ -2055,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; } @@ -2070,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; } @@ -2082,6 +2221,27 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_CVec_C2Tuple_Bloc uint32_t err_conv = LDKIOError_to_js((*val->contents.err)); return err_conv; } +jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdDecodeErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_PaymentIdDecodeErrorZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdDecodeErrorZ_get_ok(uint32_t arg) { + LDKCResult_PaymentIdDecodeErrorZ *val = (LDKCResult_PaymentIdDecodeErrorZ*)(arg & ~1); + CHECK(val->result_ok); + LDKPaymentId res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdDecodeErrorZ_get_err(uint32_t arg) { + LDKCResult_PaymentIdDecodeErrorZ *val = (LDKCResult_PaymentIdDecodeErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + LDKDecodeError err_var = (*val->contents.err); + CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t err_ref = (uint64_t)err_var.inner & ~1; + return err_ref; +} uint32_t __attribute__((visibility("default"))) TS_LDKCOption_u16Z_ref_from_ptr(uint32_t ptr) { LDKCOption_u16Z *obj = (LDKCOption_u16Z*)(ptr & ~1); switch(obj->tag) { @@ -2192,6 +2352,22 @@ static inline LDKCVec_APIErrorZ CVec_APIErrorZ_clone(const LDKCVec_APIErrorZ *or } return ret; } +jboolean __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult__u832APIErrorZ*)arg)->result_ok; +} +int8_tArray __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_get_ok(uint32_t arg) { + LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1); + CHECK(val->result_ok); + int8_tArray res_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).data, 32); + return res_arr; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult__u832APIErrorZ_get_err(uint32_t arg) { + LDKCResult__u832APIErrorZ *val = (LDKCResult__u832APIErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1; + return err_ref; +} uint32_t __attribute__((visibility("default"))) TS_LDKPaymentSendFailure_ref_from_ptr(uint32_t ptr) { LDKPaymentSendFailure *obj = (LDKPaymentSendFailure*)(ptr & ~1); switch(obj->tag) { @@ -2236,6 +2412,24 @@ uint32_t __attribute__((visibility("default"))) TS_LDKPaymentSendFailure_ref_fro default: abort(); } } +jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_result_ok(uint32_t arg) { + return ((LDKCResult_PaymentIdPaymentSendFailureZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_get_ok(uint32_t arg) { + LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1); + CHECK(val->result_ok); + LDKPaymentId res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentIdPaymentSendFailureZ_get_err(uint32_t arg) { + LDKCResult_PaymentIdPaymentSendFailureZ *val = (LDKCResult_PaymentIdPaymentSendFailureZ*)(arg & ~1); + CHECK(!val->result_ok); + uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1; + return err_ref; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFailureZ_result_ok(uint32_t arg) { return ((LDKCResult_NonePaymentSendFailureZ*)arg)->result_ok; } @@ -2250,18 +2444,57 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NonePaymentSendFa uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1; return err_ref; } -jboolean __attribute__((visibility("default"))) TS_LDKCResult_PaymentHashPaymentSendFailureZ_result_ok(uint32_t arg) { - return ((LDKCResult_PaymentHashPaymentSendFailureZ*)arg)->result_ok; +uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, uint32_t b) { + LDKC2Tuple_PaymentHashPaymentIdZ* ret = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ"); + LDKThirtyTwoBytes a_ref; + CHECK(*((uint32_t*)a) == 32); + memcpy(a_ref.data, (uint8_t*)(a + 4), 32); + ret->a = a_ref; + LDKPaymentId b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = (b & 1) || (b == 0); + b_conv = PaymentId_clone(&b_conv); + ret->b = b_conv; + return (uint64_t)ret; +} +static inline struct LDKThirtyTwoBytes C2Tuple_PaymentHashPaymentIdZ_get_a(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR tuple){ + return ThirtyTwoBytes_clone(&tuple->a); +} +int8_tArray __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_a(uint32_t tuple) { + LDKC2Tuple_PaymentHashPaymentIdZ* tuple_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(tuple & ~1); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), C2Tuple_PaymentHashPaymentIdZ_get_a(tuple_conv).data, 32); + return ret_arr; +} + +static inline struct LDKPaymentId C2Tuple_PaymentHashPaymentIdZ_get_b(LDKC2Tuple_PaymentHashPaymentIdZ *NONNULL_PTR tuple){ + return PaymentId_clone(&tuple->b); +} +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_get_b(uint32_t tuple) { + LDKC2Tuple_PaymentHashPaymentIdZ* tuple_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(tuple & ~1); + LDKPaymentId ret_var = C2Tuple_PaymentHashPaymentIdZ_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; +} + +jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_result_ok(uint32_t arg) { + return ((LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)arg)->result_ok; } -int8_tArray __attribute__((visibility("default"))) TS_LDKCResult_PaymentHashPaymentSendFailureZ_get_ok(uint32_t arg) { - LDKCResult_PaymentHashPaymentSendFailureZ *val = (LDKCResult_PaymentHashPaymentSendFailureZ*)(arg & ~1); +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_ok(uint32_t arg) { + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1); CHECK(val->result_ok); - int8_tArray res_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(res_arr + 4), (*val->contents.result).data, 32); - return res_arr; + LDKC2Tuple_PaymentHashPaymentIdZ* res_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ"); + *res_conv = (*val->contents.result); + *res_conv = C2Tuple_PaymentHashPaymentIdZ_clone(res_conv); + return ((uint64_t)res_conv); } -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PaymentHashPaymentSendFailureZ_get_err(uint32_t arg) { - LDKCResult_PaymentHashPaymentSendFailureZ *val = (LDKCResult_PaymentHashPaymentSendFailureZ*)(arg & ~1); +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_get_err(uint32_t arg) { + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ *val = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(arg & ~1); CHECK(!val->result_ok); uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1; return err_ref; @@ -2328,18 +2561,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; } @@ -2717,9 +2958,9 @@ uint32_t __attribute__((visibility("default"))) TS_KeysInterface_get_shutdown_s uint32_t __attribute__((visibility("default"))) TS_KeysInterface_get_channel_signer(uint32_t this_arg, jboolean inbound, int64_t channel_value_satoshis) { LDKKeysInterface* this_arg_conv = (LDKKeysInterface*)(((uint64_t)this_arg) & ~1); - LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign"); - *ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis); - return (uint64_t)ret; + LDKSign* ret_ret =MALLOC(sizeof(LDKSign), "LDKSign"); + *ret_ret = (this_arg_conv->get_channel_signer)(this_arg_conv->this_arg, inbound, channel_value_satoshis); + return (uint64_t)ret_ret; } int8_tArray __attribute__((visibility("default"))) TS_KeysInterface_get_secure_random_bytes(uint32_t this_arg) { @@ -2845,28 +3086,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); @@ -2919,6 +3170,119 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_OutPointDecodeErr uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } +typedef struct LDKType_JCalls { + atomic_size_t refcnt; + uint32_t type_id_meth; + uint32_t debug_str_meth; + uint32_t write_meth; +} LDKType_JCalls; +static void LDKType_JCalls_free(void* this_arg) { + LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->type_id_meth); + js_free(j_calls->debug_str_meth); + js_free(j_calls->write_meth); + FREE(j_calls); + } +} +uint16_t type_id_LDKType_jcall(const void* this_arg) { + LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg; + return js_invoke_function_0(j_calls->type_id_meth); +} +LDKStr debug_str_LDKType_jcall(const void* this_arg) { + LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg; + uint32_t ret = js_invoke_function_0(j_calls->debug_str_meth); + LDKStr ret_conv = str_ref_to_owned_c(ret); + return ret_conv; +} +LDKCVec_u8Z write_LDKType_jcall(const void* this_arg) { + LDKType_JCalls *j_calls = (LDKType_JCalls*) this_arg; + int8_tArray ret = js_invoke_function_0(j_calls->write_meth); + LDKCVec_u8Z ret_ref; + ret_ref.datalen = *((uint32_t*)ret); + ret_ref.data = MALLOC(ret_ref.datalen, "LDKCVec_u8Z Bytes"); + memcpy(ret_ref.data, (uint8_t*)(ret + 4), ret_ref.datalen); + return ret_ref; +} +static void LDKType_JCalls_cloned(LDKType* new_obj) { + LDKType_JCalls *j_calls = (LDKType_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); +} +static inline LDKType LDKType_init (/*TODO: JS Object Reference */void* o) { + LDKType_JCalls *calls = MALLOC(sizeof(LDKType_JCalls), "LDKType_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKType ret = { + .this_arg = (void*) calls, + .type_id = type_id_LDKType_jcall, + .debug_str = debug_str_LDKType_jcall, + .write = write_LDKType_jcall, + .cloned = LDKType_JCalls_cloned, + .free = LDKType_JCalls_free, + }; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKType_new(/*TODO: JS Object Reference */void* o) { + LDKType *res_ptr = MALLOC(sizeof(LDKType), "LDKType"); + *res_ptr = LDKType_init(o); + return (long)res_ptr; +} +int16_t __attribute__((visibility("default"))) TS_Type_type_id(uint32_t this_arg) { + LDKType* this_arg_conv = (LDKType*)(((uint64_t)this_arg) & ~1); + int16_t ret_val = (this_arg_conv->type_id)(this_arg_conv->this_arg); + return ret_val; +} + +jstring __attribute__((visibility("default"))) TS_Type_debug_str(uint32_t this_arg) { + LDKType* this_arg_conv = (LDKType*)(((uint64_t)this_arg) & ~1); + LDKStr ret_str = (this_arg_conv->debug_str)(this_arg_conv->this_arg); + jstring ret_conv = str_ref_to_ts(ret_str.chars, ret_str.len); + Str_free(ret_str); + return ret_conv; +} + +int8_tArray __attribute__((visibility("default"))) TS_Type_write(uint32_t this_arg) { + LDKType* this_arg_conv = (LDKType*)(((uint64_t)this_arg) & ~1); + LDKCVec_u8Z ret_var = (this_arg_conv->write)(this_arg_conv->this_arg); + 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_LDKCOption_TypeZ_ref_from_ptr(uint32_t ptr) { + LDKCOption_TypeZ *obj = (LDKCOption_TypeZ*)(ptr & ~1); + switch(obj->tag) { + case LDKCOption_TypeZ_Some: { + LDKType* some_ret =MALLOC(sizeof(LDKType), "LDKType"); + *some_ret = Type_clone(&obj->some); + return 0 /* LDKCOption_TypeZ - Some */; (void) (uint64_t)some_ret; + } + case LDKCOption_TypeZ_None: { + return 0 /* LDKCOption_TypeZ - None */; + } + default: abort(); + } +} +jboolean __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_COption_TypeZDecodeErrorZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_get_ok(uint32_t arg) { + LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1); + CHECK(val->result_ok); + uint64_t res_ref = ((uint64_t)&(*val->contents.result)) | 1; + return res_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_COption_TypeZDecodeErrorZ_get_err(uint32_t arg) { + LDKCResult_COption_TypeZDecodeErrorZ *val = (LDKCResult_COption_TypeZDecodeErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + LDKDecodeError err_var = (*val->contents.err); + CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t err_ref = (uint64_t)err_var.inner & ~1; + return err_ref; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_SiPrefixNoneZ_result_ok(uint32_t arg) { return ((LDKCResult_SiPrefixNoneZ*)arg)->result_ok; } @@ -2985,33 +3349,51 @@ 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; -} -jboolean __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_result_ok(uint32_t arg) { - return ((LDKCResult_PayeePubKeyErrorZ*)arg)->result_ok; +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_LDKCResult_PayeePubKeyErrorZ_get_ok(uint32_t arg) { - LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1); +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; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_PayeePubKeyErrorZ_get_ok(uint32_t arg) { + LDKCResult_PayeePubKeyErrorZ *val = (LDKCResult_PayeePubKeyErrorZ*)(arg & ~1); CHECK(val->result_ok); LDKPayeePubKey res_var = (*val->contents.result); CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. @@ -3244,21 +3626,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; @@ -3269,17 +3663,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); @@ -3317,32 +3721,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); @@ -3385,6 +3799,37 @@ uint32_t __attribute__((visibility("default"))) TS_LDKPaymentPurpose_ref_from_pt default: abort(); } } +uint32_t __attribute__((visibility("default"))) TS_LDKClosureReason_ref_from_ptr(uint32_t ptr) { + LDKClosureReason *obj = (LDKClosureReason*)(ptr & ~1); + switch(obj->tag) { + case LDKClosureReason_CounterpartyForceClosed: { + LDKStr peer_msg_str = obj->counterparty_force_closed.peer_msg; + jstring peer_msg_conv = str_ref_to_ts(peer_msg_str.chars, peer_msg_str.len); + return 0 /* LDKClosureReason - CounterpartyForceClosed */; (void) peer_msg_conv; + } + case LDKClosureReason_HolderForceClosed: { + return 0 /* LDKClosureReason - HolderForceClosed */; + } + case LDKClosureReason_CooperativeClosure: { + return 0 /* LDKClosureReason - CooperativeClosure */; + } + case LDKClosureReason_CommitmentTxConfirmed: { + return 0 /* LDKClosureReason - CommitmentTxConfirmed */; + } + case LDKClosureReason_ProcessingError: { + LDKStr err_str = obj->processing_error.err; + jstring err_conv = str_ref_to_ts(err_str.chars, err_str.len); + return 0 /* LDKClosureReason - ProcessingError */; (void) err_conv; + } + case LDKClosureReason_DisconnectedPeer: { + return 0 /* LDKClosureReason - DisconnectedPeer */; + } + case LDKClosureReason_OutdatedChannelManager: { + return 0 /* LDKClosureReason - OutdatedChannelManager */; + } + default: abort(); + } +} uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_t ptr) { LDKEvent *obj = (LDKEvent*)(ptr & ~1); switch(obj->tag) { @@ -3405,12 +3850,26 @@ uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_ case LDKEvent_PaymentSent: { int8_tArray payment_preimage_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); memcpy((uint8_t*)(payment_preimage_arr + 4), obj->payment_sent.payment_preimage.data, 32); - return 0 /* LDKEvent - PaymentSent */; (void) payment_preimage_arr; + int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_sent.payment_hash.data, 32); + return 0 /* LDKEvent - PaymentSent */; (void) payment_preimage_arr; (void) payment_hash_arr; } - case LDKEvent_PaymentFailed: { + case LDKEvent_PaymentPathFailed: { int8_tArray payment_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_failed.payment_hash.data, 32); - return 0 /* LDKEvent - PaymentFailed */; (void) payment_hash_arr; (void) obj->payment_failed.rejected_by_dest; + memcpy((uint8_t*)(payment_hash_arr + 4), obj->payment_path_failed.payment_hash.data, 32); + uint64_t network_update_ref = ((uint64_t)&obj->payment_path_failed.network_update) | 1; + LDKCVec_RouteHopZ path_var = obj->payment_path_failed.path; + uint32_tArray path_arr = init_arr(path_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); + uint32_t *path_arr_ptr = (uint32_t*)(path_arr + 4); + for (size_t k = 0; k < path_var.datalen; k++) { + LDKRouteHop path_conv_10_var = path_var.data[k]; + CHECK((((uint64_t)path_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&path_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t path_conv_10_ref = (uint64_t)path_conv_10_var.inner & ~1; + path_arr_ptr[k] = path_conv_10_ref; + } + uint64_t short_channel_id_ref = ((uint64_t)&obj->payment_path_failed.short_channel_id) | 1; + return 0 /* LDKEvent - PaymentPathFailed */; (void) payment_hash_arr; (void) obj->payment_path_failed.rejected_by_dest; (void) network_update_ref; (void) obj->payment_path_failed.all_paths_failed; (void) path_arr; (void) short_channel_id_ref; } case LDKEvent_PendingHTLCsForwardable: { return 0 /* LDKEvent - PendingHTLCsForwardable */; (void) obj->pending_htl_cs_forwardable.time_forwardable; @@ -3429,6 +3888,20 @@ uint32_t __attribute__((visibility("default"))) TS_LDKEvent_ref_from_ptr(uint32_ uint64_t fee_earned_msat_ref = ((uint64_t)&obj->payment_forwarded.fee_earned_msat) | 1; return 0 /* LDKEvent - PaymentForwarded */; (void) fee_earned_msat_ref; (void) obj->payment_forwarded.claim_from_onchain_tx; } + case LDKEvent_ChannelClosed: { + int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(channel_id_arr + 4), obj->channel_closed.channel_id.data, 32); + uint64_t reason_ref = ((uint64_t)&obj->channel_closed.reason) | 1; + return 0 /* LDKEvent - ChannelClosed */; (void) channel_id_arr; (void) obj->channel_closed.user_channel_id; (void) reason_ref; + } + case LDKEvent_DiscardFunding: { + int8_tArray channel_id_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(channel_id_arr + 4), obj->discard_funding.channel_id.data, 32); + LDKTransaction transaction_var = obj->discard_funding.transaction; + int8_tArray transaction_arr = init_arr(transaction_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(transaction_arr + 4), transaction_var.data, transaction_var.datalen); + return 0 /* LDKEvent - DiscardFunding */; (void) channel_id_arr; (void) transaction_arr; + } default: abort(); } } @@ -3464,15 +3937,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); @@ -3510,32 +3993,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); @@ -3560,14 +4053,58 @@ static inline LDKCVec_C2Tuple_TxidCVec_C2Tuple_u32TxOutZZZZ CVec_C2Tuple_TxidCVe } return ret; } +uint32_t __attribute__((visibility("default"))) TS_LDKBalance_ref_from_ptr(uint32_t ptr) { + LDKBalance *obj = (LDKBalance*)(ptr & ~1); + switch(obj->tag) { + case LDKBalance_ClaimableOnChannelClose: { + return 0 /* LDKBalance - ClaimableOnChannelClose */; (void) obj->claimable_on_channel_close.claimable_amount_satoshis; + } + case LDKBalance_ClaimableAwaitingConfirmations: { + return 0 /* LDKBalance - ClaimableAwaitingConfirmations */; (void) obj->claimable_awaiting_confirmations.claimable_amount_satoshis; (void) obj->claimable_awaiting_confirmations.confirmation_height; + } + case LDKBalance_ContentiousClaimable: { + return 0 /* LDKBalance - ContentiousClaimable */; (void) obj->contentious_claimable.claimable_amount_satoshis; (void) obj->contentious_claimable.timeout_height; + } + case LDKBalance_MaybeClaimableHTLCAwaitingTimeout: { + return 0 /* LDKBalance - MaybeClaimableHTLCAwaitingTimeout */; (void) obj->maybe_claimable_htlc_awaiting_timeout.claimable_amount_satoshis; (void) obj->maybe_claimable_htlc_awaiting_timeout.claimable_height; + } + default: abort(); + } +} +uint32_t __attribute__((visibility("default"))) TS_LDKCVec_BalanceZ_new(uint32_tArray elems) { + LDKCVec_BalanceZ *ret = MALLOC(sizeof(LDKCVec_BalanceZ), "LDKCVec_BalanceZ"); + ret->datalen = *((uint32_t*)elems); + if (ret->datalen == 0) { + ret->data = NULL; + } else { + ret->data = MALLOC(sizeof(LDKBalance) * ret->datalen, "LDKCVec_BalanceZ Data"); + uint32_t *java_elems = (uint32_t*)(elems + 4); + for (size_t i = 0; i < ret->datalen; i++) { + uint32_t arr_elem = java_elems[i]; + LDKBalance arr_elem_conv = *(LDKBalance*)(((uint64_t)arr_elem) & ~1); + arr_elem_conv = Balance_clone((LDKBalance*)(((uint64_t)arr_elem) & ~1)); + ret->data[i] = arr_elem_conv; + } + } + return (uint64_t)ret; +} +static inline LDKCVec_BalanceZ CVec_BalanceZ_clone(const LDKCVec_BalanceZ *orig) { + LDKCVec_BalanceZ ret = { .data = MALLOC(sizeof(LDKBalance) * orig->datalen, "LDKCVec_BalanceZ clone bytes"), .datalen = orig->datalen }; + for (size_t i = 0; i < ret.datalen; i++) { + ret.data[i] = Balance_clone(&orig->data[i]); + } + return ret; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ*)arg)->result_ok; } 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); @@ -3578,6 +4115,78 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_C2Tuple_BlockHash uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } +jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok; +} +void __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_ok(uint32_t arg) { + LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1); + CHECK(val->result_ok); + return *val->contents.result; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_err(uint32_t arg) { + LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + LDKLightningError err_var = (*val->contents.err); + CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t err_ref = (uint64_t)err_var.inner & ~1; + return err_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKC2Tuple_PublicKeyTypeZ_new(int8_tArray a, uint32_t b) { + LDKC2Tuple_PublicKeyTypeZ* ret = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKC2Tuple_PublicKeyTypeZ"); + LDKPublicKey a_ref; + CHECK(*((uint32_t*)a) == 33); + memcpy(a_ref.compressed_form, (uint8_t*)(a + 4), 33); + ret->a = a_ref; + LDKType b_conv = *(LDKType*)(((uint64_t)b) & ~1); + b_conv = Type_clone(&b_conv); + ret->b = b_conv; + return (uint64_t)ret; +} +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; +} + +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); + if (ret->datalen == 0) { + ret->data = NULL; + } else { + ret->data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * ret->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ Data"); + uint32_t *java_elems = (uint32_t*)(elems + 4); + for (size_t i = 0; i < ret->datalen; i++) { + uint32_t arr_elem = java_elems[i]; + LDKC2Tuple_PublicKeyTypeZ arr_elem_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1); + arr_elem_conv = C2Tuple_PublicKeyTypeZ_clone((LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)arr_elem) & ~1)); + ret->data[i] = arr_elem_conv; + } + } + return (uint64_t)ret; +} +static inline LDKCVec_C2Tuple_PublicKeyTypeZZ CVec_C2Tuple_PublicKeyTypeZZ_clone(const LDKCVec_C2Tuple_PublicKeyTypeZZ *orig) { + LDKCVec_C2Tuple_PublicKeyTypeZZ ret = { .data = MALLOC(sizeof(LDKC2Tuple_PublicKeyTypeZ) * orig->datalen, "LDKCVec_C2Tuple_PublicKeyTypeZZ clone bytes"), .datalen = orig->datalen }; + for (size_t i = 0; i < ret.datalen; i++) { + ret.data[i] = C2Tuple_PublicKeyTypeZ_clone(&orig->data[i]); + } + return ret; +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_boolLightningErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_boolLightningErrorZ*)arg)->result_ok; } @@ -3614,30 +4223,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); @@ -3688,23 +4318,6 @@ static inline LDKCVec_NodeAnnouncementZ CVec_NodeAnnouncementZ_clone(const LDKCV } return ret; } -jboolean __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_result_ok(uint32_t arg) { - return ((LDKCResult_NoneLightningErrorZ*)arg)->result_ok; -} -void __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_ok(uint32_t arg) { - LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1); - CHECK(val->result_ok); - return *val->contents.result; -} -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NoneLightningErrorZ_get_err(uint32_t arg) { - LDKCResult_NoneLightningErrorZ *val = (LDKCResult_NoneLightningErrorZ*)(arg & ~1); - CHECK(!val->result_ok); - LDKLightningError err_var = (*val->contents.err); - CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t err_ref = (uint64_t)err_var.inner & ~1; - return err_ref; -} jboolean __attribute__((visibility("default"))) TS_LDKCResult_CVec_u8ZPeerHandleErrorZ_result_ok(uint32_t arg) { return ((LDKCResult_CVec_u8ZPeerHandleErrorZ*)arg)->result_ok; } @@ -3759,20 +4372,20 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_boolPeerHandleErr uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } -jboolean __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) { - return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok; +jboolean __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_NodeIdDecodeErrorZ*)arg)->result_ok; } -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(uint32_t arg) { - LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1); +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_get_ok(uint32_t arg) { + LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1); CHECK(val->result_ok); - LDKDirectionalChannelInfo res_var = (*val->contents.result); + LDKNodeId res_var = (*val->contents.result); CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. uint64_t res_ref = (uint64_t)res_var.inner & ~1; return res_ref; } -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(uint32_t arg) { - LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1); +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NodeIdDecodeErrorZ_get_err(uint32_t arg) { + LDKCResult_NodeIdDecodeErrorZ *val = (LDKCResult_NodeIdDecodeErrorZ*)(arg & ~1); CHECK(!val->result_ok); LDKDecodeError err_var = (*val->contents.err); CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. @@ -3780,24 +4393,112 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChanne uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } -jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_result_ok(uint32_t arg) { - return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok; +typedef struct LDKAccess_JCalls { + atomic_size_t refcnt; + uint32_t get_utxo_meth; +} LDKAccess_JCalls; +static void LDKAccess_JCalls_free(void* this_arg) { + LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->get_utxo_meth); + FREE(j_calls); + } } -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t arg) { - LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1); - CHECK(val->result_ok); - LDKChannelInfo res_var = (*val->contents.result); - CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t res_ref = (uint64_t)res_var.inner & ~1; - return res_ref; +LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) { + LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg; + int8_tArray genesis_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(genesis_hash_arr + 4), *genesis_hash, 32); + uint32_t ret = js_invoke_function_2(j_calls->get_utxo_meth, genesis_hash_arr, short_channel_id); + LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1); + ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1)); + return ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_err(uint32_t arg) { - LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1); - CHECK(!val->result_ok); - LDKDecodeError err_var = (*val->contents.err); - CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. +static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) { + LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); +} +static inline LDKAccess LDKAccess_init (/*TODO: JS Object Reference */void* o) { + LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKAccess ret = { + .this_arg = (void*) calls, + .get_utxo = get_utxo_LDKAccess_jcall, + .free = LDKAccess_JCalls_free, + }; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKAccess_new(/*TODO: JS Object Reference */void* o) { + LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); + *res_ptr = LDKAccess_init(o); + return (long)res_ptr; +} +uint32_t __attribute__((visibility("default"))) TS_Access_get_utxo(uint32_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) { + LDKAccess* this_arg_conv = (LDKAccess*)(((uint64_t)this_arg) & ~1); + unsigned char genesis_hash_arr[32]; + CHECK(*((uint32_t*)genesis_hash) == 32); + memcpy(genesis_hash_arr, (uint8_t*)(genesis_hash + 4), 32); + unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr; + LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ"); + *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_LDKCOption_AccessZ_ref_from_ptr(uint32_t ptr) { + LDKCOption_AccessZ *obj = (LDKCOption_AccessZ*)(ptr & ~1); + switch(obj->tag) { + case LDKCOption_AccessZ_Some: { + LDKAccess* some_ret =MALLOC(sizeof(LDKAccess), "LDKAccess"); + *some_ret = obj->some; + // Warning: We likely need to clone here, but no clone is available, so we just do it for Java instances + return 0 /* LDKCOption_AccessZ - Some */; (void) (uint64_t)some_ret; + } + case LDKCOption_AccessZ_None: { + return 0 /* LDKCOption_AccessZ - None */; + } + default: abort(); + } +} +jboolean __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_DirectionalChannelInfoDecodeErrorZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_ok(uint32_t arg) { + LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1); + CHECK(val->result_ok); + LDKDirectionalChannelInfo res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_DirectionalChannelInfoDecodeErrorZ_get_err(uint32_t arg) { + LDKCResult_DirectionalChannelInfoDecodeErrorZ *val = (LDKCResult_DirectionalChannelInfoDecodeErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + LDKDecodeError err_var = (*val->contents.err); + CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t err_ref = (uint64_t)err_var.inner & ~1; + return err_ref; +} +jboolean __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_result_ok(uint32_t arg) { + return ((LDKCResult_ChannelInfoDecodeErrorZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_ok(uint32_t arg) { + LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1); + CHECK(val->result_ok); + LDKChannelInfo res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_ChannelInfoDecodeErrorZ_get_err(uint32_t arg) { + LDKCResult_ChannelInfoDecodeErrorZ *val = (LDKCResult_ChannelInfoDecodeErrorZ*)(arg & ~1); + CHECK(!val->result_ok); + LDKDecodeError err_var = (*val->contents.err); + CHECK((((uint64_t)err_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&err_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } @@ -3904,6 +4605,25 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_NetworkGraphDecod uint64_t err_ref = (uint64_t)err_var.inner & ~1; return err_ref; } +uint32_t __attribute__((visibility("default"))) TS_LDKCOption_CVec_NetAddressZZ_ref_from_ptr(uint32_t ptr) { + LDKCOption_CVec_NetAddressZZ *obj = (LDKCOption_CVec_NetAddressZZ*)(ptr & ~1); + switch(obj->tag) { + case LDKCOption_CVec_NetAddressZZ_Some: { + LDKCVec_NetAddressZ some_var = obj->some; + uint32_tArray some_arr = init_arr(some_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); + uint32_t *some_arr_ptr = (uint32_t*)(some_arr + 4); + for (size_t m = 0; m < some_var.datalen; m++) { + uint64_t some_conv_12_ref = ((uint64_t)&some_var.data[m]) | 1; + some_arr_ptr[m] = some_conv_12_ref; + } + return 0 /* LDKCOption_CVec_NetAddressZZ - Some */; (void) some_arr; + } + case LDKCOption_CVec_NetAddressZZ_None: { + return 0 /* LDKCOption_CVec_NetAddressZZ - None */; + } + default: abort(); + } +} jboolean __attribute__((visibility("default"))) TS_LDKCResult_NetAddressu8Z_result_ok(uint32_t arg) { return ((LDKCResult_NetAddressu8Z*)arg)->result_ok; } @@ -4763,6 +5483,146 @@ uint32_t __attribute__((visibility("default"))) TS_LDKCResult_InvoiceSignOrCrea uint64_t err_ref = ((uint64_t)&(*val->contents.err)) | 1; return err_ref; } +typedef struct LDKFilter_JCalls { + atomic_size_t refcnt; + uint32_t register_tx_meth; + uint32_t register_output_meth; +} LDKFilter_JCalls; +static void LDKFilter_JCalls_free(void* this_arg) { + LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->register_tx_meth); + js_free(j_calls->register_output_meth); + FREE(j_calls); + } +} +void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) { + LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; + int8_tArray txid_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(txid_arr + 4), *txid, 32); + LDKu8slice script_pubkey_var = script_pubkey; + int8_tArray script_pubkey_arr = init_arr(script_pubkey_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(script_pubkey_arr + 4), script_pubkey_var.data, script_pubkey_var.datalen); + js_invoke_function_2(j_calls->register_tx_meth, txid_arr, script_pubkey_arr); +} +LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) { + LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; + LDKWatchedOutput output_var = output; + CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t output_ref = (uint64_t)output_var.inner; + if (output_var.is_owned) { + output_ref |= 1; + } + uint32_t ret = js_invoke_function_1(j_calls->register_output_meth, output_ref); + LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1); + ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1)); + return ret_conv; +} +static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) { + LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); +} +static inline LDKFilter LDKFilter_init (/*TODO: JS Object Reference */void* o) { + LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKFilter ret = { + .this_arg = (void*) calls, + .register_tx = register_tx_LDKFilter_jcall, + .register_output = register_output_LDKFilter_jcall, + .free = LDKFilter_JCalls_free, + }; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKFilter_new(/*TODO: JS Object Reference */void* o) { + LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter"); + *res_ptr = LDKFilter_init(o); + return (long)res_ptr; +} +void __attribute__((visibility("default"))) TS_Filter_register_tx(uint32_t this_arg, int8_tArray txid, int8_tArray script_pubkey) { + LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1); + unsigned char txid_arr[32]; + CHECK(*((uint32_t*)txid) == 32); + memcpy(txid_arr, (uint8_t*)(txid + 4), 32); + unsigned char (*txid_ref)[32] = &txid_arr; + LDKu8slice script_pubkey_ref; + script_pubkey_ref.datalen = *((uint32_t*)script_pubkey); + script_pubkey_ref.data = (int8_t*)(script_pubkey + 4); + (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref); +} + +uint32_t __attribute__((visibility("default"))) TS_Filter_register_output(uint32_t this_arg, uint32_t output) { + LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1); + LDKWatchedOutput output_conv; + output_conv.inner = (void*)(output & (~1)); + output_conv.is_owned = (output & 1) || (output == 0); + output_conv = WatchedOutput_clone(&output_conv); + LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ"); + *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_LDKCOption_FilterZ_ref_from_ptr(uint32_t ptr) { + LDKCOption_FilterZ *obj = (LDKCOption_FilterZ*)(ptr & ~1); + switch(obj->tag) { + case LDKCOption_FilterZ_Some: { + LDKFilter* some_ret =MALLOC(sizeof(LDKFilter), "LDKFilter"); + *some_ret = obj->some; + // Warning: We likely need to clone here, but no clone is available, so we just do it for Java instances + return 0 /* LDKCOption_FilterZ - Some */; (void) (uint64_t)some_ret; + } + case LDKCOption_FilterZ_None: { + return 0 /* LDKCOption_FilterZ - None */; + } + default: abort(); + } +} +jboolean __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_result_ok(uint32_t arg) { + return ((LDKCResult_LockedChannelMonitorNoneZ*)arg)->result_ok; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_get_ok(uint32_t arg) { + LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1); + CHECK(val->result_ok); + LDKLockedChannelMonitor res_var = (*val->contents.result); + CHECK((((uint64_t)res_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&res_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t res_ref = (uint64_t)res_var.inner & ~1; + return res_ref; +} +void __attribute__((visibility("default"))) TS_LDKCResult_LockedChannelMonitorNoneZ_get_err(uint32_t arg) { + LDKCResult_LockedChannelMonitorNoneZ *val = (LDKCResult_LockedChannelMonitorNoneZ*)(arg & ~1); + CHECK(!val->result_ok); + return *val->contents.err; +} +uint32_t __attribute__((visibility("default"))) TS_LDKCVec_OutPointZ_new(uint32_tArray elems) { + LDKCVec_OutPointZ *ret = MALLOC(sizeof(LDKCVec_OutPointZ), "LDKCVec_OutPointZ"); + ret->datalen = *((uint32_t*)elems); + if (ret->datalen == 0) { + ret->data = NULL; + } else { + ret->data = MALLOC(sizeof(LDKOutPoint) * ret->datalen, "LDKCVec_OutPointZ Data"); + uint32_t *java_elems = (uint32_t*)(elems + 4); + for (size_t i = 0; i < ret->datalen; i++) { + uint32_t arr_elem = java_elems[i]; + LDKOutPoint arr_elem_conv; + arr_elem_conv.inner = (void*)(arr_elem & (~1)); + arr_elem_conv.is_owned = (arr_elem & 1) || (arr_elem == 0); + arr_elem_conv = OutPoint_clone(&arr_elem_conv); + ret->data[i] = arr_elem_conv; + } + } + return (uint64_t)ret; +} +static inline LDKCVec_OutPointZ CVec_OutPointZ_clone(const LDKCVec_OutPointZ *orig) { + LDKCVec_OutPointZ ret = { .data = MALLOC(sizeof(LDKOutPoint) * orig->datalen, "LDKCVec_OutPointZ clone bytes"), .datalen = orig->datalen }; + for (size_t i = 0; i < ret.datalen; i++) { + ret.data[i] = OutPoint_clone(&orig->data[i]); + } + return ret; +} typedef struct LDKMessageSendEventsProvider_JCalls { atomic_size_t refcnt; uint32_t get_and_clear_pending_msg_events_meth; @@ -4839,12 +5699,11 @@ static void LDKEventHandler_JCalls_free(void* this_arg) { FREE(j_calls); } } -void handle_event_LDKEventHandler_jcall(const void* this_arg, LDKEvent event) { +void handle_event_LDKEventHandler_jcall(const void* this_arg, const LDKEvent * event) { LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) this_arg; - LDKEvent *event_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); - *event_copy = event; - uint64_t event_ref = (uint64_t)event_copy; - js_invoke_function_1(j_calls->handle_event_meth, event_ref); + LDKEvent *ret_event = MALLOC(sizeof(LDKEvent), "LDKEvent ret conversion"); + *ret_event = Event_clone(event); + js_invoke_function_1(j_calls->handle_event_meth, (uint64_t)ret_event); } static void LDKEventHandler_JCalls_cloned(LDKEventHandler* new_obj) { LDKEventHandler_JCalls *j_calls = (LDKEventHandler_JCalls*) new_obj->this_arg; @@ -4869,7 +5728,7 @@ long __attribute__((visibility("default"))) TS_LDKEventHandler_new(/*TODO: JS O } void __attribute__((visibility("default"))) TS_EventHandler_handle_event(uint32_t this_arg, uint32_t event) { LDKEventHandler* this_arg_conv = (LDKEventHandler*)(((uint64_t)this_arg) & ~1); - LDKEvent event_conv = *(LDKEvent*)(((uint64_t)event) & ~1); + LDKEvent* event_conv = (LDKEvent*)event; (this_arg_conv->handle_event)(this_arg_conv->this_arg, event_conv); } @@ -4886,9 +5745,9 @@ static void LDKEventsProvider_JCalls_free(void* this_arg) { } void process_pending_events_LDKEventsProvider_jcall(const void* this_arg, LDKEventHandler handler) { LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) this_arg; - LDKEventHandler* ret = MALLOC(sizeof(LDKEventHandler), "LDKEventHandler"); - *ret = handler; - js_invoke_function_1(j_calls->process_pending_events_meth, (uint64_t)ret); + LDKEventHandler* handler_ret =MALLOC(sizeof(LDKEventHandler), "LDKEventHandler"); + *handler_ret = handler; + js_invoke_function_1(j_calls->process_pending_events_meth, (uint64_t)handler_ret); } static void LDKEventsProvider_JCalls_cloned(LDKEventsProvider* new_obj) { LDKEventsProvider_JCalls *j_calls = (LDKEventsProvider_JCalls*) new_obj->this_arg; @@ -4917,58 +5776,6 @@ void __attribute__((visibility("default"))) TS_EventsProvider_process_pending_e (this_arg_conv->process_pending_events)(this_arg_conv->this_arg, handler_conv); } -typedef struct LDKAccess_JCalls { - atomic_size_t refcnt; - uint32_t get_utxo_meth; -} LDKAccess_JCalls; -static void LDKAccess_JCalls_free(void* this_arg) { - LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg; - if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { - js_free(j_calls->get_utxo_meth); - FREE(j_calls); - } -} -LDKCResult_TxOutAccessErrorZ get_utxo_LDKAccess_jcall(const void* this_arg, const uint8_t (* genesis_hash)[32], uint64_t short_channel_id) { - LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) this_arg; - int8_tArray genesis_hash_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(genesis_hash_arr + 4), *genesis_hash, 32); - uint32_t ret = js_invoke_function_2(j_calls->get_utxo_meth, genesis_hash_arr, short_channel_id); - LDKCResult_TxOutAccessErrorZ ret_conv = *(LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1); - ret_conv = CResult_TxOutAccessErrorZ_clone((LDKCResult_TxOutAccessErrorZ*)(((uint64_t)ret) & ~1)); - return ret_conv; -} -static void LDKAccess_JCalls_cloned(LDKAccess* new_obj) { - LDKAccess_JCalls *j_calls = (LDKAccess_JCalls*) new_obj->this_arg; - atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); -} -static inline LDKAccess LDKAccess_init (/*TODO: JS Object Reference */void* o) { - LDKAccess_JCalls *calls = MALLOC(sizeof(LDKAccess_JCalls), "LDKAccess_JCalls"); - atomic_init(&calls->refcnt, 1); - //TODO: Assign calls->o from o - - LDKAccess ret = { - .this_arg = (void*) calls, - .get_utxo = get_utxo_LDKAccess_jcall, - .free = LDKAccess_JCalls_free, - }; - return ret; -} -long __attribute__((visibility("default"))) TS_LDKAccess_new(/*TODO: JS Object Reference */void* o) { - LDKAccess *res_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *res_ptr = LDKAccess_init(o); - return (long)res_ptr; -} -uint32_t __attribute__((visibility("default"))) TS_Access_get_utxo(uint32_t this_arg, int8_tArray genesis_hash, int64_t short_channel_id) { - LDKAccess* this_arg_conv = (LDKAccess*)(((uint64_t)this_arg) & ~1); - unsigned char genesis_hash_arr[32]; - CHECK(*((uint32_t*)genesis_hash) == 32); - memcpy(genesis_hash_arr, (uint8_t*)(genesis_hash + 4), 32); - unsigned char (*genesis_hash_ref)[32] = &genesis_hash_arr; - LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ"); - *ret_conv = (this_arg_conv->get_utxo)(this_arg_conv->this_arg, genesis_hash_ref, short_channel_id); - return (uint64_t)ret_conv; -} - typedef struct LDKListen_JCalls { atomic_size_t refcnt; uint32_t block_connected_meth; @@ -5058,10 +5865,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); @@ -5134,11 +5941,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); } @@ -5175,89 +5982,7 @@ ptrArray __attribute__((visibility("default"))) TS_Confirm_get_relevant_txids(u return ret_arr; } -typedef struct LDKFilter_JCalls { - atomic_size_t refcnt; - uint32_t register_tx_meth; - uint32_t register_output_meth; -} LDKFilter_JCalls; -static void LDKFilter_JCalls_free(void* this_arg) { - LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; - if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { - js_free(j_calls->register_tx_meth); - js_free(j_calls->register_output_meth); - FREE(j_calls); - } -} -void register_tx_LDKFilter_jcall(const void* this_arg, const uint8_t (* txid)[32], LDKu8slice script_pubkey) { - LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; - int8_tArray txid_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(txid_arr + 4), *txid, 32); - LDKu8slice script_pubkey_var = script_pubkey; - int8_tArray script_pubkey_arr = init_arr(script_pubkey_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(script_pubkey_arr + 4), script_pubkey_var.data, script_pubkey_var.datalen); - js_invoke_function_2(j_calls->register_tx_meth, txid_arr, script_pubkey_arr); -} -LDKCOption_C2Tuple_usizeTransactionZZ register_output_LDKFilter_jcall(const void* this_arg, LDKWatchedOutput output) { - LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) this_arg; - LDKWatchedOutput output_var = output; - CHECK((((uint64_t)output_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. - CHECK((((uint64_t)&output_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. - uint64_t output_ref = (uint64_t)output_var.inner; - if (output_var.is_owned) { - output_ref |= 1; - } - uint32_t ret = js_invoke_function_1(j_calls->register_output_meth, output_ref); - LDKCOption_C2Tuple_usizeTransactionZZ ret_conv = *(LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1); - ret_conv = COption_C2Tuple_usizeTransactionZZ_clone((LDKCOption_C2Tuple_usizeTransactionZZ*)(((uint64_t)ret) & ~1)); - return ret_conv; -} -static void LDKFilter_JCalls_cloned(LDKFilter* new_obj) { - LDKFilter_JCalls *j_calls = (LDKFilter_JCalls*) new_obj->this_arg; - atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); -} -static inline LDKFilter LDKFilter_init (/*TODO: JS Object Reference */void* o) { - LDKFilter_JCalls *calls = MALLOC(sizeof(LDKFilter_JCalls), "LDKFilter_JCalls"); - atomic_init(&calls->refcnt, 1); - //TODO: Assign calls->o from o - - LDKFilter ret = { - .this_arg = (void*) calls, - .register_tx = register_tx_LDKFilter_jcall, - .register_output = register_output_LDKFilter_jcall, - .free = LDKFilter_JCalls_free, - }; - return ret; -} -long __attribute__((visibility("default"))) TS_LDKFilter_new(/*TODO: JS Object Reference */void* o) { - LDKFilter *res_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter"); - *res_ptr = LDKFilter_init(o); - return (long)res_ptr; -} -void __attribute__((visibility("default"))) TS_Filter_register_tx(uint32_t this_arg, int8_tArray txid, int8_tArray script_pubkey) { - LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1); - unsigned char txid_arr[32]; - CHECK(*((uint32_t*)txid) == 32); - memcpy(txid_arr, (uint8_t*)(txid + 4), 32); - unsigned char (*txid_ref)[32] = &txid_arr; - LDKu8slice script_pubkey_ref; - script_pubkey_ref.datalen = *((uint32_t*)script_pubkey); - script_pubkey_ref.data = (int8_t*)(script_pubkey + 4); - (this_arg_conv->register_tx)(this_arg_conv->this_arg, txid_ref, script_pubkey_ref); -} - -uint32_t __attribute__((visibility("default"))) TS_Filter_register_output(uint32_t this_arg, uint32_t output) { - LDKFilter* this_arg_conv = (LDKFilter*)(((uint64_t)this_arg) & ~1); - LDKWatchedOutput output_conv; - output_conv.inner = (void*)(output & (~1)); - output_conv.is_owned = (output & 1) || (output == 0); - output_conv = WatchedOutput_clone(&output_conv); - LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ"); - *ret_copy = (this_arg_conv->register_output)(this_arg_conv->this_arg, output_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -typedef struct LDKPersist_JCalls { +typedef struct LDKPersist_JCalls { atomic_size_t refcnt; uint32_t persist_new_channel_meth; uint32_t update_persisted_channel_meth; @@ -5996,7 +6721,6 @@ typedef struct LDKRoutingMessageHandler_JCalls { uint32_t handle_node_announcement_meth; uint32_t handle_channel_announcement_meth; uint32_t handle_channel_update_meth; - uint32_t handle_htlc_fail_channel_update_meth; uint32_t get_next_channel_announcements_meth; uint32_t get_next_node_announcements_meth; uint32_t sync_routing_table_meth; @@ -6011,7 +6735,6 @@ static void LDKRoutingMessageHandler_JCalls_free(void* this_arg) { js_free(j_calls->handle_node_announcement_meth); js_free(j_calls->handle_channel_announcement_meth); js_free(j_calls->handle_channel_update_meth); - js_free(j_calls->handle_htlc_fail_channel_update_meth); js_free(j_calls->get_next_channel_announcements_meth); js_free(j_calls->get_next_node_announcements_meth); js_free(j_calls->sync_routing_table_meth); @@ -6067,11 +6790,6 @@ LDKCResult_boolLightningErrorZ handle_channel_update_LDKRoutingMessageHandler_jc ret_conv = CResult_boolLightningErrorZ_clone((LDKCResult_boolLightningErrorZ*)(((uint64_t)ret) & ~1)); return ret_conv; } -void handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall(const void* this_arg, const LDKHTLCFailChannelUpdate * update) { - LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg; - uint64_t ret_update = (uint64_t)update; - js_invoke_function_1(j_calls->handle_htlc_fail_channel_update_meth, ret_update); -} LDKCVec_C3Tuple_ChannelAnnouncementChannelUpdateChannelUpdateZZ get_next_channel_announcements_LDKRoutingMessageHandler_jcall(const void* this_arg, uint64_t starting_point, uint8_t batch_amount) { LDKRoutingMessageHandler_JCalls *j_calls = (LDKRoutingMessageHandler_JCalls*) this_arg; uint32_tArray ret = js_invoke_function_2(j_calls->get_next_channel_announcements_meth, starting_point, batch_amount); @@ -6082,11 +6800,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; } @@ -6205,7 +6923,6 @@ static inline LDKRoutingMessageHandler LDKRoutingMessageHandler_init (/*TODO: JS .handle_node_announcement = handle_node_announcement_LDKRoutingMessageHandler_jcall, .handle_channel_announcement = handle_channel_announcement_LDKRoutingMessageHandler_jcall, .handle_channel_update = handle_channel_update_LDKRoutingMessageHandler_jcall, - .handle_htlc_fail_channel_update = handle_htlc_fail_channel_update_LDKRoutingMessageHandler_jcall, .get_next_channel_announcements = get_next_channel_announcements_LDKRoutingMessageHandler_jcall, .get_next_node_announcements = get_next_node_announcements_LDKRoutingMessageHandler_jcall, .sync_routing_table = sync_routing_table_LDKRoutingMessageHandler_jcall, @@ -6254,21 +6971,15 @@ uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle_htlc_fail_channel_update(uint32_t this_arg, uint32_t update) { - LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1); - LDKHTLCFailChannelUpdate* update_conv = (LDKHTLCFailChannelUpdate*)update; - (this_arg_conv->handle_htlc_fail_channel_update)(this_arg_conv->this_arg, update_conv); -} - uint32_tArray __attribute__((visibility("default"))) TS_RoutingMessageHandler_get_next_channel_announcements(uint32_t this_arg, int64_t starting_point, int8_t batch_amount) { LDKRoutingMessageHandler* this_arg_conv = (LDKRoutingMessageHandler*)(((uint64_t)this_arg) & ~1); 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; @@ -6363,6 +7074,151 @@ uint32_t __attribute__((visibility("default"))) TS_RoutingMessageHandler_handle return (uint64_t)ret_conv; } +typedef struct LDKCustomMessageReader_JCalls { + atomic_size_t refcnt; + uint32_t read_meth; +} LDKCustomMessageReader_JCalls; +static void LDKCustomMessageReader_JCalls_free(void* this_arg) { + LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->read_meth); + FREE(j_calls); + } +} +LDKCResult_COption_TypeZDecodeErrorZ read_LDKCustomMessageReader_jcall(const void* this_arg, uint16_t message_type, LDKu8slice buffer) { + LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) this_arg; + LDKu8slice buffer_var = buffer; + int8_tArray buffer_arr = init_arr(buffer_var.datalen, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(buffer_arr + 4), buffer_var.data, buffer_var.datalen); + uint32_t ret = js_invoke_function_2(j_calls->read_meth, message_type, buffer_arr); + LDKCResult_COption_TypeZDecodeErrorZ ret_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1); + ret_conv = CResult_COption_TypeZDecodeErrorZ_clone((LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)ret) & ~1)); + return ret_conv; +} +static void LDKCustomMessageReader_JCalls_cloned(LDKCustomMessageReader* new_obj) { + LDKCustomMessageReader_JCalls *j_calls = (LDKCustomMessageReader_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); +} +static inline LDKCustomMessageReader LDKCustomMessageReader_init (/*TODO: JS Object Reference */void* o) { + LDKCustomMessageReader_JCalls *calls = MALLOC(sizeof(LDKCustomMessageReader_JCalls), "LDKCustomMessageReader_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKCustomMessageReader ret = { + .this_arg = (void*) calls, + .read = read_LDKCustomMessageReader_jcall, + .free = LDKCustomMessageReader_JCalls_free, + }; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKCustomMessageReader_new(/*TODO: JS Object Reference */void* o) { + LDKCustomMessageReader *res_ptr = MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader"); + *res_ptr = LDKCustomMessageReader_init(o); + return (long)res_ptr; +} +uint32_t __attribute__((visibility("default"))) TS_CustomMessageReader_read(uint32_t this_arg, int16_t message_type, int8_tArray buffer) { + LDKCustomMessageReader* this_arg_conv = (LDKCustomMessageReader*)(((uint64_t)this_arg) & ~1); + LDKu8slice buffer_ref; + buffer_ref.datalen = *((uint32_t*)buffer); + buffer_ref.data = (int8_t*)(buffer + 4); + LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ"); + *ret_conv = (this_arg_conv->read)(this_arg_conv->this_arg, message_type, buffer_ref); + return (uint64_t)ret_conv; +} + +typedef struct LDKCustomMessageHandler_JCalls { + atomic_size_t refcnt; + LDKCustomMessageReader_JCalls* CustomMessageReader; + uint32_t handle_custom_message_meth; + uint32_t get_and_clear_pending_msg_meth; +} LDKCustomMessageHandler_JCalls; +static void LDKCustomMessageHandler_JCalls_free(void* this_arg) { + LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->handle_custom_message_meth); + js_free(j_calls->get_and_clear_pending_msg_meth); + FREE(j_calls); + } +} +LDKCResult_NoneLightningErrorZ handle_custom_message_LDKCustomMessageHandler_jcall(const void* this_arg, LDKType msg, LDKPublicKey sender_node_id) { + LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg; + LDKType* msg_ret =MALLOC(sizeof(LDKType), "LDKType"); + *msg_ret = msg; + int8_tArray sender_node_id_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(sender_node_id_arr + 4), sender_node_id.compressed_form, 33); + uint32_t ret = js_invoke_function_2(j_calls->handle_custom_message_meth, (uint64_t)msg_ret, sender_node_id_arr); + LDKCResult_NoneLightningErrorZ ret_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1); + ret_conv = CResult_NoneLightningErrorZ_clone((LDKCResult_NoneLightningErrorZ*)(((uint64_t)ret) & ~1)); + return ret_conv; +} +LDKCVec_C2Tuple_PublicKeyTypeZZ get_and_clear_pending_msg_LDKCustomMessageHandler_jcall(const void* this_arg) { + LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) this_arg; + uint32_tArray ret = js_invoke_function_0(j_calls->get_and_clear_pending_msg_meth); + LDKCVec_C2Tuple_PublicKeyTypeZZ ret_constr; + ret_constr.datalen = *((uint32_t*)ret); + if (ret_constr.datalen > 0) + ret_constr.data = MALLOC(ret_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements"); + else + ret_constr.data = NULL; + uint32_t* ret_vals = (uint32_t*)(ret + 4); + 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; +} +static void LDKCustomMessageHandler_JCalls_cloned(LDKCustomMessageHandler* new_obj) { + LDKCustomMessageHandler_JCalls *j_calls = (LDKCustomMessageHandler_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); + atomic_fetch_add_explicit(&j_calls->CustomMessageReader->refcnt, 1, memory_order_release); +} +static inline LDKCustomMessageHandler LDKCustomMessageHandler_init (/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */void* CustomMessageReader) { + LDKCustomMessageHandler_JCalls *calls = MALLOC(sizeof(LDKCustomMessageHandler_JCalls), "LDKCustomMessageHandler_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKCustomMessageHandler ret = { + .this_arg = (void*) calls, + .handle_custom_message = handle_custom_message_LDKCustomMessageHandler_jcall, + .get_and_clear_pending_msg = get_and_clear_pending_msg_LDKCustomMessageHandler_jcall, + .free = LDKCustomMessageHandler_JCalls_free, + .CustomMessageReader = LDKCustomMessageReader_init(CustomMessageReader), + }; + calls->CustomMessageReader = ret.CustomMessageReader.this_arg; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKCustomMessageHandler_new(/*TODO: JS Object Reference */void* o, /*TODO: JS Object Reference */ void* CustomMessageReader) { + LDKCustomMessageHandler *res_ptr = MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler"); + *res_ptr = LDKCustomMessageHandler_init(o, CustomMessageReader); + return (long)res_ptr; +} +uint32_t __attribute__((visibility("default"))) TS_CustomMessageHandler_handle_custom_message(uint32_t this_arg, uint32_t msg, int8_tArray sender_node_id) { + LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)(((uint64_t)this_arg) & ~1); + LDKType msg_conv = *(LDKType*)(((uint64_t)msg) & ~1); + LDKPublicKey sender_node_id_ref; + CHECK(*((uint32_t*)sender_node_id) == 33); + memcpy(sender_node_id_ref.compressed_form, (uint8_t*)(sender_node_id + 4), 33); + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = (this_arg_conv->handle_custom_message)(this_arg_conv->this_arg, msg_conv, sender_node_id_ref); + return (uint64_t)ret_conv; +} + +uint32_tArray __attribute__((visibility("default"))) TS_CustomMessageHandler_get_and_clear_pending_msg(uint32_t this_arg) { + LDKCustomMessageHandler* this_arg_conv = (LDKCustomMessageHandler*)(((uint64_t)this_arg) & ~1); + 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 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; +} + typedef struct LDKSocketDescriptor_JCalls { atomic_size_t refcnt; uint32_t send_data_meth; @@ -6446,6 +7302,48 @@ int64_t __attribute__((visibility("default"))) TS_SocketDescriptor_hash(uint32_ return ret_val; } +typedef struct LDKScore_JCalls { + atomic_size_t refcnt; + uint32_t channel_penalty_msat_meth; +} LDKScore_JCalls; +static void LDKScore_JCalls_free(void* this_arg) { + LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg; + if (atomic_fetch_sub_explicit(&j_calls->refcnt, 1, memory_order_acquire) == 1) { + js_free(j_calls->channel_penalty_msat_meth); + FREE(j_calls); + } +} +uint64_t channel_penalty_msat_LDKScore_jcall(const void* this_arg, uint64_t short_channel_id) { + LDKScore_JCalls *j_calls = (LDKScore_JCalls*) this_arg; + return js_invoke_function_1(j_calls->channel_penalty_msat_meth, short_channel_id); +} +static void LDKScore_JCalls_cloned(LDKScore* new_obj) { + LDKScore_JCalls *j_calls = (LDKScore_JCalls*) new_obj->this_arg; + atomic_fetch_add_explicit(&j_calls->refcnt, 1, memory_order_release); +} +static inline LDKScore LDKScore_init (/*TODO: JS Object Reference */void* o) { + LDKScore_JCalls *calls = MALLOC(sizeof(LDKScore_JCalls), "LDKScore_JCalls"); + atomic_init(&calls->refcnt, 1); + //TODO: Assign calls->o from o + + LDKScore ret = { + .this_arg = (void*) calls, + .channel_penalty_msat = channel_penalty_msat_LDKScore_jcall, + .free = LDKScore_JCalls_free, + }; + return ret; +} +long __attribute__((visibility("default"))) TS_LDKScore_new(/*TODO: JS Object Reference */void* o) { + LDKScore *res_ptr = MALLOC(sizeof(LDKScore), "LDKScore"); + *res_ptr = LDKScore_init(o); + return (long)res_ptr; +} +int64_t __attribute__((visibility("default"))) TS_Score_channel_penalty_msat(uint32_t this_arg, int64_t short_channel_id) { + LDKScore* this_arg_conv = (LDKScore*)(((uint64_t)this_arg) & ~1); + int64_t ret_val = (this_arg_conv->channel_penalty_msat)(this_arg_conv->this_arg, short_channel_id); + return ret_val; +} + typedef struct LDKChannelManagerPersister_JCalls { atomic_size_t refcnt; uint32_t persist_manager_meth; @@ -6947,6 +7845,29 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_BuiltCommitmentTrans return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_ok(uint32_t o) { + LDKTrustedClosingTransaction 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 LDKTrustedClosingTransaction + LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ"); + *ret_conv = CResult_TrustedClosingTransactionNoneZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_err() { + LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ"); + *ret_conv = CResult_TrustedClosingTransactionNoneZ_err(); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_TrustedClosingTransactionNoneZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_TrustedClosingTransactionNoneZ _res_conv = *(LDKCResult_TrustedClosingTransactionNoneZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_TrustedClosingTransactionNoneZ_free(_res_conv); +} + uint32_t __attribute__((visibility("default"))) TS_CResult_CommitmentTransactionDecodeErrorZ_ok(uint32_t o) { LDKCommitmentTransaction o_conv; o_conv.inner = (void*)(o & (~1)); @@ -7348,6 +8269,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_RouteLightningErrorZ uint32_t __attribute__((visibility("default"))) TS_CResult_TxOutAccessErrorZ_ok(uint32_t o) { LDKTxOut o_conv = *(LDKTxOut*)(((uint64_t)o) & ~1); + o_conv = TxOut_clone((LDKTxOut*)(((uint64_t)o) & ~1)); LDKCResult_TxOutAccessErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_TxOutAccessErrorZ), "LDKCResult_TxOutAccessErrorZ"); *ret_conv = CResult_TxOutAccessErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -7376,9 +8298,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) { @@ -7387,9 +8309,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) { @@ -7407,11 +8329,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); } @@ -7480,6 +8402,7 @@ void __attribute__((visibility("default"))) TS_CVec_MonitorEventZ_free(uint32_t uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransactionZZ_some(uint32_t o) { LDKC2Tuple_usizeTransactionZ o_conv = *(LDKC2Tuple_usizeTransactionZ*)(((uint64_t)o) & ~1); + o_conv = C2Tuple_usizeTransactionZ_clone((LDKC2Tuple_usizeTransactionZ*)(((uint64_t)o) & ~1)); LDKCOption_C2Tuple_usizeTransactionZZ *ret_copy = MALLOC(sizeof(LDKCOption_C2Tuple_usizeTransactionZZ), "LDKCOption_C2Tuple_usizeTransactionZZ"); *ret_copy = COption_C2Tuple_usizeTransactionZZ_some(o_conv); uint64_t ret_ref = (uint64_t)ret_copy; @@ -7508,6 +8431,37 @@ uint32_t __attribute__((visibility("default"))) TS_COption_C2Tuple_usizeTransac return ret_ref; } +uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_some(uint32_t o) { + LDKNetworkUpdate o_conv = *(LDKNetworkUpdate*)(((uint64_t)o) & ~1); + o_conv = NetworkUpdate_clone((LDKNetworkUpdate*)(((uint64_t)o) & ~1)); + LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ"); + *ret_copy = COption_NetworkUpdateZ_some(o_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_none() { + LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ"); + *ret_copy = COption_NetworkUpdateZ_none(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCOption_NetworkUpdateZ _res_conv = *(LDKCOption_NetworkUpdateZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + COption_NetworkUpdateZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_COption_NetworkUpdateZ_clone(uint32_t orig) { + LDKCOption_NetworkUpdateZ* orig_conv = (LDKCOption_NetworkUpdateZ*)orig; + LDKCOption_NetworkUpdateZ *ret_copy = MALLOC(sizeof(LDKCOption_NetworkUpdateZ), "LDKCOption_NetworkUpdateZ"); + *ret_copy = COption_NetworkUpdateZ_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + void __attribute__((visibility("default"))) TS_CVec_SpendableOutputDescriptorZ_free(uint32_tArray _res) { LDKCVec_SpendableOutputDescriptorZ _res_constr; _res_constr.datalen = *((uint32_t*)_res); @@ -7720,6 +8674,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_StaticPaymentOutputD uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescriptorDecodeErrorZ_ok(uint32_t o) { LDKSpendableOutputDescriptor o_conv = *(LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1); + o_conv = SpendableOutputDescriptor_clone((LDKSpendableOutputDescriptor*)(((uint64_t)o) & ~1)); LDKCResult_SpendableOutputDescriptorDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_SpendableOutputDescriptorDecodeErrorZ), "LDKCResult_SpendableOutputDescriptorDecodeErrorZ"); *ret_conv = CResult_SpendableOutputDescriptorDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -7749,11 +8704,37 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_SpendableOutputDescr return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_ok() { + LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ"); + *ret_conv = CResult_NoneNoneZ_ok(); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_err() { + LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ"); + *ret_conv = CResult_NoneNoneZ_err(); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_NoneNoneZ _res_conv = *(LDKCResult_NoneNoneZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_NoneNoneZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NoneNoneZ_clone(uint32_t orig) { + LDKCResult_NoneNoneZ* orig_conv = (LDKCResult_NoneNoneZ*)(orig & ~1); + LDKCResult_NoneNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneNoneZ), "LDKCResult_NoneNoneZ"); + *ret_conv = CResult_NoneNoneZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + 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) { @@ -7774,9 +8755,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) { @@ -7788,6 +8769,7 @@ void __attribute__((visibility("default"))) TS_C2Tuple_SignatureCVec_SignatureZ uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(uint32_t o) { LDKC2Tuple_SignatureCVec_SignatureZZ o_conv = *(LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1); + o_conv = C2Tuple_SignatureCVec_SignatureZZ_clone((LDKC2Tuple_SignatureCVec_SignatureZZ*)(((uint64_t)o) & ~1)); LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ), "LDKCResult_C2Tuple_SignatureCVec_SignatureZZNoneZ"); *ret_conv = CResult_C2Tuple_SignatureCVec_SignatureZZNoneZ_ok(o_conv); return (uint64_t)ret_conv; @@ -8052,6 +9034,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); @@ -8060,9 +9049,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) { @@ -8080,11 +9069,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); } @@ -8097,11 +9086,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); @@ -8122,6 +9111,47 @@ 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_CResult_PaymentIdDecodeErrorZ_ok(uint32_t o) { + LDKPaymentId o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = (o & 1) || (o == 0); + o_conv = PaymentId_clone(&o_conv); + LDKCResult_PaymentIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdDecodeErrorZ), "LDKCResult_PaymentIdDecodeErrorZ"); + *ret_conv = CResult_PaymentIdDecodeErrorZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdDecodeErrorZ_err(uint32_t e) { + LDKDecodeError e_conv; + e_conv.inner = (void*)(e & (~1)); + e_conv.is_owned = (e & 1) || (e == 0); + e_conv = DecodeError_clone(&e_conv); + LDKCResult_PaymentIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdDecodeErrorZ), "LDKCResult_PaymentIdDecodeErrorZ"); + *ret_conv = CResult_PaymentIdDecodeErrorZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_PaymentIdDecodeErrorZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_PaymentIdDecodeErrorZ _res_conv = *(LDKCResult_PaymentIdDecodeErrorZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_PaymentIdDecodeErrorZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdDecodeErrorZ_clone(uint32_t orig) { + LDKCResult_PaymentIdDecodeErrorZ* orig_conv = (LDKCResult_PaymentIdDecodeErrorZ*)(orig & ~1); + LDKCResult_PaymentIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdDecodeErrorZ), "LDKCResult_PaymentIdDecodeErrorZ"); + *ret_conv = CResult_PaymentIdDecodeErrorZ_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); @@ -8159,6 +9189,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_ok() { uint32_t __attribute__((visibility("default"))) TS_CResult_NoneAPIErrorZ_err(uint32_t e) { LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1); + e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1)); LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ"); *ret_conv = CResult_NoneAPIErrorZ_err(e_conv); return (uint64_t)ret_conv; @@ -8212,60 +9243,151 @@ void __attribute__((visibility("default"))) TS_CVec_APIErrorZ_free(uint32_tArra CVec_APIErrorZ_free(_res_constr); } -uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_ok() { - LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); - *ret_conv = CResult_NonePaymentSendFailureZ_ok(); +uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_ok(int8_tArray o) { + LDKThirtyTwoBytes o_ref; + CHECK(*((uint32_t*)o) == 32); + memcpy(o_ref.data, (uint8_t*)(o + 4), 32); + LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ"); + *ret_conv = CResult__u832APIErrorZ_ok(o_ref); return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_err(uint32_t e) { - LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1); - LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); - *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv); +uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_err(uint32_t e) { + LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1); + e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1)); + LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ"); + *ret_conv = CResult__u832APIErrorZ_err(e_conv); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) { +void __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_free(uint32_t _res) { if ((_res & 1) != 0) return; - LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)_res) & ~1); + LDKCResult__u832APIErrorZ _res_conv = *(LDKCResult__u832APIErrorZ*)(((uint64_t)_res) & ~1); FREE((void*)_res); - CResult_NonePaymentSendFailureZ_free(_res_conv); + CResult__u832APIErrorZ_free(_res_conv); } -uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) { +uint32_t __attribute__((visibility("default"))) TS_CResult__u832APIErrorZ_clone(uint32_t orig) { + LDKCResult__u832APIErrorZ* orig_conv = (LDKCResult__u832APIErrorZ*)(orig & ~1); + LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ"); + *ret_conv = CResult__u832APIErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_ok(uint32_t o) { + LDKPaymentId o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = (o & 1) || (o == 0); + o_conv = PaymentId_clone(&o_conv); + LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ"); + *ret_conv = CResult_PaymentIdPaymentSendFailureZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_err(uint32_t e) { + LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1); + e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1)); + LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ"); + *ret_conv = CResult_PaymentIdPaymentSendFailureZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_PaymentIdPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentIdPaymentSendFailureZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_PaymentIdPaymentSendFailureZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentIdPaymentSendFailureZ_clone(uint32_t orig) { + LDKCResult_PaymentIdPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentIdPaymentSendFailureZ*)(orig & ~1); + LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ"); + *ret_conv = CResult_PaymentIdPaymentSendFailureZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_ok() { + LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); + *ret_conv = CResult_NonePaymentSendFailureZ_ok(); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_err(uint32_t e) { + LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1); + e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1)); + LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); + *ret_conv = CResult_NonePaymentSendFailureZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_NonePaymentSendFailureZ _res_conv = *(LDKCResult_NonePaymentSendFailureZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_NonePaymentSendFailureZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NonePaymentSendFailureZ_clone(uint32_t orig) { LDKCResult_NonePaymentSendFailureZ* orig_conv = (LDKCResult_NonePaymentSendFailureZ*)(orig & ~1); LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); *ret_conv = CResult_NonePaymentSendFailureZ_clone(orig_conv); return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentHashPaymentSendFailureZ_ok(int8_tArray o) { - LDKThirtyTwoBytes o_ref; - CHECK(*((uint32_t*)o) == 32); - memcpy(o_ref.data, (uint8_t*)(o + 4), 32); - LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ"); - *ret_conv = CResult_PaymentHashPaymentSendFailureZ_ok(o_ref); +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_clone(uint32_t orig) { + LDKC2Tuple_PaymentHashPaymentIdZ* orig_conv = (LDKC2Tuple_PaymentHashPaymentIdZ*)(orig & ~1); + LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ"); + *ret_conv = C2Tuple_PaymentHashPaymentIdZ_clone(orig_conv); + return ((uint64_t)ret_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_new(int8_tArray a, uint32_t b) { + LDKThirtyTwoBytes a_ref; + CHECK(*((uint32_t*)a) == 32); + memcpy(a_ref.data, (uint8_t*)(a + 4), 32); + LDKPaymentId b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = (b & 1) || (b == 0); + b_conv = PaymentId_clone(&b_conv); + LDKC2Tuple_PaymentHashPaymentIdZ* ret_conv = MALLOC(sizeof(LDKC2Tuple_PaymentHashPaymentIdZ), "LDKC2Tuple_PaymentHashPaymentIdZ"); + *ret_conv = C2Tuple_PaymentHashPaymentIdZ_new(a_ref, b_conv); + return ((uint64_t)ret_conv); +} + +void __attribute__((visibility("default"))) TS_C2Tuple_PaymentHashPaymentIdZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKC2Tuple_PaymentHashPaymentIdZ _res_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + C2Tuple_PaymentHashPaymentIdZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(uint32_t o) { + LDKC2Tuple_PaymentHashPaymentIdZ o_conv = *(LDKC2Tuple_PaymentHashPaymentIdZ*)(((uint64_t)o) & ~1); + o_conv = C2Tuple_PaymentHashPaymentIdZ_clone((LDKC2Tuple_PaymentHashPaymentIdZ*)(((uint64_t)o) & ~1)); + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ"); + *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_ok(o_conv); return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentHashPaymentSendFailureZ_err(uint32_t e) { +uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(uint32_t e) { LDKPaymentSendFailure e_conv = *(LDKPaymentSendFailure*)(((uint64_t)e) & ~1); - LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ"); - *ret_conv = CResult_PaymentHashPaymentSendFailureZ_err(e_conv); + e_conv = PaymentSendFailure_clone((LDKPaymentSendFailure*)(((uint64_t)e) & ~1)); + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ"); + *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_err(e_conv); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_CResult_PaymentHashPaymentSendFailureZ_free(uint32_t _res) { +void __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(uint32_t _res) { if ((_res & 1) != 0) return; - LDKCResult_PaymentHashPaymentSendFailureZ _res_conv = *(LDKCResult_PaymentHashPaymentSendFailureZ*)(((uint64_t)_res) & ~1); + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ _res_conv = *(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(((uint64_t)_res) & ~1); FREE((void*)_res); - CResult_PaymentHashPaymentSendFailureZ_free(_res_conv); + CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_free(_res_conv); } -uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentHashPaymentSendFailureZ_clone(uint32_t orig) { - LDKCResult_PaymentHashPaymentSendFailureZ* orig_conv = (LDKCResult_PaymentHashPaymentSendFailureZ*)(orig & ~1); - LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ"); - *ret_conv = CResult_PaymentHashPaymentSendFailureZ_clone(orig_conv); +uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(uint32_t orig) { + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* orig_conv = (LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ*)(orig & ~1); + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ"); + *ret_conv = CResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ_clone(orig_conv); return (uint64_t)ret_conv; } @@ -8288,9 +9410,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) { @@ -8300,9 +9422,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) { @@ -8323,6 +9445,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErro uint32_t __attribute__((visibility("default"))) TS_CResult_PaymentSecretAPIErrorZ_err(uint32_t e) { LDKAPIError e_conv = *(LDKAPIError*)(((uint64_t)e) & ~1); + e_conv = APIError_clone((LDKAPIError*)(((uint64_t)e) & ~1)); LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ"); *ret_conv = CResult_PaymentSecretAPIErrorZ_err(e_conv); return (uint64_t)ret_conv; @@ -8368,9 +9491,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) { @@ -8382,6 +9505,7 @@ void __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelManagerZ uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(uint32_t o) { LDKC2Tuple_BlockHashChannelManagerZ o_conv = *(LDKC2Tuple_BlockHashChannelManagerZ*)(((uint64_t)o) & ~1); + // Warning: we may need a move here but no clone is available for LDKC2Tuple_BlockHashChannelManagerZ LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ), "LDKCResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ"); *ret_conv = CResult_C2Tuple_BlockHashChannelManagerZDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -8472,6 +9596,68 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_OutPointDecodeErrorZ return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_some(uint32_t o) { + LDKType o_conv = *(LDKType*)(((uint64_t)o) & ~1); + LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ"); + *ret_copy = COption_TypeZ_some(o_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_none() { + LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ"); + *ret_copy = COption_TypeZ_none(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_COption_TypeZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCOption_TypeZ _res_conv = *(LDKCOption_TypeZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + COption_TypeZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_COption_TypeZ_clone(uint32_t orig) { + LDKCOption_TypeZ* orig_conv = (LDKCOption_TypeZ*)orig; + LDKCOption_TypeZ *ret_copy = MALLOC(sizeof(LDKCOption_TypeZ), "LDKCOption_TypeZ"); + *ret_copy = COption_TypeZ_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_ok(uint32_t o) { + LDKCOption_TypeZ o_conv = *(LDKCOption_TypeZ*)(((uint64_t)o) & ~1); + o_conv = COption_TypeZ_clone((LDKCOption_TypeZ*)(((uint64_t)o) & ~1)); + LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ"); + *ret_conv = CResult_COption_TypeZDecodeErrorZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_err(uint32_t e) { + LDKDecodeError e_conv; + e_conv.inner = (void*)(e & (~1)); + e_conv.is_owned = (e & 1) || (e == 0); + e_conv = DecodeError_clone(&e_conv); + LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ"); + *ret_conv = CResult_COption_TypeZDecodeErrorZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_COption_TypeZDecodeErrorZ _res_conv = *(LDKCResult_COption_TypeZDecodeErrorZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_COption_TypeZDecodeErrorZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_COption_TypeZDecodeErrorZ_clone(uint32_t orig) { + LDKCResult_COption_TypeZDecodeErrorZ* orig_conv = (LDKCResult_COption_TypeZDecodeErrorZ*)(orig & ~1); + LDKCResult_COption_TypeZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_COption_TypeZDecodeErrorZ), "LDKCResult_COption_TypeZDecodeErrorZ"); + *ret_conv = CResult_COption_TypeZDecodeErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_CResult_SiPrefixNoneZ_ok(uint32_t o) { LDKSiPrefix o_conv = LDKSiPrefix_from_js(o); LDKCResult_SiPrefixNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_SiPrefixNoneZ), "LDKCResult_SiPrefixNoneZ"); @@ -8561,9 +9747,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) { @@ -8578,9 +9764,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) { @@ -8942,9 +10128,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) { @@ -8956,9 +10142,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) { @@ -8970,9 +10156,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) { @@ -8980,9 +10166,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) { @@ -9000,20 +10186,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) { @@ -9027,15 +10213,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) { @@ -9053,11 +10239,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); } @@ -9101,16 +10287,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); - LDKC2Tuple_u32TxOutZ* ret_ref = MALLOC(sizeof(LDKC2Tuple_u32TxOutZ), "LDKC2Tuple_u32TxOutZ"); - *ret_ref = C2Tuple_u32TxOutZ_new(a, b_conv); - return (uint64_t)ret_ref; + b_conv = TxOut_clone((LDKTxOut*)(((uint64_t)b) & ~1)); + 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) { @@ -9128,20 +10315,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) { @@ -9155,15 +10342,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) { @@ -9181,17 +10368,35 @@ 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); } +void __attribute__((visibility("default"))) TS_CVec_BalanceZ_free(uint32_tArray _res) { + LDKCVec_BalanceZ _res_constr; + _res_constr.datalen = *((uint32_t*)_res); + if (_res_constr.datalen > 0) + _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKBalance), "LDKCVec_BalanceZ Elements"); + else + _res_constr.data = NULL; + uint32_t* _res_vals = (uint32_t*)(_res + 4); + for (size_t j = 0; j < _res_constr.datalen; j++) { + uint32_t _res_conv_9 = _res_vals[j]; + LDKBalance _res_conv_9_conv = *(LDKBalance*)(((uint64_t)_res_conv_9) & ~1); + FREE((void*)_res_conv_9); + _res_constr.data[j] = _res_conv_9_conv; + } + CVec_BalanceZ_free(_res_constr); +} + uint32_t __attribute__((visibility("default"))) TS_CResult_C2Tuple_BlockHashChannelMonitorZDecodeErrorZ_ok(uint32_t o) { LDKC2Tuple_BlockHashChannelMonitorZ o_conv = *(LDKC2Tuple_BlockHashChannelMonitorZ*)(((uint64_t)o) & ~1); + 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; @@ -9214,6 +10419,84 @@ 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(); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) { + LDKLightningError e_conv; + e_conv.inner = (void*)(e & (~1)); + e_conv.is_owned = (e & 1) || (e == 0); + e_conv = LightningError_clone(&e_conv); + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = CResult_NoneLightningErrorZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_NoneLightningErrorZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) { + LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1); + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_C2Tuple_PublicKeyTypeZ_clone(uint32_t orig) { + LDKC2Tuple_PublicKeyTypeZ* orig_conv = (LDKC2Tuple_PublicKeyTypeZ*)(orig & ~1); + 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) { + LDKPublicKey a_ref; + 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_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) { + if ((_res & 1) != 0) return; + LDKC2Tuple_PublicKeyTypeZ _res_conv = *(LDKC2Tuple_PublicKeyTypeZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + C2Tuple_PublicKeyTypeZ_free(_res_conv); +} + +void __attribute__((visibility("default"))) TS_CVec_C2Tuple_PublicKeyTypeZZ_free(uint32_tArray _res) { + LDKCVec_C2Tuple_PublicKeyTypeZZ _res_constr; + _res_constr.datalen = *((uint32_t*)_res); + if (_res_constr.datalen > 0) + _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKC2Tuple_PublicKeyTypeZ), "LDKCVec_C2Tuple_PublicKeyTypeZZ Elements"); + 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_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); +} + uint32_t __attribute__((visibility("default"))) TS_CResult_boolLightningErrorZ_ok(jboolean o) { LDKCResult_boolLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_boolLightningErrorZ), "LDKCResult_boolLightningErrorZ"); *ret_conv = CResult_boolLightningErrorZ_ok(o); @@ -9246,9 +10529,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) { @@ -9264,9 +10547,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) { @@ -9284,11 +10567,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); } @@ -9311,36 +10594,6 @@ void __attribute__((visibility("default"))) TS_CVec_NodeAnnouncementZ_free(uint CVec_NodeAnnouncementZ_free(_res_constr); } -uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_ok() { - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = CResult_NoneLightningErrorZ_ok(); - return (uint64_t)ret_conv; -} - -uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_err(uint32_t e) { - LDKLightningError e_conv; - e_conv.inner = (void*)(e & (~1)); - e_conv.is_owned = (e & 1) || (e == 0); - e_conv = LightningError_clone(&e_conv); - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = CResult_NoneLightningErrorZ_err(e_conv); - return (uint64_t)ret_conv; -} - -void __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_free(uint32_t _res) { - if ((_res & 1) != 0) return; - LDKCResult_NoneLightningErrorZ _res_conv = *(LDKCResult_NoneLightningErrorZ*)(((uint64_t)_res) & ~1); - FREE((void*)_res); - CResult_NoneLightningErrorZ_free(_res_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_CResult_NoneLightningErrorZ_clone(uint32_t orig) { - LDKCResult_NoneLightningErrorZ* orig_conv = (LDKCResult_NoneLightningErrorZ*)(orig & ~1); - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = CResult_NoneLightningErrorZ_clone(orig_conv); - return (uint64_t)ret_conv; -} - void __attribute__((visibility("default"))) TS_CVec_PublicKeyZ_free(ptrArray _res) { LDKCVec_PublicKeyZ _res_constr; _res_constr.datalen = *((uint32_t*)_res); @@ -9453,6 +10706,62 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_boolPeerHandleErrorZ return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_ok(uint32_t o) { + LDKNodeId o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = (o & 1) || (o == 0); + o_conv = NodeId_clone(&o_conv); + LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ"); + *ret_conv = CResult_NodeIdDecodeErrorZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_err(uint32_t e) { + LDKDecodeError e_conv; + e_conv.inner = (void*)(e & (~1)); + e_conv.is_owned = (e & 1) || (e == 0); + e_conv = DecodeError_clone(&e_conv); + LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ"); + *ret_conv = CResult_NodeIdDecodeErrorZ_err(e_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_NodeIdDecodeErrorZ _res_conv = *(LDKCResult_NodeIdDecodeErrorZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_NodeIdDecodeErrorZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NodeIdDecodeErrorZ_clone(uint32_t orig) { + LDKCResult_NodeIdDecodeErrorZ* orig_conv = (LDKCResult_NodeIdDecodeErrorZ*)(orig & ~1); + LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ"); + *ret_conv = CResult_NodeIdDecodeErrorZ_clone(orig_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_COption_AccessZ_some(uint32_t o) { + LDKAccess o_conv = *(LDKAccess*)(((uint64_t)o) & ~1); + LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ"); + *ret_copy = COption_AccessZ_some(o_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_COption_AccessZ_none() { + LDKCOption_AccessZ *ret_copy = MALLOC(sizeof(LDKCOption_AccessZ), "LDKCOption_AccessZ"); + *ret_copy = COption_AccessZ_none(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_COption_AccessZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCOption_AccessZ _res_conv = *(LDKCOption_AccessZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + COption_AccessZ_free(_res_conv); +} + uint32_t __attribute__((visibility("default"))) TS_CResult_DirectionalChannelInfoDecodeErrorZ_ok(uint32_t o) { LDKDirectionalChannelInfo o_conv; o_conv.inner = (void*)(o & (~1)); @@ -9672,15 +10981,58 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NetworkGraphDecodeEr 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); - LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z"); - *ret_conv = CResult_NetAddressu8Z_ok(o_conv); - return (uint64_t)ret_conv; +uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_some(uint32_tArray o) { + LDKCVec_NetAddressZ o_constr; + o_constr.datalen = *((uint32_t*)o); + if (o_constr.datalen > 0) + o_constr.data = MALLOC(o_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements"); + 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_12 = o_vals[m]; + LDKNetAddress o_conv_12_conv = *(LDKNetAddress*)(((uint64_t)o_conv_12) & ~1); + o_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)o_conv_12) & ~1)); + o_constr.data[m] = o_conv_12_conv; + } + LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ"); + *ret_copy = COption_CVec_NetAddressZZ_some(o_constr); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_err(int8_t e) { - LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z"); +uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_none() { + LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ"); + *ret_copy = COption_CVec_NetAddressZZ_none(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCOption_CVec_NetAddressZZ _res_conv = *(LDKCOption_CVec_NetAddressZZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + COption_CVec_NetAddressZZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_COption_CVec_NetAddressZZ_clone(uint32_t orig) { + LDKCOption_CVec_NetAddressZZ* orig_conv = (LDKCOption_CVec_NetAddressZZ*)orig; + LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ"); + *ret_copy = COption_CVec_NetAddressZZ_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +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)); + LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z"); + *ret_conv = CResult_NetAddressu8Z_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_err(int8_t e) { + LDKCResult_NetAddressu8Z* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressu8Z), "LDKCResult_NetAddressu8Z"); *ret_conv = CResult_NetAddressu8Z_err(e); return (uint64_t)ret_conv; } @@ -9701,6 +11053,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressu8Z_clone( uint32_t __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(uint32_t o) { LDKCResult_NetAddressu8Z o_conv = *(LDKCResult_NetAddressu8Z*)(((uint64_t)o) & ~1); + o_conv = CResult_NetAddressu8Z_clone((LDKCResult_NetAddressu8Z*)(((uint64_t)o) & ~1)); LDKCResult_CResult_NetAddressu8ZDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_CResult_NetAddressu8ZDecodeErrorZ), "LDKCResult_CResult_NetAddressu8ZDecodeErrorZ"); *ret_conv = CResult_CResult_NetAddressu8ZDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -9732,6 +11085,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_CResult_NetAddressu8 uint32_t __attribute__((visibility("default"))) TS_CResult_NetAddressDecodeErrorZ_ok(uint32_t o) { LDKNetAddress o_conv = *(LDKNetAddress*)(((uint64_t)o) & ~1); + o_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)o) & ~1)); LDKCResult_NetAddressDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetAddressDecodeErrorZ), "LDKCResult_NetAddressDecodeErrorZ"); *ret_conv = CResult_NetAddressDecodeErrorZ_ok(o_conv); return (uint64_t)ret_conv; @@ -10933,6 +12287,7 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreatio uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreationErrorZ_err(uint32_t e) { LDKSignOrCreationError e_conv = *(LDKSignOrCreationError*)(((uint64_t)e) & ~1); + e_conv = SignOrCreationError_clone((LDKSignOrCreationError*)(((uint64_t)e) & ~1)); LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ"); *ret_conv = CResult_InvoiceSignOrCreationErrorZ_err(e_conv); return (uint64_t)ret_conv; @@ -10952,6 +12307,69 @@ uint32_t __attribute__((visibility("default"))) TS_CResult_InvoiceSignOrCreatio return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_COption_FilterZ_some(uint32_t o) { + LDKFilter o_conv = *(LDKFilter*)(((uint64_t)o) & ~1); + LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ"); + *ret_copy = COption_FilterZ_some(o_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_COption_FilterZ_none() { + LDKCOption_FilterZ *ret_copy = MALLOC(sizeof(LDKCOption_FilterZ), "LDKCOption_FilterZ"); + *ret_copy = COption_FilterZ_none(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_COption_FilterZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCOption_FilterZ _res_conv = *(LDKCOption_FilterZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + COption_FilterZ_free(_res_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_ok(uint32_t o) { + LDKLockedChannelMonitor 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 LDKLockedChannelMonitor + LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ"); + *ret_conv = CResult_LockedChannelMonitorNoneZ_ok(o_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_err() { + LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ"); + *ret_conv = CResult_LockedChannelMonitorNoneZ_err(); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CResult_LockedChannelMonitorNoneZ_free(uint32_t _res) { + if ((_res & 1) != 0) return; + LDKCResult_LockedChannelMonitorNoneZ _res_conv = *(LDKCResult_LockedChannelMonitorNoneZ*)(((uint64_t)_res) & ~1); + FREE((void*)_res); + CResult_LockedChannelMonitorNoneZ_free(_res_conv); +} + +void __attribute__((visibility("default"))) TS_CVec_OutPointZ_free(uint32_tArray _res) { + LDKCVec_OutPointZ _res_constr; + _res_constr.datalen = *((uint32_t*)_res); + if (_res_constr.datalen > 0) + _res_constr.data = MALLOC(_res_constr.datalen * sizeof(LDKOutPoint), "LDKCVec_OutPointZ Elements"); + else + _res_constr.data = NULL; + uint32_t* _res_vals = (uint32_t*)(_res + 4); + for (size_t k = 0; k < _res_constr.datalen; k++) { + uint32_t _res_conv_10 = _res_vals[k]; + LDKOutPoint _res_conv_10_conv; + _res_conv_10_conv.inner = (void*)(_res_conv_10 & (~1)); + _res_conv_10_conv.is_owned = (_res_conv_10 & 1) || (_res_conv_10 == 0); + _res_constr.data[k] = _res_conv_10_conv; + } + CVec_OutPointZ_free(_res_constr); +} + void __attribute__((visibility("default"))) TS_PaymentPurpose_free(uint32_t this_ptr) { if ((this_ptr & 1) != 0) return; LDKPaymentPurpose this_ptr_conv = *(LDKPaymentPurpose*)(((uint64_t)this_ptr) & ~1); @@ -10990,6 +12408,81 @@ uint32_t __attribute__((visibility("default"))) TS_PaymentPurpose_spontaneous_p return ret_ref; } +void __attribute__((visibility("default"))) TS_ClosureReason_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKClosureReason this_ptr_conv = *(LDKClosureReason*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + ClosureReason_free(this_ptr_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_clone(uint32_t orig) { + LDKClosureReason* orig_conv = (LDKClosureReason*)orig; + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_counterparty_force_closed(jstring peer_msg) { + LDKStr peer_msg_conv = str_ref_to_owned_c(peer_msg); + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_counterparty_force_closed(peer_msg_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_holder_force_closed() { + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_holder_force_closed(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_cooperative_closure() { + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_cooperative_closure(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_commitment_tx_confirmed() { + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_commitment_tx_confirmed(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_processing_error(jstring err) { + LDKStr err_conv = str_ref_to_owned_c(err); + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_processing_error(err_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_disconnected_peer() { + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_disconnected_peer(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_ClosureReason_outdated_channel_manager() { + LDKClosureReason *ret_copy = MALLOC(sizeof(LDKClosureReason), "LDKClosureReason"); + *ret_copy = ClosureReason_outdated_channel_manager(); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +int8_tArray __attribute__((visibility("default"))) TS_ClosureReason_write(uint32_t obj) { + LDKClosureReason* obj_conv = (LDKClosureReason*)obj; + LDKCVec_u8Z ret_var = ClosureReason_write(obj_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; +} + void __attribute__((visibility("default"))) TS_Event_free(uint32_t this_ptr) { if ((this_ptr & 1) != 0) return; LDKEvent this_ptr_conv = *(LDKEvent*)(((uint64_t)this_ptr) & ~1); @@ -11024,28 +12517,51 @@ uint32_t __attribute__((visibility("default"))) TS_Event_payment_received(int8_ CHECK(*((uint32_t*)payment_hash) == 32); memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32); LDKPaymentPurpose purpose_conv = *(LDKPaymentPurpose*)(((uint64_t)purpose) & ~1); + purpose_conv = PaymentPurpose_clone((LDKPaymentPurpose*)(((uint64_t)purpose) & ~1)); LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); *ret_copy = Event_payment_received(payment_hash_ref, amt, purpose_conv); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_Event_payment_sent(int8_tArray payment_preimage) { +uint32_t __attribute__((visibility("default"))) TS_Event_payment_sent(int8_tArray payment_preimage, int8_tArray payment_hash) { LDKThirtyTwoBytes payment_preimage_ref; CHECK(*((uint32_t*)payment_preimage) == 32); memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32); + LDKThirtyTwoBytes payment_hash_ref; + CHECK(*((uint32_t*)payment_hash) == 32); + memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32); LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); - *ret_copy = Event_payment_sent(payment_preimage_ref); + *ret_copy = Event_payment_sent(payment_preimage_ref, payment_hash_ref); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_Event_payment_failed(int8_tArray payment_hash, jboolean rejected_by_dest) { +uint32_t __attribute__((visibility("default"))) TS_Event_payment_path_failed(int8_tArray payment_hash, jboolean rejected_by_dest, uint32_t network_update, jboolean all_paths_failed, uint32_tArray path, uint32_t short_channel_id) { LDKThirtyTwoBytes payment_hash_ref; CHECK(*((uint32_t*)payment_hash) == 32); memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32); + LDKCOption_NetworkUpdateZ network_update_conv = *(LDKCOption_NetworkUpdateZ*)(((uint64_t)network_update) & ~1); + network_update_conv = COption_NetworkUpdateZ_clone((LDKCOption_NetworkUpdateZ*)(((uint64_t)network_update) & ~1)); + LDKCVec_RouteHopZ path_constr; + path_constr.datalen = *((uint32_t*)path); + if (path_constr.datalen > 0) + path_constr.data = MALLOC(path_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements"); + else + path_constr.data = NULL; + uint32_t* path_vals = (uint32_t*)(path + 4); + for (size_t k = 0; k < path_constr.datalen; k++) { + uint32_t path_conv_10 = path_vals[k]; + LDKRouteHop path_conv_10_conv; + path_conv_10_conv.inner = (void*)(path_conv_10 & (~1)); + path_conv_10_conv.is_owned = (path_conv_10 & 1) || (path_conv_10 == 0); + path_conv_10_conv = RouteHop_clone(&path_conv_10_conv); + path_constr.data[k] = path_conv_10_conv; + } + LDKCOption_u64Z short_channel_id_conv = *(LDKCOption_u64Z*)(((uint64_t)short_channel_id) & ~1); + short_channel_id_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)short_channel_id) & ~1)); LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); - *ret_copy = Event_payment_failed(payment_hash_ref, rejected_by_dest); + *ret_copy = Event_payment_path_failed(payment_hash_ref, rejected_by_dest, network_update_conv, all_paths_failed, path_constr, short_channel_id_conv); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } @@ -11079,12 +12595,40 @@ uint32_t __attribute__((visibility("default"))) TS_Event_spendable_outputs(uint uint32_t __attribute__((visibility("default"))) TS_Event_payment_forwarded(uint32_t fee_earned_msat, jboolean claim_from_onchain_tx) { LDKCOption_u64Z fee_earned_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)fee_earned_msat) & ~1); + fee_earned_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)fee_earned_msat) & ~1)); LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); *ret_copy = Event_payment_forwarded(fee_earned_msat_conv, claim_from_onchain_tx); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } +uint32_t __attribute__((visibility("default"))) TS_Event_channel_closed(int8_tArray channel_id, int64_t user_channel_id, uint32_t reason) { + LDKThirtyTwoBytes channel_id_ref; + CHECK(*((uint32_t*)channel_id) == 32); + memcpy(channel_id_ref.data, (uint8_t*)(channel_id + 4), 32); + LDKClosureReason reason_conv = *(LDKClosureReason*)(((uint64_t)reason) & ~1); + reason_conv = ClosureReason_clone((LDKClosureReason*)(((uint64_t)reason) & ~1)); + LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); + *ret_copy = Event_channel_closed(channel_id_ref, user_channel_id, reason_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_Event_discard_funding(int8_tArray channel_id, int8_tArray transaction) { + LDKThirtyTwoBytes channel_id_ref; + CHECK(*((uint32_t*)channel_id) == 32); + memcpy(channel_id_ref.data, (uint8_t*)(channel_id + 4), 32); + LDKTransaction transaction_ref; + transaction_ref.datalen = *((uint32_t*)transaction); + transaction_ref.data = MALLOC(transaction_ref.datalen, "LDKTransaction Bytes"); + memcpy(transaction_ref.data, (uint8_t*)(transaction + 4), transaction_ref.datalen); + transaction_ref.data_is_owned = true; + LDKEvent *ret_copy = MALLOC(sizeof(LDKEvent), "LDKEvent"); + *ret_copy = Event_discard_funding(channel_id_ref, transaction_ref); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + int8_tArray __attribute__((visibility("default"))) TS_Event_write(uint32_t obj) { LDKEvent* obj_conv = (LDKEvent*)obj; LDKCVec_u8Z ret_var = Event_write(obj_conv); @@ -11319,20 +12863,13 @@ uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_handle_erro CHECK(*((uint32_t*)node_id) == 33); memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33); LDKErrorAction action_conv = *(LDKErrorAction*)(((uint64_t)action) & ~1); + action_conv = ErrorAction_clone((LDKErrorAction*)(((uint64_t)action) & ~1)); LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent"); *ret_copy = MessageSendEvent_handle_error(node_id_ref, action_conv); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_payment_failure_network_update(uint32_t update) { - LDKHTLCFailChannelUpdate update_conv = *(LDKHTLCFailChannelUpdate*)(((uint64_t)update) & ~1); - LDKMessageSendEvent *ret_copy = MALLOC(sizeof(LDKMessageSendEvent), "LDKMessageSendEvent"); - *ret_copy = MessageSendEvent_payment_failure_network_update(update_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - uint32_t __attribute__((visibility("default"))) TS_MessageSendEvent_send_channel_range_query(int8_tArray node_id, uint32_t msg) { LDKPublicKey node_id_ref; CHECK(*((uint32_t*)node_id) == 33); @@ -12217,6 +13754,22 @@ void __attribute__((visibility("default"))) TS_Confirm_free(uint32_t this_ptr) Confirm_free(this_ptr_conv); } +uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_clone(uint32_t orig) { + LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1); + uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_clone(orig_conv)); + return ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_temporary_failure() { + uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_temporary_failure()); + return ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_permanent_failure() { + uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_permanent_failure()); + return ret_conv; +} + void __attribute__((visibility("default"))) TS_Watch_free(uint32_t this_ptr) { if ((this_ptr & 1) != 0) return; LDKWatch this_ptr_conv = *(LDKWatch*)(((uint64_t)this_ptr) & ~1); @@ -12389,6 +13942,20 @@ void __attribute__((visibility("default"))) TS_FeeEstimator_free(uint32_t this_ FeeEstimator_free(this_ptr_conv); } +void __attribute__((visibility("default"))) TS_Persist_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKPersist this_ptr_conv = *(LDKPersist*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + Persist_free(this_ptr_conv); +} + +void __attribute__((visibility("default"))) TS_LockedChannelMonitor_free(uint32_t this_obj) { + LDKLockedChannelMonitor this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + LockedChannelMonitor_free(this_obj_conv); +} + void __attribute__((visibility("default"))) TS_ChainMonitor_free(uint32_t this_obj) { LDKChainMonitor this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -12397,18 +13964,16 @@ void __attribute__((visibility("default"))) TS_ChainMonitor_free(uint32_t this_ } uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_new(uint32_t chain_source, uint32_t broadcaster, uint32_t logger, uint32_t feeest, uint32_t persister) { - LDKFilter *chain_source_conv_ptr = NULL; - if (chain_source != 0) { - LDKFilter chain_source_conv; - chain_source_conv = *(LDKFilter*)(((uint64_t)chain_source) & ~1); - chain_source_conv_ptr = MALLOC(sizeof(LDKFilter), "LDKFilter"); - *chain_source_conv_ptr = chain_source_conv; + LDKCOption_FilterZ chain_source_conv = *(LDKCOption_FilterZ*)(((uint64_t)chain_source) & ~1); + // Warning: we may need a move here but no clone is available for LDKCOption_FilterZ + if (chain_source_conv.tag == LDKCOption_FilterZ_Some) { + // Manually implement clone for Java trait instances } LDKBroadcasterInterface broadcaster_conv = *(LDKBroadcasterInterface*)(((uint64_t)broadcaster) & ~1); LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); LDKFeeEstimator feeest_conv = *(LDKFeeEstimator*)(((uint64_t)feeest) & ~1); LDKPersist persister_conv = *(LDKPersist*)(((uint64_t)persister) & ~1); - LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv_ptr, broadcaster_conv, logger_conv, feeest_conv, persister_conv); + LDKChainMonitor ret_var = ChainMonitor_new(chain_source_conv, broadcaster_conv, logger_conv, feeest_conv, persister_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; @@ -12418,40 +13983,106 @@ uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_new(uint32_t ch return ret_ref; } +uint32_tArray __attribute__((visibility("default"))) TS_ChainMonitor_get_claimable_balances(uint32_t this_arg, uint32_tArray ignored_channels) { + LDKChainMonitor this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKCVec_ChannelDetailsZ ignored_channels_constr; + ignored_channels_constr.datalen = *((uint32_t*)ignored_channels); + if (ignored_channels_constr.datalen > 0) + ignored_channels_constr.data = MALLOC(ignored_channels_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements"); + else + ignored_channels_constr.data = NULL; + uint32_t* ignored_channels_vals = (uint32_t*)(ignored_channels + 4); + for (size_t q = 0; q < ignored_channels_constr.datalen; q++) { + uint32_t ignored_channels_conv_16 = ignored_channels_vals[q]; + LDKChannelDetails ignored_channels_conv_16_conv; + ignored_channels_conv_16_conv.inner = (void*)(ignored_channels_conv_16 & (~1)); + ignored_channels_conv_16_conv.is_owned = (ignored_channels_conv_16 & 1) || (ignored_channels_conv_16 == 0); + ignored_channels_conv_16_conv = ChannelDetails_clone(&ignored_channels_conv_16_conv); + ignored_channels_constr.data[q] = ignored_channels_conv_16_conv; + } + LDKCVec_BalanceZ ret_var = ChainMonitor_get_claimable_balances(&this_arg_conv, ignored_channels_constr); + 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 j = 0; j < ret_var.datalen; j++) { + LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_conv_9_copy = Balance_clone(&ret_var.data[j]); + uint64_t ret_conv_9_ref = (uint64_t)ret_conv_9_copy; + ret_arr_ptr[j] = ret_conv_9_ref; + } + FREE(ret_var.data); + return ret_arr; +} + +uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_get_monitor(uint32_t this_arg, uint32_t funding_txo) { + LDKChainMonitor this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKOutPoint funding_txo_conv; + funding_txo_conv.inner = (void*)(funding_txo & (~1)); + funding_txo_conv.is_owned = (funding_txo & 1) || (funding_txo == 0); + funding_txo_conv = OutPoint_clone(&funding_txo_conv); + LDKCResult_LockedChannelMonitorNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_LockedChannelMonitorNoneZ), "LDKCResult_LockedChannelMonitorNoneZ"); + *ret_conv = ChainMonitor_get_monitor(&this_arg_conv, funding_txo_conv); + return (uint64_t)ret_conv; +} + +uint32_tArray __attribute__((visibility("default"))) TS_ChainMonitor_list_monitors(uint32_t this_arg) { + LDKChainMonitor this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKCVec_OutPointZ ret_var = ChainMonitor_list_monitors(&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 k = 0; k < ret_var.datalen; k++) { + LDKOutPoint ret_conv_10_var = ret_var.data[k]; + CHECK((((uint64_t)ret_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_10_ref = (uint64_t)ret_conv_10_var.inner; + if (ret_conv_10_var.is_owned) { + ret_conv_10_ref |= 1; + } + ret_arr_ptr[k] = ret_conv_10_ref; + } + FREE(ret_var.data); + return ret_arr; +} + uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Listen(uint32_t this_arg) { LDKChainMonitor this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen"); - *ret = ChainMonitor_as_Listen(&this_arg_conv); - return (uint64_t)ret; + LDKListen* ret_ret =MALLOC(sizeof(LDKListen), "LDKListen"); + *ret_ret = ChainMonitor_as_Listen(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Confirm(uint32_t this_arg) { LDKChainMonitor this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm"); - *ret = ChainMonitor_as_Confirm(&this_arg_conv); - return (uint64_t)ret; + LDKConfirm* ret_ret =MALLOC(sizeof(LDKConfirm), "LDKConfirm"); + *ret_ret = ChainMonitor_as_Confirm(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_Watch(uint32_t this_arg) { LDKChainMonitor this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKWatch* ret = MALLOC(sizeof(LDKWatch), "LDKWatch"); - *ret = ChainMonitor_as_Watch(&this_arg_conv); - return (uint64_t)ret; + LDKWatch* ret_ret =MALLOC(sizeof(LDKWatch), "LDKWatch"); + *ret_ret = ChainMonitor_as_Watch(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChainMonitor_as_EventsProvider(uint32_t this_arg) { LDKChainMonitor this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider"); - *ret = ChainMonitor_as_EventsProvider(&this_arg_conv); - return (uint64_t)ret; + LDKEventsProvider* ret_ret =MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider"); + *ret_ret = ChainMonitor_as_EventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_free(uint32_t this_obj) { @@ -12510,22 +14141,6 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdate_read(in return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_clone(uint32_t orig) { - LDKChannelMonitorUpdateErr* orig_conv = (LDKChannelMonitorUpdateErr*)(orig & ~1); - uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_clone(orig_conv)); - return ret_conv; -} - -uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_temporary_failure() { - uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_temporary_failure()); - return ret_conv; -} - -uint32_t __attribute__((visibility("default"))) TS_ChannelMonitorUpdateErr_permanent_failure() { - uint32_t ret_conv = LDKChannelMonitorUpdateErr_to_js(ChannelMonitorUpdateErr_permanent_failure()); - return ret_conv; -} - void __attribute__((visibility("default"))) TS_MonitorUpdateError_free(uint32_t this_obj) { LDKMonitorUpdateError this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -12573,13 +14188,13 @@ uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_htlcevent(uint3 return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_commitment_tx_broadcasted(uint32_t a) { +uint32_t __attribute__((visibility("default"))) TS_MonitorEvent_commitment_tx_confirmed(uint32_t a) { LDKOutPoint a_conv; a_conv.inner = (void*)(a & (~1)); a_conv.is_owned = (a & 1) || (a == 0); a_conv = OutPoint_clone(&a_conv); LDKMonitorEvent *ret_copy = MALLOC(sizeof(LDKMonitorEvent), "LDKMonitorEvent"); - *ret_copy = MonitorEvent_commitment_tx_broadcasted(a_conv); + *ret_copy = MonitorEvent_commitment_tx_confirmed(a_conv); uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } @@ -12625,6 +14240,56 @@ uint32_t __attribute__((visibility("default"))) TS_HTLCUpdate_read(int8_tArray return (uint64_t)ret_conv; } +void __attribute__((visibility("default"))) TS_Balance_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKBalance this_ptr_conv = *(LDKBalance*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + Balance_free(this_ptr_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_Balance_clone(uint32_t orig) { + LDKBalance* orig_conv = (LDKBalance*)orig; + LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_copy = Balance_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_Balance_claimable_on_channel_close(int64_t claimable_amount_satoshis) { + LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_copy = Balance_claimable_on_channel_close(claimable_amount_satoshis); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_Balance_claimable_awaiting_confirmations(int64_t claimable_amount_satoshis, int32_t confirmation_height) { + LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_copy = Balance_claimable_awaiting_confirmations(claimable_amount_satoshis, confirmation_height); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_Balance_contentious_claimable(int64_t claimable_amount_satoshis, int32_t timeout_height) { + LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_copy = Balance_contentious_claimable(claimable_amount_satoshis, timeout_height); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_Balance_maybe_claimable_htlcawaiting_timeout(int64_t claimable_amount_satoshis, int32_t claimable_height) { + LDKBalance *ret_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_copy = Balance_maybe_claimable_htlcawaiting_timeout(claimable_amount_satoshis, claimable_height); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +jboolean __attribute__((visibility("default"))) TS_Balance_eq(uint32_t a, uint32_t b) { + LDKBalance* a_conv = (LDKBalance*)a; + LDKBalance* b_conv = (LDKBalance*)b; + jboolean ret_val = Balance_eq(a_conv, b_conv); + return ret_val; +} + void __attribute__((visibility("default"))) TS_ChannelMonitor_free(uint32_t this_obj) { LDKChannelMonitor this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -12684,9 +14349,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) { @@ -12696,10 +14361,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; @@ -12781,11 +14446,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); @@ -12793,10 +14458,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; @@ -12831,11 +14496,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); @@ -12843,10 +14508,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; @@ -12880,10 +14545,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; @@ -12919,11 +14584,21 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelMonitor_current_best_ return ret_ref; } -void __attribute__((visibility("default"))) TS_Persist_free(uint32_t this_ptr) { - if ((this_ptr & 1) != 0) return; - LDKPersist this_ptr_conv = *(LDKPersist*)(((uint64_t)this_ptr) & ~1); - FREE((void*)this_ptr); - Persist_free(this_ptr_conv); +uint32_tArray __attribute__((visibility("default"))) TS_ChannelMonitor_get_claimable_balances(uint32_t this_arg) { + LDKChannelMonitor this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKCVec_BalanceZ ret_var = ChannelMonitor_get_claimable_balances(&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 j = 0; j < ret_var.datalen; j++) { + LDKBalance *ret_conv_9_copy = MALLOC(sizeof(LDKBalance), "LDKBalance"); + *ret_conv_9_copy = Balance_clone(&ret_var.data[j]); + uint64_t ret_conv_9_ref = (uint64_t)ret_conv_9_copy; + ret_arr_ptr[j] = ret_conv_9_ref; + } + FREE(ret_var.data); + return ret_arr; } uint32_t __attribute__((visibility("default"))) TS_C2Tuple_BlockHashChannelMonitorZ_read(int8_tArray ser, uint32_t arg) { @@ -13124,6 +14799,7 @@ void __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescriptor_s this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1); + val_conv = TxOut_clone((LDKTxOut*)(((uint64_t)val) & ~1)); DelayedPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv); } @@ -13189,6 +14865,7 @@ uint32_t __attribute__((visibility("default"))) TS_DelayedPaymentOutputDescript CHECK(*((uint32_t*)per_commitment_point_arg) == 33); memcpy(per_commitment_point_arg_ref.compressed_form, (uint8_t*)(per_commitment_point_arg + 4), 33); LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1); + output_arg_conv = TxOut_clone((LDKTxOut*)(((uint64_t)output_arg) & ~1)); LDKPublicKey revocation_pubkey_arg_ref; CHECK(*((uint32_t*)revocation_pubkey_arg) == 33); memcpy(revocation_pubkey_arg_ref.compressed_form, (uint8_t*)(revocation_pubkey_arg + 4), 33); @@ -13276,6 +14953,7 @@ void __attribute__((visibility("default"))) TS_StaticPaymentOutputDescriptor_se this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKTxOut val_conv = *(LDKTxOut*)(((uint64_t)val) & ~1); + val_conv = TxOut_clone((LDKTxOut*)(((uint64_t)val) & ~1)); StaticPaymentOutputDescriptor_set_output(&this_ptr_conv, val_conv); } @@ -13319,6 +14997,7 @@ uint32_t __attribute__((visibility("default"))) TS_StaticPaymentOutputDescripto outpoint_arg_conv.is_owned = (outpoint_arg & 1) || (outpoint_arg == 0); outpoint_arg_conv = OutPoint_clone(&outpoint_arg_conv); LDKTxOut output_arg_conv = *(LDKTxOut*)(((uint64_t)output_arg) & ~1); + output_arg_conv = TxOut_clone((LDKTxOut*)(((uint64_t)output_arg) & ~1)); LDKThirtyTwoBytes channel_keys_id_arg_ref; CHECK(*((uint32_t*)channel_keys_id_arg) == 32); memcpy(channel_keys_id_arg_ref.data, (uint8_t*)(channel_keys_id_arg + 4), 32); @@ -13387,6 +15066,7 @@ uint32_t __attribute__((visibility("default"))) TS_SpendableOutputDescriptor_st outpoint_conv.is_owned = (outpoint & 1) || (outpoint == 0); outpoint_conv = OutPoint_clone(&outpoint_conv); LDKTxOut output_conv = *(LDKTxOut*)(((uint64_t)output) & ~1); + output_conv = TxOut_clone((LDKTxOut*)(((uint64_t)output) & ~1)); LDKSpendableOutputDescriptor *ret_copy = MALLOC(sizeof(LDKSpendableOutputDescriptor), "LDKSpendableOutputDescriptor"); *ret_copy = SpendableOutputDescriptor_static_output(outpoint_conv, output_conv); uint64_t ret_ref = (uint64_t)ret_copy; @@ -13442,9 +15122,9 @@ void __attribute__((visibility("default"))) TS_BaseSign_free(uint32_t this_ptr) uint32_t __attribute__((visibility("default"))) TS_Sign_clone(uint32_t orig) { LDKSign* orig_conv = (LDKSign*)(((uint64_t)orig) & ~1); - LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign"); - *ret = Sign_clone(orig_conv); - return (uint64_t)ret; + LDKSign* ret_ret =MALLOC(sizeof(LDKSign), "LDKSign"); + *ret_ret = Sign_clone(orig_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_Sign_free(uint32_t this_ptr) { @@ -13732,18 +15412,18 @@ uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_as_BaseSign(u LDKInMemorySigner this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKBaseSign* ret = MALLOC(sizeof(LDKBaseSign), "LDKBaseSign"); - *ret = InMemorySigner_as_BaseSign(&this_arg_conv); - return (uint64_t)ret; + LDKBaseSign* ret_ret =MALLOC(sizeof(LDKBaseSign), "LDKBaseSign"); + *ret_ret = InMemorySigner_as_BaseSign(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_InMemorySigner_as_Sign(uint32_t this_arg) { LDKInMemorySigner this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKSign* ret = MALLOC(sizeof(LDKSign), "LDKSign"); - *ret = InMemorySigner_as_Sign(&this_arg_conv); - return (uint64_t)ret; + LDKSign* ret_ret =MALLOC(sizeof(LDKSign), "LDKSign"); + *ret_ret = InMemorySigner_as_Sign(&this_arg_conv); + return (uint64_t)ret_ret; } int8_tArray __attribute__((visibility("default"))) TS_InMemorySigner_write(uint32_t obj) { @@ -13849,24 +15529,84 @@ uint32_t __attribute__((visibility("default"))) TS_KeysManager_as_KeysInterface LDKKeysManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKKeysInterface* ret = MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface"); - *ret = KeysManager_as_KeysInterface(&this_arg_conv); - return (uint64_t)ret; + LDKKeysInterface* ret_ret =MALLOC(sizeof(LDKKeysInterface), "LDKKeysInterface"); + *ret_ret = KeysManager_as_KeysInterface(&this_arg_conv); + return (uint64_t)ret_ret; } -void __attribute__((visibility("default"))) TS_ChannelManager_free(uint32_t this_obj) { - LDKChannelManager this_obj_conv; +void __attribute__((visibility("default"))) TS_PaymentId_free(uint32_t this_obj) { + LDKPaymentId this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - ChannelManager_free(this_obj_conv); + PaymentId_free(this_obj_conv); } -void __attribute__((visibility("default"))) TS_ChainParameters_free(uint32_t this_obj) { - LDKChainParameters this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - ChainParameters_free(this_obj_conv); -} +int64_t __attribute__((visibility("default"))) TS_PaymentId_hash(uint32_t o) { + LDKPaymentId o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = PaymentId_hash(&o_conv); + return ret_val; +} + +uint32_t __attribute__((visibility("default"))) TS_PaymentId_clone(uint32_t orig) { + LDKPaymentId orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKPaymentId ret_var = PaymentId_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; +} + +jboolean __attribute__((visibility("default"))) TS_PaymentId_eq(uint32_t a, uint32_t b) { + LDKPaymentId a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKPaymentId b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = PaymentId_eq(&a_conv, &b_conv); + return ret_val; +} + +int8_tArray __attribute__((visibility("default"))) TS_PaymentId_write(uint32_t obj) { + LDKPaymentId obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = PaymentId_write(&obj_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_PaymentId_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_PaymentIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdDecodeErrorZ), "LDKCResult_PaymentIdDecodeErrorZ"); + *ret_conv = PaymentId_read(ser_ref); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_ChannelManager_free(uint32_t this_obj) { + LDKChannelManager this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ChannelManager_free(this_obj_conv); +} + +void __attribute__((visibility("default"))) TS_ChainParameters_free(uint32_t this_obj) { + LDKChainParameters this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ChainParameters_free(this_obj_conv); +} uint32_t __attribute__((visibility("default"))) TS_ChainParameters_get_network(uint32_t this_ptr) { LDKChainParameters this_ptr_conv; @@ -13939,6 +15679,83 @@ uint32_t __attribute__((visibility("default"))) TS_ChainParameters_clone(uint32 return ret_ref; } +void __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_free(uint32_t this_obj) { + LDKCounterpartyForwardingInfo this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + CounterpartyForwardingInfo_free(this_obj_conv); +} + +int32_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_get_fee_base_msat(uint32_t this_ptr) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int32_t ret_val = CounterpartyForwardingInfo_get_fee_base_msat(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_set_fee_base_msat(uint32_t this_ptr, int32_t val) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + CounterpartyForwardingInfo_set_fee_base_msat(&this_ptr_conv, val); +} + +int32_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_get_fee_proportional_millionths(uint32_t this_ptr) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int32_t ret_val = CounterpartyForwardingInfo_get_fee_proportional_millionths(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_set_fee_proportional_millionths(uint32_t this_ptr, int32_t val) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + CounterpartyForwardingInfo_set_fee_proportional_millionths(&this_ptr_conv, val); +} + +int16_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_get_cltv_expiry_delta(uint32_t this_ptr) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int16_t ret_val = CounterpartyForwardingInfo_get_cltv_expiry_delta(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) { + LDKCounterpartyForwardingInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + CounterpartyForwardingInfo_set_cltv_expiry_delta(&this_ptr_conv, val); +} + +uint32_t __attribute__((visibility("default"))) TS_CounterpartyForwardingInfo_new(int32_t fee_base_msat_arg, int32_t fee_proportional_millionths_arg, int16_t cltv_expiry_delta_arg) { + LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_new(fee_base_msat_arg, fee_proportional_millionths_arg, cltv_expiry_delta_arg); + 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_CounterpartyForwardingInfo_clone(uint32_t orig) { + LDKCounterpartyForwardingInfo orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKCounterpartyForwardingInfo ret_var = CounterpartyForwardingInfo_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_ChannelCounterparty_free(uint32_t this_obj) { LDKChannelCounterparty this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -14005,6 +15822,53 @@ void __attribute__((visibility("default"))) TS_ChannelCounterparty_set_unspenda ChannelCounterparty_set_unspendable_punishment_reserve(&this_ptr_conv, val); } +uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_get_forwarding_info(uint32_t this_ptr) { + LDKChannelCounterparty this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCounterpartyForwardingInfo ret_var = ChannelCounterparty_get_forwarding_info(&this_ptr_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_ChannelCounterparty_set_forwarding_info(uint32_t this_ptr, uint32_t val) { + LDKChannelCounterparty this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCounterpartyForwardingInfo val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = CounterpartyForwardingInfo_clone(&val_conv); + ChannelCounterparty_set_forwarding_info(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelCounterparty_new(int8_tArray node_id_arg, uint32_t features_arg, int64_t unspendable_punishment_reserve_arg, uint32_t forwarding_info_arg) { + LDKPublicKey node_id_arg_ref; + CHECK(*((uint32_t*)node_id_arg) == 33); + memcpy(node_id_arg_ref.compressed_form, (uint8_t*)(node_id_arg + 4), 33); + LDKInitFeatures features_arg_conv; + features_arg_conv.inner = (void*)(features_arg & (~1)); + features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0); + features_arg_conv = InitFeatures_clone(&features_arg_conv); + LDKCounterpartyForwardingInfo forwarding_info_arg_conv; + forwarding_info_arg_conv.inner = (void*)(forwarding_info_arg & (~1)); + forwarding_info_arg_conv.is_owned = (forwarding_info_arg & 1) || (forwarding_info_arg == 0); + forwarding_info_arg_conv = CounterpartyForwardingInfo_clone(&forwarding_info_arg_conv); + LDKChannelCounterparty ret_var = ChannelCounterparty_new(node_id_arg_ref, features_arg_conv, unspendable_punishment_reserve_arg, forwarding_info_arg_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_ChannelCounterparty_clone(uint32_t orig) { LDKChannelCounterparty orig_conv; orig_conv.inner = (void*)(orig & (~1)); @@ -14110,6 +15974,7 @@ void __attribute__((visibility("default"))) TS_ChannelDetails_set_short_channel this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); ChannelDetails_set_short_channel_id(&this_ptr_conv, val_conv); } @@ -14143,22 +16008,23 @@ void __attribute__((visibility("default"))) TS_ChannelDetails_set_unspendable_p this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); ChannelDetails_set_unspendable_punishment_reserve(&this_ptr_conv, val_conv); } -int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_user_id(uint32_t this_ptr) { +int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_user_channel_id(uint32_t this_ptr) { LDKChannelDetails this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int64_t ret_val = ChannelDetails_get_user_id(&this_ptr_conv); + int64_t ret_val = ChannelDetails_get_user_channel_id(&this_ptr_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_ChannelDetails_set_user_id(uint32_t this_ptr, int64_t val) { +void __attribute__((visibility("default"))) TS_ChannelDetails_set_user_channel_id(uint32_t this_ptr, int64_t val) { LDKChannelDetails this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - ChannelDetails_set_user_id(&this_ptr_conv, val); + ChannelDetails_set_user_channel_id(&this_ptr_conv, val); } int64_t __attribute__((visibility("default"))) TS_ChannelDetails_get_outbound_capacity_msat(uint32_t this_ptr) { @@ -14206,6 +16072,7 @@ void __attribute__((visibility("default"))) TS_ChannelDetails_set_confirmations this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1); + val_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uint64_t)val) & ~1)); ChannelDetails_set_confirmations_required(&this_ptr_conv, val_conv); } @@ -14224,6 +16091,7 @@ void __attribute__((visibility("default"))) TS_ChannelDetails_set_force_close_s this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKCOption_u16Z val_conv = *(LDKCOption_u16Z*)(((uint64_t)val) & ~1); + val_conv = COption_u16Z_clone((LDKCOption_u16Z*)(((uint64_t)val) & ~1)); ChannelDetails_set_force_close_spend_delay(&this_ptr_conv, val_conv); } @@ -14287,7 +16155,7 @@ void __attribute__((visibility("default"))) TS_ChannelDetails_set_is_public(uin ChannelDetails_set_is_public(&this_ptr_conv, val); } -uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_new(int8_tArray channel_id_arg, uint32_t counterparty_arg, uint32_t funding_txo_arg, uint32_t short_channel_id_arg, int64_t channel_value_satoshis_arg, uint32_t unspendable_punishment_reserve_arg, int64_t user_id_arg, int64_t outbound_capacity_msat_arg, int64_t inbound_capacity_msat_arg, uint32_t confirmations_required_arg, uint32_t force_close_spend_delay_arg, jboolean is_outbound_arg, jboolean is_funding_locked_arg, jboolean is_usable_arg, jboolean is_public_arg) { +uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_new(int8_tArray channel_id_arg, uint32_t counterparty_arg, uint32_t funding_txo_arg, uint32_t short_channel_id_arg, int64_t channel_value_satoshis_arg, uint32_t unspendable_punishment_reserve_arg, int64_t user_channel_id_arg, int64_t outbound_capacity_msat_arg, int64_t inbound_capacity_msat_arg, uint32_t confirmations_required_arg, uint32_t force_close_spend_delay_arg, jboolean is_outbound_arg, jboolean is_funding_locked_arg, jboolean is_usable_arg, jboolean is_public_arg) { LDKThirtyTwoBytes channel_id_arg_ref; CHECK(*((uint32_t*)channel_id_arg) == 32); memcpy(channel_id_arg_ref.data, (uint8_t*)(channel_id_arg + 4), 32); @@ -14300,10 +16168,13 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelDetails_new(int8_tArr funding_txo_arg_conv.is_owned = (funding_txo_arg & 1) || (funding_txo_arg == 0); funding_txo_arg_conv = OutPoint_clone(&funding_txo_arg_conv); LDKCOption_u64Z short_channel_id_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)short_channel_id_arg) & ~1); + short_channel_id_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)short_channel_id_arg) & ~1)); LDKCOption_u64Z unspendable_punishment_reserve_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)unspendable_punishment_reserve_arg) & ~1); LDKCOption_u32Z confirmations_required_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)confirmations_required_arg) & ~1); + confirmations_required_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uint64_t)confirmations_required_arg) & ~1)); LDKCOption_u16Z force_close_spend_delay_arg_conv = *(LDKCOption_u16Z*)(((uint64_t)force_close_spend_delay_arg) & ~1); - LDKChannelDetails ret_var = ChannelDetails_new(channel_id_arg_ref, counterparty_arg_conv, funding_txo_arg_conv, short_channel_id_arg_conv, channel_value_satoshis_arg, unspendable_punishment_reserve_arg_conv, user_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg); + force_close_spend_delay_arg_conv = COption_u16Z_clone((LDKCOption_u16Z*)(((uint64_t)force_close_spend_delay_arg) & ~1)); + LDKChannelDetails ret_var = ChannelDetails_new(channel_id_arg_ref, counterparty_arg_conv, funding_txo_arg_conv, short_channel_id_arg_conv, channel_value_satoshis_arg, unspendable_punishment_reserve_arg_conv, user_channel_id_arg, outbound_capacity_msat_arg, inbound_capacity_msat_arg, confirmations_required_arg_conv, force_close_spend_delay_arg_conv, is_outbound_arg, is_funding_locked_arg, is_usable_arg, is_public_arg); 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; @@ -14344,6 +16215,7 @@ uint32_t __attribute__((visibility("default"))) TS_PaymentSendFailure_clone(uin uint32_t __attribute__((visibility("default"))) TS_PaymentSendFailure_parameter_error(uint32_t a) { LDKAPIError a_conv = *(LDKAPIError*)(((uint64_t)a) & ~1); + a_conv = APIError_clone((LDKAPIError*)(((uint64_t)a) & ~1)); LDKPaymentSendFailure *ret_copy = MALLOC(sizeof(LDKPaymentSendFailure), "LDKPaymentSendFailure"); *ret_copy = PaymentSendFailure_parameter_error(a_conv); uint64_t ret_ref = (uint64_t)ret_copy; @@ -14448,7 +16320,7 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_get_current_d return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_channel(uint32_t this_arg, int8_tArray their_network_key, int64_t channel_value_satoshis, int64_t push_msat, int64_t user_id, uint32_t override_config) { +uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_channel(uint32_t this_arg, int8_tArray their_network_key, int64_t channel_value_satoshis, int64_t push_msat, int64_t user_channel_id, uint32_t override_config) { LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; @@ -14459,8 +16331,8 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_channe override_config_conv.inner = (void*)(override_config & (~1)); override_config_conv.is_owned = (override_config & 1) || (override_config == 0); override_config_conv = UserConfig_clone(&override_config_conv); - LDKCResult_NoneAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneAPIErrorZ), "LDKCResult_NoneAPIErrorZ"); - *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_id, override_config_conv); + LDKCResult__u832APIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult__u832APIErrorZ), "LDKCResult__u832APIErrorZ"); + *ret_conv = ChannelManager_create_channel(&this_arg_conv, their_network_key_ref, channel_value_satoshis, push_msat, user_channel_id, override_config_conv); return (uint64_t)ret_conv; } @@ -14565,11 +16437,27 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_send_payment( LDKThirtyTwoBytes payment_secret_ref; CHECK(*((uint32_t*)payment_secret) == 32); memcpy(payment_secret_ref.data, (uint8_t*)(payment_secret + 4), 32); - LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); + LDKCResult_PaymentIdPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentIdPaymentSendFailureZ), "LDKCResult_PaymentIdPaymentSendFailureZ"); *ret_conv = ChannelManager_send_payment(&this_arg_conv, &route_conv, payment_hash_ref, payment_secret_ref); return (uint64_t)ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_ChannelManager_retry_payment(uint32_t this_arg, uint32_t route, uint32_t payment_id) { + LDKChannelManager this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKRoute route_conv; + route_conv.inner = (void*)(route & (~1)); + route_conv.is_owned = false; + LDKPaymentId payment_id_conv; + payment_id_conv.inner = (void*)(payment_id & (~1)); + payment_id_conv.is_owned = (payment_id & 1) || (payment_id == 0); + payment_id_conv = PaymentId_clone(&payment_id_conv); + LDKCResult_NonePaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_NonePaymentSendFailureZ), "LDKCResult_NonePaymentSendFailureZ"); + *ret_conv = ChannelManager_retry_payment(&this_arg_conv, &route_conv, payment_id_conv); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_ChannelManager_send_spontaneous_payment(uint32_t this_arg, uint32_t route, int8_tArray payment_preimage) { LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); @@ -14580,7 +16468,7 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_send_spontane LDKThirtyTwoBytes payment_preimage_ref; CHECK(*((uint32_t*)payment_preimage) == 32); memcpy(payment_preimage_ref.data, (uint8_t*)(payment_preimage + 4), 32); - LDKCResult_PaymentHashPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentHashPaymentSendFailureZ), "LDKCResult_PaymentHashPaymentSendFailureZ"); + LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ* ret_conv = MALLOC(sizeof(LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ), "LDKCResult_C2Tuple_PaymentHashPaymentIdZPaymentSendFailureZ"); *ret_conv = ChannelManager_send_spontaneous_payment(&this_arg_conv, &route_conv, payment_preimage_ref); return (uint64_t)ret_conv; } @@ -14689,9 +16577,10 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_inboun this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; LDKCOption_u64Z min_value_msat_conv = *(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; + min_value_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)min_value_msat) & ~1)); + 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) { @@ -14702,6 +16591,7 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_create_inboun CHECK(*((uint32_t*)payment_hash) == 32); memcpy(payment_hash_ref.data, (uint8_t*)(payment_hash + 4), 32); 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)); LDKCResult_PaymentSecretAPIErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PaymentSecretAPIErrorZ), "LDKCResult_PaymentSecretAPIErrorZ"); *ret_conv = ChannelManager_create_inbound_payment_for_hash(&this_arg_conv, payment_hash_ref, min_value_msat_conv, invoice_expiry_delta_secs, user_payment_id); return (uint64_t)ret_conv; @@ -14711,36 +16601,36 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_MessageSen LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); - *ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv); - return (uint64_t)ret; + LDKMessageSendEventsProvider* ret_ret =MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); + *ret_ret = ChannelManager_as_MessageSendEventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_EventsProvider(uint32_t this_arg) { LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKEventsProvider* ret = MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider"); - *ret = ChannelManager_as_EventsProvider(&this_arg_conv); - return (uint64_t)ret; + LDKEventsProvider* ret_ret =MALLOC(sizeof(LDKEventsProvider), "LDKEventsProvider"); + *ret_ret = ChannelManager_as_EventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_Listen(uint32_t this_arg) { LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKListen* ret = MALLOC(sizeof(LDKListen), "LDKListen"); - *ret = ChannelManager_as_Listen(&this_arg_conv); - return (uint64_t)ret; + LDKListen* ret_ret =MALLOC(sizeof(LDKListen), "LDKListen"); + *ret_ret = ChannelManager_as_Listen(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_Confirm(uint32_t this_arg) { LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKConfirm* ret = MALLOC(sizeof(LDKConfirm), "LDKConfirm"); - *ret = ChannelManager_as_Confirm(&this_arg_conv); - return (uint64_t)ret; + LDKConfirm* ret_ret =MALLOC(sizeof(LDKConfirm), "LDKConfirm"); + *ret_ret = ChannelManager_as_Confirm(&this_arg_conv); + return (uint64_t)ret_ret; } jboolean __attribute__((visibility("default"))) TS_ChannelManager_await_persistable_update_timeout(uint32_t this_arg, int64_t max_wait) { @@ -14776,9 +16666,9 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelManager_as_ChannelMes LDKChannelManager this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler"); - *ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv); - return (uint64_t)ret; + LDKChannelMessageHandler* ret_ret =MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler"); + *ret_ret = ChannelManager_as_ChannelMessageHandler(&this_arg_conv); + return (uint64_t)ret_ret; } int8_tArray __attribute__((visibility("default"))) TS_ChannelManager_write(uint32_t obj) { @@ -18556,12 +20446,14 @@ void __attribute__((visibility("default"))) TS_LightningError_set_action(uint32 this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKErrorAction val_conv = *(LDKErrorAction*)(((uint64_t)val) & ~1); + val_conv = ErrorAction_clone((LDKErrorAction*)(((uint64_t)val) & ~1)); LightningError_set_action(&this_ptr_conv, val_conv); } uint32_t __attribute__((visibility("default"))) TS_LightningError_new(jstring err_arg, uint32_t action_arg) { LDKStr err_arg_conv = str_ref_to_owned_c(err_arg); LDKErrorAction action_arg_conv = *(LDKErrorAction*)(((uint64_t)action_arg) & ~1); + action_arg_conv = ErrorAction_clone((LDKErrorAction*)(((uint64_t)action_arg) & ~1)); LDKLightningError ret_var = LightningError_new(err_arg_conv, action_arg_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. @@ -18593,6 +20485,27 @@ void __attribute__((visibility("default"))) TS_CommitmentUpdate_free(uint32_t t CommitmentUpdate_free(this_obj_conv); } +uint32_tArray __attribute__((visibility("default"))) TS_CommitmentUpdate_get_update_add_htlcs(uint32_t this_ptr) { + LDKCommitmentUpdate this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCVec_UpdateAddHTLCZ ret_var = CommitmentUpdate_get_update_add_htlcs(&this_ptr_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 p = 0; p < ret_var.datalen; p++) { + LDKUpdateAddHTLC ret_conv_15_var = ret_var.data[p]; + CHECK((((uint64_t)ret_conv_15_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_15_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_15_ref = (uint64_t)ret_conv_15_var.inner; + if (ret_conv_15_var.is_owned) { + ret_conv_15_ref |= 1; + } + ret_arr_ptr[p] = ret_conv_15_ref; + } + FREE(ret_var.data); + return ret_arr; +} + void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_add_htlcs(uint32_t this_ptr, uint32_tArray val) { LDKCommitmentUpdate this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); @@ -18615,6 +20528,27 @@ void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_add_ CommitmentUpdate_set_update_add_htlcs(&this_ptr_conv, val_constr); } +uint32_tArray __attribute__((visibility("default"))) TS_CommitmentUpdate_get_update_fulfill_htlcs(uint32_t this_ptr) { + LDKCommitmentUpdate this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCVec_UpdateFulfillHTLCZ ret_var = CommitmentUpdate_get_update_fulfill_htlcs(&this_ptr_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 t = 0; t < ret_var.datalen; t++) { + LDKUpdateFulfillHTLC ret_conv_19_var = ret_var.data[t]; + CHECK((((uint64_t)ret_conv_19_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_19_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_19_ref = (uint64_t)ret_conv_19_var.inner; + if (ret_conv_19_var.is_owned) { + ret_conv_19_ref |= 1; + } + ret_arr_ptr[t] = ret_conv_19_ref; + } + FREE(ret_var.data); + return ret_arr; +} + void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fulfill_htlcs(uint32_t this_ptr, uint32_tArray val) { LDKCommitmentUpdate this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); @@ -18637,6 +20571,27 @@ void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fulf CommitmentUpdate_set_update_fulfill_htlcs(&this_ptr_conv, val_constr); } +uint32_tArray __attribute__((visibility("default"))) TS_CommitmentUpdate_get_update_fail_htlcs(uint32_t this_ptr) { + LDKCommitmentUpdate this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCVec_UpdateFailHTLCZ ret_var = CommitmentUpdate_get_update_fail_htlcs(&this_ptr_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 q = 0; q < ret_var.datalen; q++) { + LDKUpdateFailHTLC ret_conv_16_var = ret_var.data[q]; + CHECK((((uint64_t)ret_conv_16_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_16_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_16_ref = (uint64_t)ret_conv_16_var.inner; + if (ret_conv_16_var.is_owned) { + ret_conv_16_ref |= 1; + } + ret_arr_ptr[q] = ret_conv_16_ref; + } + FREE(ret_var.data); + return ret_arr; +} + void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fail_htlcs(uint32_t this_ptr, uint32_tArray val) { LDKCommitmentUpdate this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); @@ -18659,6 +20614,27 @@ void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fail CommitmentUpdate_set_update_fail_htlcs(&this_ptr_conv, val_constr); } +uint32_tArray __attribute__((visibility("default"))) TS_CommitmentUpdate_get_update_fail_malformed_htlcs(uint32_t this_ptr) { + LDKCommitmentUpdate this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCVec_UpdateFailMalformedHTLCZ ret_var = CommitmentUpdate_get_update_fail_malformed_htlcs(&this_ptr_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 z = 0; z < ret_var.datalen; z++) { + LDKUpdateFailMalformedHTLC ret_conv_25_var = ret_var.data[z]; + CHECK((((uint64_t)ret_conv_25_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_25_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_25_ref = (uint64_t)ret_conv_25_var.inner; + if (ret_conv_25_var.is_owned) { + ret_conv_25_ref |= 1; + } + ret_arr_ptr[z] = ret_conv_25_ref; + } + FREE(ret_var.data); + return ret_arr; +} + void __attribute__((visibility("default"))) TS_CommitmentUpdate_set_update_fail_malformed_htlcs(uint32_t this_ptr, uint32_tArray val) { LDKCommitmentUpdate this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); @@ -18824,49 +20800,6 @@ uint32_t __attribute__((visibility("default"))) TS_CommitmentUpdate_clone(uint3 return ret_ref; } -void __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_free(uint32_t this_ptr) { - if ((this_ptr & 1) != 0) return; - LDKHTLCFailChannelUpdate this_ptr_conv = *(LDKHTLCFailChannelUpdate*)(((uint64_t)this_ptr) & ~1); - FREE((void*)this_ptr); - HTLCFailChannelUpdate_free(this_ptr_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_clone(uint32_t orig) { - LDKHTLCFailChannelUpdate* orig_conv = (LDKHTLCFailChannelUpdate*)orig; - LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate"); - *ret_copy = HTLCFailChannelUpdate_clone(orig_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -uint32_t __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_channel_update_message(uint32_t msg) { - LDKChannelUpdate msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = (msg & 1) || (msg == 0); - msg_conv = ChannelUpdate_clone(&msg_conv); - LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate"); - *ret_copy = HTLCFailChannelUpdate_channel_update_message(msg_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -uint32_t __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_channel_closed(int64_t short_channel_id, jboolean is_permanent) { - LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate"); - *ret_copy = HTLCFailChannelUpdate_channel_closed(short_channel_id, is_permanent); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -uint32_t __attribute__((visibility("default"))) TS_HTLCFailChannelUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) { - LDKPublicKey node_id_ref; - CHECK(*((uint32_t*)node_id) == 33); - memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33); - LDKHTLCFailChannelUpdate *ret_copy = MALLOC(sizeof(LDKHTLCFailChannelUpdate), "LDKHTLCFailChannelUpdate"); - *ret_copy = HTLCFailChannelUpdate_node_failure(node_id_ref, is_permanent); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - void __attribute__((visibility("default"))) TS_ChannelMessageHandler_free(uint32_t this_ptr) { if ((this_ptr & 1) != 0) return; LDKChannelMessageHandler this_ptr_conv = *(LDKChannelMessageHandler*)(((uint64_t)this_ptr) & ~1); @@ -19441,15 +21374,6 @@ int8_tArray __attribute__((visibility("default"))) TS_QueryShortChannelIds_writ return ret_arr; } -uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ"); - *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref); - return (uint64_t)ret_conv; -} - int8_tArray __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_write(uint32_t obj) { LDKReplyShortChannelIdsEnd obj_conv; obj_conv.inner = (void*)(obj & (~1)); @@ -19461,6 +21385,15 @@ int8_tArray __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_w return ret_arr; } +uint32_t __attribute__((visibility("default"))) TS_ReplyShortChannelIdsEnd_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ), "LDKCResult_ReplyShortChannelIdsEndDecodeErrorZ"); + *ret_conv = ReplyShortChannelIdsEnd_read(ser_ref); + return (uint64_t)ret_conv; +} + int32_t __attribute__((visibility("default"))) TS_QueryChannelRange_end_blocknum(uint32_t this_arg) { LDKQueryChannelRange this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); @@ -19469,15 +21402,6 @@ int32_t __attribute__((visibility("default"))) TS_QueryChannelRange_end_blocknu return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ"); - *ret_conv = QueryChannelRange_read(ser_ref); - return (uint64_t)ret_conv; -} - int8_tArray __attribute__((visibility("default"))) TS_QueryChannelRange_write(uint32_t obj) { LDKQueryChannelRange obj_conv; obj_conv.inner = (void*)(obj & (~1)); @@ -19489,6 +21413,15 @@ int8_tArray __attribute__((visibility("default"))) TS_QueryChannelRange_write(u return ret_arr; } +uint32_t __attribute__((visibility("default"))) TS_QueryChannelRange_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_QueryChannelRangeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_QueryChannelRangeDecodeErrorZ), "LDKCResult_QueryChannelRangeDecodeErrorZ"); + *ret_conv = QueryChannelRange_read(ser_ref); + return (uint64_t)ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_ReplyChannelRange_read(int8_tArray ser) { LDKu8slice ser_ref; ser_ref.datalen = *((uint32_t*)ser); @@ -19509,15 +21442,6 @@ int8_tArray __attribute__((visibility("default"))) TS_ReplyChannelRange_write(u return ret_arr; } -uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ"); - *ret_conv = GossipTimestampFilter_read(ser_ref); - return (uint64_t)ret_conv; -} - int8_tArray __attribute__((visibility("default"))) TS_GossipTimestampFilter_write(uint32_t obj) { LDKGossipTimestampFilter obj_conv; obj_conv.inner = (void*)(obj & (~1)); @@ -19529,6 +21453,22 @@ int8_tArray __attribute__((visibility("default"))) TS_GossipTimestampFilter_wri return ret_arr; } +uint32_t __attribute__((visibility("default"))) TS_GossipTimestampFilter_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_GossipTimestampFilterDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_GossipTimestampFilterDecodeErrorZ), "LDKCResult_GossipTimestampFilterDecodeErrorZ"); + *ret_conv = GossipTimestampFilter_read(ser_ref); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_CustomMessageHandler_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKCustomMessageHandler this_ptr_conv = *(LDKCustomMessageHandler*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + CustomMessageHandler_free(this_ptr_conv); +} + void __attribute__((visibility("default"))) TS_IgnoringMessageHandler_free(uint32_t this_obj) { LDKIgnoringMessageHandler this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -19551,18 +21491,36 @@ uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_Me LDKIgnoringMessageHandler this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); - *ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv); - return (uint64_t)ret; + LDKMessageSendEventsProvider* ret_ret =MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); + *ret_ret = IgnoringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_RoutingMessageHandler(uint32_t this_arg) { LDKIgnoringMessageHandler this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler"); - *ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv); - return (uint64_t)ret; + LDKRoutingMessageHandler* ret_ret =MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler"); + *ret_ret = IgnoringMessageHandler_as_RoutingMessageHandler(&this_arg_conv); + return (uint64_t)ret_ret; +} + +uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_CustomMessageReader(uint32_t this_arg) { + LDKIgnoringMessageHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKCustomMessageReader* ret_ret =MALLOC(sizeof(LDKCustomMessageReader), "LDKCustomMessageReader"); + *ret_ret = IgnoringMessageHandler_as_CustomMessageReader(&this_arg_conv); + return (uint64_t)ret_ret; +} + +uint32_t __attribute__((visibility("default"))) TS_IgnoringMessageHandler_as_CustomMessageHandler(uint32_t this_arg) { + LDKIgnoringMessageHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKCustomMessageHandler* ret_ret =MALLOC(sizeof(LDKCustomMessageHandler), "LDKCustomMessageHandler"); + *ret_ret = IgnoringMessageHandler_as_CustomMessageHandler(&this_arg_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_ErroringMessageHandler_free(uint32_t this_obj) { @@ -19587,18 +21545,18 @@ uint32_t __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_Me LDKErroringMessageHandler this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); - *ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv); - return (uint64_t)ret; + LDKMessageSendEventsProvider* ret_ret =MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); + *ret_ret = ErroringMessageHandler_as_MessageSendEventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; } uint32_t __attribute__((visibility("default"))) TS_ErroringMessageHandler_as_ChannelMessageHandler(uint32_t this_arg) { LDKErroringMessageHandler this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKChannelMessageHandler* ret = MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler"); - *ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv); - return (uint64_t)ret; + LDKChannelMessageHandler* ret_ret =MALLOC(sizeof(LDKChannelMessageHandler), "LDKChannelMessageHandler"); + *ret_ret = ErroringMessageHandler_as_ChannelMessageHandler(&this_arg_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_MessageHandler_free(uint32_t this_obj) { @@ -19655,9 +21613,9 @@ uint32_t __attribute__((visibility("default"))) TS_MessageHandler_new(uint32_t uint32_t __attribute__((visibility("default"))) TS_SocketDescriptor_clone(uint32_t orig) { LDKSocketDescriptor* orig_conv = (LDKSocketDescriptor*)(((uint64_t)orig) & ~1); - LDKSocketDescriptor* ret = MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor"); - *ret = SocketDescriptor_clone(orig_conv); - return (uint64_t)ret; + LDKSocketDescriptor* ret_ret =MALLOC(sizeof(LDKSocketDescriptor), "LDKSocketDescriptor"); + *ret_ret = SocketDescriptor_clone(orig_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_SocketDescriptor_free(uint32_t this_ptr) { @@ -19721,7 +21679,7 @@ void __attribute__((visibility("default"))) TS_PeerManager_free(uint32_t this_o PeerManager_free(this_obj_conv); } -uint32_t __attribute__((visibility("default"))) TS_PeerManager_new(uint32_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, uint32_t logger) { +uint32_t __attribute__((visibility("default"))) TS_PeerManager_new(uint32_t message_handler, int8_tArray our_node_secret, int8_tArray ephemeral_random_data, uint32_t logger, uint32_t custom_message_handler) { LDKMessageHandler message_handler_conv; message_handler_conv.inner = (void*)(message_handler & (~1)); message_handler_conv.is_owned = (message_handler & 1) || (message_handler == 0); @@ -19734,7 +21692,8 @@ uint32_t __attribute__((visibility("default"))) TS_PeerManager_new(uint32_t mes memcpy(ephemeral_random_data_arr, (uint8_t*)(ephemeral_random_data + 4), 32); unsigned char (*ephemeral_random_data_ref)[32] = &ephemeral_random_data_arr; LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv); + LDKCustomMessageHandler custom_message_handler_conv = *(LDKCustomMessageHandler*)(((uint64_t)custom_message_handler) & ~1); + LDKPeerManager ret_var = PeerManager_new(message_handler_conv, our_node_secret_ref, ephemeral_random_data_ref, logger_conv, custom_message_handler_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; @@ -19848,6 +21807,26 @@ int8_tArray __attribute__((visibility("default"))) TS_build_commitment_secret(i return ret_arr; } +int8_tArray __attribute__((visibility("default"))) TS_build_closing_transaction(int64_t to_holder_value_sat, int64_t to_counterparty_value_sat, int8_tArray to_holder_script, int8_tArray to_counterparty_script, uint32_t funding_outpoint) { + LDKCVec_u8Z to_holder_script_ref; + to_holder_script_ref.datalen = *((uint32_t*)to_holder_script); + to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes"); + memcpy(to_holder_script_ref.data, (uint8_t*)(to_holder_script + 4), to_holder_script_ref.datalen); + LDKCVec_u8Z to_counterparty_script_ref; + to_counterparty_script_ref.datalen = *((uint32_t*)to_counterparty_script); + to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes"); + memcpy(to_counterparty_script_ref.data, (uint8_t*)(to_counterparty_script + 4), to_counterparty_script_ref.datalen); + LDKOutPoint funding_outpoint_conv; + funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1)); + funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0); + funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv); + LDKTransaction ret_var = build_closing_transaction(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_conv); + 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_derive_private_key(int8_tArray per_commitment_point, int8_tArray base_secret) { LDKPublicKey per_commitment_point_ref; CHECK(*((uint32_t*)per_commitment_point) == 33); @@ -20359,6 +22338,7 @@ void __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_set_trans this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKCOption_u32Z val_conv = *(LDKCOption_u32Z*)(((uint64_t)val) & ~1); + val_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uint64_t)val) & ~1)); HTLCOutputInCommitment_set_transaction_output_index(&this_ptr_conv, val_conv); } @@ -20367,6 +22347,7 @@ uint32_t __attribute__((visibility("default"))) TS_HTLCOutputInCommitment_new(j CHECK(*((uint32_t*)payment_hash_arg) == 32); memcpy(payment_hash_arg_ref.data, (uint8_t*)(payment_hash_arg + 4), 32); LDKCOption_u32Z transaction_output_index_arg_conv = *(LDKCOption_u32Z*)(((uint64_t)transaction_output_index_arg) & ~1); + transaction_output_index_arg_conv = COption_u32Z_clone((LDKCOption_u32Z*)(((uint64_t)transaction_output_index_arg) & ~1)); LDKHTLCOutputInCommitment ret_var = HTLCOutputInCommitment_new(offered_arg, amount_msat_arg, cltv_expiry_arg, payment_hash_arg_ref, transaction_output_index_arg_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. @@ -21075,6 +23056,145 @@ int8_tArray __attribute__((visibility("default"))) TS_BuiltCommitmentTransactio return ret_arr; } +void __attribute__((visibility("default"))) TS_ClosingTransaction_free(uint32_t this_obj) { + LDKClosingTransaction this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ClosingTransaction_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ClosingTransaction_new(int64_t to_holder_value_sat, int64_t to_counterparty_value_sat, int8_tArray to_holder_script, int8_tArray to_counterparty_script, uint32_t funding_outpoint) { + LDKCVec_u8Z to_holder_script_ref; + to_holder_script_ref.datalen = *((uint32_t*)to_holder_script); + to_holder_script_ref.data = MALLOC(to_holder_script_ref.datalen, "LDKCVec_u8Z Bytes"); + memcpy(to_holder_script_ref.data, (uint8_t*)(to_holder_script + 4), to_holder_script_ref.datalen); + LDKCVec_u8Z to_counterparty_script_ref; + to_counterparty_script_ref.datalen = *((uint32_t*)to_counterparty_script); + to_counterparty_script_ref.data = MALLOC(to_counterparty_script_ref.datalen, "LDKCVec_u8Z Bytes"); + memcpy(to_counterparty_script_ref.data, (uint8_t*)(to_counterparty_script + 4), to_counterparty_script_ref.datalen); + LDKOutPoint funding_outpoint_conv; + funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1)); + funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0); + funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv); + LDKClosingTransaction ret_var = ClosingTransaction_new(to_holder_value_sat, to_counterparty_value_sat, to_holder_script_ref, to_counterparty_script_ref, funding_outpoint_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_ClosingTransaction_trust(uint32_t this_arg) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKTrustedClosingTransaction ret_var = ClosingTransaction_trust(&this_arg_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_ClosingTransaction_verify(uint32_t this_arg, uint32_t funding_outpoint) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKOutPoint funding_outpoint_conv; + funding_outpoint_conv.inner = (void*)(funding_outpoint & (~1)); + funding_outpoint_conv.is_owned = (funding_outpoint & 1) || (funding_outpoint == 0); + funding_outpoint_conv = OutPoint_clone(&funding_outpoint_conv); + LDKCResult_TrustedClosingTransactionNoneZ* ret_conv = MALLOC(sizeof(LDKCResult_TrustedClosingTransactionNoneZ), "LDKCResult_TrustedClosingTransactionNoneZ"); + *ret_conv = ClosingTransaction_verify(&this_arg_conv, funding_outpoint_conv); + return (uint64_t)ret_conv; +} + +int64_t __attribute__((visibility("default"))) TS_ClosingTransaction_to_holder_value_sat(uint32_t this_arg) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + int64_t ret_val = ClosingTransaction_to_holder_value_sat(&this_arg_conv); + return ret_val; +} + +int64_t __attribute__((visibility("default"))) TS_ClosingTransaction_to_counterparty_value_sat(uint32_t this_arg) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + int64_t ret_val = ClosingTransaction_to_counterparty_value_sat(&this_arg_conv); + return ret_val; +} + +int8_tArray __attribute__((visibility("default"))) TS_ClosingTransaction_to_holder_script(uint32_t this_arg) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKu8slice ret_var = ClosingTransaction_to_holder_script(&this_arg_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); + return ret_arr; +} + +int8_tArray __attribute__((visibility("default"))) TS_ClosingTransaction_to_counterparty_script(uint32_t this_arg) { + LDKClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKu8slice ret_var = ClosingTransaction_to_counterparty_script(&this_arg_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); + return ret_arr; +} + +void __attribute__((visibility("default"))) TS_TrustedClosingTransaction_free(uint32_t this_obj) { + LDKTrustedClosingTransaction this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + TrustedClosingTransaction_free(this_obj_conv); +} + +int8_tArray __attribute__((visibility("default"))) TS_TrustedClosingTransaction_built_transaction(uint32_t this_arg) { + LDKTrustedClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKTransaction ret_var = TrustedClosingTransaction_built_transaction(&this_arg_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; +} + +int8_tArray __attribute__((visibility("default"))) TS_TrustedClosingTransaction_get_sighash_all(uint32_t this_arg, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) { + LDKTrustedClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKu8slice funding_redeemscript_ref; + funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript); + funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), TrustedClosingTransaction_get_sighash_all(&this_arg_conv, funding_redeemscript_ref, channel_value_satoshis).data, 32); + return ret_arr; +} + +int8_tArray __attribute__((visibility("default"))) TS_TrustedClosingTransaction_sign(uint32_t this_arg, int8_tArray funding_key, int8_tArray funding_redeemscript, int64_t channel_value_satoshis) { + LDKTrustedClosingTransaction this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + unsigned char funding_key_arr[32]; + CHECK(*((uint32_t*)funding_key) == 32); + memcpy(funding_key_arr, (uint8_t*)(funding_key + 4), 32); + unsigned char (*funding_key_ref)[32] = &funding_key_arr; + LDKu8slice funding_redeemscript_ref; + funding_redeemscript_ref.datalen = *((uint32_t*)funding_redeemscript); + funding_redeemscript_ref.data = (int8_t*)(funding_redeemscript + 4); + int8_tArray ret_arr = init_arr(64, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), TrustedClosingTransaction_sign(&this_arg_conv, funding_key_ref, funding_redeemscript_ref, channel_value_satoshis).compact_form, 64); + return ret_arr; +} + void __attribute__((visibility("default"))) TS_CommitmentTransaction_free(uint32_t this_obj) { LDKCommitmentTransaction this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); @@ -21401,6 +23521,14 @@ uint32_t __attribute__((visibility("default"))) TS_InitFeatures_known() { return ret_ref; } +jboolean __attribute__((visibility("default"))) TS_InitFeatures_requires_unknown_bits(uint32_t this_arg) { + LDKInitFeatures this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + jboolean ret_val = InitFeatures_requires_unknown_bits(&this_arg_conv); + return ret_val; +} + uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_empty() { LDKNodeFeatures ret_var = NodeFeatures_empty(); CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. @@ -21423,6 +23551,14 @@ uint32_t __attribute__((visibility("default"))) TS_NodeFeatures_known() { return ret_ref; } +jboolean __attribute__((visibility("default"))) TS_NodeFeatures_requires_unknown_bits(uint32_t this_arg) { + LDKNodeFeatures this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + jboolean ret_val = NodeFeatures_requires_unknown_bits(&this_arg_conv); + return ret_val; +} + uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_empty() { LDKChannelFeatures ret_var = ChannelFeatures_empty(); CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. @@ -21445,6 +23581,14 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelFeatures_known() { return ret_ref; } +jboolean __attribute__((visibility("default"))) TS_ChannelFeatures_requires_unknown_bits(uint32_t this_arg) { + LDKChannelFeatures this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + jboolean ret_val = ChannelFeatures_requires_unknown_bits(&this_arg_conv); + return ret_val; +} + uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_empty() { LDKInvoiceFeatures ret_var = InvoiceFeatures_empty(); CHECK((((uint64_t)ret_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. @@ -21467,6 +23611,14 @@ uint32_t __attribute__((visibility("default"))) TS_InvoiceFeatures_known() { return ret_ref; } +jboolean __attribute__((visibility("default"))) TS_InvoiceFeatures_requires_unknown_bits(uint32_t this_arg) { + LDKInvoiceFeatures this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + jboolean ret_val = InvoiceFeatures_requires_unknown_bits(&this_arg_conv); + return ret_val; +} + jboolean __attribute__((visibility("default"))) TS_InitFeatures_supports_payment_secret(uint32_t this_arg) { LDKInitFeatures this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); @@ -21655,36 +23807,6 @@ uint32_t __attribute__((visibility("default"))) TS_ShutdownScript_read(int8_tAr return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_ShutdownScript_new_p2pkh(int8_tArray pubkey_hash) { - unsigned char pubkey_hash_arr[20]; - CHECK(*((uint32_t*)pubkey_hash) == 20); - memcpy(pubkey_hash_arr, (uint8_t*)(pubkey_hash + 4), 20); - unsigned char (*pubkey_hash_ref)[20] = &pubkey_hash_arr; - LDKShutdownScript ret_var = ShutdownScript_new_p2pkh(pubkey_hash_ref); - 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_ShutdownScript_new_p2sh(int8_tArray script_hash) { - unsigned char script_hash_arr[20]; - CHECK(*((uint32_t*)script_hash) == 20); - memcpy(script_hash_arr, (uint8_t*)(script_hash + 4), 20); - unsigned char (*script_hash_ref)[20] = &script_hash_arr; - LDKShutdownScript ret_var = ShutdownScript_new_p2sh(script_hash_ref); - 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_ShutdownScript_new_p2wpkh(int8_tArray pubkey_hash) { unsigned char pubkey_hash_arr[20]; CHECK(*((uint32_t*)pubkey_hash) == 20); @@ -21756,37 +23878,46 @@ jboolean __attribute__((visibility("default"))) TS_ShutdownScript_is_compatible return ret_val; } -void __attribute__((visibility("default"))) TS_RouteHop_free(uint32_t this_obj) { - LDKRouteHop this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - RouteHop_free(this_obj_conv); +void __attribute__((visibility("default"))) TS_CustomMessageReader_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKCustomMessageReader this_ptr_conv = *(LDKCustomMessageReader*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + CustomMessageReader_free(this_ptr_conv); } -int8_tArray __attribute__((visibility("default"))) TS_RouteHop_get_pubkey(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33); - return ret_arr; +uint32_t __attribute__((visibility("default"))) TS_Type_clone(uint32_t orig) { + LDKType* orig_conv = (LDKType*)(((uint64_t)orig) & ~1); + LDKType* ret_ret =MALLOC(sizeof(LDKType), "LDKType"); + *ret_ret = Type_clone(orig_conv); + return (uint64_t)ret_ret; } -void __attribute__((visibility("default"))) TS_RouteHop_set_pubkey(uint32_t this_ptr, int8_tArray val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKPublicKey val_ref; - CHECK(*((uint32_t*)val) == 33); - memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); - RouteHop_set_pubkey(&this_ptr_conv, val_ref); +void __attribute__((visibility("default"))) TS_Type_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKType this_ptr_conv = *(LDKType*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + Type_free(this_ptr_conv); } -uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_node_features(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_conv); +void __attribute__((visibility("default"))) TS_Score_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKScore this_ptr_conv = *(LDKScore*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + Score_free(this_ptr_conv); +} + +void __attribute__((visibility("default"))) TS_NodeId_free(uint32_t this_obj) { + LDKNodeId this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + NodeId_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_NodeId_clone(uint32_t orig) { + LDKNodeId orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKNodeId ret_var = NodeId_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; @@ -21796,37 +23927,11 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_node_features(u return ret_ref; } -void __attribute__((visibility("default"))) TS_RouteHop_set_node_features(uint32_t this_ptr, uint32_t val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKNodeFeatures val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = NodeFeatures_clone(&val_conv); - RouteHop_set_node_features(&this_ptr_conv, val_conv); -} - -int64_t __attribute__((visibility("default"))) TS_RouteHop_get_short_channel_id(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv); - return ret_val; -} - -void __attribute__((visibility("default"))) TS_RouteHop_set_short_channel_id(uint32_t this_ptr, int64_t val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - RouteHop_set_short_channel_id(&this_ptr_conv, val); -} - -uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_channel_features(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_conv); +uint32_t __attribute__((visibility("default"))) TS_NodeId_from_pubkey(int8_tArray pubkey) { + LDKPublicKey pubkey_ref; + CHECK(*((uint32_t*)pubkey) == 33); + memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33); + LDKNodeId ret_var = NodeId_from_pubkey(pubkey_ref); 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; @@ -21836,60 +23941,56 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_channel_feature return ret_ref; } -void __attribute__((visibility("default"))) TS_RouteHop_set_channel_features(uint32_t this_ptr, uint32_t val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKChannelFeatures val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = ChannelFeatures_clone(&val_conv); - RouteHop_set_channel_features(&this_ptr_conv, val_conv); +int8_tArray __attribute__((visibility("default"))) TS_NodeId_as_slice(uint32_t this_arg) { + LDKNodeId this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKu8slice ret_var = NodeId_as_slice(&this_arg_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); + return ret_arr; } -int64_t __attribute__((visibility("default"))) TS_RouteHop_get_fee_msat(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv); +int64_t __attribute__((visibility("default"))) TS_NodeId_hash(uint32_t o) { + LDKNodeId o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = NodeId_hash(&o_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_RouteHop_set_fee_msat(uint32_t this_ptr, int64_t val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - RouteHop_set_fee_msat(&this_ptr_conv, val); +int8_tArray __attribute__((visibility("default"))) TS_NodeId_write(uint32_t obj) { + LDKNodeId obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = NodeId_write(&obj_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; } -int32_t __attribute__((visibility("default"))) TS_RouteHop_get_cltv_expiry_delta(uint32_t this_ptr) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv); - return ret_val; +uint32_t __attribute__((visibility("default"))) TS_NodeId_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_NodeIdDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeIdDecodeErrorZ), "LDKCResult_NodeIdDecodeErrorZ"); + *ret_conv = NodeId_read(ser_ref); + return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_RouteHop_set_cltv_expiry_delta(uint32_t this_ptr, int32_t val) { - LDKRouteHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val); +void __attribute__((visibility("default"))) TS_NetworkGraph_free(uint32_t this_obj) { + LDKNetworkGraph this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + NetworkGraph_free(this_obj_conv); } -uint32_t __attribute__((visibility("default"))) TS_RouteHop_new(int8_tArray pubkey_arg, uint32_t node_features_arg, int64_t short_channel_id_arg, uint32_t channel_features_arg, int64_t fee_msat_arg, int32_t cltv_expiry_delta_arg) { - LDKPublicKey pubkey_arg_ref; - CHECK(*((uint32_t*)pubkey_arg) == 33); - memcpy(pubkey_arg_ref.compressed_form, (uint8_t*)(pubkey_arg + 4), 33); - LDKNodeFeatures node_features_arg_conv; - node_features_arg_conv.inner = (void*)(node_features_arg & (~1)); - node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0); - node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv); - LDKChannelFeatures channel_features_arg_conv; - channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1)); - channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0); - channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv); - LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg); +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; @@ -21899,108 +24000,86 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHop_new(int8_tArray pub return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_RouteHop_clone(uint32_t orig) { - LDKRouteHop orig_conv; - orig_conv.inner = (void*)(orig & (~1)); - orig_conv.is_owned = false; - LDKRouteHop ret_var = RouteHop_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; - } +void __attribute__((visibility("default"))) TS_ReadOnlyNetworkGraph_free(uint32_t this_obj) { + LDKReadOnlyNetworkGraph this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ReadOnlyNetworkGraph_free(this_obj_conv); +} + +void __attribute__((visibility("default"))) TS_NetworkUpdate_free(uint32_t this_ptr) { + if ((this_ptr & 1) != 0) return; + LDKNetworkUpdate this_ptr_conv = *(LDKNetworkUpdate*)(((uint64_t)this_ptr) & ~1); + FREE((void*)this_ptr); + NetworkUpdate_free(this_ptr_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_clone(uint32_t orig) { + LDKNetworkUpdate* orig_conv = (LDKNetworkUpdate*)orig; + LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate"); + *ret_copy = NetworkUpdate_clone(orig_conv); + uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_RouteHop_write(uint32_t obj) { - LDKRouteHop obj_conv; - obj_conv.inner = (void*)(obj & (~1)); - obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = RouteHop_write(&obj_conv); +uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_channel_update_message(uint32_t msg) { + LDKChannelUpdate msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = (msg & 1) || (msg == 0); + msg_conv = ChannelUpdate_clone(&msg_conv); + LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate"); + *ret_copy = NetworkUpdate_channel_update_message(msg_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_channel_closed(int64_t short_channel_id, jboolean is_permanent) { + LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate"); + *ret_copy = NetworkUpdate_channel_closed(short_channel_id, is_permanent); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkUpdate_node_failure(int8_tArray node_id, jboolean is_permanent) { + LDKPublicKey node_id_ref; + CHECK(*((uint32_t*)node_id) == 33); + memcpy(node_id_ref.compressed_form, (uint8_t*)(node_id + 4), 33); + LDKNetworkUpdate *ret_copy = MALLOC(sizeof(LDKNetworkUpdate), "LDKNetworkUpdate"); + *ret_copy = NetworkUpdate_node_failure(node_id_ref, is_permanent); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +int8_tArray __attribute__((visibility("default"))) TS_NetworkUpdate_write(uint32_t obj) { + LDKNetworkUpdate* obj_conv = (LDKNetworkUpdate*)obj; + LDKCVec_u8Z ret_var = NetworkUpdate_write(obj_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_RouteHop_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ"); - *ret_conv = RouteHop_read(ser_ref); - return (uint64_t)ret_conv; +uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_EventHandler(uint32_t this_arg) { + LDKNetGraphMsgHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKEventHandler* ret_ret =MALLOC(sizeof(LDKEventHandler), "LDKEventHandler"); + *ret_ret = NetGraphMsgHandler_as_EventHandler(&this_arg_conv); + return (uint64_t)ret_ret; } -void __attribute__((visibility("default"))) TS_Route_free(uint32_t this_obj) { - LDKRoute this_obj_conv; +void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_free(uint32_t this_obj) { + LDKNetGraphMsgHandler this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - Route_free(this_obj_conv); + NetGraphMsgHandler_free(this_obj_conv); } -void __attribute__((visibility("default"))) TS_Route_set_paths(uint32_t this_ptr, ptrArray val) { - LDKRoute this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_get_network_graph(uint32_t this_ptr) { + LDKNetGraphMsgHandler this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKCVec_CVec_RouteHopZZ val_constr; - val_constr.datalen = *((uint32_t*)val); - if (val_constr.datalen > 0) - val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements"); - else - val_constr.data = NULL; - uint32_tArray* val_vals = (uint32_tArray*)(val + 4); - for (size_t m = 0; m < val_constr.datalen; m++) { - uint32_tArray val_conv_12 = val_vals[m]; - LDKCVec_RouteHopZ val_conv_12_constr; - val_conv_12_constr.datalen = *((uint32_t*)val_conv_12); - if (val_conv_12_constr.datalen > 0) - val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements"); - else - val_conv_12_constr.data = NULL; - uint32_t* val_conv_12_vals = (uint32_t*)(val_conv_12 + 4); - for (size_t k = 0; k < val_conv_12_constr.datalen; k++) { - uint32_t val_conv_12_conv_10 = val_conv_12_vals[k]; - LDKRouteHop val_conv_12_conv_10_conv; - val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1)); - val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0); - val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv); - val_conv_12_constr.data[k] = val_conv_12_conv_10_conv; - } - val_constr.data[m] = val_conv_12_constr; - } - Route_set_paths(&this_ptr_conv, val_constr); -} - -uint32_t __attribute__((visibility("default"))) TS_Route_new(ptrArray paths_arg) { - LDKCVec_CVec_RouteHopZZ paths_arg_constr; - paths_arg_constr.datalen = *((uint32_t*)paths_arg); - if (paths_arg_constr.datalen > 0) - paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements"); - else - paths_arg_constr.data = NULL; - uint32_tArray* paths_arg_vals = (uint32_tArray*)(paths_arg + 4); - for (size_t m = 0; m < paths_arg_constr.datalen; m++) { - uint32_tArray paths_arg_conv_12 = paths_arg_vals[m]; - LDKCVec_RouteHopZ paths_arg_conv_12_constr; - paths_arg_conv_12_constr.datalen = *((uint32_t*)paths_arg_conv_12); - if (paths_arg_conv_12_constr.datalen > 0) - paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements"); - else - paths_arg_conv_12_constr.data = NULL; - uint32_t* paths_arg_conv_12_vals = (uint32_t*)(paths_arg_conv_12 + 4); - for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) { - uint32_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k]; - LDKRouteHop paths_arg_conv_12_conv_10_conv; - paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1)); - paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0); - paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv); - paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv; - } - paths_arg_constr.data[m] = paths_arg_conv_12_constr; - } - LDKRoute ret_var = Route_new(paths_arg_constr); + LDKNetworkGraph ret_var = NetGraphMsgHandler_get_network_graph(&this_ptr_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; @@ -22010,11 +24089,29 @@ uint32_t __attribute__((visibility("default"))) TS_Route_new(ptrArray paths_arg return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) { - LDKRoute orig_conv; - orig_conv.inner = (void*)(orig & (~1)); - orig_conv.is_owned = false; - LDKRoute ret_var = Route_clone(&orig_conv); +void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_set_network_graph(uint32_t this_ptr, uint32_t val) { + LDKNetGraphMsgHandler this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNetworkGraph val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = NetworkGraph_clone(&val_conv); + NetGraphMsgHandler_set_network_graph(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_new(uint32_t network_graph, uint32_t chain_access, uint32_t logger) { + LDKNetworkGraph network_graph_conv; + network_graph_conv.inner = (void*)(network_graph & (~1)); + network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0); + 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) { + // Manually implement clone for Java trait instances + } + LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); + LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_new(network_graph_conv, chain_access_conv, logger_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; @@ -22024,104 +24121,127 @@ uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) { return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_Route_write(uint32_t obj) { - LDKRoute obj_conv; - obj_conv.inner = (void*)(obj & (~1)); - obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = Route_write(&obj_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; +void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_add_chain_access(uint32_t this_arg, uint32_t chain_access) { + LDKNetGraphMsgHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + 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) { + // Manually implement clone for Java trait instances + } + NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv); } -uint32_t __attribute__((visibility("default"))) TS_Route_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ"); - *ret_conv = Route_read(ser_ref); - return (uint64_t)ret_conv; +uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_RoutingMessageHandler(uint32_t this_arg) { + LDKNetGraphMsgHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKRoutingMessageHandler* ret_ret =MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler"); + *ret_ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv); + return (uint64_t)ret_ret; } -void __attribute__((visibility("default"))) TS_RouteHint_free(uint32_t this_obj) { - LDKRouteHint this_obj_conv; +uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_MessageSendEventsProvider(uint32_t this_arg) { + LDKNetGraphMsgHandler this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKMessageSendEventsProvider* ret_ret =MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); + *ret_ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv); + return (uint64_t)ret_ret; +} + +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_free(uint32_t this_obj) { + LDKDirectionalChannelInfo this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - RouteHint_free(this_obj_conv); + DirectionalChannelInfo_free(this_obj_conv); } -jboolean __attribute__((visibility("default"))) TS_RouteHint_eq(uint32_t a, uint32_t b) { - LDKRouteHint a_conv; - a_conv.inner = (void*)(a & (~1)); - a_conv.is_owned = false; - LDKRouteHint b_conv; - b_conv.inner = (void*)(b & (~1)); - b_conv.is_owned = false; - jboolean ret_val = RouteHint_eq(&a_conv, &b_conv); +int32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv); return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) { - LDKRouteHint orig_conv; - orig_conv.inner = (void*)(orig & (~1)); - orig_conv.is_owned = false; - LDKRouteHint ret_var = RouteHint_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_DirectionalChannelInfo_set_last_update(uint32_t this_ptr, int32_t val) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + DirectionalChannelInfo_set_last_update(&this_ptr_conv, val); } -void __attribute__((visibility("default"))) TS_RouteHintHop_free(uint32_t this_obj) { - LDKRouteHintHop this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - RouteHintHop_free(this_obj_conv); +jboolean __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_enabled(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv); + return ret_val; } -int8_tArray __attribute__((visibility("default"))) TS_RouteHintHop_get_src_node_id(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_enabled(uint32_t this_ptr, jboolean val) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33); - return ret_arr; + DirectionalChannelInfo_set_enabled(&this_ptr_conv, val); } -void __attribute__((visibility("default"))) TS_RouteHintHop_set_src_node_id(uint32_t this_ptr, int8_tArray val) { - LDKRouteHintHop this_ptr_conv; +int16_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_cltv_expiry_delta(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKPublicKey val_ref; - CHECK(*((uint32_t*)val) == 33); - memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); - RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref); + int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv); + return ret_val; } -int64_t __attribute__((visibility("default"))) TS_RouteHintHop_get_short_channel_id(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv); + DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val); +} + +int64_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_minimum_msat(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_RouteHintHop_set_short_channel_id(uint32_t this_ptr, int64_t val) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - RouteHintHop_set_short_channel_id(&this_ptr_conv, val); + DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val); } -uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_fees(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_maximum_msat(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_conv); + LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); + *ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); + DirectionalChannelInfo_set_htlc_maximum_msat(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_fees(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_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; @@ -22131,79 +24251,134 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_fees(uint32 return ret_ref; } -void __attribute__((visibility("default"))) TS_RouteHintHop_set_fees(uint32_t this_ptr, uint32_t val) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_fees(uint32_t this_ptr, uint32_t val) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKRoutingFees val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); val_conv = RoutingFees_clone(&val_conv); - RouteHintHop_set_fees(&this_ptr_conv, val_conv); + DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv); } -int16_t __attribute__((visibility("default"))) TS_RouteHintHop_get_cltv_expiry_delta(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update_message(uint32_t this_ptr) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv); - return ret_val; + LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_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_RouteHintHop_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_last_update_message(uint32_t this_ptr, uint32_t val) { + LDKDirectionalChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val); + LDKChannelUpdate val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = ChannelUpdate_clone(&val_conv); + DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_minimum_msat(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); - *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv); - uint64_t ret_ref = (uint64_t)ret_copy; +uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_new(int32_t last_update_arg, jboolean enabled_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg, uint32_t fees_arg, uint32_t last_update_message_arg) { + LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1); + htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1)); + LDKRoutingFees fees_arg_conv; + fees_arg_conv.inner = (void*)(fees_arg & (~1)); + fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0); + fees_arg_conv = RoutingFees_clone(&fees_arg_conv); + LDKChannelUpdate last_update_message_arg_conv; + last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1)); + last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0); + last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv); + LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv); + 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_RouteHintHop_set_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) { - LDKRouteHintHop this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); - RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv); +uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone(uint32_t orig) { + LDKDirectionalChannelInfo orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_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; } -uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_maximum_msat(uint32_t this_ptr) { - LDKRouteHintHop this_ptr_conv; +int8_tArray __attribute__((visibility("default"))) TS_DirectionalChannelInfo_write(uint32_t obj) { + LDKDirectionalChannelInfo obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_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_DirectionalChannelInfo_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ"); + *ret_conv = DirectionalChannelInfo_read(ser_ref); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_ChannelInfo_free(uint32_t this_obj) { + LDKChannelInfo this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ChannelInfo_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_features(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); - *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv); - uint64_t ret_ref = (uint64_t)ret_copy; + LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_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_RouteHintHop_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) { - LDKRouteHintHop this_ptr_conv; +void __attribute__((visibility("default"))) TS_ChannelInfo_set_features(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); - RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv); + LDKChannelFeatures val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = ChannelFeatures_clone(&val_conv); + ChannelInfo_set_features(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_new(int8_tArray src_node_id_arg, int64_t short_channel_id_arg, uint32_t fees_arg, int16_t cltv_expiry_delta_arg, uint32_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg) { - LDKPublicKey src_node_id_arg_ref; - CHECK(*((uint32_t*)src_node_id_arg) == 33); - memcpy(src_node_id_arg_ref.compressed_form, (uint8_t*)(src_node_id_arg + 4), 33); - LDKRoutingFees fees_arg_conv; - fees_arg_conv.inner = (void*)(fees_arg & (~1)); - fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0); - fees_arg_conv = RoutingFees_clone(&fees_arg_conv); - LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_minimum_msat_arg) & ~1); - LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1); - LDKRouteHintHop ret_var = RouteHintHop_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_arg_conv, htlc_maximum_msat_arg_conv); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_node_one(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeId ret_var = ChannelInfo_get_node_one(&this_ptr_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; @@ -22213,22 +24388,22 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_new(int8_tArray return ret_ref; } -jboolean __attribute__((visibility("default"))) TS_RouteHintHop_eq(uint32_t a, uint32_t b) { - LDKRouteHintHop a_conv; - a_conv.inner = (void*)(a & (~1)); - a_conv.is_owned = false; - LDKRouteHintHop b_conv; - b_conv.inner = (void*)(b & (~1)); - b_conv.is_owned = false; - jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv); - return ret_val; +void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_one(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeId val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = NodeId_clone(&val_conv); + ChannelInfo_set_node_one(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t orig) { - LDKRouteHintHop orig_conv; - orig_conv.inner = (void*)(orig & (~1)); - orig_conv.is_owned = false; - LDKRouteHintHop ret_var = RouteHintHop_clone(&orig_conv); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_one_to_two(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_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; @@ -22238,122 +24413,22 @@ uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_get_keysend_route(int8_tArray our_node_id, uint32_t network, int8_tArray payee, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger) { - LDKPublicKey our_node_id_ref; - CHECK(*((uint32_t*)our_node_id) == 33); - memcpy(our_node_id_ref.compressed_form, (uint8_t*)(our_node_id + 4), 33); - LDKNetworkGraph network_conv; - network_conv.inner = (void*)(network & (~1)); - network_conv.is_owned = false; - LDKPublicKey payee_ref; - CHECK(*((uint32_t*)payee) == 33); - memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33); - LDKCVec_ChannelDetailsZ first_hops_constr; - LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL; - if (first_hops != 0) { - first_hops_constr.datalen = *((uint32_t*)first_hops); - if (first_hops_constr.datalen > 0) - first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements"); - else - first_hops_constr.data = NULL; - uint32_t* first_hops_vals = (uint32_t*)(first_hops + 4); - for (size_t q = 0; q < first_hops_constr.datalen; q++) { - uint32_t first_hops_conv_16 = first_hops_vals[q]; - LDKChannelDetails first_hops_conv_16_conv; - first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1)); - first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0); - first_hops_constr.data[q] = first_hops_conv_16_conv; - } - first_hops_ptr = &first_hops_constr; - } - LDKCVec_RouteHintZ last_hops_constr; - last_hops_constr.datalen = *((uint32_t*)last_hops); - if (last_hops_constr.datalen > 0) - last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements"); - else - last_hops_constr.data = NULL; - uint32_t* last_hops_vals = (uint32_t*)(last_hops + 4); - for (size_t l = 0; l < last_hops_constr.datalen; l++) { - uint32_t last_hops_conv_11 = last_hops_vals[l]; - LDKRouteHint last_hops_conv_11_conv; - last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1)); - last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0); - last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv); - last_hops_constr.data[l] = last_hops_conv_11_conv; - } - LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ"); - *ret_conv = get_keysend_route(our_node_id_ref, &network_conv, payee_ref, first_hops_ptr, last_hops_constr, final_value_msat, final_cltv, logger_conv); - if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); } - return (uint64_t)ret_conv; -} - -uint32_t __attribute__((visibility("default"))) TS_get_route(int8_tArray our_node_id, uint32_t network, int8_tArray payee, uint32_t payee_features, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger) { - LDKPublicKey our_node_id_ref; - CHECK(*((uint32_t*)our_node_id) == 33); - memcpy(our_node_id_ref.compressed_form, (uint8_t*)(our_node_id + 4), 33); - LDKNetworkGraph network_conv; - network_conv.inner = (void*)(network & (~1)); - network_conv.is_owned = false; - LDKPublicKey payee_ref; - CHECK(*((uint32_t*)payee) == 33); - memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33); - LDKInvoiceFeatures payee_features_conv; - payee_features_conv.inner = (void*)(payee_features & (~1)); - payee_features_conv.is_owned = (payee_features & 1) || (payee_features == 0); - payee_features_conv = InvoiceFeatures_clone(&payee_features_conv); - LDKCVec_ChannelDetailsZ first_hops_constr; - LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL; - if (first_hops != 0) { - first_hops_constr.datalen = *((uint32_t*)first_hops); - if (first_hops_constr.datalen > 0) - first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements"); - else - first_hops_constr.data = NULL; - uint32_t* first_hops_vals = (uint32_t*)(first_hops + 4); - for (size_t q = 0; q < first_hops_constr.datalen; q++) { - uint32_t first_hops_conv_16 = first_hops_vals[q]; - LDKChannelDetails first_hops_conv_16_conv; - first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1)); - first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0); - first_hops_constr.data[q] = first_hops_conv_16_conv; - } - first_hops_ptr = &first_hops_constr; - } - LDKCVec_RouteHintZ last_hops_constr; - last_hops_constr.datalen = *((uint32_t*)last_hops); - if (last_hops_constr.datalen > 0) - last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements"); - else - last_hops_constr.data = NULL; - uint32_t* last_hops_vals = (uint32_t*)(last_hops + 4); - for (size_t l = 0; l < last_hops_constr.datalen; l++) { - uint32_t last_hops_conv_11 = last_hops_vals[l]; - LDKRouteHint last_hops_conv_11_conv; - last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1)); - last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0); - last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv); - last_hops_constr.data[l] = last_hops_conv_11_conv; - } - LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ"); - *ret_conv = get_route(our_node_id_ref, &network_conv, payee_ref, payee_features_conv, first_hops_ptr, last_hops_constr, final_value_msat, final_cltv, logger_conv); - if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); } - return (uint64_t)ret_conv; -} - -void __attribute__((visibility("default"))) TS_NetworkGraph_free(uint32_t this_obj) { - LDKNetworkGraph this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - NetworkGraph_free(this_obj_conv); +void __attribute__((visibility("default"))) TS_ChannelInfo_set_one_to_two(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKDirectionalChannelInfo val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = DirectionalChannelInfo_clone(&val_conv); + ChannelInfo_set_one_to_two(&this_ptr_conv, val_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); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_node_two(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeId ret_var = ChannelInfo_get_node_two(&this_ptr_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; @@ -22363,33 +24438,22 @@ uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_clone(uint32_t return ret_ref; } -void __attribute__((visibility("default"))) TS_LockedNetworkGraph_free(uint32_t this_obj) { - LDKLockedNetworkGraph this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - LockedNetworkGraph_free(this_obj_conv); -} - -void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_free(uint32_t this_obj) { - LDKNetGraphMsgHandler this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - NetGraphMsgHandler_free(this_obj_conv); +void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_two(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeId val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = NodeId_clone(&val_conv); + ChannelInfo_set_node_two(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_new(int8_tArray genesis_hash, uint32_t chain_access, uint32_t logger) { - LDKThirtyTwoBytes genesis_hash_ref; - CHECK(*((uint32_t*)genesis_hash) == 32); - memcpy(genesis_hash_ref.data, (uint8_t*)(genesis_hash + 4), 32); - LDKAccess *chain_access_conv_ptr = NULL; - if (chain_access != 0) { - LDKAccess chain_access_conv; - chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1); - chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *chain_access_conv_ptr = chain_access_conv; - } - LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_new(genesis_hash_ref, chain_access_conv_ptr, logger_conv); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_two_to_one(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_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; @@ -22399,20 +24463,41 @@ uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_new(int8_ return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_from_net_graph(uint32_t chain_access, uint32_t logger, uint32_t network_graph) { - LDKAccess *chain_access_conv_ptr = NULL; - if (chain_access != 0) { - LDKAccess chain_access_conv; - chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1); - chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *chain_access_conv_ptr = chain_access_conv; - } - LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKNetworkGraph network_graph_conv; - network_graph_conv.inner = (void*)(network_graph & (~1)); - network_graph_conv.is_owned = (network_graph & 1) || (network_graph == 0); - network_graph_conv = NetworkGraph_clone(&network_graph_conv); - LDKNetGraphMsgHandler ret_var = NetGraphMsgHandler_from_net_graph(chain_access_conv_ptr, logger_conv, network_graph_conv); +void __attribute__((visibility("default"))) TS_ChannelInfo_set_two_to_one(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKDirectionalChannelInfo val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = DirectionalChannelInfo_clone(&val_conv); + ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_capacity_sats(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); + *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_ChannelInfo_set_capacity_sats(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); + ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_announcement_message(uint32_t this_ptr) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_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; @@ -22422,25 +24507,45 @@ uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_from_net_ return ret_ref; } -void __attribute__((visibility("default"))) TS_NetGraphMsgHandler_add_chain_access(uint32_t this_arg, uint32_t chain_access) { - LDKNetGraphMsgHandler this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKAccess *chain_access_conv_ptr = NULL; - if (chain_access != 0) { - LDKAccess chain_access_conv; - chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1); - chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *chain_access_conv_ptr = chain_access_conv; - } - NetGraphMsgHandler_add_chain_access(&this_arg_conv, chain_access_conv_ptr); +void __attribute__((visibility("default"))) TS_ChannelInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) { + LDKChannelInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKChannelAnnouncement val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = ChannelAnnouncement_clone(&val_conv); + ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_read_locked_graph(uint32_t this_arg) { - LDKNetGraphMsgHandler this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKLockedNetworkGraph ret_var = NetGraphMsgHandler_read_locked_graph(&this_arg_conv); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_new(uint32_t features_arg, uint32_t node_one_arg, uint32_t one_to_two_arg, uint32_t node_two_arg, uint32_t two_to_one_arg, uint32_t capacity_sats_arg, uint32_t announcement_message_arg) { + LDKChannelFeatures features_arg_conv; + features_arg_conv.inner = (void*)(features_arg & (~1)); + features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0); + features_arg_conv = ChannelFeatures_clone(&features_arg_conv); + LDKNodeId node_one_arg_conv; + node_one_arg_conv.inner = (void*)(node_one_arg & (~1)); + node_one_arg_conv.is_owned = (node_one_arg & 1) || (node_one_arg == 0); + node_one_arg_conv = NodeId_clone(&node_one_arg_conv); + LDKDirectionalChannelInfo one_to_two_arg_conv; + one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1)); + one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0); + one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv); + LDKNodeId node_two_arg_conv; + node_two_arg_conv.inner = (void*)(node_two_arg & (~1)); + node_two_arg_conv.is_owned = (node_two_arg & 1) || (node_two_arg == 0); + node_two_arg_conv = NodeId_clone(&node_two_arg_conv); + LDKDirectionalChannelInfo two_to_one_arg_conv; + two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1)); + two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0); + two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv); + LDKCOption_u64Z capacity_sats_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)capacity_sats_arg) & ~1); + capacity_sats_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)capacity_sats_arg) & ~1)); + LDKChannelAnnouncement announcement_message_arg_conv; + announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1)); + announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0); + announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv); + LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_conv, one_to_two_arg_conv, node_two_arg_conv, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_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; @@ -22450,11 +24555,11 @@ uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_read_lock return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_LockedNetworkGraph_graph(uint32_t this_arg) { - LDKLockedNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKNetworkGraph ret_var = LockedNetworkGraph_graph(&this_arg_conv); +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t orig) { + LDKChannelInfo orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKChannelInfo ret_var = ChannelInfo_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; @@ -22464,139 +24569,65 @@ uint32_t __attribute__((visibility("default"))) TS_LockedNetworkGraph_graph(uin return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NetGraphMsgHandler_as_RoutingMessageHandler(uint32_t this_arg) { - LDKNetGraphMsgHandler this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKRoutingMessageHandler* ret = MALLOC(sizeof(LDKRoutingMessageHandler), "LDKRoutingMessageHandler"); - *ret = NetGraphMsgHandler_as_RoutingMessageHandler(&this_arg_conv); - return (uint64_t)ret; +int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_write(uint32_t obj) { + LDKChannelInfo obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_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_NetGraphMsgHandler_as_MessageSendEventsProvider(uint32_t this_arg) { - LDKNetGraphMsgHandler this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKMessageSendEventsProvider* ret = MALLOC(sizeof(LDKMessageSendEventsProvider), "LDKMessageSendEventsProvider"); - *ret = NetGraphMsgHandler_as_MessageSendEventsProvider(&this_arg_conv); - return (uint64_t)ret; +uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ"); + *ret_conv = ChannelInfo_read(ser_ref); + return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_free(uint32_t this_obj) { - LDKDirectionalChannelInfo this_obj_conv; +void __attribute__((visibility("default"))) TS_RoutingFees_free(uint32_t this_obj) { + LDKRoutingFees this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - DirectionalChannelInfo_free(this_obj_conv); + RoutingFees_free(this_obj_conv); } -int32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; +int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_base_msat(uint32_t this_ptr) { + LDKRoutingFees this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int32_t ret_val = DirectionalChannelInfo_get_last_update(&this_ptr_conv); + int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_last_update(uint32_t this_ptr, int32_t val) { - LDKDirectionalChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RoutingFees_set_base_msat(uint32_t this_ptr, int32_t val) { + LDKRoutingFees this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - DirectionalChannelInfo_set_last_update(&this_ptr_conv, val); + RoutingFees_set_base_msat(&this_ptr_conv, val); } -jboolean __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_enabled(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - jboolean ret_val = DirectionalChannelInfo_get_enabled(&this_ptr_conv); - return ret_val; -} - -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_enabled(uint32_t this_ptr, jboolean val) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - DirectionalChannelInfo_set_enabled(&this_ptr_conv, val); -} - -int16_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_cltv_expiry_delta(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - int16_t ret_val = DirectionalChannelInfo_get_cltv_expiry_delta(&this_ptr_conv); - return ret_val; -} - -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - DirectionalChannelInfo_set_cltv_expiry_delta(&this_ptr_conv, val); -} - -int64_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_minimum_msat(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; +int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_proportional_millionths(uint32_t this_ptr) { + LDKRoutingFees this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int64_t ret_val = DirectionalChannelInfo_get_htlc_minimum_msat(&this_ptr_conv); + int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_minimum_msat(uint32_t this_ptr, int64_t val) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - DirectionalChannelInfo_set_htlc_minimum_msat(&this_ptr_conv, val); -} - -uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_htlc_maximum_msat(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); - *ret_copy = DirectionalChannelInfo_get_htlc_maximum_msat(&this_ptr_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); - DirectionalChannelInfo_set_htlc_maximum_msat(&this_ptr_conv, val_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_fees(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKRoutingFees ret_var = DirectionalChannelInfo_get_fees(&this_ptr_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_DirectionalChannelInfo_set_fees(uint32_t this_ptr, uint32_t val) { - LDKDirectionalChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RoutingFees_set_proportional_millionths(uint32_t this_ptr, int32_t val) { + LDKRoutingFees this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKRoutingFees val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = RoutingFees_clone(&val_conv); - DirectionalChannelInfo_set_fees(&this_ptr_conv, val_conv); + RoutingFees_set_proportional_millionths(&this_ptr_conv, val); } -uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_last_update_message(uint32_t this_ptr) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKChannelUpdate ret_var = DirectionalChannelInfo_get_last_update_message(&this_ptr_conv); +uint32_t __attribute__((visibility("default"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) { + LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg); 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; @@ -22606,42 +24637,22 @@ uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_get_l return ret_ref; } -void __attribute__((visibility("default"))) TS_DirectionalChannelInfo_set_last_update_message(uint32_t this_ptr, uint32_t val) { - LDKDirectionalChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKChannelUpdate val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = ChannelUpdate_clone(&val_conv); - DirectionalChannelInfo_set_last_update_message(&this_ptr_conv, val_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_new(int32_t last_update_arg, jboolean enabled_arg, int16_t cltv_expiry_delta_arg, int64_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg, uint32_t fees_arg, uint32_t last_update_message_arg) { - LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1); - LDKRoutingFees fees_arg_conv; - fees_arg_conv.inner = (void*)(fees_arg & (~1)); - fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0); - fees_arg_conv = RoutingFees_clone(&fees_arg_conv); - LDKChannelUpdate last_update_message_arg_conv; - last_update_message_arg_conv.inner = (void*)(last_update_message_arg & (~1)); - last_update_message_arg_conv.is_owned = (last_update_message_arg & 1) || (last_update_message_arg == 0); - last_update_message_arg_conv = ChannelUpdate_clone(&last_update_message_arg_conv); - LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_new(last_update_arg, enabled_arg, cltv_expiry_delta_arg, htlc_minimum_msat_arg, htlc_maximum_msat_arg_conv, fees_arg_conv, last_update_message_arg_conv); - 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_RoutingFees_eq(uint32_t a, uint32_t b) { + LDKRoutingFees a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKRoutingFees b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv); + return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone(uint32_t orig) { - LDKDirectionalChannelInfo orig_conv; +uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t orig) { + LDKRoutingFees orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKDirectionalChannelInfo ret_var = DirectionalChannelInfo_clone(&orig_conv); + LDKRoutingFees ret_var = RoutingFees_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; @@ -22651,38 +24662,46 @@ uint32_t __attribute__((visibility("default"))) TS_DirectionalChannelInfo_clone return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_DirectionalChannelInfo_write(uint32_t obj) { - LDKDirectionalChannelInfo obj_conv; +int64_t __attribute__((visibility("default"))) TS_RoutingFees_hash(uint32_t o) { + LDKRoutingFees o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = RoutingFees_hash(&o_conv); + return ret_val; +} + +int8_tArray __attribute__((visibility("default"))) TS_RoutingFees_write(uint32_t obj) { + LDKRoutingFees obj_conv; obj_conv.inner = (void*)(obj & (~1)); obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = DirectionalChannelInfo_write(&obj_conv); + LDKCVec_u8Z ret_var = RoutingFees_write(&obj_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_DirectionalChannelInfo_read(int8_tArray ser) { +uint32_t __attribute__((visibility("default"))) TS_RoutingFees_read(int8_tArray ser) { LDKu8slice ser_ref; ser_ref.datalen = *((uint32_t*)ser); ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_DirectionalChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_DirectionalChannelInfoDecodeErrorZ), "LDKCResult_DirectionalChannelInfoDecodeErrorZ"); - *ret_conv = DirectionalChannelInfo_read(ser_ref); + LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ"); + *ret_conv = RoutingFees_read(ser_ref); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_ChannelInfo_free(uint32_t this_obj) { - LDKChannelInfo this_obj_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_free(uint32_t this_obj) { + LDKNodeAnnouncementInfo this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - ChannelInfo_free(this_obj_conv); + NodeAnnouncementInfo_free(this_obj_conv); } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_features(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_features(uint32_t this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKChannelFeatures ret_var = ChannelInfo_get_features(&this_ptr_conv); + LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_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; @@ -22692,128 +24711,95 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_features(uin return ret_ref; } -void __attribute__((visibility("default"))) TS_ChannelInfo_set_features(uint32_t this_ptr, uint32_t val) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_features(uint32_t this_ptr, uint32_t val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKChannelFeatures val_conv; + LDKNodeFeatures val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); - val_conv = ChannelFeatures_clone(&val_conv); - ChannelInfo_set_features(&this_ptr_conv, val_conv); + val_conv = NodeFeatures_clone(&val_conv); + NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv); } -int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_get_node_one(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +int32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_last_update(uint32_t this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), ChannelInfo_get_node_one(&this_ptr_conv).compressed_form, 33); - return ret_arr; + int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv); + return ret_val; } -void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_one(uint32_t this_ptr, int8_tArray val) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_last_update(uint32_t this_ptr, int32_t val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKPublicKey val_ref; - CHECK(*((uint32_t*)val) == 33); - memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); - ChannelInfo_set_node_one(&this_ptr_conv, val_ref); + NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val); } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_one_to_two(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_rgb(uint32_t this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKDirectionalChannelInfo ret_var = ChannelInfo_get_one_to_two(&this_ptr_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; + int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3); + return ret_arr; } -void __attribute__((visibility("default"))) TS_ChannelInfo_set_one_to_two(uint32_t this_ptr, uint32_t val) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_rgb(uint32_t this_ptr, int8_tArray val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKDirectionalChannelInfo val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = DirectionalChannelInfo_clone(&val_conv); - ChannelInfo_set_one_to_two(&this_ptr_conv, val_conv); + LDKThreeBytes val_ref; + CHECK(*((uint32_t*)val) == 3); + memcpy(val_ref.data, (uint8_t*)(val + 4), 3); + NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref); } -int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_get_node_two(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_alias(uint32_t this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), ChannelInfo_get_node_two(&this_ptr_conv).compressed_form, 33); + int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_alias(&this_ptr_conv), 32); return ret_arr; } -void __attribute__((visibility("default"))) TS_ChannelInfo_set_node_two(uint32_t this_ptr, int8_tArray val) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_alias(uint32_t this_ptr, int8_tArray val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKPublicKey val_ref; - CHECK(*((uint32_t*)val) == 33); - memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); - ChannelInfo_set_node_two(&this_ptr_conv, val_ref); + LDKThirtyTwoBytes val_ref; + CHECK(*((uint32_t*)val) == 32); + memcpy(val_ref.data, (uint8_t*)(val + 4), 32); + NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_ref); } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_two_to_one(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_addresses(uint32_t this_ptr, uint32_tArray val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKDirectionalChannelInfo ret_var = ChannelInfo_get_two_to_one(&this_ptr_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; + LDKCVec_NetAddressZ val_constr; + val_constr.datalen = *((uint32_t*)val); + if (val_constr.datalen > 0) + val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements"); + else + val_constr.data = NULL; + uint32_t* val_vals = (uint32_t*)(val + 4); + for (size_t m = 0; m < val_constr.datalen; m++) { + uint32_t val_conv_12 = val_vals[m]; + LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1); + val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1)); + val_constr.data[m] = val_conv_12_conv; } - return ret_ref; -} - -void __attribute__((visibility("default"))) TS_ChannelInfo_set_two_to_one(uint32_t this_ptr, uint32_t val) { - LDKChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKDirectionalChannelInfo val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = DirectionalChannelInfo_clone(&val_conv); - ChannelInfo_set_two_to_one(&this_ptr_conv, val_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_capacity_sats(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); - *ret_copy = ChannelInfo_get_capacity_sats(&this_ptr_conv); - uint64_t ret_ref = (uint64_t)ret_copy; - return ret_ref; -} - -void __attribute__((visibility("default"))) TS_ChannelInfo_set_capacity_sats(uint32_t this_ptr, uint32_t val) { - LDKChannelInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); - ChannelInfo_set_capacity_sats(&this_ptr_conv, val_conv); + NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr); } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_announcement_message(uint32_t this_ptr) { - LDKChannelInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_announcement_message(uint32_t this_ptr) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKChannelAnnouncement ret_var = ChannelInfo_get_announcement_message(&this_ptr_conv); + LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_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; @@ -22823,42 +24809,45 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_get_announcement return ret_ref; } -void __attribute__((visibility("default"))) TS_ChannelInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) { - LDKChannelInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) { + LDKNodeAnnouncementInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKChannelAnnouncement val_conv; + LDKNodeAnnouncement val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); - val_conv = ChannelAnnouncement_clone(&val_conv); - ChannelInfo_set_announcement_message(&this_ptr_conv, val_conv); + val_conv = NodeAnnouncement_clone(&val_conv); + NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_new(uint32_t features_arg, int8_tArray node_one_arg, uint32_t one_to_two_arg, int8_tArray node_two_arg, uint32_t two_to_one_arg, uint32_t capacity_sats_arg, uint32_t announcement_message_arg) { - LDKChannelFeatures features_arg_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_new(uint32_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, int8_tArray alias_arg, uint32_tArray addresses_arg, uint32_t announcement_message_arg) { + LDKNodeFeatures features_arg_conv; features_arg_conv.inner = (void*)(features_arg & (~1)); features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0); - features_arg_conv = ChannelFeatures_clone(&features_arg_conv); - LDKPublicKey node_one_arg_ref; - CHECK(*((uint32_t*)node_one_arg) == 33); - memcpy(node_one_arg_ref.compressed_form, (uint8_t*)(node_one_arg + 4), 33); - LDKDirectionalChannelInfo one_to_two_arg_conv; - one_to_two_arg_conv.inner = (void*)(one_to_two_arg & (~1)); - one_to_two_arg_conv.is_owned = (one_to_two_arg & 1) || (one_to_two_arg == 0); - one_to_two_arg_conv = DirectionalChannelInfo_clone(&one_to_two_arg_conv); - LDKPublicKey node_two_arg_ref; - CHECK(*((uint32_t*)node_two_arg) == 33); - memcpy(node_two_arg_ref.compressed_form, (uint8_t*)(node_two_arg + 4), 33); - LDKDirectionalChannelInfo two_to_one_arg_conv; - two_to_one_arg_conv.inner = (void*)(two_to_one_arg & (~1)); - two_to_one_arg_conv.is_owned = (two_to_one_arg & 1) || (two_to_one_arg == 0); - two_to_one_arg_conv = DirectionalChannelInfo_clone(&two_to_one_arg_conv); - LDKCOption_u64Z capacity_sats_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)capacity_sats_arg) & ~1); - LDKChannelAnnouncement announcement_message_arg_conv; + features_arg_conv = NodeFeatures_clone(&features_arg_conv); + LDKThreeBytes rgb_arg_ref; + CHECK(*((uint32_t*)rgb_arg) == 3); + memcpy(rgb_arg_ref.data, (uint8_t*)(rgb_arg + 4), 3); + LDKThirtyTwoBytes alias_arg_ref; + CHECK(*((uint32_t*)alias_arg) == 32); + memcpy(alias_arg_ref.data, (uint8_t*)(alias_arg + 4), 32); + LDKCVec_NetAddressZ addresses_arg_constr; + addresses_arg_constr.datalen = *((uint32_t*)addresses_arg); + if (addresses_arg_constr.datalen > 0) + addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements"); + else + addresses_arg_constr.data = NULL; + uint32_t* addresses_arg_vals = (uint32_t*)(addresses_arg + 4); + for (size_t m = 0; m < addresses_arg_constr.datalen; m++) { + uint32_t addresses_arg_conv_12 = addresses_arg_vals[m]; + LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_arg_conv_12) & ~1); + addresses_arg_constr.data[m] = addresses_arg_conv_12_conv; + } + LDKNodeAnnouncement announcement_message_arg_conv; announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1)); announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0); - announcement_message_arg_conv = ChannelAnnouncement_clone(&announcement_message_arg_conv); - LDKChannelInfo ret_var = ChannelInfo_new(features_arg_conv, node_one_arg_ref, one_to_two_arg_conv, node_two_arg_ref, two_to_one_arg_conv, capacity_sats_arg_conv, announcement_message_arg_conv); + announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv); + LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_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; @@ -22868,11 +24857,11 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_new(uint32_t fea return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t orig) { - LDKChannelInfo orig_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) { + LDKNodeAnnouncementInfo orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKChannelInfo ret_var = ChannelInfo_clone(&orig_conv); + LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_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; @@ -22882,65 +24871,81 @@ uint32_t __attribute__((visibility("default"))) TS_ChannelInfo_clone(uint32_t o return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_ChannelInfo_write(uint32_t obj) { - LDKChannelInfo obj_conv; +int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_write(uint32_t obj) { + LDKNodeAnnouncementInfo obj_conv; obj_conv.inner = (void*)(obj & (~1)); obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = ChannelInfo_write(&obj_conv); + LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_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_ChannelInfo_read(int8_tArray ser) { +uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_read(int8_tArray ser) { LDKu8slice ser_ref; ser_ref.datalen = *((uint32_t*)ser); ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_ChannelInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_ChannelInfoDecodeErrorZ), "LDKCResult_ChannelInfoDecodeErrorZ"); - *ret_conv = ChannelInfo_read(ser_ref); + LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ"); + *ret_conv = NodeAnnouncementInfo_read(ser_ref); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_RoutingFees_free(uint32_t this_obj) { - LDKRoutingFees this_obj_conv; +void __attribute__((visibility("default"))) TS_NodeInfo_free(uint32_t this_obj) { + LDKNodeInfo this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - RoutingFees_free(this_obj_conv); + NodeInfo_free(this_obj_conv); } -int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_base_msat(uint32_t this_ptr) { - LDKRoutingFees this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeInfo_set_channels(uint32_t this_ptr, int64_tArray val) { + LDKNodeInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int32_t ret_val = RoutingFees_get_base_msat(&this_ptr_conv); - return ret_val; + LDKCVec_u64Z val_constr; + val_constr.datalen = *((uint32_t*)val); + if (val_constr.datalen > 0) + val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements"); + else + val_constr.data = NULL; + int64_t* val_vals = (int64_t*)(val + 4); + for (size_t i = 0; i < val_constr.datalen; i++) { + int64_t val_conv_8 = val_vals[i]; + val_constr.data[i] = val_conv_8; + } + NodeInfo_set_channels(&this_ptr_conv, val_constr); } -void __attribute__((visibility("default"))) TS_RoutingFees_set_base_msat(uint32_t this_ptr, int32_t val) { - LDKRoutingFees this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_lowest_inbound_channel_fees(uint32_t this_ptr) { + LDKNodeInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - RoutingFees_set_base_msat(&this_ptr_conv, val); + LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_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; } -int32_t __attribute__((visibility("default"))) TS_RoutingFees_get_proportional_millionths(uint32_t this_ptr) { - LDKRoutingFees this_ptr_conv; +void __attribute__((visibility("default"))) TS_NodeInfo_set_lowest_inbound_channel_fees(uint32_t this_ptr, uint32_t val) { + LDKNodeInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int32_t ret_val = RoutingFees_get_proportional_millionths(&this_ptr_conv); - return ret_val; + LDKRoutingFees val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = RoutingFees_clone(&val_conv); + NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv); } -void __attribute__((visibility("default"))) TS_RoutingFees_set_proportional_millionths(uint32_t this_ptr, int32_t val) { - LDKRoutingFees this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_announcement_info(uint32_t this_ptr) { + LDKNodeInfo this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - RoutingFees_set_proportional_millionths(&this_ptr_conv, val); -} - -uint32_t __attribute__((visibility("default"))) TS_RoutingFees_new(int32_t base_msat_arg, int32_t proportional_millionths_arg) { - LDKRoutingFees ret_var = RoutingFees_new(base_msat_arg, proportional_millionths_arg); + LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_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; @@ -22950,22 +24955,52 @@ uint32_t __attribute__((visibility("default"))) TS_RoutingFees_new(int32_t base return ret_ref; } -jboolean __attribute__((visibility("default"))) TS_RoutingFees_eq(uint32_t a, uint32_t b) { - LDKRoutingFees a_conv; - a_conv.inner = (void*)(a & (~1)); - a_conv.is_owned = false; - LDKRoutingFees b_conv; - b_conv.inner = (void*)(b & (~1)); - b_conv.is_owned = false; - jboolean ret_val = RoutingFees_eq(&a_conv, &b_conv); - return ret_val; +void __attribute__((visibility("default"))) TS_NodeInfo_set_announcement_info(uint32_t this_ptr, uint32_t val) { + LDKNodeInfo this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeAnnouncementInfo val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = NodeAnnouncementInfo_clone(&val_conv); + NodeInfo_set_announcement_info(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t orig) { - LDKRoutingFees orig_conv; +uint32_t __attribute__((visibility("default"))) TS_NodeInfo_new(int64_tArray channels_arg, uint32_t lowest_inbound_channel_fees_arg, uint32_t announcement_info_arg) { + LDKCVec_u64Z channels_arg_constr; + channels_arg_constr.datalen = *((uint32_t*)channels_arg); + if (channels_arg_constr.datalen > 0) + channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements"); + else + channels_arg_constr.data = NULL; + int64_t* channels_arg_vals = (int64_t*)(channels_arg + 4); + for (size_t i = 0; i < channels_arg_constr.datalen; i++) { + int64_t channels_arg_conv_8 = channels_arg_vals[i]; + channels_arg_constr.data[i] = channels_arg_conv_8; + } + LDKRoutingFees lowest_inbound_channel_fees_arg_conv; + lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1)); + lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0); + lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv); + LDKNodeAnnouncementInfo announcement_info_arg_conv; + announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1)); + announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0); + announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv); + LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_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_NodeInfo_clone(uint32_t orig) { + LDKNodeInfo orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKRoutingFees ret_var = RoutingFees_clone(&orig_conv); + LDKNodeInfo ret_var = NodeInfo_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; @@ -22975,184 +25010,478 @@ uint32_t __attribute__((visibility("default"))) TS_RoutingFees_clone(uint32_t o return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_RoutingFees_write(uint32_t obj) { - LDKRoutingFees obj_conv; +int8_tArray __attribute__((visibility("default"))) TS_NodeInfo_write(uint32_t obj) { + LDKNodeInfo obj_conv; obj_conv.inner = (void*)(obj & (~1)); obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = RoutingFees_write(&obj_conv); + LDKCVec_u8Z ret_var = NodeInfo_write(&obj_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_RoutingFees_read(int8_tArray ser) { +uint32_t __attribute__((visibility("default"))) TS_NodeInfo_read(int8_tArray ser) { LDKu8slice ser_ref; ser_ref.datalen = *((uint32_t*)ser); ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_RoutingFeesDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RoutingFeesDecodeErrorZ), "LDKCResult_RoutingFeesDecodeErrorZ"); - *ret_conv = RoutingFees_read(ser_ref); + LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ"); + *ret_conv = NodeInfo_read(ser_ref); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_free(uint32_t this_obj) { - LDKNodeAnnouncementInfo this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - NodeAnnouncementInfo_free(this_obj_conv); -} - -uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_features(uint32_t this_ptr) { - LDKNodeAnnouncementInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKNodeFeatures ret_var = NodeAnnouncementInfo_get_features(&this_ptr_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; +int8_tArray __attribute__((visibility("default"))) TS_NetworkGraph_write(uint32_t obj) { + LDKNetworkGraph obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_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; } -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_features(uint32_t this_ptr, uint32_t val) { - LDKNodeAnnouncementInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ"); + *ret_conv = NetworkGraph_read(ser_ref); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_new(int8_tArray genesis_hash) { + LDKThirtyTwoBytes genesis_hash_ref; + CHECK(*((uint32_t*)genesis_hash) == 32); + memcpy(genesis_hash_ref.data, (uint8_t*)(genesis_hash + 4), 32); + LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref); + 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_NetworkGraph_read_only(uint32_t this_arg) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKReadOnlyNetworkGraph ret_var = NetworkGraph_read_only(&this_arg_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_NetworkGraph_update_node_from_announcement(uint32_t this_arg, uint32_t msg) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKNodeAnnouncement msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_node_from_unsigned_announcement(uint32_t this_arg, uint32_t msg) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKUnsignedNodeAnnouncement msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKChannelAnnouncement msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + 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) { + // Manually implement clone for Java trait instances + } + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_unsigned_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKUnsignedChannelAnnouncement msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + 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) { + // Manually implement clone for Java trait instances + } + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_NetworkGraph_close_channel_from_update(uint32_t this_arg, int64_t short_channel_id, jboolean is_permanent) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent); +} + +void __attribute__((visibility("default"))) TS_NetworkGraph_fail_node(uint32_t this_arg, int8_tArray _node_id, jboolean is_permanent) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKPublicKey _node_id_ref; + CHECK(*((uint32_t*)_node_id) == 33); + memcpy(_node_id_ref.compressed_form, (uint8_t*)(_node_id + 4), 33); + NetworkGraph_fail_node(&this_arg_conv, _node_id_ref, is_permanent); +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel(uint32_t this_arg, uint32_t msg) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKChannelUpdate msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_unsigned(uint32_t this_arg, uint32_t msg) { + LDKNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKUnsignedChannelUpdate msg_conv; + msg_conv.inner = (void*)(msg & (~1)); + msg_conv.is_owned = false; + LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); + *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv); + return (uint64_t)ret_conv; +} + +uint32_t __attribute__((visibility("default"))) TS_ReadOnlyNetworkGraph_get_addresses(uint32_t this_arg, int8_tArray pubkey) { + LDKReadOnlyNetworkGraph this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + LDKPublicKey pubkey_ref; + CHECK(*((uint32_t*)pubkey) == 33); + memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33); + LDKCOption_CVec_NetAddressZZ *ret_copy = MALLOC(sizeof(LDKCOption_CVec_NetAddressZZ), "LDKCOption_CVec_NetAddressZZ"); + *ret_copy = ReadOnlyNetworkGraph_get_addresses(&this_arg_conv, pubkey_ref); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_RouteHop_free(uint32_t this_obj) { + LDKRouteHop this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + RouteHop_free(this_obj_conv); +} + +int8_tArray __attribute__((visibility("default"))) TS_RouteHop_get_pubkey(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), RouteHop_get_pubkey(&this_ptr_conv).compressed_form, 33); + return ret_arr; +} + +void __attribute__((visibility("default"))) TS_RouteHop_set_pubkey(uint32_t this_ptr, int8_tArray val) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKPublicKey val_ref; + CHECK(*((uint32_t*)val) == 33); + memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); + RouteHop_set_pubkey(&this_ptr_conv, val_ref); +} + +uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_node_features(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKNodeFeatures ret_var = RouteHop_get_node_features(&this_ptr_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_RouteHop_set_node_features(uint32_t this_ptr, uint32_t val) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKNodeFeatures val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); val_conv = NodeFeatures_clone(&val_conv); - NodeAnnouncementInfo_set_features(&this_ptr_conv, val_conv); + RouteHop_set_node_features(&this_ptr_conv, val_conv); } -int32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_last_update(uint32_t this_ptr) { - LDKNodeAnnouncementInfo this_ptr_conv; +int64_t __attribute__((visibility("default"))) TS_RouteHop_get_short_channel_id(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int32_t ret_val = NodeAnnouncementInfo_get_last_update(&this_ptr_conv); + int64_t ret_val = RouteHop_get_short_channel_id(&this_ptr_conv); return ret_val; } -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_last_update(uint32_t this_ptr, int32_t val) { - LDKNodeAnnouncementInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RouteHop_set_short_channel_id(uint32_t this_ptr, int64_t val) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - NodeAnnouncementInfo_set_last_update(&this_ptr_conv, val); + RouteHop_set_short_channel_id(&this_ptr_conv, val); } -int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_rgb(uint32_t this_ptr) { - LDKNodeAnnouncementInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_RouteHop_get_channel_features(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(3, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_rgb(&this_ptr_conv), 3); - return ret_arr; + LDKChannelFeatures ret_var = RouteHop_get_channel_features(&this_ptr_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_NodeAnnouncementInfo_set_rgb(uint32_t this_ptr, int8_tArray val) { - LDKNodeAnnouncementInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RouteHop_set_channel_features(uint32_t this_ptr, uint32_t val) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKThreeBytes val_ref; - CHECK(*((uint32_t*)val) == 3); - memcpy(val_ref.data, (uint8_t*)(val + 4), 3); - NodeAnnouncementInfo_set_rgb(&this_ptr_conv, val_ref); + LDKChannelFeatures val_conv; + val_conv.inner = (void*)(val & (~1)); + val_conv.is_owned = (val & 1) || (val == 0); + val_conv = ChannelFeatures_clone(&val_conv); + RouteHop_set_channel_features(&this_ptr_conv, val_conv); } -int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_alias(uint32_t this_ptr) { - LDKNodeAnnouncementInfo this_ptr_conv; +int64_t __attribute__((visibility("default"))) TS_RouteHop_get_fee_msat(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - int8_tArray ret_arr = init_arr(32, sizeof(uint8_t), "Native int8_tArray Bytes"); - memcpy((uint8_t*)(ret_arr + 4), *NodeAnnouncementInfo_get_alias(&this_ptr_conv), 32); + int64_t ret_val = RouteHop_get_fee_msat(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_RouteHop_set_fee_msat(uint32_t this_ptr, int64_t val) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + RouteHop_set_fee_msat(&this_ptr_conv, val); +} + +int32_t __attribute__((visibility("default"))) TS_RouteHop_get_cltv_expiry_delta(uint32_t this_ptr) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int32_t ret_val = RouteHop_get_cltv_expiry_delta(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_RouteHop_set_cltv_expiry_delta(uint32_t this_ptr, int32_t val) { + LDKRouteHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + RouteHop_set_cltv_expiry_delta(&this_ptr_conv, val); +} + +uint32_t __attribute__((visibility("default"))) TS_RouteHop_new(int8_tArray pubkey_arg, uint32_t node_features_arg, int64_t short_channel_id_arg, uint32_t channel_features_arg, int64_t fee_msat_arg, int32_t cltv_expiry_delta_arg) { + LDKPublicKey pubkey_arg_ref; + CHECK(*((uint32_t*)pubkey_arg) == 33); + memcpy(pubkey_arg_ref.compressed_form, (uint8_t*)(pubkey_arg + 4), 33); + LDKNodeFeatures node_features_arg_conv; + node_features_arg_conv.inner = (void*)(node_features_arg & (~1)); + node_features_arg_conv.is_owned = (node_features_arg & 1) || (node_features_arg == 0); + node_features_arg_conv = NodeFeatures_clone(&node_features_arg_conv); + LDKChannelFeatures channel_features_arg_conv; + channel_features_arg_conv.inner = (void*)(channel_features_arg & (~1)); + channel_features_arg_conv.is_owned = (channel_features_arg & 1) || (channel_features_arg == 0); + channel_features_arg_conv = ChannelFeatures_clone(&channel_features_arg_conv); + LDKRouteHop ret_var = RouteHop_new(pubkey_arg_ref, node_features_arg_conv, short_channel_id_arg, channel_features_arg_conv, fee_msat_arg, cltv_expiry_delta_arg); + 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_RouteHop_clone(uint32_t orig) { + LDKRouteHop orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKRouteHop ret_var = RouteHop_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; +} + +int64_t __attribute__((visibility("default"))) TS_RouteHop_hash(uint32_t o) { + LDKRouteHop o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = RouteHop_hash(&o_conv); + return ret_val; +} + +jboolean __attribute__((visibility("default"))) TS_RouteHop_eq(uint32_t a, uint32_t b) { + LDKRouteHop a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKRouteHop b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = RouteHop_eq(&a_conv, &b_conv); + return ret_val; +} + +int8_tArray __attribute__((visibility("default"))) TS_RouteHop_write(uint32_t obj) { + LDKRouteHop obj_conv; + obj_conv.inner = (void*)(obj & (~1)); + obj_conv.is_owned = false; + LDKCVec_u8Z ret_var = RouteHop_write(&obj_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; } -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_alias(uint32_t this_ptr, int8_tArray val) { - LDKNodeAnnouncementInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_RouteHop_read(int8_tArray ser) { + LDKu8slice ser_ref; + ser_ref.datalen = *((uint32_t*)ser); + ser_ref.data = (int8_t*)(ser + 4); + LDKCResult_RouteHopDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteHopDecodeErrorZ), "LDKCResult_RouteHopDecodeErrorZ"); + *ret_conv = RouteHop_read(ser_ref); + return (uint64_t)ret_conv; +} + +void __attribute__((visibility("default"))) TS_Route_free(uint32_t this_obj) { + LDKRoute this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + Route_free(this_obj_conv); +} + +ptrArray __attribute__((visibility("default"))) TS_Route_get_paths(uint32_t this_ptr) { + LDKRoute this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKThirtyTwoBytes val_ref; - CHECK(*((uint32_t*)val) == 32); - memcpy(val_ref.data, (uint8_t*)(val + 4), 32); - NodeAnnouncementInfo_set_alias(&this_ptr_conv, val_ref); + LDKCVec_CVec_RouteHopZZ ret_var = Route_get_paths(&this_ptr_conv); + ptrArray ret_arr = init_arr(ret_var.datalen, sizeof(uint32_t), "Native ptrArray Bytes"); + uint32_tArray *ret_arr_ptr = (uint32_tArray*)(ret_arr + 4); + for (size_t m = 0; m < ret_var.datalen; m++) { + LDKCVec_RouteHopZ ret_conv_12_var = ret_var.data[m]; + uint32_tArray ret_conv_12_arr = init_arr(ret_conv_12_var.datalen, sizeof(uint32_t), "Native uint32_tArray Bytes"); + uint32_t *ret_conv_12_arr_ptr = (uint32_t*)(ret_conv_12_arr + 4); + for (size_t k = 0; k < ret_conv_12_var.datalen; k++) { + LDKRouteHop ret_conv_12_conv_10_var = ret_conv_12_var.data[k]; + CHECK((((uint64_t)ret_conv_12_conv_10_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this. + CHECK((((uint64_t)&ret_conv_12_conv_10_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this. + uint64_t ret_conv_12_conv_10_ref = (uint64_t)ret_conv_12_conv_10_var.inner; + if (ret_conv_12_conv_10_var.is_owned) { + ret_conv_12_conv_10_ref |= 1; + } + ret_conv_12_arr_ptr[k] = ret_conv_12_conv_10_ref; + } + FREE(ret_conv_12_var.data); + ret_arr_ptr[m] = ret_conv_12_arr; + } + FREE(ret_var.data); + return ret_arr; } -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_addresses(uint32_t this_ptr, uint32_tArray val) { - LDKNodeAnnouncementInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_Route_set_paths(uint32_t this_ptr, ptrArray val) { + LDKRoute this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKCVec_NetAddressZ val_constr; + LDKCVec_CVec_RouteHopZZ val_constr; val_constr.datalen = *((uint32_t*)val); if (val_constr.datalen > 0) - val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements"); + val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements"); else val_constr.data = NULL; - uint32_t* val_vals = (uint32_t*)(val + 4); + uint32_tArray* val_vals = (uint32_tArray*)(val + 4); for (size_t m = 0; m < val_constr.datalen; m++) { - uint32_t val_conv_12 = val_vals[m]; - LDKNetAddress val_conv_12_conv = *(LDKNetAddress*)(((uint64_t)val_conv_12) & ~1); - val_conv_12_conv = NetAddress_clone((LDKNetAddress*)(((uint64_t)val_conv_12) & ~1)); - val_constr.data[m] = val_conv_12_conv; - } - NodeAnnouncementInfo_set_addresses(&this_ptr_conv, val_constr); -} - -uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_get_announcement_message(uint32_t this_ptr) { - LDKNodeAnnouncementInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKNodeAnnouncement ret_var = NodeAnnouncementInfo_get_announcement_message(&this_ptr_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; + uint32_tArray val_conv_12 = val_vals[m]; + LDKCVec_RouteHopZ val_conv_12_constr; + val_conv_12_constr.datalen = *((uint32_t*)val_conv_12); + if (val_conv_12_constr.datalen > 0) + val_conv_12_constr.data = MALLOC(val_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements"); + else + val_conv_12_constr.data = NULL; + uint32_t* val_conv_12_vals = (uint32_t*)(val_conv_12 + 4); + for (size_t k = 0; k < val_conv_12_constr.datalen; k++) { + uint32_t val_conv_12_conv_10 = val_conv_12_vals[k]; + LDKRouteHop val_conv_12_conv_10_conv; + val_conv_12_conv_10_conv.inner = (void*)(val_conv_12_conv_10 & (~1)); + val_conv_12_conv_10_conv.is_owned = (val_conv_12_conv_10 & 1) || (val_conv_12_conv_10 == 0); + val_conv_12_conv_10_conv = RouteHop_clone(&val_conv_12_conv_10_conv); + val_conv_12_constr.data[k] = val_conv_12_conv_10_conv; + } + val_constr.data[m] = val_conv_12_constr; } - return ret_ref; -} - -void __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_set_announcement_message(uint32_t this_ptr, uint32_t val) { - LDKNodeAnnouncementInfo this_ptr_conv; - this_ptr_conv.inner = (void*)(this_ptr & (~1)); - this_ptr_conv.is_owned = false; - LDKNodeAnnouncement val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = NodeAnnouncement_clone(&val_conv); - NodeAnnouncementInfo_set_announcement_message(&this_ptr_conv, val_conv); + Route_set_paths(&this_ptr_conv, val_constr); } -uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_new(uint32_t features_arg, int32_t last_update_arg, int8_tArray rgb_arg, int8_tArray alias_arg, uint32_tArray addresses_arg, uint32_t announcement_message_arg) { - LDKNodeFeatures features_arg_conv; - features_arg_conv.inner = (void*)(features_arg & (~1)); - features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0); - features_arg_conv = NodeFeatures_clone(&features_arg_conv); - LDKThreeBytes rgb_arg_ref; - CHECK(*((uint32_t*)rgb_arg) == 3); - memcpy(rgb_arg_ref.data, (uint8_t*)(rgb_arg + 4), 3); - LDKThirtyTwoBytes alias_arg_ref; - CHECK(*((uint32_t*)alias_arg) == 32); - memcpy(alias_arg_ref.data, (uint8_t*)(alias_arg + 4), 32); - LDKCVec_NetAddressZ addresses_arg_constr; - addresses_arg_constr.datalen = *((uint32_t*)addresses_arg); - if (addresses_arg_constr.datalen > 0) - addresses_arg_constr.data = MALLOC(addresses_arg_constr.datalen * sizeof(LDKNetAddress), "LDKCVec_NetAddressZ Elements"); +uint32_t __attribute__((visibility("default"))) TS_Route_new(ptrArray paths_arg) { + LDKCVec_CVec_RouteHopZZ paths_arg_constr; + paths_arg_constr.datalen = *((uint32_t*)paths_arg); + if (paths_arg_constr.datalen > 0) + paths_arg_constr.data = MALLOC(paths_arg_constr.datalen * sizeof(LDKCVec_RouteHopZ), "LDKCVec_CVec_RouteHopZZ Elements"); else - addresses_arg_constr.data = NULL; - uint32_t* addresses_arg_vals = (uint32_t*)(addresses_arg + 4); - for (size_t m = 0; m < addresses_arg_constr.datalen; m++) { - uint32_t addresses_arg_conv_12 = addresses_arg_vals[m]; - LDKNetAddress addresses_arg_conv_12_conv = *(LDKNetAddress*)(((uint64_t)addresses_arg_conv_12) & ~1); - addresses_arg_constr.data[m] = addresses_arg_conv_12_conv; + paths_arg_constr.data = NULL; + uint32_tArray* paths_arg_vals = (uint32_tArray*)(paths_arg + 4); + for (size_t m = 0; m < paths_arg_constr.datalen; m++) { + uint32_tArray paths_arg_conv_12 = paths_arg_vals[m]; + LDKCVec_RouteHopZ paths_arg_conv_12_constr; + paths_arg_conv_12_constr.datalen = *((uint32_t*)paths_arg_conv_12); + if (paths_arg_conv_12_constr.datalen > 0) + paths_arg_conv_12_constr.data = MALLOC(paths_arg_conv_12_constr.datalen * sizeof(LDKRouteHop), "LDKCVec_RouteHopZ Elements"); + else + paths_arg_conv_12_constr.data = NULL; + uint32_t* paths_arg_conv_12_vals = (uint32_t*)(paths_arg_conv_12 + 4); + for (size_t k = 0; k < paths_arg_conv_12_constr.datalen; k++) { + uint32_t paths_arg_conv_12_conv_10 = paths_arg_conv_12_vals[k]; + LDKRouteHop paths_arg_conv_12_conv_10_conv; + paths_arg_conv_12_conv_10_conv.inner = (void*)(paths_arg_conv_12_conv_10 & (~1)); + paths_arg_conv_12_conv_10_conv.is_owned = (paths_arg_conv_12_conv_10 & 1) || (paths_arg_conv_12_conv_10 == 0); + paths_arg_conv_12_conv_10_conv = RouteHop_clone(&paths_arg_conv_12_conv_10_conv); + paths_arg_conv_12_constr.data[k] = paths_arg_conv_12_conv_10_conv; + } + paths_arg_constr.data[m] = paths_arg_conv_12_constr; } - LDKNodeAnnouncement announcement_message_arg_conv; - announcement_message_arg_conv.inner = (void*)(announcement_message_arg & (~1)); - announcement_message_arg_conv.is_owned = (announcement_message_arg & 1) || (announcement_message_arg == 0); - announcement_message_arg_conv = NodeAnnouncement_clone(&announcement_message_arg_conv); - LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_new(features_arg_conv, last_update_arg, rgb_arg_ref, alias_arg_ref, addresses_arg_constr, announcement_message_arg_conv); + LDKRoute ret_var = Route_new(paths_arg_constr); 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; @@ -23162,11 +25491,11 @@ uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_new(uin return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(uint32_t orig) { - LDKNodeAnnouncementInfo orig_conv; +uint32_t __attribute__((visibility("default"))) TS_Route_clone(uint32_t orig) { + LDKRoute orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKNodeAnnouncementInfo ret_var = NodeAnnouncementInfo_clone(&orig_conv); + LDKRoute ret_var = Route_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; @@ -23176,56 +25505,147 @@ uint32_t __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_clone(u return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_NodeAnnouncementInfo_write(uint32_t obj) { - LDKNodeAnnouncementInfo obj_conv; +int64_t __attribute__((visibility("default"))) TS_Route_hash(uint32_t o) { + LDKRoute o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = Route_hash(&o_conv); + return ret_val; +} + +jboolean __attribute__((visibility("default"))) TS_Route_eq(uint32_t a, uint32_t b) { + LDKRoute a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKRoute b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = Route_eq(&a_conv, &b_conv); + return ret_val; +} + +int64_t __attribute__((visibility("default"))) TS_Route_get_total_fees(uint32_t this_arg) { + LDKRoute this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + int64_t ret_val = Route_get_total_fees(&this_arg_conv); + return ret_val; +} + +int64_t __attribute__((visibility("default"))) TS_Route_get_total_amount(uint32_t this_arg) { + LDKRoute this_arg_conv; + this_arg_conv.inner = (void*)(this_arg & (~1)); + this_arg_conv.is_owned = false; + int64_t ret_val = Route_get_total_amount(&this_arg_conv); + return ret_val; +} + +int8_tArray __attribute__((visibility("default"))) TS_Route_write(uint32_t obj) { + LDKRoute obj_conv; obj_conv.inner = (void*)(obj & (~1)); obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = NodeAnnouncementInfo_write(&obj_conv); + LDKCVec_u8Z ret_var = Route_write(&obj_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_NodeAnnouncementInfo_read(int8_tArray ser) { +uint32_t __attribute__((visibility("default"))) TS_Route_read(int8_tArray ser) { LDKu8slice ser_ref; ser_ref.datalen = *((uint32_t*)ser); ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_NodeAnnouncementInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeAnnouncementInfoDecodeErrorZ), "LDKCResult_NodeAnnouncementInfoDecodeErrorZ"); - *ret_conv = NodeAnnouncementInfo_read(ser_ref); + LDKCResult_RouteDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteDecodeErrorZ), "LDKCResult_RouteDecodeErrorZ"); + *ret_conv = Route_read(ser_ref); return (uint64_t)ret_conv; } -void __attribute__((visibility("default"))) TS_NodeInfo_free(uint32_t this_obj) { - LDKNodeInfo this_obj_conv; +void __attribute__((visibility("default"))) TS_RouteHint_free(uint32_t this_obj) { + LDKRouteHint this_obj_conv; this_obj_conv.inner = (void*)(this_obj & (~1)); this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - NodeInfo_free(this_obj_conv); + RouteHint_free(this_obj_conv); } -void __attribute__((visibility("default"))) TS_NodeInfo_set_channels(uint32_t this_ptr, int64_tArray val) { - LDKNodeInfo this_ptr_conv; +uint32_t __attribute__((visibility("default"))) TS_RouteHint_clone(uint32_t orig) { + LDKRouteHint orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKRouteHint ret_var = RouteHint_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; +} + +int64_t __attribute__((visibility("default"))) TS_RouteHint_hash(uint32_t o) { + LDKRouteHint o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = RouteHint_hash(&o_conv); + return ret_val; +} + +jboolean __attribute__((visibility("default"))) TS_RouteHint_eq(uint32_t a, uint32_t b) { + LDKRouteHint a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKRouteHint b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = RouteHint_eq(&a_conv, &b_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_RouteHintHop_free(uint32_t this_obj) { + LDKRouteHintHop this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + RouteHintHop_free(this_obj_conv); +} + +int8_tArray __attribute__((visibility("default"))) TS_RouteHintHop_get_src_node_id(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKCVec_u64Z val_constr; - val_constr.datalen = *((uint32_t*)val); - if (val_constr.datalen > 0) - val_constr.data = MALLOC(val_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements"); - else - val_constr.data = NULL; - int64_t* val_vals = (int64_t*)(val + 4); - for (size_t i = 0; i < val_constr.datalen; i++) { - int64_t val_conv_8 = val_vals[i]; - val_constr.data[i] = val_conv_8; - } - NodeInfo_set_channels(&this_ptr_conv, val_constr); + int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes"); + memcpy((uint8_t*)(ret_arr + 4), RouteHintHop_get_src_node_id(&this_ptr_conv).compressed_form, 33); + return ret_arr; } -uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_lowest_inbound_channel_fees(uint32_t this_ptr) { - LDKNodeInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RouteHintHop_set_src_node_id(uint32_t this_ptr, int8_tArray val) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKPublicKey val_ref; + CHECK(*((uint32_t*)val) == 33); + memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33); + RouteHintHop_set_src_node_id(&this_ptr_conv, val_ref); +} + +int64_t __attribute__((visibility("default"))) TS_RouteHintHop_get_short_channel_id(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + int64_t ret_val = RouteHintHop_get_short_channel_id(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_RouteHintHop_set_short_channel_id(uint32_t this_ptr, int64_t val) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + RouteHintHop_set_short_channel_id(&this_ptr_conv, val); +} + +uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_fees(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKRoutingFees ret_var = NodeInfo_get_lowest_inbound_channel_fees(&this_ptr_conv); + LDKRoutingFees ret_var = RouteHintHop_get_fees(&this_ptr_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; @@ -23235,63 +25655,83 @@ uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_lowest_inbound_ return ret_ref; } -void __attribute__((visibility("default"))) TS_NodeInfo_set_lowest_inbound_channel_fees(uint32_t this_ptr, uint32_t val) { - LDKNodeInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RouteHintHop_set_fees(uint32_t this_ptr, uint32_t val) { + LDKRouteHintHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; LDKRoutingFees val_conv; val_conv.inner = (void*)(val & (~1)); val_conv.is_owned = (val & 1) || (val == 0); val_conv = RoutingFees_clone(&val_conv); - NodeInfo_set_lowest_inbound_channel_fees(&this_ptr_conv, val_conv); + RouteHintHop_set_fees(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_NodeInfo_get_announcement_info(uint32_t this_ptr) { - LDKNodeInfo this_ptr_conv; +int16_t __attribute__((visibility("default"))) TS_RouteHintHop_get_cltv_expiry_delta(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKNodeAnnouncementInfo ret_var = NodeInfo_get_announcement_info(&this_ptr_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; - } + int16_t ret_val = RouteHintHop_get_cltv_expiry_delta(&this_ptr_conv); + return ret_val; +} + +void __attribute__((visibility("default"))) TS_RouteHintHop_set_cltv_expiry_delta(uint32_t this_ptr, int16_t val) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + RouteHintHop_set_cltv_expiry_delta(&this_ptr_conv, val); +} + +uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_minimum_msat(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); + *ret_copy = RouteHintHop_get_htlc_minimum_msat(&this_ptr_conv); + uint64_t ret_ref = (uint64_t)ret_copy; return ret_ref; } -void __attribute__((visibility("default"))) TS_NodeInfo_set_announcement_info(uint32_t this_ptr, uint32_t val) { - LDKNodeInfo this_ptr_conv; +void __attribute__((visibility("default"))) TS_RouteHintHop_set_htlc_minimum_msat(uint32_t this_ptr, uint32_t val) { + LDKRouteHintHop this_ptr_conv; this_ptr_conv.inner = (void*)(this_ptr & (~1)); this_ptr_conv.is_owned = false; - LDKNodeAnnouncementInfo val_conv; - val_conv.inner = (void*)(val & (~1)); - val_conv.is_owned = (val & 1) || (val == 0); - val_conv = NodeAnnouncementInfo_clone(&val_conv); - NodeInfo_set_announcement_info(&this_ptr_conv, val_conv); + LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); + RouteHintHop_set_htlc_minimum_msat(&this_ptr_conv, val_conv); } -uint32_t __attribute__((visibility("default"))) TS_NodeInfo_new(int64_tArray channels_arg, uint32_t lowest_inbound_channel_fees_arg, uint32_t announcement_info_arg) { - LDKCVec_u64Z channels_arg_constr; - channels_arg_constr.datalen = *((uint32_t*)channels_arg); - if (channels_arg_constr.datalen > 0) - channels_arg_constr.data = MALLOC(channels_arg_constr.datalen * sizeof(int64_t), "LDKCVec_u64Z Elements"); - else - channels_arg_constr.data = NULL; - int64_t* channels_arg_vals = (int64_t*)(channels_arg + 4); - for (size_t i = 0; i < channels_arg_constr.datalen; i++) { - int64_t channels_arg_conv_8 = channels_arg_vals[i]; - channels_arg_constr.data[i] = channels_arg_conv_8; - } - LDKRoutingFees lowest_inbound_channel_fees_arg_conv; - lowest_inbound_channel_fees_arg_conv.inner = (void*)(lowest_inbound_channel_fees_arg & (~1)); - lowest_inbound_channel_fees_arg_conv.is_owned = (lowest_inbound_channel_fees_arg & 1) || (lowest_inbound_channel_fees_arg == 0); - lowest_inbound_channel_fees_arg_conv = RoutingFees_clone(&lowest_inbound_channel_fees_arg_conv); - LDKNodeAnnouncementInfo announcement_info_arg_conv; - announcement_info_arg_conv.inner = (void*)(announcement_info_arg & (~1)); - announcement_info_arg_conv.is_owned = (announcement_info_arg & 1) || (announcement_info_arg == 0); - announcement_info_arg_conv = NodeAnnouncementInfo_clone(&announcement_info_arg_conv); - LDKNodeInfo ret_var = NodeInfo_new(channels_arg_constr, lowest_inbound_channel_fees_arg_conv, announcement_info_arg_conv); +uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_get_htlc_maximum_msat(uint32_t this_ptr) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z"); + *ret_copy = RouteHintHop_get_htlc_maximum_msat(&this_ptr_conv); + uint64_t ret_ref = (uint64_t)ret_copy; + return ret_ref; +} + +void __attribute__((visibility("default"))) TS_RouteHintHop_set_htlc_maximum_msat(uint32_t this_ptr, uint32_t val) { + LDKRouteHintHop this_ptr_conv; + this_ptr_conv.inner = (void*)(this_ptr & (~1)); + this_ptr_conv.is_owned = false; + LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(((uint64_t)val) & ~1); + val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1)); + RouteHintHop_set_htlc_maximum_msat(&this_ptr_conv, val_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_new(int8_tArray src_node_id_arg, int64_t short_channel_id_arg, uint32_t fees_arg, int16_t cltv_expiry_delta_arg, uint32_t htlc_minimum_msat_arg, uint32_t htlc_maximum_msat_arg) { + LDKPublicKey src_node_id_arg_ref; + CHECK(*((uint32_t*)src_node_id_arg) == 33); + memcpy(src_node_id_arg_ref.compressed_form, (uint8_t*)(src_node_id_arg + 4), 33); + LDKRoutingFees fees_arg_conv; + fees_arg_conv.inner = (void*)(fees_arg & (~1)); + fees_arg_conv.is_owned = (fees_arg & 1) || (fees_arg == 0); + fees_arg_conv = RoutingFees_clone(&fees_arg_conv); + LDKCOption_u64Z htlc_minimum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_minimum_msat_arg) & ~1); + htlc_minimum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)htlc_minimum_msat_arg) & ~1)); + LDKCOption_u64Z htlc_maximum_msat_arg_conv = *(LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1); + htlc_maximum_msat_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)htlc_maximum_msat_arg) & ~1)); + LDKRouteHintHop ret_var = RouteHintHop_new(src_node_id_arg_ref, short_channel_id_arg, fees_arg_conv, cltv_expiry_delta_arg, htlc_minimum_msat_arg_conv, htlc_maximum_msat_arg_conv); 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; @@ -23301,11 +25741,11 @@ uint32_t __attribute__((visibility("default"))) TS_NodeInfo_new(int64_tArray ch return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NodeInfo_clone(uint32_t orig) { - LDKNodeInfo orig_conv; +uint32_t __attribute__((visibility("default"))) TS_RouteHintHop_clone(uint32_t orig) { + LDKRouteHintHop orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKNodeInfo ret_var = NodeInfo_clone(&orig_conv); + LDKRouteHintHop ret_var = RouteHintHop_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; @@ -23315,151 +25755,167 @@ uint32_t __attribute__((visibility("default"))) TS_NodeInfo_clone(uint32_t orig return ret_ref; } -int8_tArray __attribute__((visibility("default"))) TS_NodeInfo_write(uint32_t obj) { - LDKNodeInfo obj_conv; - obj_conv.inner = (void*)(obj & (~1)); - obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = NodeInfo_write(&obj_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_NodeInfo_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_NodeInfoDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NodeInfoDecodeErrorZ), "LDKCResult_NodeInfoDecodeErrorZ"); - *ret_conv = NodeInfo_read(ser_ref); - return (uint64_t)ret_conv; +int64_t __attribute__((visibility("default"))) TS_RouteHintHop_hash(uint32_t o) { + LDKRouteHintHop o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = RouteHintHop_hash(&o_conv); + return ret_val; } -int8_tArray __attribute__((visibility("default"))) TS_NetworkGraph_write(uint32_t obj) { - LDKNetworkGraph obj_conv; - obj_conv.inner = (void*)(obj & (~1)); - obj_conv.is_owned = false; - LDKCVec_u8Z ret_var = NetworkGraph_write(&obj_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; +jboolean __attribute__((visibility("default"))) TS_RouteHintHop_eq(uint32_t a, uint32_t b) { + LDKRouteHintHop a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKRouteHintHop b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = RouteHintHop_eq(&a_conv, &b_conv); + return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_read(int8_tArray ser) { - LDKu8slice ser_ref; - ser_ref.datalen = *((uint32_t*)ser); - ser_ref.data = (int8_t*)(ser + 4); - LDKCResult_NetworkGraphDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NetworkGraphDecodeErrorZ), "LDKCResult_NetworkGraphDecodeErrorZ"); - *ret_conv = NetworkGraph_read(ser_ref); +uint32_t __attribute__((visibility("default"))) TS_get_keysend_route(int8_tArray our_node_pubkey, uint32_t network, int8_tArray payee, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger, uint32_t scorer) { + LDKPublicKey our_node_pubkey_ref; + CHECK(*((uint32_t*)our_node_pubkey) == 33); + memcpy(our_node_pubkey_ref.compressed_form, (uint8_t*)(our_node_pubkey + 4), 33); + LDKNetworkGraph network_conv; + network_conv.inner = (void*)(network & (~1)); + network_conv.is_owned = false; + LDKPublicKey payee_ref; + CHECK(*((uint32_t*)payee) == 33); + memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33); + LDKCVec_ChannelDetailsZ first_hops_constr; + LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL; + if (first_hops != 0) { + first_hops_constr.datalen = *((uint32_t*)first_hops); + if (first_hops_constr.datalen > 0) + first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements"); + else + first_hops_constr.data = NULL; + uint32_t* first_hops_vals = (uint32_t*)(first_hops + 4); + for (size_t q = 0; q < first_hops_constr.datalen; q++) { + uint32_t first_hops_conv_16 = first_hops_vals[q]; + LDKChannelDetails first_hops_conv_16_conv; + first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1)); + first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0); + first_hops_constr.data[q] = first_hops_conv_16_conv; + } + first_hops_ptr = &first_hops_constr; + } + LDKCVec_RouteHintZ last_hops_constr; + last_hops_constr.datalen = *((uint32_t*)last_hops); + if (last_hops_constr.datalen > 0) + last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements"); + else + last_hops_constr.data = NULL; + uint32_t* last_hops_vals = (uint32_t*)(last_hops + 4); + for (size_t l = 0; l < last_hops_constr.datalen; l++) { + uint32_t last_hops_conv_11 = last_hops_vals[l]; + LDKRouteHint last_hops_conv_11_conv; + last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1)); + last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0); + last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv); + last_hops_constr.data[l] = last_hops_conv_11_conv; + } + LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); + LDKScore* scorer_conv = (LDKScore*)(((uint64_t)scorer) & ~1); + LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ"); + *ret_conv = get_keysend_route(our_node_pubkey_ref, &network_conv, payee_ref, first_hops_ptr, last_hops_constr, final_value_msat, final_cltv, logger_conv, scorer_conv); + if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); } return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_new(int8_tArray genesis_hash) { - LDKThirtyTwoBytes genesis_hash_ref; - CHECK(*((uint32_t*)genesis_hash) == 32); - memcpy(genesis_hash_ref.data, (uint8_t*)(genesis_hash + 4), 32); - LDKNetworkGraph ret_var = NetworkGraph_new(genesis_hash_ref); - 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; +uint32_t __attribute__((visibility("default"))) TS_get_route(int8_tArray our_node_pubkey, uint32_t network, int8_tArray payee, uint32_t payee_features, uint32_tArray first_hops, uint32_tArray last_hops, int64_t final_value_msat, int32_t final_cltv, uint32_t logger, uint32_t scorer) { + LDKPublicKey our_node_pubkey_ref; + CHECK(*((uint32_t*)our_node_pubkey) == 33); + memcpy(our_node_pubkey_ref.compressed_form, (uint8_t*)(our_node_pubkey + 4), 33); + LDKNetworkGraph network_conv; + network_conv.inner = (void*)(network & (~1)); + network_conv.is_owned = false; + LDKPublicKey payee_ref; + CHECK(*((uint32_t*)payee) == 33); + memcpy(payee_ref.compressed_form, (uint8_t*)(payee + 4), 33); + LDKInvoiceFeatures payee_features_conv; + payee_features_conv.inner = (void*)(payee_features & (~1)); + payee_features_conv.is_owned = (payee_features & 1) || (payee_features == 0); + payee_features_conv = InvoiceFeatures_clone(&payee_features_conv); + LDKCVec_ChannelDetailsZ first_hops_constr; + LDKCVec_ChannelDetailsZ *first_hops_ptr = NULL; + if (first_hops != 0) { + first_hops_constr.datalen = *((uint32_t*)first_hops); + if (first_hops_constr.datalen > 0) + first_hops_constr.data = MALLOC(first_hops_constr.datalen * sizeof(LDKChannelDetails), "LDKCVec_ChannelDetailsZ Elements"); + else + first_hops_constr.data = NULL; + uint32_t* first_hops_vals = (uint32_t*)(first_hops + 4); + for (size_t q = 0; q < first_hops_constr.datalen; q++) { + uint32_t first_hops_conv_16 = first_hops_vals[q]; + LDKChannelDetails first_hops_conv_16_conv; + first_hops_conv_16_conv.inner = (void*)(first_hops_conv_16 & (~1)); + first_hops_conv_16_conv.is_owned = (first_hops_conv_16 & 1) || (first_hops_conv_16 == 0); + first_hops_constr.data[q] = first_hops_conv_16_conv; + } + first_hops_ptr = &first_hops_constr; } - return ret_ref; -} - -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_node_from_announcement(uint32_t this_arg, uint32_t msg) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKNodeAnnouncement msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_node_from_announcement(&this_arg_conv, &msg_conv); + LDKCVec_RouteHintZ last_hops_constr; + last_hops_constr.datalen = *((uint32_t*)last_hops); + if (last_hops_constr.datalen > 0) + last_hops_constr.data = MALLOC(last_hops_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements"); + else + last_hops_constr.data = NULL; + uint32_t* last_hops_vals = (uint32_t*)(last_hops + 4); + for (size_t l = 0; l < last_hops_constr.datalen; l++) { + uint32_t last_hops_conv_11 = last_hops_vals[l]; + LDKRouteHint last_hops_conv_11_conv; + last_hops_conv_11_conv.inner = (void*)(last_hops_conv_11 & (~1)); + last_hops_conv_11_conv.is_owned = (last_hops_conv_11 & 1) || (last_hops_conv_11 == 0); + last_hops_conv_11_conv = RouteHint_clone(&last_hops_conv_11_conv); + last_hops_constr.data[l] = last_hops_conv_11_conv; + } + LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); + LDKScore* scorer_conv = (LDKScore*)(((uint64_t)scorer) & ~1); + LDKCResult_RouteLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteLightningErrorZ), "LDKCResult_RouteLightningErrorZ"); + *ret_conv = get_route(our_node_pubkey_ref, &network_conv, payee_ref, payee_features_conv, first_hops_ptr, last_hops_constr, final_value_msat, final_cltv, logger_conv, scorer_conv); + if (first_hops_ptr != NULL) { FREE(first_hops_constr.data); } return (uint64_t)ret_conv; } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_node_from_unsigned_announcement(uint32_t this_arg, uint32_t msg) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKUnsignedNodeAnnouncement msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_node_from_unsigned_announcement(&this_arg_conv, &msg_conv); - return (uint64_t)ret_conv; +void __attribute__((visibility("default"))) TS_Scorer_free(uint32_t this_obj) { + LDKScorer this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + Scorer_free(this_obj_conv); } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKChannelAnnouncement msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKAccess *chain_access_conv_ptr = NULL; - if (chain_access != 0) { - LDKAccess chain_access_conv; - chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1); - chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *chain_access_conv_ptr = chain_access_conv; +uint32_t __attribute__((visibility("default"))) TS_Scorer_new(int64_t base_penalty_msat) { + LDKScorer ret_var = Scorer_new(base_penalty_msat); + 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; } - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_channel_from_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr); - return (uint64_t)ret_conv; + return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_from_unsigned_announcement(uint32_t this_arg, uint32_t msg, uint32_t chain_access) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKUnsignedChannelAnnouncement msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKAccess *chain_access_conv_ptr = NULL; - if (chain_access != 0) { - LDKAccess chain_access_conv; - chain_access_conv = *(LDKAccess*)(((uint64_t)chain_access) & ~1); - chain_access_conv_ptr = MALLOC(sizeof(LDKAccess), "LDKAccess"); - *chain_access_conv_ptr = chain_access_conv; +uint32_t __attribute__((visibility("default"))) TS_Scorer_default() { + LDKScorer ret_var = Scorer_default(); + 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; } - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_channel_from_unsigned_announcement(&this_arg_conv, &msg_conv, chain_access_conv_ptr); - return (uint64_t)ret_conv; -} - -void __attribute__((visibility("default"))) TS_NetworkGraph_close_channel_from_update(uint32_t this_arg, int64_t short_channel_id, jboolean is_permanent) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - NetworkGraph_close_channel_from_update(&this_arg_conv, short_channel_id, is_permanent); -} - -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel(uint32_t this_arg, uint32_t msg) { - LDKNetworkGraph this_arg_conv; - this_arg_conv.inner = (void*)(this_arg & (~1)); - this_arg_conv.is_owned = false; - LDKChannelUpdate msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_channel(&this_arg_conv, &msg_conv); - return (uint64_t)ret_conv; + return ret_ref; } -uint32_t __attribute__((visibility("default"))) TS_NetworkGraph_update_channel_unsigned(uint32_t this_arg, uint32_t msg) { - LDKNetworkGraph this_arg_conv; +uint32_t __attribute__((visibility("default"))) TS_Scorer_as_Score(uint32_t this_arg) { + LDKScorer this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKUnsignedChannelUpdate msg_conv; - msg_conv.inner = (void*)(msg & (~1)); - msg_conv.is_owned = false; - LDKCResult_NoneLightningErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_NoneLightningErrorZ), "LDKCResult_NoneLightningErrorZ"); - *ret_conv = NetworkGraph_update_channel_unsigned(&this_arg_conv, &msg_conv); - return (uint64_t)ret_conv; + LDKScore* ret_ret =MALLOC(sizeof(LDKScore), "LDKScore"); + *ret_ret = Scorer_as_Score(&this_arg_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_FilesystemPersister_free(uint32_t this_obj) { @@ -23515,9 +25971,9 @@ uint32_t __attribute__((visibility("default"))) TS_FilesystemPersister_as_Persi LDKFilesystemPersister this_arg_conv; this_arg_conv.inner = (void*)(this_arg & (~1)); this_arg_conv.is_owned = false; - LDKPersist* ret = MALLOC(sizeof(LDKPersist), "LDKPersist"); - *ret = FilesystemPersister_as_Persist(&this_arg_conv); - return (uint64_t)ret; + LDKPersist* ret_ret =MALLOC(sizeof(LDKPersist), "LDKPersist"); + *ret_ret = FilesystemPersister_as_Persist(&this_arg_conv); + return (uint64_t)ret_ret; } void __attribute__((visibility("default"))) TS_BackgroundProcessor_free(uint32_t this_obj) { @@ -23534,7 +25990,7 @@ void __attribute__((visibility("default"))) TS_ChannelManagerPersister_free(uin ChannelManagerPersister_free(this_ptr_conv); } -uint32_t __attribute__((visibility("default"))) TS_BackgroundProcessor_start(uint32_t persister, uint32_t event_handler, uint32_t chain_monitor, uint32_t channel_manager, uint32_t peer_manager, uint32_t logger) { +uint32_t __attribute__((visibility("default"))) TS_BackgroundProcessor_start(uint32_t persister, uint32_t event_handler, uint32_t chain_monitor, uint32_t channel_manager, uint32_t net_graph_msg_handler, uint32_t peer_manager, uint32_t logger) { LDKChannelManagerPersister persister_conv = *(LDKChannelManagerPersister*)(((uint64_t)persister) & ~1); LDKEventHandler event_handler_conv = *(LDKEventHandler*)(((uint64_t)event_handler) & ~1); LDKChainMonitor chain_monitor_conv; @@ -23543,11 +25999,14 @@ uint32_t __attribute__((visibility("default"))) TS_BackgroundProcessor_start(ui LDKChannelManager channel_manager_conv; channel_manager_conv.inner = (void*)(channel_manager & (~1)); channel_manager_conv.is_owned = false; + LDKNetGraphMsgHandler net_graph_msg_handler_conv; + net_graph_msg_handler_conv.inner = (void*)(net_graph_msg_handler & (~1)); + net_graph_msg_handler_conv.is_owned = (net_graph_msg_handler & 1) || (net_graph_msg_handler == 0); LDKPeerManager peer_manager_conv; peer_manager_conv.inner = (void*)(peer_manager & (~1)); peer_manager_conv.is_owned = false; LDKLogger logger_conv = *(LDKLogger*)(((uint64_t)logger) & ~1); - LDKBackgroundProcessor ret_var = BackgroundProcessor_start(persister_conv, event_handler_conv, &chain_monitor_conv, &channel_manager_conv, &peer_manager_conv, logger_conv); + LDKBackgroundProcessor ret_var = BackgroundProcessor_start(persister_conv, event_handler_conv, &chain_monitor_conv, &channel_manager_conv, net_graph_msg_handler_conv, &peer_manager_conv, logger_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; @@ -23861,6 +26320,12 @@ uint32_t __attribute__((visibility("default"))) TS_Currency_signet() { return ret_conv; } +int64_t __attribute__((visibility("default"))) TS_Currency_hash(uint32_t o) { + LDKCurrency* o_conv = (LDKCurrency*)(o & ~1); + int64_t ret_val = Currency_hash(o_conv); + return ret_val; +} + jboolean __attribute__((visibility("default"))) TS_Currency_eq(uint32_t a, uint32_t b) { LDKCurrency* a_conv = (LDKCurrency*)(a & ~1); LDKCurrency* b_conv = (LDKCurrency*)(b & ~1); @@ -23875,6 +26340,28 @@ void __attribute__((visibility("default"))) TS_Sha256_free(uint32_t this_obj) { Sha256_free(this_obj_conv); } +uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) { + LDKSha256 orig_conv; + orig_conv.inner = (void*)(orig & (~1)); + orig_conv.is_owned = false; + LDKSha256 ret_var = Sha256_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; +} + +int64_t __attribute__((visibility("default"))) TS_Sha256_hash(uint32_t o) { + LDKSha256 o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = Sha256_hash(&o_conv); + return ret_val; +} + jboolean __attribute__((visibility("default"))) TS_Sha256_eq(uint32_t a, uint32_t b) { LDKSha256 a_conv; a_conv.inner = (void*)(a & (~1)); @@ -23886,11 +26373,18 @@ jboolean __attribute__((visibility("default"))) TS_Sha256_eq(uint32_t a, uint32 return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) { - LDKSha256 orig_conv; +void __attribute__((visibility("default"))) TS_Description_free(uint32_t this_obj) { + LDKDescription this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + Description_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t orig) { + LDKDescription orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKSha256 ret_var = Sha256_clone(&orig_conv); + LDKDescription ret_var = Description_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; @@ -23900,11 +26394,12 @@ uint32_t __attribute__((visibility("default"))) TS_Sha256_clone(uint32_t orig) return ret_ref; } -void __attribute__((visibility("default"))) TS_Description_free(uint32_t this_obj) { - LDKDescription this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - Description_free(this_obj_conv); +int64_t __attribute__((visibility("default"))) TS_Description_hash(uint32_t o) { + LDKDescription o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = Description_hash(&o_conv); + return ret_val; } jboolean __attribute__((visibility("default"))) TS_Description_eq(uint32_t a, uint32_t b) { @@ -23918,11 +26413,18 @@ jboolean __attribute__((visibility("default"))) TS_Description_eq(uint32_t a, u return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t orig) { - LDKDescription orig_conv; +void __attribute__((visibility("default"))) TS_PayeePubKey_free(uint32_t this_obj) { + LDKPayeePubKey this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + PayeePubKey_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t orig) { + LDKPayeePubKey orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKDescription ret_var = Description_clone(&orig_conv); + LDKPayeePubKey ret_var = PayeePubKey_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; @@ -23932,11 +26434,12 @@ uint32_t __attribute__((visibility("default"))) TS_Description_clone(uint32_t o return ret_ref; } -void __attribute__((visibility("default"))) TS_PayeePubKey_free(uint32_t this_obj) { - LDKPayeePubKey this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - PayeePubKey_free(this_obj_conv); +int64_t __attribute__((visibility("default"))) TS_PayeePubKey_hash(uint32_t o) { + LDKPayeePubKey o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = PayeePubKey_hash(&o_conv); + return ret_val; } jboolean __attribute__((visibility("default"))) TS_PayeePubKey_eq(uint32_t a, uint32_t b) { @@ -23950,11 +26453,18 @@ jboolean __attribute__((visibility("default"))) TS_PayeePubKey_eq(uint32_t a, u return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t orig) { - LDKPayeePubKey orig_conv; +void __attribute__((visibility("default"))) TS_ExpiryTime_free(uint32_t this_obj) { + LDKExpiryTime this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + ExpiryTime_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t orig) { + LDKExpiryTime orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKPayeePubKey ret_var = PayeePubKey_clone(&orig_conv); + LDKExpiryTime ret_var = ExpiryTime_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; @@ -23964,11 +26474,12 @@ uint32_t __attribute__((visibility("default"))) TS_PayeePubKey_clone(uint32_t o return ret_ref; } -void __attribute__((visibility("default"))) TS_ExpiryTime_free(uint32_t this_obj) { - LDKExpiryTime this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - ExpiryTime_free(this_obj_conv); +int64_t __attribute__((visibility("default"))) TS_ExpiryTime_hash(uint32_t o) { + LDKExpiryTime o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = ExpiryTime_hash(&o_conv); + return ret_val; } jboolean __attribute__((visibility("default"))) TS_ExpiryTime_eq(uint32_t a, uint32_t b) { @@ -23982,11 +26493,18 @@ jboolean __attribute__((visibility("default"))) TS_ExpiryTime_eq(uint32_t a, ui return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t orig) { - LDKExpiryTime orig_conv; +void __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_free(uint32_t this_obj) { + LDKMinFinalCltvExpiry this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + MinFinalCltvExpiry_free(this_obj_conv); +} + +uint32_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) { + LDKMinFinalCltvExpiry orig_conv; orig_conv.inner = (void*)(orig & (~1)); orig_conv.is_owned = false; - LDKExpiryTime ret_var = ExpiryTime_clone(&orig_conv); + LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_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; @@ -23996,11 +26514,12 @@ uint32_t __attribute__((visibility("default"))) TS_ExpiryTime_clone(uint32_t or return ret_ref; } -void __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_free(uint32_t this_obj) { - LDKMinFinalCltvExpiry this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - MinFinalCltvExpiry_free(this_obj_conv); +int64_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_hash(uint32_t o) { + LDKMinFinalCltvExpiry o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = MinFinalCltvExpiry_hash(&o_conv); + return ret_val; } jboolean __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_eq(uint32_t a, uint32_t b) { @@ -24014,20 +26533,6 @@ jboolean __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_eq(uint32 return ret_val; } -uint32_t __attribute__((visibility("default"))) TS_MinFinalCltvExpiry_clone(uint32_t orig) { - LDKMinFinalCltvExpiry orig_conv; - orig_conv.inner = (void*)(orig & (~1)); - orig_conv.is_owned = false; - LDKMinFinalCltvExpiry ret_var = MinFinalCltvExpiry_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_Fallback_free(uint32_t this_ptr) { if ((this_ptr & 1) != 0) return; LDKFallback this_ptr_conv = *(LDKFallback*)(((uint64_t)this_ptr) & ~1); @@ -24075,6 +26580,12 @@ uint32_t __attribute__((visibility("default"))) TS_Fallback_script_hash(int8_tA return ret_ref; } +int64_t __attribute__((visibility("default"))) TS_Fallback_hash(uint32_t o) { + LDKFallback* o_conv = (LDKFallback*)o; + int64_t ret_val = Fallback_hash(o_conv); + return ret_val; +} + jboolean __attribute__((visibility("default"))) TS_Fallback_eq(uint32_t a, uint32_t b) { LDKFallback* a_conv = (LDKFallback*)a; LDKFallback* b_conv = (LDKFallback*)b; @@ -24089,17 +26600,6 @@ void __attribute__((visibility("default"))) TS_InvoiceSignature_free(uint32_t t InvoiceSignature_free(this_obj_conv); } -jboolean __attribute__((visibility("default"))) TS_InvoiceSignature_eq(uint32_t a, uint32_t b) { - LDKInvoiceSignature a_conv; - a_conv.inner = (void*)(a & (~1)); - a_conv.is_owned = false; - LDKInvoiceSignature b_conv; - b_conv.inner = (void*)(b & (~1)); - b_conv.is_owned = false; - jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv); - return ret_val; -} - uint32_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone(uint32_t orig) { LDKInvoiceSignature orig_conv; orig_conv.inner = (void*)(orig & (~1)); @@ -24114,24 +26614,24 @@ uint32_t __attribute__((visibility("default"))) TS_InvoiceSignature_clone(uint3 return ret_ref; } -void __attribute__((visibility("default"))) TS_PrivateRoute_free(uint32_t this_obj) { - LDKPrivateRoute this_obj_conv; - this_obj_conv.inner = (void*)(this_obj & (~1)); - this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); - PrivateRoute_free(this_obj_conv); -} - -jboolean __attribute__((visibility("default"))) TS_PrivateRoute_eq(uint32_t a, uint32_t b) { - LDKPrivateRoute a_conv; +jboolean __attribute__((visibility("default"))) TS_InvoiceSignature_eq(uint32_t a, uint32_t b) { + LDKInvoiceSignature a_conv; a_conv.inner = (void*)(a & (~1)); a_conv.is_owned = false; - LDKPrivateRoute b_conv; + LDKInvoiceSignature b_conv; b_conv.inner = (void*)(b & (~1)); b_conv.is_owned = false; - jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv); + jboolean ret_val = InvoiceSignature_eq(&a_conv, &b_conv); return ret_val; } +void __attribute__((visibility("default"))) TS_PrivateRoute_free(uint32_t this_obj) { + LDKPrivateRoute this_obj_conv; + this_obj_conv.inner = (void*)(this_obj & (~1)); + this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0); + PrivateRoute_free(this_obj_conv); +} + uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_clone(uint32_t orig) { LDKPrivateRoute orig_conv; orig_conv.inner = (void*)(orig & (~1)); @@ -24146,14 +26646,33 @@ uint32_t __attribute__((visibility("default"))) TS_PrivateRoute_clone(uint32_t return ret_ref; } +int64_t __attribute__((visibility("default"))) TS_PrivateRoute_hash(uint32_t o) { + LDKPrivateRoute o_conv; + o_conv.inner = (void*)(o & (~1)); + o_conv.is_owned = false; + int64_t ret_val = PrivateRoute_hash(&o_conv); + return ret_val; +} + +jboolean __attribute__((visibility("default"))) TS_PrivateRoute_eq(uint32_t a, uint32_t b) { + LDKPrivateRoute a_conv; + a_conv.inner = (void*)(a & (~1)); + a_conv.is_owned = false; + LDKPrivateRoute b_conv; + b_conv.inner = (void*)(b & (~1)); + b_conv.is_owned = false; + jboolean ret_val = PrivateRoute_eq(&a_conv, &b_conv); + return ret_val; +} + uint32_t __attribute__((visibility("default"))) TS_SignedRawInvoice_into_parts(uint32_t this_arg) { LDKSignedRawInvoice this_arg_conv; 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) { @@ -24699,6 +27218,11 @@ uint32_t __attribute__((visibility("default"))) TS_SemanticError_multiple_descr return ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_SemanticError_no_payment_secret() { + uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_no_payment_secret()); + return ret_conv; +} + uint32_t __attribute__((visibility("default"))) TS_SemanticError_multiple_payment_secrets() { uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_multiple_payment_secrets()); return ret_conv; @@ -24719,6 +27243,11 @@ uint32_t __attribute__((visibility("default"))) TS_SemanticError_invalid_signat return ret_conv; } +uint32_t __attribute__((visibility("default"))) TS_SemanticError_imprecise_amount() { + uint32_t ret_conv = LDKSemanticError_to_js(SemanticError_imprecise_amount()); + return ret_conv; +} + jboolean __attribute__((visibility("default"))) TS_SemanticError_eq(uint32_t a, uint32_t b) { LDKSemanticError* a_conv = (LDKSemanticError*)(a & ~1); LDKSemanticError* b_conv = (LDKSemanticError*)(b & ~1); @@ -24786,6 +27315,7 @@ uint32_t __attribute__((visibility("default"))) TS_create_invoice_from_channelm LDKKeysInterface keys_manager_conv = *(LDKKeysInterface*)(((uint64_t)keys_manager) & ~1); LDKCurrency network_conv = LDKCurrency_from_js(network); LDKCOption_u64Z amt_msat_conv = *(LDKCOption_u64Z*)(((uint64_t)amt_msat) & ~1); + amt_msat_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)amt_msat) & ~1)); LDKStr description_conv = str_ref_to_owned_c(description); LDKCResult_InvoiceSignOrCreationErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_InvoiceSignOrCreationErrorZ), "LDKCResult_InvoiceSignOrCreationErrorZ"); *ret_conv = create_invoice_from_channelmanager(&channelmanager_conv, keys_manager_conv, network_conv, amt_msat_conv, description_conv);