Added integration for new properties in user config

Author: SessionHero01

library/src/main/cpp/CMakeLists.txt

@@ -96,7 +96,7 @@ set(SOURCES
         webp_utils.cpp
         gif_utils.cpp
         pro_backend.cpp
-        pro_proof.cpp
+        pro_proof_util.cpp
 
         ${cgif_SOURCE_DIR}/src/cgif.c
         ${cgif_SOURCE_DIR}/src/cgif_rgb.c

library/src/main/cpp/pro_backend.cpp

@@ -76,14 +76,14 @@ Java_network_loki_messenger_libsession_1util_pro_BackendRequests_getPaymentProvi
         auto clazz = env->FindClass("network/loki/messenger/libsession_util/protocol/PaymentProviderMetadata");
         return env->NewObject(
                 clazz,
-                env->GetMethodID(clazz, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
+                env->GetMethodID(clazz, "<init>", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V"),
                 util::jstringFromOptional(env, std::string_view(metadata.device.data, metadata.device.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.store.data, metadata.store.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.platform.data, metadata.platform.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.platform_account.data, metadata.platform_account.size)),
-                util::jstringFromOptional(env, std::string_view(metadata.refund_url.data, metadata.refund_url.size)),
-                util::jstringFromOptional(env, std::string_view(metadata.refund_after_platform_deadline_url.data, metadata.refund_after_platform_deadline_url.size)),
+                util::jstringFromOptional(env, std::string_view(metadata.refund_platform_url.data, metadata.refund_platform_url.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.refund_support_url.data, metadata.refund_support_url.size)),
+                util::jstringFromOptional(env, std::string_view(metadata.refund_status_url.data, metadata.refund_status_url.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.update_subscription_url.data, metadata.update_subscription_url.size)),
                 util::jstringFromOptional(env, std::string_view(metadata.cancel_subscription_url.data, metadata.cancel_subscription_url.size))
             );

library/src/main/cpp/pro_proof.cpp

@@ -0,0 +1,94 @@
+#include <session/session_protocol.hpp>
+#include <oxenc/base64.h>
+#include <oxenc/hex.h>
+#include <nlohmann/json.hpp>
+#include <jni.h>
+
+#include "util.h"
+#include "jni_utils.h"
+#include "pro_proof_util.h"
+
+using namespace jni_utils;
+
+template <size_t N>
+static std::array<unsigned char, N> from_hex(std::span<char> input) {
+    std::array<unsigned char, N> output = {0};
+    oxenc::from_hex(input.begin(), input.end(), output.begin());
+    return output;
+}
+
+session::ProProof java_to_cpp_proof(JNIEnv *env, jobject proof) {
+    struct ProProofMethods {
+        jmethodID get_version;
+        jmethodID get_gen_index_hash;
+        jmethodID get_rotating_pub_key;
+        jmethodID get_expiry_ms;
+        jmethodID get_signature;
+
+        ProProofMethods(JNIEnv *env, jclass clazz) {
+            get_version = env->GetMethodID(clazz, "getVersion", "()I");
+            get_gen_index_hash = env->GetMethodID(clazz, "getGenIndexHashHex", "()Ljava/lang/String;");
+            get_rotating_pub_key = env->GetMethodID(clazz, "getRotatingPubKeyHex", "()Ljava/lang/String;");
+            get_expiry_ms = env->GetMethodID(clazz, "getExpiryMs", "()J");
+            get_signature = env->GetMethodID(clazz, "getSignatureHex", "()Ljava/lang/String;");
+        }
+    };
+
+    // Cache method IDs
+    static ProProofMethods methods(env, jni_utils::JavaLocalRef(env, env->GetObjectClass(proof)).get());
+
+    jni_utils::JavaLocalRef<jstring> gen_index_hash(env, (jstring) env->CallObjectMethod(proof, methods.get_gen_index_hash));
+    jni_utils::JavaLocalRef<jstring> rotating_pub_key(env, (jstring) env->CallObjectMethod(proof, methods.get_rotating_pub_key));
+    jni_utils::JavaLocalRef<jstring> signature(env, (jstring) env->CallObjectMethod(proof, methods.get_signature));
+
+    return {
+            .version = static_cast<std::uint8_t>(env->CallIntMethod(proof, methods.get_version)),
+            .gen_index_hash = from_hex<32>(jni_utils::JavaStringRef(env, gen_index_hash.get()).get()),
+            .rotating_pubkey = from_hex<32>(jni_utils::JavaStringRef(env, rotating_pub_key.get()).get()),
+            .expiry_unix_ts = std::chrono::sys_time<std::chrono::milliseconds>(
+                    std::chrono::milliseconds(env->CallLongMethod(proof, methods.get_expiry_ms))),
+            .sig = from_hex<64>(jni_utils::JavaStringRef(env, signature.get()).get()),
+    };
+}
+
+jobject cpp_to_java_proof(JNIEnv *env, const session::ProProof &proof) {
+    JavaLocalRef<jclass> pro_proof_clazz(env, env->FindClass(
+            "network/loki/messenger/libsession_util/pro/ProProof"));
+    jmethodID init = env->GetMethodID(pro_proof_clazz.get(), "<init>", "(I[B[BJ[B)V");
+    return env->NewObject(
+            pro_proof_clazz.get(),
+            init,
+            static_cast<jint>(proof.version),
+            util::bytes_from_span(env, proof.gen_index_hash),
+            util::bytes_from_span(env, proof.rotating_pubkey),
+            static_cast<jlong>(proof.expiry_unix_ts.time_since_epoch().count()),
+            util::bytes_from_span(env, proof.sig)
+    );
+}
+
+extern "C"
+JNIEXPORT jint JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_nativeStatus(JNIEnv *env, jobject thiz,
+                                                                       jlong now_unix_ts,
+                                                                       jbyteArray verify_pub_key,
+                                                                       jbyteArray signed_message_data,
+                                                                       jbyteArray signed_message_signature) {
+    return run_catching_cxx_exception_or_throws<jint>(env, [=]() {
+        std::optional<session::ProSignedMessage> signed_msg;
+        JavaByteArrayRef signed_message_data_ref(env, signed_message_data);
+        JavaByteArrayRef signed_message_signature_ref(env, signed_message_signature);
+
+        if (signed_message_data && signed_message_signature) {
+            signed_msg.emplace(session::ProSignedMessage {
+                    .sig = signed_message_signature_ref.get(),
+                    .msg = signed_message_data_ref.get(),
+            });
+        }
+
+        return static_cast<jint>(java_to_cpp_proof(env, thiz).status(
+                JavaByteArrayRef(env, verify_pub_key).get(),
+                std::chrono::sys_time<std::chrono::milliseconds>{std::chrono::milliseconds(now_unix_ts)},
+                signed_msg
+        ));
+    });
+}

library/src/main/cpp/pro_proof_util.cpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <session/session_protocol.hpp>
+#include <jni.h>
+
+session::ProProof java_to_cpp_proof(JNIEnv *, jobject proof);
+jobject cpp_to_java_proof(JNIEnv *, const session::ProProof &proof);

library/src/main/cpp/pro_proof_util.h

@@ -3,24 +3,11 @@
 #include <session/sodium_array.hpp>
 
 #include "jni_utils.h"
+#include "pro_proof_util.h"
 
 using namespace jni_utils;
 
 
-static JavaLocalRef<jobject> serializeProProof(JNIEnv *env, const session::ProProof &proof) {
-    JavaLocalRef<jclass> pro_proof_clazz(env, env->FindClass(
-            "network/loki/messenger/libsession_util/pro/ProProof"));
-    jmethodID init = env->GetMethodID(pro_proof_clazz.get(), "<init>", "(I[B[BJ[B)V");
-    return {env, env->NewObject(
-            pro_proof_clazz.get(),
-            init,
-            static_cast<jint>(proof.version),
-            util::bytes_from_span(env, proof.gen_index_hash),
-            util::bytes_from_span(env, proof.rotating_pubkey),
-            static_cast<jlong>(proof.expiry_unix_ts.time_since_epoch().count()),
-            util::bytes_from_span(env, proof.sig)
-    )};
-}
 
 static JavaLocalRef<jobject> serializeEnvelop(JNIEnv *env, const session::Envelope &envelope) {
     JavaLocalRef envelopClass(env, env->FindClass(
@@ -60,7 +47,7 @@ static jobject serializeDecodedEnvelope(JNIEnv *env, const session::DecodedEnvel
                           serializeEnvelop(env, envelop.envelope).get(),
                           envelop.pro ? static_cast<jint>(envelop.pro->status)
                                        : static_cast<jint>(-1),
-                          envelop.pro ? serializeProProof(env, envelop.pro->proof).get() : nullptr,
+                          envelop.pro ? JavaLocalRef(env, cpp_to_java_proof(env, envelop.pro->proof)).get() : nullptr,
                           static_cast<jlong>(envelop.pro ? envelop.pro->features : 0),
                           content.get(),
                           sender_ed25519.get(),
@@ -174,7 +161,7 @@ Java_network_loki_messenger_libsession_1util_protocol_SessionProtocol_decodeForC
                 init,
                 decoded.pro ? static_cast<jint>(decoded.pro->status)
                              : static_cast<jint>(-1),
-                decoded.pro ? serializeProProof(env, decoded.pro->proof).get() : nullptr,
+                decoded.pro ? JavaLocalRef(env, cpp_to_java_proof(env, decoded.pro->proof)).get() : nullptr,
                 static_cast<jlong>(decoded.pro ? decoded.pro->features : 0),
                 util::bytes_from_vector(env, decoded.content_plaintext)
         );

library/src/main/cpp/protocol.cpp

@@ -1,10 +1,11 @@
 #include "user_profile.h"
 #include "util.h"
+#include "pro_proof_util.h"
 
 extern "C" {
 JNIEXPORT void JNICALL
 Java_network_loki_messenger_libsession_1util_UserProfile_setName(
-        JNIEnv* env,
+        JNIEnv *env,
         jobject thiz,
         jstring newName) {
     auto profile = ptrToProfile(env, thiz);
@@ -57,7 +58,7 @@ Java_network_loki_messenger_libsession_1util_UserProfile_setNtsExpiry(JNIEnv *en
                                                                       jobject expiry_mode) {
     auto profile = ptrToProfile(env, thiz);
     auto expiry = util::deserialize_expiry(env, expiry_mode);
-    profile->set_nts_expiry(std::chrono::seconds (expiry.second));
+    profile->set_nts_expiry(std::chrono::seconds(expiry.second));
 }
 
 extern "C"
@@ -66,10 +67,12 @@ Java_network_loki_messenger_libsession_1util_UserProfile_getNtsExpiry(JNIEnv *en
     auto profile = ptrToProfile(env, thiz);
     auto nts_expiry = profile->get_nts_expiry();
     if (nts_expiry == std::nullopt) {
-        auto expiry = util::serialize_expiry(env, session::config::expiration_mode::none, std::chrono::seconds(0));
+        auto expiry = util::serialize_expiry(env, session::config::expiration_mode::none,
+                                             std::chrono::seconds(0));
         return expiry;
     }
-    auto expiry = util::serialize_expiry(env, session::config::expiration_mode::after_send, std::chrono::seconds(*nts_expiry));
+    auto expiry = util::serialize_expiry(env, session::config::expiration_mode::after_send,
+                                         std::chrono::seconds(*nts_expiry));
     return expiry;
 }
 
@@ -90,7 +93,7 @@ JNIEXPORT void JNICALL
 Java_network_loki_messenger_libsession_1util_UserProfile_setCommunityMessageRequests(
         JNIEnv *env, jobject thiz, jboolean blocks) {
     auto profile = ptrToProfile(env, thiz);
-    profile->set_blinded_msgreqs(std::optional{(bool)blocks});
+    profile->set_blinded_msgreqs(std::optional{(bool) blocks});
 }
 
 extern "C"
@@ -113,4 +116,97 @@ JNIEXPORT void JNICALL
 Java_network_loki_messenger_libsession_1util_UserProfile_setReuploadedPic(JNIEnv *env, jobject thiz,
                                                                           jobject user_pic) {
     ptrToProfile(env, thiz)->set_reupload_profile_pic(util::deserialize_user_pic(env, user_pic));
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_removeProConfig(JNIEnv *env,
+                                                                         jobject thiz) {
+    ptrToProfile(env, thiz)->remove_pro_config();
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_setProConfig(JNIEnv *env, jobject thiz,
+                                                                      jobject proof,
+                                                                      jbyteArray rotating_private_key) {
+    jni_utils::run_catching_cxx_exception_or_throws<void>(env, [=]() {
+
+        jni_utils::JavaByteArrayRef key_ref(env, rotating_private_key);
+        auto r = key_ref.get();
+        session::cleared_uc64 rotating_privkey;
+        std::copy(r.begin(), r.end(), rotating_privkey.begin());
+
+        ptrToProfile(env, thiz)->set_pro_config(
+                {
+                        .rotating_privkey = rotating_privkey,
+                        .proof = java_to_cpp_proof(env, proof),
+                }
+        );
+    });
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_setProBadge(JNIEnv *env, jobject thiz,
+                                                                     jboolean pro_badge) {
+    ptrToProfile(env, thiz)->set_pro_badge(pro_badge);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_setAnimatedAvatar(JNIEnv *env,
+                                                                           jobject thiz,
+                                                                           jboolean enabled) {
+    ptrToProfile(env, thiz)->set_animated_avatar(enabled);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_setProAccessExpiryMs(JNIEnv *env,
+                                                                              jobject thiz,
+                                                                              jlong epoch_mills) {
+    ptrToProfile(env, thiz)->set_pro_access_expiry(std::chrono::sys_time<std::chrono::milliseconds>{
+            std::chrono::milliseconds{epoch_mills}
+    });
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_removeProAccessExpiry(JNIEnv *env,
+                                                                               jobject thiz) {
+    ptrToProfile(env, thiz)->set_pro_access_expiry(std::nullopt);
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_getProFeaturesRaw(JNIEnv *env,
+                                                                           jobject thiz) {
+    return static_cast<jlong>(ptrToProfile(env, thiz)->get_pro_features());
+}
+
+extern "C"
+JNIEXPORT jobject JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_getProConfig(JNIEnv *env, jobject thiz) {
+    auto profile = ptrToProfile(env, thiz)->get_pro_config();
+    if (profile) {
+        return nullptr;
+    }
+
+    auto clazz = env->FindClass("network/loki/messenger/libsession_util/pro/ProConfig");
+    auto constructor = env->GetMethodID(clazz, "<init>", "(Lnetwork/loki/messenger/libsession_util/pro/ProProof;[B)V");
+
+    return env->NewObject(clazz,
+                          constructor,
+                          cpp_to_java_proof(env, profile->proof),
+                          util::bytes_from_span(env, profile->rotating_privkey)
+    );
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_network_loki_messenger_libsession_1util_UserProfile_getProAccessExpiryMsOrZero(JNIEnv *env,
+                                                                                    jobject thiz) {
+    auto expiry = ptrToProfile(env, thiz)->get_pro_access_expiry();
+    return expiry ? expiry->time_since_epoch().count() : 0;
 }