pakstr 0.0.4 → 0.2.0

package/android-template/app/src/main/java/com/pakstr/app/signer/NostrBridge.kt

@@ -4,93 +4,358 @@ import android.os.Handler
 import android.os.Looper
 import android.webkit.JavascriptInterface
 import android.webkit.WebView
-import android.widget.Toast
+
+import com.pakstr.app.debug.AppDebugLogger
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import org.json.JSONObject
 
 class NostrBridge(
-
     private val webView: WebView,
-
     private val signerManager: SignerManager
-
 ) {
 
     private val mainHandler = Handler(Looper.getMainLooper())
 
+    private val scope = CoroutineScope(
+        SupervisorJob() + Dispatchers.IO
+    )
+
     @JavascriptInterface
-    fun call(method: String, callbackId: String, payload: String?) {
+    fun call(
+        method: String,
+        callbackId: String,
+        payload: String?
+    ) {
 
         when (method) {
 
             "getPublicKey" -> {
 
-                CoroutineScope(Dispatchers.IO).launch {
+                scope.launch {
 
                     try {
+                        val pk =
+                            signerManager
+                                .getSigner()
+                                .getPublicKey()
+                        resolve(
+                            callbackId,
+                            pk
+                        )
+                    } catch (e: SignerUnavailableException) {
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
+                        )
 
-                        val pk = signerManager
+                    } catch (e: Exception) {
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
+                    }
+                }
+            }
 
-                            .getSigner()
+            "signEvent" -> {
+                AppDebugLogger.log(
+                    "NOSTR_SIGN",
+                    "Signing event request"
+                )
 
-                            .getPublicKey()
+                scope.launch {
 
-                        resolve(callbackId, pk)
+                    try {
+                        require(!payload.isNullOrBlank()) {
+                            "Event payload is empty"
+                        }
 
-                    } catch (e: Exception) {
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .signEvent(
+                                    payload
+                                )
 
-                        showToast(
+                        resolve(
+                            callbackId,
+                            result
+                        )
 
-                            e.message ?: "Signer error"
+                    } catch (e: SignerUnavailableException) {
 
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
                         )
 
+                    } catch (e: Exception) {
                         resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
+                    }
+                }
+            }
+
+            "nip04_encrypt" -> {
 
+                scope.launch {
+
+                    try {
+
+                        require(!payload.isNullOrBlank()) {
+                            "NIP04 encrypt payload is empty"
+                        }
+
+                        val json =
+                            JSONObject(payload)
+
+                        val pubkey =
+                            json.getString("pubkey")
+
+                        val plaintext =
+                            json.getString("plaintext")
+
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip04Encrypt(
+                                    pubkey,
+                                    plaintext
+                                )
+
+
+                        resolve(
                             callbackId,
+                            result
+                        )
 
-                            ""
+                    } catch (e: SignerUnavailableException) {
 
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
                         )
 
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
                     }
+                }
+            }
+
+
+            "nip04_decrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        require(!payload.isNullOrBlank()) {
+                            "NIP04 decrypt payload is empty"
+                        }
+
+
+                        val json =
+                            JSONObject(payload)
+
+                        val pubkey =
+                            json.getString("pubkey")
+
+                        val ciphertext =
+                            json.getString("ciphertext")
+
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip04Decrypt(
+                                    pubkey,
+                                    ciphertext
+                                )
 
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+
+                    } catch (e: SignerUnavailableException) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_UNAVAILABLE",
+                                e.message ?: "Signer unavailable"
+                            )
+                        )
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: "Unknown signer error"
+                            )
+                        )
+                    }
                 }
+            }
+
+            "nip44_encrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        val json =
+                            JSONObject(payload ?: "")
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip44Encrypt(
+                                    json.getString("pubkey"),
+                                    json.getString("plaintext")
+                                )
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
 
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: ""
+                            )
+                        )
+                    }
+                }
             }
 
-            "signEvent" -> {
-                CoroutineScope(Dispatchers.IO).launch {
-                    val result = signerManager.getSigner().signEvent(payload ?: "")
-                    resolve(callbackId, result)
+            "nip44_decrypt" -> {
+
+                scope.launch {
+
+                    try {
+
+                        val json =
+                            JSONObject(payload ?: "")
+
+                        val result =
+                            signerManager
+                                .getSigner()
+                                .nip44Decrypt(
+                                    json.getString("pubkey"),
+                                    json.getString("ciphertext")
+                                )
+
+                        resolve(
+                            callbackId,
+                            result
+                        )
+
+
+                    } catch (e: Exception) {
+
+                        resolve(
+                            callbackId,
+                            errorResponse(
+                                "SIGNER_ERROR",
+                                e.message ?: ""
+                            )
+                        )
+                    }
                 }
             }
-        }
-    }
 
-    private fun resolve(callbackId: String, result: String) {
-        mainHandler.post {
-            val js = "window.__nostrResolve('$callbackId', '$result')"
-            webView.evaluateJavascript(js, null)
+            else -> {
+
+                resolve(
+                    callbackId,
+                    ""
+                )
+            }
         }
     }
 
-    private fun showToast(message: String) {
+    private fun resolve(
+        callbackId: String,
+        result: String
+    ) {
+
+        AppDebugLogger.log(
+            "NOSTR_BRIDGE",
+            "Bridge response received"
+        )
 
         mainHandler.post {
 
-            Toast.makeText(
+            val js =
+                """
+            window.__nostrResolve(
+                ${JSONObject.quote(callbackId)},
+                ${JSONObject.quote(result)}
+            );
+            """.trimIndent()
 
-                webView.context,
+            webView.evaluateJavascript(js, null)
+        }
+    }
 
-                message,
+    private fun errorResponse(
+        code: String,
+        message: String
+    ): String {
 
-                Toast.LENGTH_LONG
+        return JSONObject()
+            .apply {
 
-            ).show()
+                put(
+                    "error",
+                    code
+                )
 
-        }
+                put(
+                    "message",
+                    message
+                )
 
+            }
+            .toString()
     }
-}
+}

package/android-template/app/src/main/java/com/pakstr/app/signer/NostrEventBuilder.kt

@@ -0,0 +1,39 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.crypto.NostrEventHasher
+import org.json.JSONObject
+
+/**
+ * Builds Nostr events before signing.
+ *
+ * Generates the event ID according to Nostr event hashing rules
+ * and adds it to the event JSON.
+ *
+ * The generated ID is later used as the message that gets signed
+ * by the external signer (e.g. Amber).
+ */
+object NostrEventBuilder {
+
+    /**
+     * Calculates and adds the Nostr event ID.
+     *
+     * @param event unsigned Nostr event JSON
+     * @return the same event containing the generated "id" field
+     */
+    fun addId(
+        event: JSONObject
+    ): JSONObject {
+
+        val id = NostrEventHasher.hashEvent(
+            event
+        )
+
+        event.put(
+            "id", id
+        )
+
+        return event
+
+    }
+
+}

package/android-template/app/src/main/java/com/pakstr/app/signer/SignerManager.kt

@@ -1,148 +1,178 @@
 package com.pakstr.app.signer
 
 import android.content.Context
+import android.content.Intent
 import androidx.activity.result.ActivityResult
+import androidx.activity.result.ActivityResultLauncher
 import com.pakstr.app.signer.interfaces.NostrSigner
-
+import androidx.core.content.edit
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+
+/**
+ * Manages Nostr signer selection and lifecycle.
+ *
+ * Provides a single access point for obtaining the active NostrSigner
+ * implementation used by the application.
+ *
+ * Supported signer types:
+ *
+ * - Amber
+ *      External Android signer app using the nostrsigner URI scheme.
+ *
+ * - Fake
+ *      Test signer used for development and testing.
+ *
+ * - Bunker
+ *      Reserved for NIP-46 remote signer implementation.
+ *
+ * The selected signer type is persisted using SharedPreferences.
+ * The signer instance is cached and recreated only when the user
+ * changes the active signer.
+ */
 class SignerManager(
-    private val context: Context,
-    private val launchAmber: (android.content.Intent) -> Unit
+    context: Context,
+    private val amberLauncher: ActivityResultLauncher<Intent>
 ) {
+    private val context =
+        context.applicationContext
 
     private val prefs =
-        context.getSharedPreferences(
+        this.context.getSharedPreferences(
             "signer",
             Context.MODE_PRIVATE
         )
 
-
     private var activeSigner: NostrSigner? = null
 
+    private var currentUserPubkey: String? = null
 
     fun getActiveType(): SignerType? {
 
-        return prefs.getString(
-            "type",
-            null
-        )?.let {
+        val value =
+            prefs.getString(
+                "type",
+                SignerType.AMBER.name
+            )
 
-            SignerType.valueOf(it)
+        return try {
+            SignerType.valueOf(value.toString())
 
+        } catch (_: IllegalArgumentException) {
+            SignerType.AMBER
         }
-
     }
 
+    suspend fun getCurrentUserPubkey(): String {
 
-    fun setActiveType(type: SignerType) {
+        currentUserPubkey?.let {
 
-        prefs.edit()
-            .putString(
-                "type",
-                type.name
-            )
-            .apply()
+            return it
 
+        }
 
-        activeSigner = null
+        val pk =
 
-    }
+            getSigner()
 
+                .getPublicKey()
 
-    fun getSigner(): NostrSigner {
+        currentUserPubkey = pk
+
+        return pk
+
+    }
 
+    fun setActiveType(
+        type: SignerType
+    ) {
 
-        if (activeSigner != null) {
-            return activeSigner!!
+        prefs.edit {
+            putString(
+                "type",
+                type.name
+            )
         }
 
+        activeSigner = null
+    }
+
+    /**
+     * Returns the currently selected signer implementation.
+     *
+     * Creates the signer lazily on first request and reuses the same
+     * instance until the signer type changes.
+     */
+    fun getSigner(): NostrSigner {
 
-        activeSigner =
+        activeSigner?.let {
+            return it
+        }
 
-            when(getActiveType()) {
+        val signer =
+            when (getActiveType()) {
 
                 SignerType.AMBER -> {
 
                     if (!isAmberInstalled()) {
-
+                        throw SignerUnavailableException(
+                            "Amber signer application is not installed"
+                        )
                     }
 
                     AmberSigner(
-
-                        context,
-
-                        launchAmber
-
+                        amberLauncher
                     )
-
                 }
 
                 SignerType.BUNKER -> {
+                    throw SignerUnavailableException(
+                        "Bunker signer is not implemented"
+                    )
+                }
 
+                SignerType.FAKE -> {
                     FakeSigner()
-
                 }
 
                 null -> {
 
                     throw IllegalStateException(
-
                         "No signer selected"
-
                     )
-
-                }
-
-                else -> {
-
-                    FakeSigner()
-
                 }
-
             }
 
+        activeSigner = signer
 
-        return activeSigner!!
-
-    }
-
-
-
-    fun handleAmberResult(
-        result: ActivityResult
-    ) {
-
-        val signer =
-            activeSigner
-
-
-        if (signer is AmberSigner) {
-
-            signer.handleResult(result)
-
-        }
-
+        return signer
     }
 
     private fun isAmberInstalled(): Boolean {
 
         return try {
 
-            context.packageManager.getPackageInfo(
-
-                "com.greenart7c3.nostrsigner",
-
-                0
-
-            )
+            context.packageManager
+                .getPackageInfo(
+                    "com.greenart7c3.nostrsigner",
+                    0
+                )
 
             true
 
-        } catch (e: Exception) {
+        } catch (_: Exception) {
 
             false
-
         }
-
     }
 
+    /**
+     * Forwards Android Activity results back to the active Amber signer.
+     *
+     * Required because Amber communication is based on the Android
+     * Activity Result API.
+     */
+    fun handleAmberResult(result: ActivityResult) {
+        (activeSigner as? AmberSigner)
+            ?.onResult(result)
+    }
 }

package/android-template/app/src/main/java/com/pakstr/app/signer/SignerType.kt

@@ -2,7 +2,6 @@ package com.pakstr.app.signer
 
 enum class SignerType {
     AMBER,
-
     BUNKER,
     FAKE
 

package/android-template/app/src/main/java/com/pakstr/app/signer/exceptions/SignerUnavailableException.kt

@@ -0,0 +1,5 @@
+package com.pakstr.app.signer.exceptions
+
+class SignerUnavailableException(
+    message: String
+) : Exception(message)

package/android-template/app/src/main/java/com/pakstr/app/signer/interfaces/NostrSigner.kt

@@ -22,4 +22,14 @@ interface NostrSigner {
 
     ): String
 
+    suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String
+
+    suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String
+
 }