Add addProPayment/getProProof integration

Author: SessionHero01

library/src/main/cpp/CMakeLists.txt

@@ -95,6 +95,8 @@ set(SOURCES
         attachments.cpp
         webp_utils.cpp
         gif_utils.cpp
+        pro_backend.cpp
+        pro_proof.cpp
 
         ${cgif_SOURCE_DIR}/src/cgif.c
         ${cgif_SOURCE_DIR}/src/cgif_rgb.c

library/src/main/cpp/jni_utils.h

@@ -194,6 +194,10 @@ namespace jni_utils {
             std::span<char> get() const {
                 return data;
             }
+
+            std::span<uint8_t> get_raw() const {
+                return std::span<uint8_t>(reinterpret_cast<uint8_t *>(data.data()), data.size());
+            }
     };
 
     /**

library/src/main/cpp/pro_backend.cpp

@@ -0,0 +1,84 @@
+#include <jni.h>
+#include "jni_utils.h"
+#include "util.h"
+
+#include <session/pro_backend.hpp>
+
+using namespace jni_utils;
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_network_loki_messenger_libsession_1util_pro_AddProPaymentRequests_buildJson(JNIEnv *env,
+                                                                                 jobject thiz,
+                                                                                 jint version,
+                                                                                 jbyteArray master_private_key,
+                                                                                 jbyteArray rotating_private_key,
+                                                                                 jint payment_provider,
+                                                                                 jstring payment_transaction_id,
+                                                                                 jstring payment_order_id) {
+    return run_catching_cxx_exception_or_throws<jstring>(env, [=]() {
+        return util::jstringFromOptional(env, session::pro_backend::AddProPaymentRequest::build_to_json(
+                version,
+                JavaByteArrayRef(env, master_private_key).get(),
+                JavaByteArrayRef(env, rotating_private_key).get(),
+                static_cast<SESSION_PRO_BACKEND_PAYMENT_PROVIDER>(payment_provider),
+                JavaStringRef(env, payment_transaction_id).get_raw(),
+                JavaStringRef(env, payment_order_id).get_raw()
+                )
+        );
+    });
+}
+
+
+extern "C"
+JNIEXPORT jobject JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProofResponse_00024Companion_nativeParseRaw(
+        JNIEnv *env, jobject thiz, jstring json) {
+    return run_catching_cxx_exception_or_throws<jobject>(env, [=]() {
+        auto response = session::pro_backend::AddProPaymentOrGetProProofResponse::parse(
+                JavaStringRef(env, json).view()
+        );
+
+        if (response.errors.empty()) {
+            JavaLocalRef<jclass> pro_proof_class(env, env->FindClass("network/loki/messenger/libsession_util/pro/ProProof"));
+            JavaLocalRef<jclass> success_class(env, env->FindClass("network/loki/messenger/libsession_util/pro/ProProofResponse$Success"));
+
+            return env->NewObject(
+                    success_class.get(),
+                    env->GetMethodID(success_class.get(), "<init>", "(Lnetwork/loki/messenger/libsession_util/pro/ProProof;)V"),
+                    env->NewObject(
+                            pro_proof_class.get(),
+                            env->GetMethodID(pro_proof_class.get(), "<init>", "(J)V"),
+                            reinterpret_cast<jlong>(new session::ProProof(response.proof))
+                    )
+            );
+        }
+
+        JavaLocalRef<jclass> error_class(env, env->FindClass("network/loki/messenger/libsession_util/pro/ProProofResponse$Failure"));
+
+        return env->NewObject(
+                error_class.get(),
+                env->GetMethodID(error_class.get(), "<init>", "(ILjava/util/List;)V"),
+                static_cast<jint>(response.status),
+                jstring_list_from_collection(env, response.errors)
+        );
+    });
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_network_loki_messenger_libsession_1util_pro_GetProProofRequests_buildJson(JNIEnv *env,
+                                                                               jint version,
+                                                                               jobject thiz,
+                                                                               jbyteArray master_private_key,
+                                                                               jbyteArray rotating_private_key,
+                                                                               jlong now_unix_ts) {
+    return run_catching_cxx_exception_or_throws<jstring>(env, [=] () {
+        return util::jstringFromOptional(env, session::pro_backend::GetProProofRequest::build_to_json(
+                version,
+                JavaByteArrayRef(env, master_private_key).get(),
+                JavaByteArrayRef(env, rotating_private_key).get(),
+                std::chrono::sys_time<std::chrono::milliseconds> { std::chrono::milliseconds{static_cast<int64_t>(now_unix_ts)} }
+        ));
+    });
+}

library/src/main/cpp/pro_proof.cpp

@@ -0,0 +1,54 @@
+#include <session/session_protocol.hpp>
+
+#include <jni.h>
+#include "util.h"
+
+
+extern "C"
+JNIEXPORT jint JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeGetVersion(
+        JNIEnv *env, jobject thiz, jlong native_value) {
+    return static_cast<jint>(
+            reinterpret_cast<session::ProProof*>(native_value)->version);
+}
+
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeGetExpiry(
+        JNIEnv *env, jobject thiz, jlong native_value) {
+    return static_cast<jlong>(
+            reinterpret_cast<session::ProProof*>(native_value)->expiry_unix_ts.time_since_epoch().count());
+}
+
+extern "C"
+JNIEXPORT jbyteArray JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeGetRotatingPubKey(
+        JNIEnv *env, jobject thiz, jlong native_value) {
+    const auto& rotating_pubkey =
+            reinterpret_cast<session::ProProof*>(native_value)->rotating_pubkey;
+
+    return util::bytes_from_span(env, rotating_pubkey);
+}
+
+extern "C"
+JNIEXPORT jstring JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeSerialize(
+        JNIEnv *env, jobject thiz, jlong native_value) {
+    // TODO: implement nativeSerialize()
+}
+
+extern "C"
+JNIEXPORT jlong JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeDeserialize(
+        JNIEnv *env, jobject thiz, jstring data) {
+    // TODO: implement nativeDeserialize()
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_network_loki_messenger_libsession_1util_pro_ProProof_00024Companion_nativeDestroy(JNIEnv *env,
+                                                                                       jobject thiz,
+                                                                                       jlong native_value) {
+    delete reinterpret_cast<session::ProProof*>(native_value);
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/AddProPayment.kt

@@ -0,0 +1,81 @@
+package network.loki.messenger.libsession_util.pro
+
+import network.loki.messenger.libsession_util.LibSessionUtilCApi
+
+object AddProPaymentRequests : LibSessionUtilCApi() {
+    private external fun buildJson(
+        version: Int,
+        masterPrivateKey: ByteArray,
+        rotatingPrivateKey: ByteArray,
+        paymentProvider: Int,
+        paymentTransactionId: String,
+        paymentOrderId: String,
+    ): String
+
+    fun buildJson(
+        /**
+         * Version of the request to build a hash for
+         */
+        version: Int,
+        /**
+         * 64-byte libsodium style or 32 byte Ed25519 master private key
+         */
+        masterPrivateKey: ByteArray,
+
+        /**
+         * 64-byte libsodium style or 32 byte Ed25519 rotating private key
+         */
+        rotatingPrivateKey: ByteArray,
+
+        /**
+         * Provider that the payment to register is coming from
+         */
+        paymentProvider: PaymentProvider,
+
+        /**
+         * ID that is associated with the payment from the payment provider
+         */
+        paymentTransactionId: String,
+
+        /**
+         * Order ID that is associated with the payment
+         */
+        paymentOrderId: String,
+
+    ): String = buildJson(
+        version = version,
+        masterPrivateKey = masterPrivateKey,
+        rotatingPrivateKey = rotatingPrivateKey,
+        paymentProvider = paymentProvider.nativeValue,
+        paymentTransactionId = paymentTransactionId,
+        paymentOrderId = paymentOrderId,
+    )
+}
+
+
+enum class AddProPaymentError(internal val nativeValue: Int) {
+    Generic(1),
+    AlreadyRedeemed(2),
+    UnknownPayment(3),
+}
+
+
+
+object AddProPaymentResponses {
+    fun parse(jsonResponse: String): ProProofResponse<AddProPaymentError> {
+        return when (val r = ProProofResponse.parseRaw(jsonResponse)) {
+            is ProProofResponse.Failure<Int> -> {
+                ProProofResponse.Failure(
+                    status = AddProPaymentError.entries.firstOrNull {
+                        it.nativeValue == r.status
+                    } ?: AddProPaymentError.Generic,
+                    errors = r.errors,
+                )
+            }
+
+            is ProProofResponse.Success -> {
+                ProProofResponse.Success(r.proof)
+            }
+        }
+    }
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/GetProProof.kt

@@ -0,0 +1,34 @@
+package network.loki.messenger.libsession_util.pro
+
+import network.loki.messenger.libsession_util.LibSessionUtilCApi
+
+enum class GetProProofError {
+    Generic,
+}
+
+object GetProProofRequests : LibSessionUtilCApi() {
+    external fun buildJson(
+        version: Int,
+        /**
+         * 64-byte libsodium style or 32 byte Ed25519 master private key
+         */
+        masterPrivateKey: ByteArray,
+
+        /**
+         * 64-byte libsodium style or 32 byte Ed25519 rotating private key
+         */
+        rotatingPrivateKey: ByteArray,
+        nowUnixTs: Long,
+    ): String
+}
+
+object GetProProofResponses {
+    fun parse(json: String): ProProofResponse<GetProProofError> {
+        return when (val r = ProProofResponse.parseRaw(json)) {
+            is ProProofResponse.Success -> ProProofResponse.Success(r.proof)
+            is ProProofResponse.Failure -> {
+                ProProofResponse.Failure(GetProProofError.Generic, r.errors)
+            }
+        }
+    }
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/PaymentProvider.kt

@@ -0,0 +1,6 @@
+package network.loki.messenger.libsession_util.pro
+
+enum class PaymentProvider(val nativeValue: Int) {
+    GooglePlayStore(1),
+    AppleAppStore(2),
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/ProProof.kt

@@ -0,0 +1,40 @@
+package network.loki.messenger.libsession_util.pro
+
+import androidx.annotation.Keep
+import network.loki.messenger.libsession_util.LibSessionUtilCApi
+import java.time.Instant
+
+class ProProof @Keep private constructor(private val nativeValue: Long) {
+
+    val version: Int get() = nativeGetVersion(nativeValue)
+    val expiry: Instant get() = Instant.ofEpochSecond(nativeGetExpiry(nativeValue))
+    val rotatingPubKey: ByteArray get() = nativeGetRotatingPubKey(nativeValue)
+
+
+    /**
+     * Serialize the [ProProof] to a byte array for storage or transmission
+     */
+    fun serialize(): String = nativeSerialize(nativeValue)
+
+
+    protected fun finalize() {
+        nativeDestroy(nativeValue)
+    }
+
+
+    companion object : LibSessionUtilCApi() {
+        private external fun nativeGetVersion(nativeValue: Long): Int
+        private external fun nativeGetExpiry(nativeValue: Long): Long
+        private external fun nativeGetRotatingPubKey(nativeValue: Long): ByteArray
+        private external fun nativeSerialize(nativeValue: Long): String
+        private external fun nativeDeserialize(data: String): Long
+        private external fun nativeDestroy(nativeValue: Long)
+
+        /**
+         * Deserialize a [ProProof] from a byte array
+         */
+        fun deserialize(data: String): ProProof {
+            return ProProof(nativeDeserialize(data))
+        }
+    }
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/ProProofResponse.kt

@@ -0,0 +1,24 @@
+package network.loki.messenger.libsession_util.pro
+
+import androidx.annotation.Keep
+import network.loki.messenger.libsession_util.LibSessionUtilCApi
+
+
+/**
+ * Represents the response that returns a [ProProof]
+ */
+sealed interface ProProofResponse<out StatusCode> {
+    data class Success @Keep constructor(val proof: ProProof) : ProProofResponse<Nothing>
+    data class Failure<T>(val status: T, val errors: List<String>) : ProProofResponse<T>
+
+    companion object : LibSessionUtilCApi() {
+        /**
+         * Parses a raw JSON string into a [ProProofResponse] with an integer status code.
+         */
+        private external fun nativeParseRaw(json: String): ProProofResponse<Int>
+
+        internal fun parseRaw(json: String): ProProofResponse<Int> {
+            return nativeParseRaw(json)
+        }
+    }
+}

library/src/main/java/network/loki/messenger/libsession_util/pro/ResponseStatus.kt

@@ -0,0 +1,5 @@
+package network.loki.messenger.libsession_util.pro
+
+typealias ResponseStatus = Int
+
+const val RESPONSE_STATUS_SUCCESS: ResponseStatus = 200