pakstr 0.21.1 → 0.22.0

package/android-template/app/src/androidTest/java/com/pakstr/app/Nip55CallbackTest.kt

@@ -10,7 +10,7 @@ class Nip55CallbackTest {
 
     @Test
     fun accepts_fragment_callback_and_preserves_logical_event() {
-        val event = "{\"kind\":27235,\"content\":\"hello & goodbye / 100%\"}"
+        val event = "{\"id\":\"${"a".repeat(64)}\",\"pubkey\":\"${"b".repeat(64)}\",\"created_at\":1789552517,\"kind\":27235,\"tags\":[],\"content\":\"hello & goodbye / 100%\",\"sig\":\"${"c".repeat(128)}\"}"
         val intent = callbackIntent(
             "${Nip55Callback.PARAM}=${Uri.encode(event)}"
         )

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

@@ -10,6 +10,9 @@ internal object Nip55Callback {
     private const val FRAGMENT_PREFIX = "$PARAM="
     private const val MAX_RESULT_LENGTH = 128 * 1024
 
+    val callbackPrefix: String
+        get() = "${BuildConfig.PAKSTR_NIP55_CALLBACK_SCHEME}://$HOST#$FRAGMENT_PREFIX"
+
     fun result(intent: Intent?): String? {
         if (intent?.action != Intent.ACTION_VIEW) {
             return null

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

@@ -0,0 +1,303 @@
+package com.pakstr.app
+
+import com.pakstr.app.crypto.NostrEventHasher
+import com.pakstr.app.signer.SignerType
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.nio.charset.CodingErrorAction
+
+internal sealed interface Nip55SignEventRequest {
+    data object External : Nip55SignEventRequest
+
+    data class Rejected(
+        val reason: String
+    ) : Nip55SignEventRequest
+
+    data class Parsed(
+        val event: JSONObject,
+        val callbackUrl: String
+    ) : Nip55SignEventRequest
+}
+
+internal sealed interface Nip55NormalizedEvent {
+    data class Rejected(
+        val reason: String
+    ) : Nip55NormalizedEvent
+
+    data class Ready(
+        val eventJson: String
+    ) : Nip55NormalizedEvent
+}
+
+internal object Nip55SignEventParser {
+    private const val SCHEME_PREFIX = "nostrsigner:"
+    private const val MAX_REQUEST_BYTES = 128 * 1024
+    private val RELEVANT_PARAMETERS = setOf(
+        "type",
+        "returnType",
+        "compressionType",
+        "callbackUrl"
+    )
+    private val EVENT_FIELDS = setOf(
+        "kind",
+        "created_at",
+        "tags",
+        "content",
+        "pubkey",
+        "id",
+        "sig"
+    )
+
+    fun parse(
+        rawUrl: String,
+        expectedCallbackUrl: String
+    ): Nip55SignEventRequest {
+        if (rawUrl.toByteArray(Charsets.UTF_8).size > MAX_REQUEST_BYTES) {
+            return rejected("request too large")
+        }
+        if (!rawUrl.startsWith(SCHEME_PREFIX, ignoreCase = true)) {
+            return Nip55SignEventRequest.External
+        }
+
+        val schemeSpecificPart = rawUrl.substring(SCHEME_PREFIX.length)
+        if ('#' in schemeSpecificPart) {
+            return rejected("malformed request")
+        }
+        val separator = schemeSpecificPart.indexOf('?')
+        val encodedEvent = if (separator >= 0) {
+            schemeSpecificPart.substring(0, separator)
+        } else {
+            schemeSpecificPart
+        }
+        val rawQuery = if (separator >= 0) {
+            schemeSpecificPart.substring(separator + 1)
+        } else {
+            ""
+        }
+        if (encodedEvent.isEmpty()) {
+            return rejected("missing event")
+        }
+        if (!hasOpaquePayloadEncoding(encodedEvent)) {
+            return rejected("malformed event encoding")
+        }
+
+        val parameters = parseParameters(rawQuery)
+            ?: return rejected("malformed parameters")
+        val type = parameters["type"]
+        if (type != "sign_event") {
+            return Nip55SignEventRequest.External
+        }
+        if (parameters["returnType"] != "event") {
+            return rejected("unsupported return type")
+        }
+        val compressionType = parameters["compressionType"]
+        if (compressionType != null && compressionType != "none") {
+            return rejected("unsupported compression")
+        }
+        val callbackUrl = parameters["callbackUrl"]
+            ?: return rejected("missing callback")
+        if (callbackUrl != expectedCallbackUrl) {
+            return rejected("unexpected callback")
+        }
+
+        val eventText = percentDecode(encodedEvent)
+            ?: return rejected("malformed event encoding")
+        val event = try {
+            JSONObject(eventText)
+        } catch (_: Exception) {
+            return rejected("invalid event")
+        }
+        if (event.keys().asSequence().any { it !in EVENT_FIELDS }) {
+            return rejected("unsupported event field")
+        }
+        if (!hasIntegral(event, "kind") ||
+            event.getLong("kind") !in 0L..65535L ||
+            !hasIntegral(event, "created_at") ||
+            event.optJSONArray("tags") == null ||
+            !hasString(event, "content") ||
+            !hasValidTags(event.getJSONArray("tags"))
+        ) {
+            return rejected("invalid event fields")
+        }
+        if (event.has("sig") &&
+            (!hasString(event, "sig") || event.getString("sig").isNotEmpty())
+        ) {
+            return rejected("event already signed")
+        }
+        if (event.has("pubkey") && !hasString(event, "pubkey")) {
+            return rejected("invalid pubkey")
+        }
+        if (event.has("id") && !hasString(event, "id")) {
+            return rejected("invalid event id")
+        }
+
+        return Nip55SignEventRequest.Parsed(event, callbackUrl)
+    }
+
+    fun normalize(
+        request: Nip55SignEventRequest.Parsed,
+        activePubkey: String
+    ): Nip55NormalizedEvent {
+        if (activePubkey.isBlank()) {
+            return normalizedRejected("signer unavailable")
+        }
+        val event = JSONObject(request.event.toString())
+        if (event.has("pubkey") && event.getString("pubkey") != activePubkey) {
+            return normalizedRejected("pubkey mismatch")
+        }
+
+        if (event.has("id")) {
+            val expectedId = event.getString("id")
+            event.put("pubkey", activePubkey)
+            val actualId = try {
+                NostrEventHasher.hashEvent(event)
+            } catch (_: Exception) {
+                return normalizedRejected("invalid event id")
+            }
+            if (actualId != expectedId) {
+                return normalizedRejected("event id mismatch")
+            }
+        }
+
+        return Nip55NormalizedEvent.Ready(
+            JSONObject()
+                .put("kind", event.getInt("kind"))
+                .put("created_at", event.getLong("created_at"))
+                .put("tags", event.getJSONArray("tags"))
+                .put("content", event.getString("content"))
+                .toString()
+        )
+    }
+
+    private fun hasOpaquePayloadEncoding(value: String): Boolean {
+        var index = 0
+        while (index < value.length) {
+            if (value[index] == '%') {
+                if (index + 2 >= value.length ||
+                    value[index + 1].digitToIntOrNull(16) == null ||
+                    value[index + 2].digitToIntOrNull(16) == null
+                ) {
+                    return false
+                }
+                index += 3
+            } else {
+                val character = value[index]
+                if (!character.isLetterOrDigit() && character !in "-._~") {
+                    return false
+                }
+                index++
+            }
+        }
+        return true
+    }
+
+    private fun parseParameters(rawQuery: String): Map<String, String>? {
+        val parameters = mutableMapOf<String, String>()
+        if (rawQuery.isEmpty()) {
+            return parameters
+        }
+        for (part in rawQuery.split('&')) {
+            val separator = part.indexOf('=')
+            if (separator < 0) {
+                return null
+            }
+            val name = percentDecode(part.substring(0, separator)) ?: return null
+            val value = percentDecode(part.substring(separator + 1)) ?: return null
+            if (name in RELEVANT_PARAMETERS && parameters.containsKey(name)) {
+                return null
+            }
+            parameters[name] = value
+        }
+        return parameters
+    }
+
+    private fun percentDecode(value: String): String? {
+        val bytes = ByteArrayOutputStream(value.length)
+        var index = 0
+        while (index < value.length) {
+            val character = value[index]
+            if (character == '%') {
+                if (index + 2 >= value.length) return null
+                val high = value[index + 1].digitToIntOrNull(16) ?: return null
+                val low = value[index + 2].digitToIntOrNull(16) ?: return null
+                bytes.write((high shl 4) or low)
+                index += 3
+            } else {
+                val codePoint = value.codePointAt(index)
+                bytes.write(String(Character.toChars(codePoint)).toByteArray(Charsets.UTF_8))
+                index += Character.charCount(codePoint)
+            }
+        }
+        return try {
+            Charsets.UTF_8.newDecoder()
+                .onMalformedInput(CodingErrorAction.REPORT)
+                .onUnmappableCharacter(CodingErrorAction.REPORT)
+                .decode(ByteBuffer.wrap(bytes.toByteArray()))
+                .toString()
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private fun hasIntegral(event: JSONObject, name: String): Boolean {
+        if (!event.has(name) || event.isNull(name)) return false
+        return event.get(name) is Byte ||
+                event.get(name) is Short ||
+                event.get(name) is Int ||
+                event.get(name) is Long
+    }
+
+    private fun hasString(event: JSONObject, name: String): Boolean {
+        return event.has(name) && !event.isNull(name) && event.get(name) is String
+    }
+
+    private fun hasValidTags(tags: JSONArray): Boolean {
+        for (tagIndex in 0 until tags.length()) {
+            val tag = tags.optJSONArray(tagIndex) ?: return false
+            if (tag.length() == 0) return false
+            for (valueIndex in 0 until tag.length()) {
+                if (tag.get(valueIndex) !is String) return false
+            }
+        }
+        return true
+    }
+
+    private fun rejected(reason: String) = Nip55SignEventRequest.Rejected(reason)
+
+    private fun normalizedRejected(reason: String) = Nip55NormalizedEvent.Rejected(reason)
+}
+
+internal fun dispatchNip55SignEvent(
+    rawUrl: String,
+    activeSignerType: SignerType?,
+    expectedCallbackUrl: String,
+    forwardExternally: () -> Unit,
+    launchSigning: (suspend () -> Unit) -> Unit,
+    getActivePubkey: suspend () -> String,
+    signEvent: suspend (String) -> String,
+    deliverSignedEvent: suspend (String) -> Unit,
+    logRejection: (String) -> Unit
+) {
+    if (activeSignerType != SignerType.BUNKER) {
+        forwardExternally()
+        return
+    }
+
+    when (val request = Nip55SignEventParser.parse(rawUrl, expectedCallbackUrl)) {
+        Nip55SignEventRequest.External -> forwardExternally()
+        is Nip55SignEventRequest.Rejected -> logRejection(request.reason)
+        is Nip55SignEventRequest.Parsed -> launchSigning {
+            when (val normalized = Nip55SignEventParser.normalize(
+                request,
+                getActivePubkey()
+            )) {
+                is Nip55NormalizedEvent.Rejected -> logRejection(normalized.reason)
+                is Nip55NormalizedEvent.Ready -> deliverSignedEvent(
+                    signEvent(normalized.eventJson)
+                )
+            }
+        }
+    }
+}

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

@@ -6,6 +6,6 @@ class PakstrBridge {
 
     @JavascriptInterface
     fun getNip55CallbackUrl(): String {
-        return "${BuildConfig.PAKSTR_NIP55_CALLBACK_SCHEME}://nip55-callback#nip55_event="
+        return Nip55Callback.callbackPrefix
     }
 }

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

@@ -17,6 +17,13 @@ import com.pakstr.app.debug.AppDebugLogger
 import com.pakstr.app.permissions.interfaces.PermissionHandler
 import com.pakstr.app.signer.NostrBridge
 import com.pakstr.app.signer.SignerManager
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 /**
  * Controls WebView configuration and lifecycle.
@@ -44,6 +51,7 @@ class WebViewController(
 ) {
     private var pendingNip55Result: String? = null
     private var isSetup = false
+    private val nip55Scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
     // Keeps a reference to the runnable to prevent memory leaks if destroyed early
     private val loadRunnable = Runnable {
@@ -228,22 +236,37 @@ class WebViewController(
                 ): Boolean {
                     val url = request?.url ?: return true
                     if (url.scheme.equals("nostrsigner", ignoreCase = true)) {
-                        try {
-                            val intent = Intent(Intent.ACTION_VIEW, url).apply {
-                                putExtra(
-                                    Browser.EXTRA_APPLICATION_ID,
-                                    context.packageName
-                                )
-                            }
-                            context.startActivity(intent)
-                        } catch (error: ActivityNotFoundException) {
-                            AppDebugLogger.error(
-                                context,
-                                "WEBVIEW",
-                                "No app can handle nostrsigner URL",
-                                error
-                            )
-                        }
+                        dispatchNip55SignEvent(
+                            rawUrl = url.toString(),
+                            activeSignerType = signerManager.getActiveType(),
+                            expectedCallbackUrl = Nip55Callback.callbackPrefix,
+                            forwardExternally = { launchExternalNip55(url) },
+                            launchSigning = { operation ->
+                                nip55Scope.launch {
+                                    try {
+                                        operation()
+                                    } catch (error: CancellationException) {
+                                        throw error
+                                    } catch (error: Exception) {
+                                        AppDebugLogger.log(
+                                            context,
+                                            "NIP55",
+                                            "Bunker flow failed: ${error::class.java.simpleName}"
+                                        )
+                                    }
+                                }
+                            },
+                            getActivePubkey = signerManager::getCurrentUserPubkey,
+                            signEvent = { event ->
+                                signerManager.getSigner().signEvent(event)
+                            },
+                            deliverSignedEvent = { signedEvent ->
+                                withContext(Dispatchers.Main) {
+                                    handleNip55Callback(signedEvent)
+                                }
+                            },
+                            logRejection = ::logNip55Rejection
+                        )
                         return true
                     }
                     return url.host != "127.0.0.1"
@@ -355,7 +378,34 @@ class WebViewController(
         (context as? Activity)?.findViewById<View>(R.id.loader)?.visibility = View.GONE
     }
 
+    private fun launchExternalNip55(url: android.net.Uri) {
+        try {
+            val intent = Intent(Intent.ACTION_VIEW, url).apply {
+                putExtra(
+                    Browser.EXTRA_APPLICATION_ID,
+                    context.packageName
+                )
+            }
+            context.startActivity(intent)
+        } catch (_: ActivityNotFoundException) {
+            AppDebugLogger.error(
+                context,
+                "WEBVIEW",
+                "No app can handle nostrsigner URL"
+            )
+        }
+    }
+
+    private fun logNip55Rejection(reason: String) {
+        AppDebugLogger.log(
+            context,
+            "NIP55",
+            "Request rejected: $reason"
+        )
+    }
+
     fun destroy() {
+        nip55Scope.cancel()
         webView.stopLoading()
 
         webView.clearHistory()

package/android-template/app/src/test/java/com/pakstr/app/Nip55SignEventDispatchTest.kt

@@ -0,0 +1,115 @@
+package com.pakstr.app
+
+import com.pakstr.app.signer.SignerType
+import kotlinx.coroutines.runBlocking
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class Nip55SignEventDispatchTest {
+    private val callback = "pakstr-test://nip55-callback#nip55_event="
+    private val activePubkey = "1".repeat(64)
+
+    @Test
+    fun bunker_valid_sign_event_signs_internally_without_external_intent() {
+        val result = dispatch(SignerType.BUNKER, validRequest())
+
+        assertTrue(result.signed)
+        assertFalse(result.forwarded)
+        assertEquals(SIGNED_EVENT, result.delivered)
+    }
+
+    @Test
+    fun bunker_invalid_sign_event_is_consumed_without_external_intent() {
+        val result = dispatch(
+            SignerType.BUNKER,
+            validRequest().replace("returnType=event", "returnType=signature")
+        )
+
+        assertFalse(result.signed)
+        assertFalse(result.forwarded)
+        assertTrue(result.rejection != null)
+    }
+
+    @Test
+    fun bunker_other_operation_is_forwarded_externally() {
+        val result = dispatch(
+            SignerType.BUNKER,
+            validRequest().replace("type=sign_event", "type=get_public_key")
+        )
+
+        assertFalse(result.signed)
+        assertTrue(result.forwarded)
+    }
+
+    @Test
+    fun amber_sign_event_is_forwarded_externally() {
+        val result = dispatch(SignerType.AMBER, validRequest())
+
+        assertFalse(result.signed)
+        assertTrue(result.forwarded)
+    }
+
+    private fun dispatch(type: SignerType, rawUrl: String): Result {
+        var forwarded = false
+        var signed = false
+        var delivered: String? = null
+        var rejection: String? = null
+
+        dispatchNip55SignEvent(
+            rawUrl = rawUrl,
+            activeSignerType = type,
+            expectedCallbackUrl = callback,
+            forwardExternally = { forwarded = true },
+            launchSigning = { operation -> runBlocking { operation() } },
+            getActivePubkey = { activePubkey },
+            signEvent = {
+                signed = true
+                SIGNED_EVENT
+            },
+            deliverSignedEvent = { delivered = it },
+            logRejection = { rejection = it }
+        )
+
+        return Result(forwarded, signed, delivered, rejection)
+    }
+
+    private fun validRequest(): String {
+        val event = JSONObject()
+            .put("kind", 27235)
+            .put("created_at", 1789552517L)
+            .put("tags", JSONArray())
+            .put("content", "")
+            .toString()
+        return "nostrsigner:${encode(event)}" +
+                "?type=sign_event&returnType=event&compressionType=none" +
+                "&callbackUrl=${encode(callback)}"
+    }
+
+    private fun encode(value: String): String {
+        return value.toByteArray(Charsets.UTF_8).joinToString("") { byte ->
+            val valueInt = byte.toInt() and 0xff
+            val character = valueInt.toChar()
+            if (character.isLetterOrDigit() || character in "-._~") {
+                character.toString()
+            } else {
+                "%${valueInt.toString(16).uppercase().padStart(2, '0')}"
+            }
+        }
+    }
+
+    private data class Result(
+        val forwarded: Boolean,
+        val signed: Boolean,
+        val delivered: String?,
+        val rejection: String?
+    )
+
+    private companion object {
+        const val SIGNED_EVENT =
+            "{\"id\":\"signed-id\",\"pubkey\":\"signed-pubkey\",\"sig\":\"signed-sig\"}"
+    }
+}

package/android-template/app/src/test/java/com/pakstr/app/Nip55SignEventRequestTest.kt

@@ -0,0 +1,90 @@
+package com.pakstr.app
+
+import org.json.JSONObject
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class Nip55SignEventRequestTest {
+    private val callback =
+        "pakstr-7f7e720bd582301afabb6b441f89a4fb8d1a481c3e0286c69345d03e7cb1929c://nip55-callback#nip55_event="
+
+    @Test
+    fun parses_exact_regress_request() {
+        val rawUrl =
+            "nostrsigner:%7B%22kind%22%3A27235%2C%22created_at%22%3A1789552517%2C%22content%22%3A%22%22%2C%22tags%22%3A%5B%5B%22u%22%2C%22http%3A%2F%2F127.0.0.1%3A8080%2Fapi%2Fauth%2Flogin%22%5D%2C%5B%22method%22%2C%22POST%22%5D%5D%7D?compressionType=none&returnType=event&type=sign_event&callbackUrl=pakstr-7f7e720bd582301afabb6b441f89a4fb8d1a481c3e0286c69345d03e7cb1929c%3A%2F%2Fnip55-callback%23nip55_event%3D"
+
+        val parsed = Nip55SignEventParser.parse(rawUrl, callback)
+
+        assertTrue(parsed is Nip55SignEventRequest.Parsed)
+        parsed as Nip55SignEventRequest.Parsed
+        assertEquals(callback, parsed.callbackUrl)
+        assertEquals(27235, parsed.event.getInt("kind"))
+        assertEquals(1789552517L, parsed.event.getLong("created_at"))
+        assertEquals("", parsed.event.getString("content"))
+        assertEquals(
+            "http://127.0.0.1:8080/api/auth/login",
+            parsed.event.getJSONArray("tags").getJSONArray(0).getString(1)
+        )
+    }
+
+    @Test
+    fun accepts_event_return_with_none_or_omitted_compression() {
+        val base = requestQuery("type=sign_event&returnType=event&callbackUrl=${encode(callback)}")
+        val withNone = requestQuery(
+            "type=sign_event&returnType=event&compressionType=none&callbackUrl=${encode(callback)}"
+        )
+
+        assertTrue(Nip55SignEventParser.parse(base, callback) is Nip55SignEventRequest.Parsed)
+        assertTrue(Nip55SignEventParser.parse(withNone, callback) is Nip55SignEventRequest.Parsed)
+    }
+
+    @Test
+    fun rejects_malformed_or_unsupported_sign_event() {
+        val unsupported = requestQuery(
+            "type=sign_event&returnType=event&compressionType=gzip&callbackUrl=${encode(callback)}"
+        )
+        val malformed =
+            "nostrsigner:%7Bbad?type=sign_event&returnType=event&callbackUrl=${encode(callback)}"
+
+        assertTrue(
+            Nip55SignEventParser.parse(unsupported, callback) is Nip55SignEventRequest.Rejected
+        )
+        assertTrue(
+            Nip55SignEventParser.parse(malformed, callback) is Nip55SignEventRequest.Rejected
+        )
+    }
+
+    @Test
+    fun rejects_foreign_callback() {
+        val rawUrl = requestQuery(
+            "type=sign_event&returnType=event&callbackUrl=${encode("other://nip55-callback#nip55_event=")}"
+        )
+
+        assertTrue(
+            Nip55SignEventParser.parse(rawUrl, callback) is Nip55SignEventRequest.Rejected
+        )
+    }
+
+    private fun requestQuery(query: String): String {
+        val event = JSONObject()
+            .put("kind", 27235)
+            .put("created_at", 1789552517L)
+            .put("tags", org.json.JSONArray())
+            .put("content", "")
+            .toString()
+        return "nostrsigner:${encode(event)}?$query"
+    }
+
+    private fun encode(value: String): String {
+        return value.toByteArray(Charsets.UTF_8).joinToString("") { byte ->
+            val valueInt = byte.toInt() and 0xff
+            val character = valueInt.toChar()
+            if (character.isLetterOrDigit() || character in "-._~") {
+                character.toString()
+            } else {
+                "%${valueInt.toString(16).uppercase().padStart(2, '0')}"
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",