pakstr 0.31.0 → 1.0.1

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

@@ -7,12 +7,10 @@ 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.suspendCancellableCoroutine
-import kotlinx.coroutines.withTimeout
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
 import org.json.JSONObject
-import kotlin.coroutines.resume
 
 /**
  * NIP-07 signer implementation using Amber as an external signer.
@@ -31,170 +29,86 @@ import kotlin.coroutines.resume
  *      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.
+ * Concurrent requests are serialized and matched to their activity results
+ * by [AmberRequestChannel].
  */
-class AmberSigner(
-    private val launcher: ActivityResultLauncher<Intent>
+class AmberSigner internal constructor(
+    private val launcher: ActivityResultLauncher<Intent>,
+    private val channel: AmberRequestChannel
 ) : 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 {
-
-            return it
-
-        }
-
-        return withTimeout(30_000) {
-
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { pubkey ->
-
-                    cachedPubkey = pubkey
-
-                    if (continuation.isActive) {
-
-                        continuation.resume(pubkey)
-
-                    }
-
-                }
-
-                val intent = Intent(
-
-                    Intent.ACTION_VIEW
-
-                ).apply {
-
-                    data = Uri.parse(
-
-                        "nostrsigner:?type=get_public_key"
-
-                    )
-
-                    putExtra(
-
-                        "type",
-
-                        "get_public_key"
+    constructor(
+        launcher: ActivityResultLauncher<Intent>
+    ) : this(launcher, AmberRequestChannel())
 
-                    )
-
-                }
-
-                try {
+    private val session = channel.openSession()
 
-                    launcher.launch(intent)
+    private val pubkeyMutex = Mutex()
 
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-
-                        continuation.resume("")
+    @Volatile
+    private var cachedPubkey: String? = null
 
+    override suspend fun getPublicKey(): String {
+        cachedPubkey?.let { return it }
+
+        return session.withRequestTimeout {
+            // Concurrent callers share one Amber prompt.
+            pubkeyMutex.withLock {
+                cachedPubkey ?: send(
+                    Intent(Intent.ACTION_VIEW).apply {
+                        data = Uri.parse("nostrsigner:?type=get_public_key")
+                        putExtra("type", "get_public_key")
                     }
-
+                ).also { pubkey ->
+                    if (pubkey.isNotBlank()) cachedPubkey = pubkey
                 }
-
-                continuation.invokeOnCancellation {
-
-                    pendingCallback = null
-
-                }
-
             }
-
         }
-
     }
 
     override suspend fun signEvent(
         eventJson: String
     ): String =
-        withTimeout(30_000) {
-
+        session.withRequestTimeout {
             val event = JSONObject(eventJson)
 
             val currentPubkey = event.optString("pubkey")
 
             if (currentPubkey.isBlank()) {
-
                 val amberPubkey = getPublicKey()
 
                 require(amberPubkey.isNotBlank()) {
-
                     "Amber returned empty pubkey"
-
                 }
 
-                event.put(
-
-                    "pubkey",
-
-                    amberPubkey
+                event.put("pubkey", amberPubkey)
+            }
 
+            val intent = Intent(
+                Intent.ACTION_VIEW,
+                Uri.parse(
+                    "nostrsigner:${Uri.encode(event.toString())}"
                 )
-
+            ).apply {
+                putExtra("type", "sign_event")
             }
 
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { signature ->
-
-                    if (signature.isEmpty()) {
-
-                        continuation.resume("")
-
-                    } else {
-
-                        val signedEvent =
-                            NostrEventBuilder.addId(event)
-                                .apply {
-                                    put(
-                                        "sig",
-                                        signature
-                                    )
-                                }
-
-
-                        val verified =
-                            NostrEventVerifier.verify(
-                                signedEvent
-                            )
-
-
-                        if (verified) {
-                            continuation.resume(
-                                signedEvent.toString()
-                            )
-                        } else {
-                            continuation.resume("")
-                        }
-                    }
-                }
+            val signature = session.request { requestId ->
+                launcher.launch(intent.putExtra("id", requestId))
+            }
 
+            if (signature.isEmpty()) {
+                ""
+            } else {
+                val signedEvent =
+                    NostrEventBuilder.addId(event)
+                        .apply { put("sig", signature) }
 
-                val intent = Intent(
-                    Intent.ACTION_VIEW,
-                    Uri.parse(
-                        "nostrsigner:${Uri.encode(event.toString())}"
-                    )
-                ).apply {
-                    putExtra(
-                        "type",
-                        "sign_event"
-                    )
+                if (NostrEventVerifier.verify(signedEvent)) {
+                    signedEvent.toString()
+                } else {
+                    ""
                 }
-
-
-                launcher.launch(intent)
             }
         }
 
@@ -202,297 +116,135 @@ class AmberSigner(
         pubkey: String,
         plaintext: String
     ): String =
-        withTimeout(30_000) {
-
-            suspendCancellableCoroutine { continuation ->
-
-                pendingCallback = { encrypted ->
-
-                    if (continuation.isActive) {
-                        continuation.resume(encrypted)
-                    }
-                }
-
-                val intent = Intent(
-                    Intent.ACTION_VIEW
-                ).apply {
-
+        session.withRequestTimeout {
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
                     data = Uri.parse(
                         "nostrsigner:?type=nip04_encrypt" +
                                 "&pubkey=$pubkey" +
                                 "&plaintext=${Uri.encode(plaintext)}"
                     )
-
-                    putExtra(
-                        "type",
-                        "nip04_encrypt"
-                    )
-
-                    putExtra(
-                        "pubkey",
-                        pubkey
-                    )
-
-                    putExtra(
-                        "plaintext",
-                        plaintext
-                    )
-                }
-
-                try {
-
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-                        continuation.resume("")
-                    }
+                    putExtra("type", "nip04_encrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("plaintext", plaintext)
                 }
-
-                continuation.invokeOnCancellation {
-                    pendingCallback = null
-                }
-            }
+            )
         }
 
     override suspend fun nip04Decrypt(
         pubkey: String,
         ciphertext: String
-    ): String = withTimeout(30_000) {
-
-        suspendCancellableCoroutine { continuation ->
-
-            pendingCallback = { result ->
-
-                if (continuation.isActive) {
-                    continuation.resume(result)
-                }
-            }
-
-            val intent = Intent(
-                Intent.ACTION_VIEW
-            ).apply {
-
-                data = Uri.parse(
-                    "nostrsigner:?type=nip04_decrypt" +
-                            "&pubkey=$pubkey" +
-                            "&message=${Uri.encode(ciphertext)}"
-                )
-
-                putExtra(
-                    "type",
-                    "nip04_decrypt"
-                )
-
-                putExtra(
-                    "pubkey",
-                    pubkey
-                )
-
-                putExtra(
-                    "message",
-                    ciphertext
-                )
-            }
-
-            try {
-
-                launcher.launch(intent)
-
-            } catch (_: ActivityNotFoundException) {
-
-                if (continuation.isActive) {
-                    continuation.resume("")
+    ): String =
+        session.withRequestTimeout {
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse(
+                        "nostrsigner:?type=nip04_decrypt" +
+                                "&pubkey=$pubkey" +
+                                "&message=${Uri.encode(ciphertext)}"
+                    )
+                    putExtra("type", "nip04_decrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("message", ciphertext)
                 }
-            }
-
-            continuation.invokeOnCancellation {
-                pendingCallback = null
-            }
+            )
         }
-    }
 
     override suspend fun nip44Encrypt(
-
         pubkey: String,
-
         plaintext: String
-
     ): String =
-
-        withTimeout(30_000) {
-
+        session.withRequestTimeout {
             val currentUser = getCachedPublicKey()
-
-            suspendCancellableCoroutine { continuation ->
-
-                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
-
-                }
-
-            }
-
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse("nostrsigner:${Uri.encode(plaintext)}")
+                    putExtra("type", "nip44_encrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("current_user", currentUser)
+                }
+            )
         }
 
     override suspend fun nip44Decrypt(
         pubkey: String,
         ciphertext: String
     ): String =
-        withTimeout(30_000) {
+        session.withRequestTimeout {
             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)}"
-                    )
-
-                    putExtra(
-                        "type",
-                        "nip44_decrypt"
-                    )
-
-                    putExtra(
-                        "pubkey",
-                        pubkey
-                    )
-
-                    putExtra(
-                        "current_user",
-                        currentUser
-                    )
-                }
-
-                try {
-
-                    launcher.launch(intent)
-
-                } catch (_: ActivityNotFoundException) {
-
-                    if (continuation.isActive) {
-                        continuation.resume("")
-                    }
-                }
-
-
-                continuation.invokeOnCancellation {
-                    pendingCallback = null
-                }
-            }
+            send(
+                Intent(Intent.ACTION_VIEW).apply {
+                    data = Uri.parse("nostrsigner:${Uri.encode(ciphertext)}")
+                    putExtra("type", "nip44_decrypt")
+                    putExtra("pubkey", pubkey)
+                    putExtra("current_user", currentUser)
+                }
+            )
         }
 
+    /**
+     * Delivers an Amber activity result to the request that launched it.
+     * Returns false if no outstanding request matched and it was dropped.
+     */
     fun onResult(
         result: ActivityResult
-    ) {
-
-        val callback = pendingCallback
-
-        pendingCallback = null
+    ): Boolean = channel.deliver(result)
+
+    /**
+     * Fails this signer's waiting requests and stops it launching Amber;
+     * used when the signer is replaced.
+     */
+    fun close() {
+        session.close()
+    }
 
-        if (result.resultCode != Activity.RESULT_OK) {
-            callback?.let {
-                it("")
+    /** Launches [intent] and waits for its result; "" if Amber is missing. */
+    private suspend fun send(intent: Intent): String {
+        return try {
+            session.request { requestId ->
+                launcher.launch(intent.putExtra("id", requestId))
             }
-            return
-
+        } catch (_: ActivityNotFoundException) {
+            ""
         }
-
-        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")
-
-                ?: ""
-        
-        callback?.invoke(value)
     }
 
     private suspend fun getCachedPublicKey(): String {
-
         return cachedPubkey ?: getPublicKey()
-
     }
-}
+}
+
+/** Delivers [result] to the request it answers; see [AmberRequestChannel.deliver]. */
+internal fun AmberRequestChannel.deliver(result: ActivityResult): Boolean {
+    val data = result.data
+    return deliver(
+        data?.getStringExtra("id"),
+        amberResultOutcome(
+            resultCode = result.resultCode,
+            rejected = data?.getBooleanExtra("rejected", false) == true,
+            extra = { name -> data?.getStringExtra(name) }
+        )
+    )
+}
+
+/**
+ * Maps an Amber activity result to the value its request resolves with.
+ * A NIP-55 rejection fails the request and none of its extras are read.
+ */
+internal fun amberResultOutcome(
+    resultCode: Int,
+    rejected: Boolean,
+    extra: (String) -> String?
+): Result<String> = when {
+    resultCode != Activity.RESULT_OK -> Result.success("")
+    rejected -> Result.failure(AmberRequestRejectedException())
+    else -> Result.success(
+        extra("result")
+            ?: extra("event")
+            ?: extra("signature")
+            ?: extra("plaintext")
+            ?: extra("message")
+            ?: extra("content")
+            ?: ""
+    )
+}