More integration of pro state

library/src/main/cpp/conversation.cpp

@@ -49,6 +49,64 @@ JavaLocalRef<jobject> serialize_one_to_one(JNIEnv *env, const session::config::c
                                                    one_to_one.pro_expiry_unix_ts).get())};
 }
 
+
+struct WithProProofInfoClassInfo : public JavaClassInfo {
+    jmethodID proProofInfo_getter;
+
+    WithProProofInfoClassInfo(JNIEnv *env, jobject obj)
+        : JavaClassInfo(env, obj)
+        , proProofInfo_getter(env->GetMethodID(java_class, "getProProofInfo", "()Lnetwork/loki/messenger/libsession_util/util/Conversation$ProProofInfo;"))
+        {}
+
+    static const WithProProofInfoClassInfo& get(JNIEnv *env, jobject obj) {
+        static WithProProofInfoClassInfo instance(env, obj);
+        return instance;
+    }
+};
+
+struct ProProofInfoClassInfo : public JavaClassInfo {
+    jmethodID genIndexHash_getter;
+    jmethodID expiryUnixTs_getter;
+
+    ProProofInfoClassInfo(JNIEnv *env, jobject obj)
+        : JavaClassInfo(env, obj)
+        , genIndexHash_getter(env->GetMethodID(java_class, "getGenIndexHashBytes", "()[B"))
+        , expiryUnixTs_getter(env->GetMethodID(java_class, "getExpiryUnixTs", "()J"))
+        {}
+
+    static const ProProofInfoClassInfo& get(JNIEnv *env, jobject obj) {
+        static ProProofInfoClassInfo instance(env, obj);
+        return instance;
+    }
+
+    static void read_gen_index_hash(std::optional<session::array_uc32> &out, JNIEnv *env, jobject obj) {
+        if (!obj) {
+            out = std::nullopt;
+            return;
+        }
+
+        JavaLocalRef<jbyteArray> hash_bytes(
+                env,
+                (jbyteArray) env->CallObjectMethod(
+                        obj,
+                        get(env, obj).genIndexHash_getter));
+
+        JavaByteArrayRef bytes_ref(env, hash_bytes.get());
+
+        out.emplace();
+        std::copy_n(bytes_ref.get().begin(),
+                    std::min(env->GetArrayLength(hash_bytes.get()), 32), out->begin());
+    }
+
+    static std::chrono::sys_time<std::chrono::milliseconds> read_pro_expiry(JNIEnv *env, jobject obj) {
+        if (!obj) return {};
+
+        jlong expiry_ts = env->CallLongMethod(obj, get(env, obj).expiryUnixTs_getter);
+        return std::chrono::sys_time<std::chrono::milliseconds>{std::chrono::milliseconds{expiry_ts}};
+    }
+};
+
+
 session::config::convo::one_to_one deserialize_one_to_one(JNIEnv *env, jobject info) {
     struct ClassInfo : public JavaClassInfo {
         jmethodID id_getter;
@@ -73,6 +131,13 @@ session::config::convo::one_to_one deserialize_one_to_one(JNIEnv *env, jobject i
 
     r.last_read = env->CallLongMethod(info, class_info.lastRead_getter);
     r.unread = env->CallBooleanMethod(info, class_info.unread_getter);
+
+    JavaLocalRef<jobject> pro_proof(env, env->CallObjectMethod(
+            info, WithProProofInfoClassInfo::get(env, info).proProofInfo_getter));
+
+    ProProofInfoClassInfo::read_gen_index_hash(r.pro_gen_index_hash, env, pro_proof.get());
+    r.pro_expiry_unix_ts = ProProofInfoClassInfo::read_pro_expiry(env, pro_proof.get());
+
     return r;
 }
 
@@ -234,6 +299,13 @@ session::config::convo::blinded_one_to_one deserialize_blinded_one_to_one(JNIEnv
     r.last_read = env->CallLongMethod(info, class_info.last_read_getter);
     r.unread = env->CallBooleanMethod(info, class_info.unread_getter);
 
+    JavaLocalRef<jobject> pro_proof(env, env->CallObjectMethod(
+            info, WithProProofInfoClassInfo::get(env, info).proProofInfo_getter));
+
+    ProProofInfoClassInfo::read_gen_index_hash(r.pro_gen_index_hash, env, pro_proof.get());
+    r.pro_expiry_unix_ts = ProProofInfoClassInfo::read_pro_expiry(env, pro_proof.get());
+
+
     return r;
 }
 

library/src/main/cpp/group_keys.cpp

@@ -127,11 +127,13 @@ extern "C"
 JNIEXPORT jbyteArray JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_rekey(JNIEnv *env, jobject thiz,
                                                                    jlong info_ptr, jlong members_ptr) {
-    auto keys = ptrToKeys(env, thiz);
-    auto info = reinterpret_cast<session::config::groups::Info*>(info_ptr);
-    auto members = reinterpret_cast<session::config::groups::Members*>(members_ptr);
-    auto rekey = keys->rekey(*info, *members);
-    return util::bytes_from_span(env, rekey).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jbyteArray>(env, [=] {
+        auto keys = ptrToKeys(env, thiz);
+        auto info = reinterpret_cast<session::config::groups::Info*>(info_ptr);
+        auto members = reinterpret_cast<session::config::groups::Members*>(members_ptr);
+        auto rekey = keys->rekey(*info, *members);
+        return util::bytes_from_span(env, rekey).release();
+    });
 }
 
 extern "C"
@@ -188,8 +190,9 @@ Java_network_loki_messenger_libsession_1util_GroupKeysConfig_keys(JNIEnv *env, j
 extern "C"
 JNIEXPORT jbyteArray JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_groupEncKey(JNIEnv *env, jobject thiz) {
-    auto ptr = ptrToKeys(env, thiz);
-    return util::bytes_from_span(env, ptr->group_enc_key()).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jbyteArray>(env, [=] {
+        return util::bytes_from_span(env, ptrToKeys(env, thiz)->group_enc_key()).release();
+    });
 }
 
 extern "C"
@@ -206,9 +209,11 @@ Java_network_loki_messenger_libsession_1util_GroupKeysConfig_makeSubAccount(JNIE
                                                                             jstring session_id,
                                                                             jboolean can_write,
                                                                             jboolean can_delete) {
-    auto ptr = ptrToKeys(env, thiz);
-    auto new_subaccount_key = ptr->swarm_make_subaccount(jni_utils::JavaStringRef(env, session_id).view(), can_write, can_delete);
-    return util::bytes_from_vector(env, new_subaccount_key).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jbyteArray>(env, [=] {
+        auto new_subaccount_key = ptrToKeys(env, thiz)->swarm_make_subaccount(
+                jni_utils::JavaStringRef(env, session_id).view(), can_write, can_delete);
+        return util::bytes_from_vector(env, new_subaccount_key).release();
+    });
 }
 
 extern "C"
@@ -218,18 +223,21 @@ Java_network_loki_messenger_libsession_1util_GroupKeysConfig_getSubAccountToken(
                                                                                 jstring session_id,
                                                                                 jboolean can_write,
                                                                                 jboolean can_delete) {
-    auto ptr = ptrToKeys(env, thiz);
-    auto token = ptr->swarm_subaccount_token(jni_utils::JavaStringRef(env, session_id).view(), can_write, can_delete);
-    return util::bytes_from_vector(env, token).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jbyteArray>(env, [=] {
+        auto token = ptrToKeys(env, thiz)->swarm_subaccount_token(
+                jni_utils::JavaStringRef(env, session_id).view(),
+                can_write, can_delete);
+        return util::bytes_from_vector(env, token).release();
+    });
 }
 
 static jni_utils::JavaLocalRef<jobject> deserialize_swarm_auth(JNIEnv *env, session::config::groups::Keys::swarm_auth auth) {
     static jni_utils::BasicJavaClassInfo class_info(
             env, "network/loki/messenger/libsession_util/GroupKeysConfig$SwarmAuth", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
 
-    auto sub_account = jni_utils::JavaLocalRef(env, env->NewStringUTF(auth.subaccount.data()));
-    auto sub_account_sig = jni_utils::JavaLocalRef(env, env->NewStringUTF(auth.subaccount_sig.data()));
-    auto signature = jni_utils::JavaLocalRef(env, env->NewStringUTF(auth.signature.data()));
+    jni_utils::JavaLocalRef sub_account(env, env->NewStringUTF(auth.subaccount.data()));
+    jni_utils::JavaLocalRef sub_account_sig(env, env->NewStringUTF(auth.subaccount_sig.data()));
+    jni_utils::JavaLocalRef signature(env, env->NewStringUTF(auth.signature.data()));
 
     return {env, env->NewObject(class_info.java_class, class_info.constructor, sub_account.get(), sub_account_sig.get(), signature.get())};
 }
@@ -240,26 +248,35 @@ Java_network_loki_messenger_libsession_1util_GroupKeysConfig_subAccountSign(JNIE
                                                                             jobject thiz,
                                                                             jbyteArray message,
                                                                             jbyteArray signing_value) {
-    auto ptr = ptrToKeys(env, thiz);
-    auto message_vector = util::vector_from_bytes(env, message);
-    auto signing_value_vector = util::vector_from_bytes(env, signing_value);
-    auto swarm_auth = ptr->swarm_subaccount_sign(message_vector, signing_value_vector, false);
-    return deserialize_swarm_auth(env, swarm_auth).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jobject>(env, [=] {
+        auto ptr = ptrToKeys(env, thiz);
+        auto message_vector = util::vector_from_bytes(env, message);
+        auto signing_value_vector = util::vector_from_bytes(env, signing_value);
+        auto swarm_auth = ptr->swarm_subaccount_sign(message_vector, signing_value_vector, false);
+        return deserialize_swarm_auth(env, swarm_auth).release();
+    });
 }
 
 extern "C"
 JNIEXPORT jbyteArray JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_supplementFor(JNIEnv *env,
                                                                            jobject thiz,
                                                                            jobjectArray j_user_session_ids) {
-    auto ptr = ptrToKeys(env, thiz);
-    std::vector<std::string> user_session_ids;
-    for (int i = 0, size = env->GetArrayLength(j_user_session_ids); i < size; i++) {
-        user_session_ids.push_back(jni_utils::JavaStringRef(env, jni_utils::JavaLocalRef(env, (jstring)(env->GetObjectArrayElement(j_user_session_ids, i))).get()).copy());
-    }
-    auto supplement = ptr->key_supplement(user_session_ids);
-    return util::bytes_from_vector(env, supplement).release();
+    return jni_utils::run_catching_cxx_exception_or_throws<jbyteArray>(env, [=] {
+        auto ptr = ptrToKeys(env, thiz);
+        std::vector<std::string> user_session_ids;
+        for (int i = 0, size = env->GetArrayLength(j_user_session_ids); i < size; i++) {
+            jni_utils::JavaLocalRef element(
+                    env, (jstring)(env->GetObjectArrayElement(j_user_session_ids, i)));
+
+            user_session_ids.emplace_back(jni_utils::JavaStringRef(env, element.get()).view());
+        }
+
+        auto supplement = ptr->key_supplement(user_session_ids);
+        return util::bytes_from_vector(env, supplement).release();
+    });
 }
+
 extern "C"
 JNIEXPORT jint JNICALL
 Java_network_loki_messenger_libsession_1util_GroupKeysConfig_currentGeneration(JNIEnv *env,

library/src/main/java/network/loki/messenger/libsession_util/util/Conversation.kt

@@ -24,6 +24,14 @@ sealed interface Conversation {
             genIndexHash = Bytes(genIndexHash),
             expiry = Instant.ofEpochMilli(expiryMs)
         )
+
+        @get:Keep
+        val genIndexHashBytes: ByteArray
+            get() = genIndexHash.data
+
+        @get:Keep
+        val expiryUnixTs: Long
+            get() = expiry.toEpochMilli()
     }
 
     /**