pakstr 0.0.4 → 0.2.0

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

@@ -1,167 +1,520 @@
 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 cachedPubkey: String? = null
+    override suspend fun getPublicKey(): String {
+
+        cachedPubkey?.let {
 
-    private var pendingPublicKey:
-            CancellableContinuation<String>? = null
+            return it
 
+        }
 
+        return withTimeout(30_000) {
 
-    override suspend fun getPublicKey(): String {
+            suspendCancellableCoroutine { continuation ->
 
-        return suspendCancellableCoroutine { cont ->
+                pendingCallback = { pubkey ->
 
-            pendingPublicKey = cont
+                    cachedPubkey = pubkey
 
-            val intent = Intent().apply {
+                    if (continuation.isActive) {
 
-                action =
+                        continuation.resume(pubkey)
 
-                    "com.greenart7c3.nostrsigner.GET_PUBLIC_KEY"
+                    }
 
-            }
+                }
 
-            val activities =
+                val intent = Intent(
 
-                context.packageManager.queryIntentActivities(
+                    Intent.ACTION_VIEW
 
-                    intent,
+                ).apply {
 
-                    0
+                    data = Uri.parse(
 
-                )
+                        "nostrsigner:?type=get_public_key"
+
+                    )
 
-            if (activities.isEmpty()) {
-                activities.forEach {
+                    putExtra(
 
-                    println(
+                        "type",
 
-                        "Amber activity: ${it.activityInfo.packageName}/${it.activityInfo.name}"
+                        "get_public_key"
 
                     )
 
                 }
-                pendingPublicKey = null
 
-                cont.resumeWith(
+                try {
 
-                    Result.failure(
+                    launcher.launch(intent)
 
-                        Exception(
+                } catch (_: ActivityNotFoundException) {
 
-                            "Amber signer is not installed. Please install Amber to continue."
+                    if (continuation.isActive) {
 
-                        )
+                        continuation.resume("")
 
-                    )
+                    }
 
-                )
+                }
 
-                return@suspendCancellableCoroutine
+                continuation.invokeOnCancellation {
 
-            }
+                    pendingCallback = null
 
-            launchIntent(intent)
+                }
+
+            }
 
         }
 
     }
 
+    override suspend fun signEvent(
+        eventJson: String
+    ): String =
 
+        withTimeout(30_000) {
 
-    fun handleResult(
-        result: ActivityResult
-    ) {
+            suspendCancellableCoroutine { continuation ->
 
-        if (result.resultCode != Activity.RESULT_OK) {
+                val event = JSONObject(eventJson)
+
+                pendingCallback = { signature ->
 
-            pendingPublicKey?.resumeWith(
-                Result.failure(
-                    Exception(
-                        "Amber cancelled"
+                    if (signature.isEmpty()) {
+
+                        if (continuation.isActive) {
+
+                            continuation.resume("")
+
+                        }
+
+                    } else {
+
+                        val signedEvent =
+
+                            NostrEventBuilder.addId(event)
+                                .apply {
+
+                                    put(
+                                        "sig", signature
+                                    )
+
+                                }
+                        // 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("")
+                            }
+                        }
+                    }
+                }
+
+                val intent = Intent(
+                    Intent.ACTION_VIEW, Uri.parse(
+                        "nostrsigner:${Uri.encode(event.toString())}"
                     )
-                )
-            )
+                ).apply {
+                    putExtra(
+                        "type", "sign_event"
+                    )
+                }
+                try {
+                    launcher.launch(intent)
 
-            pendingPublicKey = null
+                } catch (_: ActivityNotFoundException) {
 
-            return
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
 
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
         }
 
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String =
+        withTimeout(30_000) {
+
+            suspendCancellableCoroutine { continuation ->
 
-        val pubkey =
-            result.data
-                ?.getStringExtra("pubkey")
+                pendingCallback = { encrypted ->
 
+                    if (continuation.isActive) {
+                        continuation.resume(encrypted)
+                    }
+                }
+
+                val intent = Intent(
+                    Intent.ACTION_VIEW
+                ).apply {
 
-        if (pubkey != null) {
+                    data = Uri.parse(
+                        "nostrsigner:?type=nip04_encrypt" +
+                                "&pubkey=$pubkey" +
+                                "&plaintext=${Uri.encode(plaintext)}"
+                    )
 
-            pendingPublicKey?.resume(
-                pubkey
-            )
+                    putExtra(
+                        "type",
+                        "nip04_encrypt"
+                    )
 
-        } else {
+                    putExtra(
+                        "pubkey",
+                        pubkey
+                    )
 
-            pendingPublicKey?.resumeWith(
-                Result.failure(
-                    Exception(
-                        "No public key returned"
+                    putExtra(
+                        "plaintext",
+                        plaintext
                     )
-                )
-            )
+                }
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
 
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
         }
 
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String = withTimeout(30_000) {
 
-        pendingPublicKey = null
+        suspendCancellableCoroutine { continuation ->
 
-    }
+            pendingCallback = { result ->
 
+                if (continuation.isActive) {
+                    continuation.resume(result)
+                }
+            }
 
+            val intent = Intent(
+                Intent.ACTION_VIEW
+            ).apply {
 
-    override suspend fun signEvent(
-        eventJson: String
-    ): String {
+                data = Uri.parse(
+                    "nostrsigner:?type=nip04_decrypt" +
+                            "&pubkey=$pubkey" +
+                            "&message=${Uri.encode(ciphertext)}"
+                )
+
+                putExtra(
+                    "type",
+                    "nip04_decrypt"
+                )
 
-        TODO()
+                putExtra(
+                    "pubkey",
+                    pubkey
+                )
 
-    }
+                putExtra(
+                    "message",
+                    ciphertext
+                )
+            }
 
+            try {
 
+                launcher.launch(intent)
+
+            } catch (_: ActivityNotFoundException) {
+
+                if (continuation.isActive) {
+                    continuation.resume("")
+                }
+            }
+
+            continuation.invokeOnCancellation {
+                pendingCallback = null
+            }
+        }
+    }
+
+    override suspend fun nip44Encrypt(
 
-    override suspend fun nip04Encrypt(
         pubkey: String,
+
         plaintext: String
-    ): String {
 
-        TODO()
+    ): String =
 
-    }
+        withTimeout(30_000) {
 
+            val currentUser = getCachedPublicKey()
 
+            suspendCancellableCoroutine { continuation ->
 
-    override suspend fun nip04Decrypt(
+                pendingCallback = { encrypted ->
+
+                    if (continuation.isActive) {
+
+                        continuation.resume(encrypted)
+
+                    }
+
+                }
+
+                val intent = Intent(
+
+                    Intent.ACTION_VIEW
+
+                ).apply {
+
+                    data = Uri.parse(
+
+                        "nostrsigner:${Uri.encode(plaintext)}"
+
+                    )
+
+                    putExtra(
+
+                        "type",
+
+                        "nip44_encrypt"
+
+                    )
+
+                    putExtra(
+
+                        "pubkey",
+
+                        pubkey
+
+                    )
+
+                    putExtra(
+
+                        "current_user",
+
+                        currentUser
+
+                    )
+
+                }
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+
+                        continuation.resume("")
+
+                    }
+
+                }
+
+                continuation.invokeOnCancellation {
+
+                    pendingCallback = null
+
+                }
+
+            }
+
+        }
+
+    override suspend fun nip44Decrypt(
         pubkey: String,
         ciphertext: String
-    ): String {
+    ): String =
+        withTimeout(30_000) {
+            val currentUser = getCachedPublicKey()
+            suspendCancellableCoroutine { continuation ->
+
+                pendingCallback = { result ->
+
+                    if (continuation.isActive) {
+                        continuation.resume(result)
+                    }
+                }
+
+                val intent = Intent(
+                    Intent.ACTION_VIEW
+                ).apply {
+
+                    data = Uri.parse(
+                        "nostrsigner:${Uri.encode(ciphertext)}"
+                    )
 
-        TODO()
+                    putExtra(
+                        "type",
+                        "nip44_decrypt"
+                    )
 
+                    putExtra(
+                        "pubkey",
+                        pubkey
+                    )
+
+                    putExtra(
+                        "current_user",
+                        currentUser
+                    )
+                }
+
+
+                AppDebugLogger.log(
+                    "NIP44",
+                    "decrypt sender=$pubkey current=$pubkey length=${ciphertext.length}"
+                )
+
+
+                try {
+
+                    launcher.launch(intent)
+
+                } catch (_: ActivityNotFoundException) {
+
+                    if (continuation.isActive) {
+                        continuation.resume("")
+                    }
+                }
+
+
+                continuation.invokeOnCancellation {
+                    pendingCallback = null
+                }
+            }
+        }
+
+    fun onResult(
+        result: ActivityResult
+    ) {
+
+        val callback = pendingCallback
+
+        pendingCallback = null
+
+        if (result.resultCode != Activity.RESULT_OK) {
+            callback?.let {
+                it("")
+            }
+            return
+
+        }
+
+        val value =
+
+            result.data?.getStringExtra("result")
+
+                ?: result.data?.getStringExtra("event")
+
+                ?: result.data?.getStringExtra("signature")
+
+                ?: result.data?.getStringExtra("plaintext")
+
+                ?: result.data?.getStringExtra("message")
+                ?: result.data?.getStringExtra("content")
+
+                ?: ""
+
+        AppDebugLogger.log(
+
+            "AMBER_RESULT",
+
+            value
+
+        )
+        AppDebugLogger.log(
+
+            "AMBER_RESULT_KEYS",
+
+            result.data?.extras?.keySet()?.joinToString()
+
+                ?: "NO_KEYS"
+
+        )
+
+        callback?.invoke(
+            value
+        )
     }
 
+    private suspend fun getCachedPublicKey(): String {
+
+        return cachedPubkey ?: getPublicKey()
+
+    }
 }

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

@@ -25,4 +25,18 @@ class BunkerSigner(context: Context) : NostrSigner {
     ): String {
         TODO("Not yet implemented")
     }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
 }

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

@@ -28,4 +28,18 @@ class FakeSigner : NostrSigner {
 
     }
 
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        TODO("Not yet implemented")
+    }
+
 }