@baerae/zkap-zkp-react-native 0.1.0 → 0.1.2

package/android/build.gradle

@@ -24,6 +24,8 @@ repositories {
 
 dependencies {
   implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:1.9.0"
+  // JNA is required by uniffi-generated Kotlin bindings
+  implementation "net.java.dev.jna:jna:5.14.0@aar"
   // expo-modules-core provides Module, ModuleDefinition, AsyncFunction, etc.
   // compileOnly: provided by the consumer app at runtime
   compileOnly project(':expo-modules-core')

package/android/src/main/java/expo/modules/zkap/ZkapSdkModule.kt

@@ -2,63 +2,152 @@ package expo.modules.zkap
 
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
+import org.json.JSONArray
+import org.json.JSONObject
+import uniffi.zkap_uniffi_bindings.*
 
+@OptIn(kotlin.ExperimentalUnsignedTypes::class)
 class ZkapSdkModule : Module() {
 
-    // Load the native Rust library (built as libzkap_zkp_rn.so)
-    companion object {
-        init {
-            System.loadLibrary("zkap_zkp_rn")
-        }
-
-        // JNI-compatible native methods (no underscores → no name-mangling issues).
-        // Corresponding Rust symbol: Java_expo_modules_zkap_ZkapSdkModule_native<X>
-        // Each JNI wrapper in Rust calls the C-ABI function, copies the result into
-        // a Java String, and frees the Rust allocation — no memory leak.
-        @JvmStatic external fun nativeGenerateHash(inputJson: String): String
-        @JvmStatic external fun nativeGenerateAnchor(inputJson: String): String
-        @JvmStatic external fun nativeGenerateAudHash(inputJson: String): String
-        @JvmStatic external fun nativeGenerateLeafHash(inputJson: String): String
-        @JvmStatic external fun nativeProve(inputJson: String): String
-    }
-
     override fun definition() = ModuleDefinition {
         Name("ZkapSdk")
 
         AsyncFunction("generateHash") { inputJson: String ->
-            unwrapResult(nativeGenerateHash(inputJson))
-        }
-
-        AsyncFunction("generateAnchor") { inputJson: String ->
-            unwrapResult(nativeGenerateAnchor(inputJson))
+            try {
+                val obj = JSONObject(inputJson)
+                val messagesArr = obj.getJSONArray("messages")
+                val messages = List(messagesArr.length()) { messagesArr.getString(it) }
+                val result = generateHash(messages)
+                JSONObject().put("result", result).toString()
+            } catch (e: ZkapException) {
+                throw ZkapError(e.message ?: "ZkapException")
+            }
         }
 
         AsyncFunction("generateAudHash") { inputJson: String ->
-            unwrapResult(nativeGenerateAudHash(inputJson))
+            try {
+                val obj = JSONObject(inputJson)
+                val config = parseConfig(obj.getJSONObject("config"))
+                val audArr = obj.getJSONArray("aud_list")
+                val audList = List(audArr.length()) { audArr.getString(it) }
+                val result = generateAudHash(config, audList)
+                val audHashesArr = JSONArray(result.audHashes)
+                JSONObject()
+                    .put("aud_hashes", audHashesArr)
+                    .put("h_aud_list", result.hAudList)
+                    .toString()
+            } catch (e: ZkapException) {
+                throw ZkapError(e.message ?: "ZkapException")
+            }
         }
 
         AsyncFunction("generateLeafHash") { inputJson: String ->
-            unwrapResult(nativeGenerateLeafHash(inputJson))
+            try {
+                val obj = JSONObject(inputJson)
+                val config = parseConfig(obj.getJSONObject("config"))
+                val iss = obj.getString("iss")
+                val pkB64 = obj.getString("pk_b64")
+                val result = generateLeafHash(config, iss, pkB64)
+                JSONObject().put("result", result).toString()
+            } catch (e: ZkapException) {
+                throw ZkapError(e.message ?: "ZkapException")
+            }
         }
 
-        AsyncFunction("prove") { inputJson: String ->
-            unwrapResult(nativeProve(inputJson))
+        AsyncFunction("generateAnchor") { inputJson: String ->
+            try {
+                val obj = JSONObject(inputJson)
+                val config = parseConfig(obj.getJSONObject("config"))
+                val secretsArr = obj.getJSONArray("secrets")
+                val secrets = List(secretsArr.length()) { i ->
+                    val s = secretsArr.getJSONObject(i)
+                    ZkapSecret(sub = s.getString("sub"), iss = s.getString("iss"), aud = s.getString("aud"))
+                }
+                val result = generateAnchor(config, secrets)
+                JSONObject().put("evaluations", JSONArray(result.evaluations)).toString()
+            } catch (e: ZkapException) {
+                throw ZkapError(e.message ?: "ZkapException")
+            }
         }
-    }
 
-    /** Parse JSON result from Rust FFI. Throws if the result contains an "error" field. */
-    @Suppress("UNCHECKED_CAST")
-    private fun unwrapResult(json: String): String {
-        try {
-            val obj = org.json.JSONObject(json)
-            if (obj.has("error")) {
-                throw ZkapException(obj.getString("error"))
+        AsyncFunction("prove") { inputJson: String ->
+            try {
+                val obj = JSONObject(inputJson)
+                val config = parseConfig(obj.getJSONObject("config"))
+                val req = obj.getJSONObject("request")
+
+                val jwtsArr = req.getJSONArray("jwts")
+                val jwts = List(jwtsArr.length()) { jwtsArr.getString(it) }
+
+                val pkOpsArr = req.getJSONArray("pk_ops")
+                val pkOps = List(pkOpsArr.length()) { pkOpsArr.getString(it) }
+
+                val merklePathsArr = req.getJSONArray("merkle_paths")
+                val merklePaths = List(merklePathsArr.length()) { i ->
+                    val inner = merklePathsArr.getJSONArray(i)
+                    List(inner.length()) { j -> inner.getString(j) }
+                }
+
+                val leafIndicesArr = req.getJSONArray("leaf_indices")
+                val leafIndices = List(leafIndicesArr.length()) { leafIndicesArr.getLong(it).toULong() }
+
+                val anchorEvalsArr = req.getJSONArray("anchor_evals")
+                val anchorEvals = List(anchorEvalsArr.length()) { anchorEvalsArr.getString(it) }
+
+                val audHashListArr = req.getJSONArray("aud_hash_list")
+                val audHashList = List(audHashListArr.length()) { audHashListArr.getString(it) }
+
+                val request = ZkapProofRequest(
+                    pkPath = req.getString("pk_path"),
+                    jwts = jwts,
+                    pkOps = pkOps,
+                    merklePaths = merklePaths,
+                    leafIndices = leafIndices,
+                    root = req.getString("root"),
+                    anchorEvals = anchorEvals,
+                    hanchor = req.getString("hanchor"),
+                    hSignUserOp = req.getString("h_sign_user_op"),
+                    random = req.getString("random"),
+                    audHashList = audHashList
+                )
+
+                val output = prove(config, request)
+
+                val proofsArr = JSONArray()
+                for (proofList in output.proofs) {
+                    proofsArr.put(JSONArray(proofList))
+                }
+
+                JSONObject()
+                    .put("proofs", proofsArr)
+                    .put("shared_inputs", JSONArray(output.sharedInputs))
+                    .put("partial_rhs_list", JSONArray(output.partialRhsList))
+                    .put("jwt_exp_list", JSONArray(output.jwtExpList))
+                    .toString()
+            } catch (e: ZkapException) {
+                throw ZkapError(e.message ?: "ZkapException")
             }
-        } catch (e: org.json.JSONException) {
-            // Not a JSON object — return as-is
         }
-        return json
+    }
+
+    private fun parseConfig(obj: JSONObject): ZkapCircuitConfig {
+        val claimsArr = obj.getJSONArray("claims")
+        return ZkapCircuitConfig(
+            maxJwtB64Len = obj.getLong("max_jwt_b64_len").toULong(),
+            maxPayloadB64Len = obj.getLong("max_payload_b64_len").toULong(),
+            maxAudLen = obj.getLong("max_aud_len").toULong(),
+            maxExpLen = obj.getLong("max_exp_len").toULong(),
+            maxIssLen = obj.getLong("max_iss_len").toULong(),
+            maxNonceLen = obj.getLong("max_nonce_len").toULong(),
+            maxSubLen = obj.getLong("max_sub_len").toULong(),
+            n = obj.getLong("n").toULong(),
+            k = obj.getLong("k").toULong(),
+            treeHeight = obj.getLong("tree_height").toULong(),
+            numAudienceLimit = obj.getLong("num_audience_limit").toULong(),
+            claims = List(claimsArr.length()) { claimsArr.getString(it) },
+            forbiddenString = obj.getString("forbidden_string")
+        )
     }
 }
 
-class ZkapException(message: String) : Exception("[zkap] $message")
+class ZkapError(message: String) : Exception("[zkap] $message")