pakstr 0.0.4 → 0.1.0

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

@@ -1,167 +1,209 @@
 package com.pakstr.app.signer
 
 import android.app.Activity
-import android.content.Context
+import android.content.ActivityNotFoundException
 import android.content.Intent
+import android.net.Uri
 import androidx.activity.result.ActivityResult
+import androidx.activity.result.ActivityResultLauncher
+import com.pakstr.app.crypto.NostrEventVerifier
+import com.pakstr.app.debug.AppDebugLogger
 import com.pakstr.app.signer.interfaces.NostrSigner
-import kotlinx.coroutines.CancellableContinuation
 import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeout
+import org.json.JSONObject
 import kotlin.coroutines.resume
 
-
+/**
+ * NIP-07 signer implementation using Amber as an external signer.
+ *
+ * This class communicates with the Amber app through Android intents.
+ * The private key never leaves Amber. This app only sends signing requests
+ * and receives public keys or signatures back.
+ *
+ * Supported operations:
+ *
+ * - getPublicKey()
+ *      Requests the user's public key from Amber.
+ *
+ * - signEvent(eventJson)
+ *      Sends an unsigned Nostr event to Amber for signing.
+ *      After receiving the signature, the event ID is generated and the
+ *      signature is locally verified before returning the signed event.
+ *
+ * The class uses suspendCancellableCoroutine to bridge the asynchronous
+ * Android Activity Result API with Kotlin coroutines.
+ */
 class AmberSigner(
-    private val context: Context,
-    private val launchIntent: (Intent) -> Unit
+    private val launcher: ActivityResultLauncher<Intent>
 ) : NostrSigner {
 
+    // Stores the current pending signer request.
+    // Android intents return results asynchronously, so the callback is used
+    // to resume the suspended coroutine when Amber responds.
+    private var pendingCallback: ((String) -> Unit)? = null
 
-    private var pendingPublicKey:
-            CancellableContinuation<String>? = null
-
-
-
-    override suspend fun getPublicKey(): String {
-
-        return suspendCancellableCoroutine { cont ->
+    override suspend fun getPublicKey(): String = withTimeout(30_000) {
 
-            pendingPublicKey = cont
+        suspendCancellableCoroutine { continuation ->
 
-            val intent = Intent().apply {
-
-                action =
-
-                    "com.greenart7c3.nostrsigner.GET_PUBLIC_KEY"
+            pendingCallback = { pubkey ->
 
+                if (continuation.isActive) {
+                    continuation.resume(pubkey)
+                }
             }
 
-            val activities =
-
-                context.packageManager.queryIntentActivities(
+            val intent = Intent(
+                Intent.ACTION_VIEW
+            ).apply {
 
-                    intent,
-
-                    0
+                data = Uri.parse(
+                    "nostrsigner:?type=get_public_key"
+                )
 
+                putExtra(
+                    "type", "get_public_key"
                 )
 
-            if (activities.isEmpty()) {
-                activities.forEach {
+            }
 
-                    println(
+            try {
 
-                        "Amber activity: ${it.activityInfo.packageName}/${it.activityInfo.name}"
+                launcher.launch(intent)
 
-                    )
+            } catch (_: ActivityNotFoundException) {
 
+                if (continuation.isActive) {
+                    continuation.resume("")
                 }
-                pendingPublicKey = null
-
-                cont.resumeWith(
-
-                    Result.failure(
-
-                        Exception(
-
-                            "Amber signer is not installed. Please install Amber to continue."
-
-                        )
-
-                    )
-
-                )
-
-                return@suspendCancellableCoroutine
-
             }
 
-            launchIntent(intent)
-
+            continuation.invokeOnCancellation {
+                pendingCallback = null
+            }
         }
-
     }
 
+    override suspend fun signEvent(
+        eventJson: String
+    ): String =
 
+        withTimeout(30_000) {
 
-    fun handleResult(
-        result: ActivityResult
-    ) {
-
-        if (result.resultCode != Activity.RESULT_OK) {
+            suspendCancellableCoroutine { continuation ->
 
-            pendingPublicKey?.resumeWith(
-                Result.failure(
-                    Exception(
-                        "Amber cancelled"
-                    )
-                )
-            )
+                val event = JSONObject(eventJson)
 
-            pendingPublicKey = null
+                pendingCallback = { signature ->
 
-            return
+                    if (signature.isEmpty()) {
 
-        }
+                        if (continuation.isActive) {
 
+                            continuation.resume("")
 
-        val pubkey =
-            result.data
-                ?.getStringExtra("pubkey")
+                        }
 
+                    } else {
 
-        if (pubkey != null) {
+                        val signedEvent =
 
-            pendingPublicKey?.resume(
-                pubkey
-            )
+                            NostrEventBuilder.addId(event)
+                                .apply {
 
-        } else {
+                                    put(
+                                        "sig", signature
+                                    )
 
-            pendingPublicKey?.resumeWith(
-                Result.failure(
-                    Exception(
-                        "No public key returned"
-                    )
-                )
-            )
+                                }
+                        // Verify the signed event locally before returning it.
+                        // This ensures that the received signature matches the event data
+                        // and protects against invalid signer responses.
+                        val verified = NostrEventVerifier.verify(signedEvent)
 
-        }
+                        AppDebugLogger.log(
+                            "NOSTR_VERIFY", "Event verified=$verified"
+                        )
 
+                        if (continuation.isActive) {
+                            if (verified) {
+                                continuation.resume(
+                                    signedEvent.toString()
+                                )
+
+                            } else {
+                                continuation.resume("")
+                            }
+                        }
+                    }
+                }
 
-        pendingPublicKey = null
+                val intent = Intent(
+                    Intent.ACTION_VIEW, Uri.parse(
+                        "nostrsigner:${Uri.encode(event.toString())}"
+                    )
+                ).apply {
+                    putExtra(
+                        "type", "sign_event"
+                    )
+                }
+                try {
+                    launcher.launch(intent)
 
-    }
+                } catch (_: ActivityNotFoundException) {
 
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
 
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
+        }
 
-    override suspend fun signEvent(
-        eventJson: String
+    override suspend fun nip04Encrypt(
+        pubkey: String, plaintext: String
     ): String {
 
-        TODO()
-
+        throw NotImplementedError(
+            "NIP04 not implemented"
+        )
     }
 
+    override suspend fun nip04Decrypt(
+        pubkey: String, ciphertext: String
+    ): String {
 
+        throw NotImplementedError(
+            "NIP04 not implemented"
+        )
+    }
 
-    override suspend fun nip04Encrypt(
-        pubkey: String,
-        plaintext: String
-    ): String {
+    fun onResult(
+        result: ActivityResult
+    ) {
 
-        TODO()
+        val callback = pendingCallback
 
-    }
+        pendingCallback = null
 
+        if (result.resultCode != Activity.RESULT_OK) {
+            callback?.let {
+                it("")
+            }
+            return
 
+        }
 
-    override suspend fun nip04Decrypt(
-        pubkey: String,
-        ciphertext: String
-    ): String {
+        val value =
 
-        TODO()
+            result.data?.getStringExtra("result") ?: result.data?.getStringExtra("signature") ?: ""
 
+        callback?.invoke(
+            value
+        )
     }
-
 }

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

@@ -4,93 +4,169 @@ 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"
+                            )
                         )
-
                     }
-
                 }
-
             }
 
-            "signEvent" -> {
-                CoroutineScope(Dispatchers.IO).launch {
-                    val result = signerManager.getSigner().signEvent(payload ?: "")
-                    resolve(callbackId, result)
-                }
+            else -> {
+
+                resolve(
+                    callbackId,
+                    ""
+                )
             }
         }
     }
 
-    private fun resolve(callbackId: String, result: String) {
-        mainHandler.post {
-            val js = "window.__nostrResolve('$callbackId', '$result')"
-            webView.evaluateJavascript(js, null)
-        }
-    }
+    private fun resolve(
+        callbackId: String,
+        result: String
+    ) {
 
-    private fun showToast(message: 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
+
+    }
+
+}