+void __attribute__((visibility("default"))) TS_RouteParameters_free(uint32_t this_obj) {
+ LDKRouteParameters this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ RouteParameters_free(this_obj_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_RouteParameters_get_payee(uint32_t this_ptr) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKPayee ret_var = RouteParameters_get_payee(&this_ptr_conv);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_RouteParameters_set_payee(uint32_t this_ptr, uint32_t val) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKPayee val_conv;
+ val_conv.inner = (void*)(val & (~1));
+ val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
+ val_conv = Payee_clone(&val_conv);
+ RouteParameters_set_payee(&this_ptr_conv, val_conv);
+}
+
+int64_t __attribute__((visibility("default"))) TS_RouteParameters_get_final_value_msat(uint32_t this_ptr) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int64_t ret_val = RouteParameters_get_final_value_msat(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_RouteParameters_set_final_value_msat(uint32_t this_ptr, int64_t val) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ RouteParameters_set_final_value_msat(&this_ptr_conv, val);
+}
+
+int32_t __attribute__((visibility("default"))) TS_RouteParameters_get_final_cltv_expiry_delta(uint32_t this_ptr) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int32_t ret_val = RouteParameters_get_final_cltv_expiry_delta(&this_ptr_conv);
+ return ret_val;
+}
+
+void __attribute__((visibility("default"))) TS_RouteParameters_set_final_cltv_expiry_delta(uint32_t this_ptr, int32_t val) {
+ LDKRouteParameters this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ RouteParameters_set_final_cltv_expiry_delta(&this_ptr_conv, val);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_RouteParameters_new(uint32_t payee_arg, int64_t final_value_msat_arg, int32_t final_cltv_expiry_delta_arg) {
+ LDKPayee payee_arg_conv;
+ payee_arg_conv.inner = (void*)(payee_arg & (~1));
+ payee_arg_conv.is_owned = (payee_arg & 1) || (payee_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(payee_arg_conv);
+ payee_arg_conv = Payee_clone(&payee_arg_conv);
+ LDKRouteParameters ret_var = RouteParameters_new(payee_arg_conv, final_value_msat_arg, final_cltv_expiry_delta_arg);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+static inline uint64_t RouteParameters_clone_ptr(LDKRouteParameters *NONNULL_PTR arg) {
+ LDKRouteParameters ret_var = RouteParameters_clone(arg);
+uint64_t ret_ref = 0;
+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.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_RouteParameters_clone_ptr(uint32_t arg) {
+ LDKRouteParameters arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = RouteParameters_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_RouteParameters_clone(uint32_t orig) {
+ LDKRouteParameters orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKRouteParameters ret_var = RouteParameters_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+int8_tArray __attribute__((visibility("default"))) TS_RouteParameters_write(uint32_t obj) {
+ LDKRouteParameters obj_conv;
+ obj_conv.inner = (void*)(obj & (~1));
+ obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ LDKCVec_u8Z ret_var = RouteParameters_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_RouteParameters_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_RouteParametersDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_RouteParametersDecodeErrorZ), "LDKCResult_RouteParametersDecodeErrorZ");
+ *ret_conv = RouteParameters_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
+void __attribute__((visibility("default"))) TS_Payee_free(uint32_t this_obj) {
+ LDKPayee this_obj_conv;
+ this_obj_conv.inner = (void*)(this_obj & (~1));
+ this_obj_conv.is_owned = (this_obj & 1) || (this_obj == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_obj_conv);
+ Payee_free(this_obj_conv);
+}
+
+int8_tArray __attribute__((visibility("default"))) TS_Payee_get_pubkey(uint32_t this_ptr) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ int8_tArray ret_arr = init_arr(33, sizeof(uint8_t), "Native int8_tArray Bytes");
+ memcpy((uint8_t*)(ret_arr + 4), Payee_get_pubkey(&this_ptr_conv).compressed_form, 33);
+ return ret_arr;
+}
+
+void __attribute__((visibility("default"))) TS_Payee_set_pubkey(uint32_t this_ptr, int8_tArray val) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKPublicKey val_ref;
+ CHECK(*((uint32_t*)val) == 33);
+ memcpy(val_ref.compressed_form, (uint8_t*)(val + 4), 33);
+ Payee_set_pubkey(&this_ptr_conv, val_ref);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_get_features(uint32_t this_ptr) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKInvoiceFeatures ret_var = Payee_get_features(&this_ptr_conv);
+ uint64_t ret_ref = 0;
+ if ((uint64_t)ret_var.inner > 4096) {
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ }
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_Payee_set_features(uint32_t this_ptr, uint32_t val) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKInvoiceFeatures val_conv;
+ val_conv.inner = (void*)(val & (~1));
+ val_conv.is_owned = (val & 1) || (val == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv);
+ val_conv = InvoiceFeatures_clone(&val_conv);
+ Payee_set_features(&this_ptr_conv, val_conv);
+}
+
+uint32_tArray __attribute__((visibility("default"))) TS_Payee_get_route_hints(uint32_t this_ptr) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKCVec_RouteHintZ ret_var = Payee_get_route_hints(&this_ptr_conv);
+ uint32_tArray ret_arr = NULL;
+ 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++) {
+ LDKRouteHint ret_conv_11_var = ret_var.data[l];
+ uint64_t ret_conv_11_ref = 0;
+ CHECK((((uint64_t)ret_conv_11_var.inner) & 1) == 0); // We rely on a free low bit, malloc guarantees this.
+ CHECK((((uint64_t)&ret_conv_11_var) & 1) == 0); // We rely on a free low bit, pointer alignment guarantees this.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_conv_11_var);
+ ret_conv_11_ref = (uint64_t)ret_conv_11_var.inner;
+ if (ret_conv_11_var.is_owned) {
+ ret_conv_11_ref |= 1;
+ }
+ ret_arr_ptr[l] = ret_conv_11_ref;
+ }
+
+ FREE(ret_var.data);
+ return ret_arr;
+}
+
+void __attribute__((visibility("default"))) TS_Payee_set_route_hints(uint32_t this_ptr, uint32_tArray val) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKCVec_RouteHintZ val_constr;
+ val_constr.datalen = *((uint32_t*)val);
+ if (val_constr.datalen > 0)
+ val_constr.data = MALLOC(val_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
+ else
+ val_constr.data = NULL;
+ uint32_t* val_vals = (uint32_t*)(val + 4);
+ for (size_t l = 0; l < val_constr.datalen; l++) {
+ uint32_t val_conv_11 = val_vals[l];
+ LDKRouteHint val_conv_11_conv;
+ val_conv_11_conv.inner = (void*)(val_conv_11 & (~1));
+ val_conv_11_conv.is_owned = (val_conv_11 & 1) || (val_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(val_conv_11_conv);
+ val_conv_11_conv = RouteHint_clone(&val_conv_11_conv);
+ val_constr.data[l] = val_conv_11_conv;
+ }
+ Payee_set_route_hints(&this_ptr_conv, val_constr);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_get_expiry_time(uint32_t this_ptr) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ LDKCOption_u64Z *ret_copy = MALLOC(sizeof(LDKCOption_u64Z), "LDKCOption_u64Z");
+ *ret_copy = Payee_get_expiry_time(&this_ptr_conv);
+ uint64_t ret_ref = (uint64_t)ret_copy;
+ return ret_ref;
+}
+
+void __attribute__((visibility("default"))) TS_Payee_set_expiry_time(uint32_t this_ptr, uint32_t val) {
+ LDKPayee this_ptr_conv;
+ this_ptr_conv.inner = (void*)(this_ptr & (~1));
+ this_ptr_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(this_ptr_conv);
+ void* val_ptr = (void*)(((uint64_t)val) & ~1);
+ CHECK_ACCESS(val_ptr);
+ LDKCOption_u64Z val_conv = *(LDKCOption_u64Z*)(val_ptr);
+ val_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)val) & ~1));
+ Payee_set_expiry_time(&this_ptr_conv, val_conv);
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_new(int8_tArray pubkey_arg, uint32_t features_arg, uint32_tArray route_hints_arg, uint32_t expiry_time_arg) {
+ LDKPublicKey pubkey_arg_ref;
+ CHECK(*((uint32_t*)pubkey_arg) == 33);
+ memcpy(pubkey_arg_ref.compressed_form, (uint8_t*)(pubkey_arg + 4), 33);
+ LDKInvoiceFeatures features_arg_conv;
+ features_arg_conv.inner = (void*)(features_arg & (~1));
+ features_arg_conv.is_owned = (features_arg & 1) || (features_arg == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(features_arg_conv);
+ features_arg_conv = InvoiceFeatures_clone(&features_arg_conv);
+ LDKCVec_RouteHintZ route_hints_arg_constr;
+ route_hints_arg_constr.datalen = *((uint32_t*)route_hints_arg);
+ if (route_hints_arg_constr.datalen > 0)
+ route_hints_arg_constr.data = MALLOC(route_hints_arg_constr.datalen * sizeof(LDKRouteHint), "LDKCVec_RouteHintZ Elements");
+ else
+ route_hints_arg_constr.data = NULL;
+ uint32_t* route_hints_arg_vals = (uint32_t*)(route_hints_arg + 4);
+ for (size_t l = 0; l < route_hints_arg_constr.datalen; l++) {
+ uint32_t route_hints_arg_conv_11 = route_hints_arg_vals[l];
+ LDKRouteHint route_hints_arg_conv_11_conv;
+ route_hints_arg_conv_11_conv.inner = (void*)(route_hints_arg_conv_11 & (~1));
+ route_hints_arg_conv_11_conv.is_owned = (route_hints_arg_conv_11 & 1) || (route_hints_arg_conv_11 == 0);
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(route_hints_arg_conv_11_conv);
+ route_hints_arg_conv_11_conv = RouteHint_clone(&route_hints_arg_conv_11_conv);
+ route_hints_arg_constr.data[l] = route_hints_arg_conv_11_conv;
+ }
+ void* expiry_time_arg_ptr = (void*)(((uint64_t)expiry_time_arg) & ~1);
+ CHECK_ACCESS(expiry_time_arg_ptr);
+ LDKCOption_u64Z expiry_time_arg_conv = *(LDKCOption_u64Z*)(expiry_time_arg_ptr);
+ expiry_time_arg_conv = COption_u64Z_clone((LDKCOption_u64Z*)(((uint64_t)expiry_time_arg) & ~1));
+ LDKPayee ret_var = Payee_new(pubkey_arg_ref, features_arg_conv, route_hints_arg_constr, expiry_time_arg_conv);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+static inline uint64_t Payee_clone_ptr(LDKPayee *NONNULL_PTR arg) {
+ LDKPayee ret_var = Payee_clone(arg);
+uint64_t ret_ref = 0;
+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.
+CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ret_ref = (uint64_t)ret_var.inner;
+if (ret_var.is_owned) {
+ ret_ref |= 1;
+}
+ return ret_ref;
+}
+int64_t __attribute__((visibility("default"))) TS_Payee_clone_ptr(uint32_t arg) {
+ LDKPayee arg_conv;
+ arg_conv.inner = (void*)(arg & (~1));
+ arg_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(arg_conv);
+ int64_t ret_val = Payee_clone_ptr(&arg_conv);
+ return ret_val;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_clone(uint32_t orig) {
+ LDKPayee orig_conv;
+ orig_conv.inner = (void*)(orig & (~1));
+ orig_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(orig_conv);
+ LDKPayee ret_var = Payee_clone(&orig_conv);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+int64_t __attribute__((visibility("default"))) TS_Payee_hash(uint32_t o) {
+ LDKPayee o_conv;
+ o_conv.inner = (void*)(o & (~1));
+ o_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(o_conv);
+ int64_t ret_val = Payee_hash(&o_conv);
+ return ret_val;
+}
+
+jboolean __attribute__((visibility("default"))) TS_Payee_eq(uint32_t a, uint32_t b) {
+ LDKPayee a_conv;
+ a_conv.inner = (void*)(a & (~1));
+ a_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(a_conv);
+ LDKPayee b_conv;
+ b_conv.inner = (void*)(b & (~1));
+ b_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(b_conv);
+ jboolean ret_val = Payee_eq(&a_conv, &b_conv);
+ return ret_val;
+}
+
+int8_tArray __attribute__((visibility("default"))) TS_Payee_write(uint32_t obj) {
+ LDKPayee obj_conv;
+ obj_conv.inner = (void*)(obj & (~1));
+ obj_conv.is_owned = false;
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(obj_conv);
+ LDKCVec_u8Z ret_var = Payee_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_Payee_read(int8_tArray ser) {
+ LDKu8slice ser_ref;
+ ser_ref.datalen = *((uint32_t*)ser);
+ ser_ref.data = (int8_t*)(ser + 4);
+ LDKCResult_PayeeDecodeErrorZ* ret_conv = MALLOC(sizeof(LDKCResult_PayeeDecodeErrorZ), "LDKCResult_PayeeDecodeErrorZ");
+ *ret_conv = Payee_read(ser_ref);
+ return (uint64_t)ret_conv;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_from_node_id(int8_tArray pubkey) {
+ LDKPublicKey pubkey_ref;
+ CHECK(*((uint32_t*)pubkey) == 33);
+ memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33);
+ LDKPayee ret_var = Payee_from_node_id(pubkey_ref);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+
+uint32_t __attribute__((visibility("default"))) TS_Payee_for_keysend(int8_tArray pubkey) {
+ LDKPublicKey pubkey_ref;
+ CHECK(*((uint32_t*)pubkey) == 33);
+ memcpy(pubkey_ref.compressed_form, (uint8_t*)(pubkey + 4), 33);
+ LDKPayee ret_var = Payee_for_keysend(pubkey_ref);
+ uint64_t ret_ref = 0;
+ 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.
+ CHECK_INNER_FIELD_ACCESS_OR_NULL(ret_var);
+ ret_ref = (uint64_t)ret_var.inner;
+ if (ret_var.is_owned) {
+ ret_ref |= 1;
+ }
+ return ret_ref;
+}
+