pakstr 0.20.0 → 0.21.0

package/android-template/app/src/test/java/com/pakstr/app/signer/bunker/RelayNip46ClientTest.kt

@@ -0,0 +1,678 @@
+package com.pakstr.app.signer.bunker
+
+import com.pakstr.app.crypto.Bip340Hash
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.signer.NostrEventBuilder
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.cancelAndJoin
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.json.JSONArray
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import java.util.concurrent.AbstractExecutorService
+import java.util.concurrent.Callable
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+
+class RelayNip46ClientTest {
+    private lateinit var clientKey: Nip46ClientKey
+    private lateinit var communicationKey: Nip46ClientKey
+    private lateinit var userKey: Nip46ClientKey
+    private lateinit var config: BunkerConfig
+    private lateinit var protocol: Nip46Protocol
+    private lateinit var transport: FakeTransport
+    private lateinit var client: RelayNip46Client
+    private lateinit var requestIds: Iterator<String>
+
+    @Before
+    fun setup() {
+        clientKey = Nip46ClientKey.fromPrivateKey(privateKey(1))
+        communicationKey = Nip46ClientKey.fromPrivateKey(privateKey(2))
+        userKey = Nip46ClientKey.fromPrivateKey(privateKey(3))
+        requestIds = (1..32).map(::requestId).iterator()
+        config =
+            BunkerConfig.parse(
+                "bunker://${communicationKey.publicKeyHex}" +
+                        "?relay=wss://relay.example&secret=$PAIRING_SECRET"
+            )
+        protocol =
+            Nip46Protocol(
+                clientKey,
+                config,
+                Nip46RequestIdGenerator { requestIds.next() },
+                clockSeconds = { CREATED_AT }
+            )
+        transport = FakeTransport()
+        client =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 2_000,
+                activationHandler = {
+                    config.clearPairingSecret()
+                }
+            )
+    }
+
+    @After
+    fun teardown() {
+        client.close()
+        clientKey.close()
+        communicationKey.close()
+        userKey.close()
+    }
+
+    @Test
+    fun connect_then_get_public_key_binds_distinct_user_identity() = runBlocking {
+        val request = async { client.getPublicKey() }
+
+        val connect = awaitRequest(Nip46Method.CONNECT)
+        assertEquals(communicationKey.publicKeyHex, connect.params[0])
+        assertEquals(PAIRING_SECRET, connect.params[1])
+        respond(connect.id, "ack")
+
+        val getPublicKey = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+        respond(getPublicKey.id, userKey.publicKeyHex)
+
+        assertEquals(userKey.publicKeyHex, request.await())
+        assertFalse(userKey.publicKeyHex == communicationKey.publicKeyHex)
+        assertFalse(transport.publishedEvents.any { it.contains(PAIRING_SECRET) })
+        assertEquals(null, config.pairingSecret)
+    }
+
+    @Test
+    fun connect_advertises_permissions_and_client_metadata() = runBlocking {
+        val configuredClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 2_000,
+                requestedPermissions = "sign_event,nip44_encrypt",
+                clientMetadataJson =
+                    JSONObject()
+                        .put("name", "Pakstr")
+                        .toString()
+            )
+        try {
+            val activation = async { configuredClient.getPublicKey() }
+            val connect = awaitRequest(Nip46Method.CONNECT)
+
+            assertEquals(PAIRING_SECRET, connect.params[1])
+            assertEquals("sign_event,nip44_encrypt", connect.params[2])
+            assertEquals("Pakstr", JSONObject(connect.params[3]).getString("name"))
+
+            respond(connect.id, "ack")
+            val getPublicKey = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+            respond(getPublicKey.id, userKey.publicKeyHex)
+            assertEquals(userKey.publicKeyHex, activation.await())
+        } finally {
+            configuredClient.close()
+        }
+    }
+
+    @Test
+    fun disconnect_is_best_effort_and_safe_around_close() {
+        client.disconnect()
+
+        val disconnect = transport.requests().single()
+        assertEquals(Nip46Method.DISCONNECT, disconnect.method)
+        assertTrue(disconnect.params.isEmpty())
+        assertTrue(transport.cancelledRequestIds.isEmpty())
+
+        client.close()
+        client.disconnect()
+        assertEquals(1, transport.publishedEvents.size)
+    }
+
+    @Test
+    fun disconnect_ignores_transport_failure() {
+        transport.publishError = IllegalStateException("relay unavailable")
+
+        client.disconnect()
+
+        assertTrue(transport.publishedEvents.isEmpty())
+    }
+
+    @Test
+    fun sign_event_uses_bound_user_identity() = runBlocking {
+        activate()
+        val unsigned =
+            JSONObject()
+                .put("kind", 1)
+                .put("created_at", CREATED_AT)
+                .put("tags", JSONArray())
+                .put("content", "message")
+        val request = async { client.signEvent(unsigned.toString()) }
+        val signRequest = awaitRequest(Nip46Method.SIGN_EVENT)
+        val signed = signUserEvent(JSONObject(signRequest.params.single()))
+
+        respond(signRequest.id, signed)
+
+        assertEquals(userKey.publicKeyHex, JSONObject(request.await()).getString("pubkey"))
+    }
+
+    @Test
+    fun nip44_operations_run_after_activation() = runBlocking {
+        activate()
+        val encrypted = async {
+            client.nip44Encrypt(userKey.publicKeyHex, "private message")
+        }
+        val encryptRequest = awaitRequest(Nip46Method.NIP44_ENCRYPT)
+        assertEquals(userKey.publicKeyHex, encryptRequest.params[0])
+        respond(encryptRequest.id, "encrypted-result")
+        assertEquals("encrypted-result", encrypted.await())
+
+        val decrypted = async {
+            client.nip44Decrypt(userKey.publicKeyHex, "encrypted-result")
+        }
+        val decryptRequest = awaitRequest(Nip46Method.NIP44_DECRYPT)
+        respond(decryptRequest.id, "decrypted-result")
+        assertEquals("decrypted-result", decrypted.await())
+    }
+
+    @Test
+    fun concurrent_activation_publishes_one_handshake() = runBlocking {
+        val first = async { client.getPublicKey() }
+        val second = async { client.getPublicKey() }
+
+        val connect = awaitRequest(Nip46Method.CONNECT)
+        assertEquals(1, transport.requests().count { it.method == Nip46Method.CONNECT })
+        respond(connect.id, "ack")
+
+        val getPublicKey = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+        assertEquals(
+            1,
+            transport.requests().count { it.method == Nip46Method.GET_PUBLIC_KEY }
+        )
+        respond(getPublicKey.id, userKey.publicKeyHex)
+
+        assertEquals(userKey.publicKeyHex, first.await())
+        assertEquals(userKey.publicKeyHex, second.await())
+    }
+
+    @Test
+    fun activation_retries_get_public_key_lost_during_amber_subscription_race() = runBlocking {
+        val compatibilityClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 25,
+                connected = true
+            )
+        try {
+            val activation = async { compatibilityClient.getPublicKey() }
+            val dropped = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+            val retried = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+            assertFalse(dropped.id == retried.id)
+            respond(retried.id, userKey.publicKeyHex)
+
+            assertEquals(userKey.publicKeyHex, activation.await())
+            assertTrue(
+                transport.requests().none {
+                    it.method == Nip46Method.CONNECT
+                }
+            )
+            assertEquals(
+                2,
+                transport.requests().count {
+                    it.method == Nip46Method.GET_PUBLIC_KEY
+                }
+            )
+        } finally {
+            compatibilityClient.close()
+        }
+    }
+
+    @Test
+    fun concurrent_requests_are_correlated_when_responses_arrive_out_of_order() = runBlocking {
+        activate()
+        val first = async {
+            client.nip44Encrypt(userKey.publicKeyHex, "first")
+        }
+        val firstRequest = awaitRequest(Nip46Method.NIP44_ENCRYPT)
+        val second = async {
+            client.nip44Encrypt(userKey.publicKeyHex, "second")
+        }
+        val secondRequest = awaitRequest(Nip46Method.NIP44_ENCRYPT)
+
+        assertFalse(firstRequest.id == secondRequest.id)
+        respond(secondRequest.id, "second-result")
+        respond(firstRequest.id, "first-result")
+
+        assertEquals("first-result", first.await())
+        assertEquals("second-result", second.await())
+    }
+
+    @Test
+    fun unsolicited_and_repeated_valid_responses_are_ignored() = runBlocking {
+        activate()
+        val request = async {
+            client.nip44Encrypt(userKey.publicKeyHex, "message")
+        }
+        val encryptRequest = awaitRequest(Nip46Method.NIP44_ENCRYPT)
+
+        respond(requestId(31), "unsolicited")
+        assertFalse(request.isCompleted)
+
+        respond(encryptRequest.id, "expected")
+        assertEquals("expected", request.await())
+        respond(encryptRequest.id, "repeated")
+
+        assertEquals(
+            1,
+            transport.cancelledRequestIds.count { it == encryptRequest.id }
+        )
+    }
+
+    @Test
+    fun publish_failure_fails_request_and_cleans_up_pending_state() {
+        transport.publishError = IllegalStateException("relay unavailable")
+
+        assertThrows(SignerUnavailableException::class.java) {
+            runBlocking { client.getPublicKey() }
+        }
+
+        assertEquals(1, transport.cancelledRequestIds.size)
+        assertTrue(transport.publishedEvents.isEmpty())
+    }
+
+    @Test
+    fun restored_session_uses_persisted_user_identity_without_new_handshake() = runBlocking {
+        val restored =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 2_000,
+                initialUserPubkey = userKey.publicKeyHex
+            )
+        try {
+            assertEquals(userKey.publicKeyHex, restored.getPublicKey())
+            assertTrue(transport.publishedEvents.isEmpty())
+        } finally {
+            restored.close()
+        }
+    }
+
+    @Test
+    fun invalid_remote_identity_is_ignored_until_timeout() {
+        val scheduler = Executors.newSingleThreadScheduledExecutor()
+        val shortClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 25,
+                scheduler = scheduler
+            )
+        try {
+            assertThrows(Nip46RequestTimeoutException::class.java) {
+                runBlocking {
+                    val request = async { shortClient.getPublicKey() }
+                    val connect = awaitRequest(Nip46Method.CONNECT)
+                    transport.deliver(
+                        createResponseEvent(
+                            connect.id,
+                            "ack",
+                            signingKey = userKey
+                        )
+                    )
+                    request.await()
+                }
+            }
+        } finally {
+            shortClient.close()
+        }
+    }
+
+    @Test
+    fun auth_challenge_is_delivered_and_request_can_complete() = runBlocking {
+        var challenge: String? = null
+        val challengeClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 2_000,
+                authChallengeHandler = { challenge = it }
+            )
+        try {
+            val request = async { challengeClient.getPublicKey() }
+            val connect = awaitRequest(Nip46Method.CONNECT)
+            respond(
+                connect.id,
+                result = "auth_url",
+                error = AUTH_URL
+            )
+            assertEquals(AUTH_URL, challenge)
+            assertFalse(request.isCompleted)
+
+            respond(connect.id, "ack")
+            val getPublicKey = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+            respond(getPublicKey.id, userKey.publicKeyHex)
+            assertEquals(userKey.publicKeyHex, request.await())
+        } finally {
+            challengeClient.close()
+        }
+    }
+
+    @Test
+    fun auth_challenge_replaces_normal_timeout_with_extended_timeout() = runBlocking {
+        val scheduler = RecordingScheduler()
+        val challengeClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 30_000,
+                scheduler = scheduler,
+                authChallengeHandler = { },
+                authChallengeTimeoutMillis = 300_000
+            )
+        try {
+            val request = async { challengeClient.getPublicKey() }
+            val connect = awaitRequest(Nip46Method.CONNECT)
+            assertEquals(listOf(30_000L), scheduler.delays)
+
+            respond(
+                connect.id,
+                result = "auth_url",
+                error = AUTH_URL
+            )
+
+            assertEquals(
+                listOf(30_000L, 300_000L),
+                scheduler.delays
+            )
+            assertTrue(scheduler.futures[0].cancelled)
+            assertFalse(scheduler.futures[1].cancelled)
+            request.cancelAndJoin()
+        } finally {
+            challengeClient.close()
+        }
+    }
+
+    @Test
+    fun normal_request_keeps_normal_timeout() = runBlocking {
+        val scheduler = RecordingScheduler()
+        val normalClient =
+            RelayNip46Client(
+                protocol = protocol,
+                transport = transport,
+                requestTimeoutMillis = 30_000,
+                scheduler = scheduler,
+                authChallengeTimeoutMillis = 300_000
+            )
+        try {
+            val request = async { normalClient.getPublicKey() }
+            awaitRequest(Nip46Method.CONNECT)
+
+            assertEquals(listOf(30_000L), scheduler.delays)
+            request.cancelAndJoin()
+        } finally {
+            normalClient.close()
+        }
+    }
+
+    @Test
+    fun auth_challenge_without_handler_fails_without_leaking_url() {
+        val error =
+            assertThrows(Nip46AuthChallengeException::class.java) {
+                runBlocking {
+                    val request = async { client.getPublicKey() }
+                    val connect = awaitRequest(Nip46Method.CONNECT)
+                    respond(
+                        connect.id,
+                        result = "auth_url",
+                        error = AUTH_URL
+                    )
+                    request.await()
+                }
+            }
+        assertFalse(error.message.orEmpty().contains(AUTH_URL))
+        assertFalse(error.toString().contains(PAIRING_SECRET))
+    }
+
+    @Test
+    fun cancellation_and_close_clean_up_session() {
+        runBlocking {
+            val request = async { client.getPublicKey() }
+            val connect = awaitRequest(Nip46Method.CONNECT)
+            request.cancelAndJoin()
+            assertTrue(transport.cancelledRequestIds.contains(connect.id))
+
+            client.close()
+            client.close()
+            assertTrue(transport.closed)
+            assertThrows(
+                com.pakstr.app.signer.exceptions.SignerUnavailableException::class.java
+            ) {
+                runBlocking { client.getPublicKey() }
+            }
+        }
+    }
+
+    private suspend fun activate() {
+        coroutineScope {
+            val request = async { client.getPublicKey() }
+            val connect = awaitRequest(Nip46Method.CONNECT)
+            respond(connect.id, "ack")
+            val getPublicKey = awaitRequest(Nip46Method.GET_PUBLIC_KEY)
+            respond(getPublicKey.id, userKey.publicKeyHex)
+            assertEquals(userKey.publicKeyHex, request.await())
+        }
+    }
+
+    private suspend fun awaitRequest(method: Nip46Method): Nip46Request {
+        return withTimeout(2_000) {
+            while (true) {
+                transport.requests()
+                    .firstOrNull { it.method == method && it.id !in transport.observedIds }
+                    ?.let { request ->
+                        transport.observedIds += request.id
+                        return@withTimeout request
+                    }
+                kotlinx.coroutines.yield()
+            }
+            error("unreachable")
+        }
+    }
+
+    private fun FakeTransport.requests(): List<Nip46Request> {
+        return publishedEvents.map { eventJson ->
+            val encrypted = JSONObject(eventJson).getString("content")
+            Nip46Request.parse(
+                communicationKey.decryptNip44(
+                    encrypted,
+                    clientKey.publicKeyHex
+                )
+            )
+        }
+    }
+
+    private fun respond(
+        id: String,
+        result: String,
+        error: String? = null
+    ) {
+        transport.deliver(createResponseEvent(id, result, error))
+    }
+
+    private fun createResponseEvent(
+        id: String,
+        result: String,
+        error: String? = null,
+        signingKey: Nip46ClientKey = communicationKey
+    ): String {
+        val response = JSONObject().put("id", id).put("result", result)
+        error?.let { response.put("error", it) }
+        val encrypted =
+            communicationKey.encryptNip44(
+                response.toString(),
+                clientKey.publicKeyHex
+            )
+        val event =
+            JSONObject()
+                .put("pubkey", signingKey.publicKeyHex)
+                .put("created_at", CREATED_AT)
+                .put("kind", 24133)
+                .put(
+                    "tags",
+                    JSONArray().put(
+                        JSONArray()
+                            .put("p")
+                            .put(clientKey.publicKeyHex)
+                    )
+                )
+                .put("content", encrypted)
+        NostrEventBuilder.addId(event)
+        val eventId = Bip340Hash.hexToBytes(event.getString("id"))
+        val signature = signingKey.sign(eventId)
+        event.put("sig", Bip340Hash.bytesToHex(signature))
+        eventId.fill(0)
+        signature.fill(0)
+        return event.toString()
+    }
+
+    private fun signUserEvent(unsigned: JSONObject): String {
+        val event = JSONObject(unsigned.toString()).put("pubkey", userKey.publicKeyHex)
+        NostrEventBuilder.addId(event)
+        val eventId = Bip340Hash.hexToBytes(event.getString("id"))
+        val signature = userKey.sign(eventId)
+        event.put("sig", Bip340Hash.bytesToHex(signature))
+        eventId.fill(0)
+        signature.fill(0)
+        return event.toString()
+    }
+
+    private fun privateKey(value: Int): ByteArray {
+        return ByteArray(32).also { it[31] = value.toByte() }
+    }
+
+    private fun requestId(value: Int): String {
+        return "%064x".format(value)
+    }
+
+    private class RecordingScheduler : AbstractExecutorService(),
+        java.util.concurrent.ScheduledExecutorService {
+        val delays = mutableListOf<Long>()
+        val futures = mutableListOf<RecordingFuture>()
+        private var shutdown = false
+
+        override fun schedule(
+            command: Runnable,
+            delay: Long,
+            unit: TimeUnit
+        ): ScheduledFuture<*> {
+            delays += unit.toMillis(delay)
+            return RecordingFuture().also(futures::add)
+        }
+
+        override fun <V : Any?> schedule(
+            callable: Callable<V>,
+            delay: Long,
+            unit: TimeUnit
+        ): ScheduledFuture<V> = throw UnsupportedOperationException()
+
+        override fun scheduleAtFixedRate(
+            command: Runnable,
+            initialDelay: Long,
+            period: Long,
+            unit: TimeUnit
+        ): ScheduledFuture<*> = throw UnsupportedOperationException()
+
+        override fun scheduleWithFixedDelay(
+            command: Runnable,
+            initialDelay: Long,
+            delay: Long,
+            unit: TimeUnit
+        ): ScheduledFuture<*> = throw UnsupportedOperationException()
+
+        override fun shutdown() {
+            shutdown = true
+        }
+
+        override fun shutdownNow(): MutableList<Runnable> {
+            shutdown = true
+            return mutableListOf()
+        }
+
+        override fun isShutdown(): Boolean = shutdown
+
+        override fun isTerminated(): Boolean = shutdown
+
+        override fun awaitTermination(
+            timeout: Long,
+            unit: TimeUnit
+        ): Boolean = shutdown
+
+        override fun execute(command: Runnable) {
+            command.run()
+        }
+    }
+
+    private class RecordingFuture : ScheduledFuture<Unit> {
+        var cancelled = false
+            private set
+
+        override fun cancel(mayInterruptIfRunning: Boolean): Boolean {
+            cancelled = true
+            return true
+        }
+
+        override fun isCancelled(): Boolean = cancelled
+
+        override fun isDone(): Boolean = cancelled
+
+        override fun get(): Unit = Unit
+
+        override fun get(timeout: Long, unit: TimeUnit): Unit = Unit
+
+        override fun getDelay(unit: TimeUnit): Long = 0
+
+        override fun compareTo(other: java.util.concurrent.Delayed): Int = 0
+    }
+
+    private class FakeTransport : Nip46Transport {
+        private lateinit var listener: (String) -> Unit
+        val publishedEvents = mutableListOf<String>()
+        val cancelledRequestIds = mutableListOf<String>()
+        val observedIds = mutableSetOf<String>()
+        var closed = false
+        var publishError: Exception? = null
+
+        override fun start(listener: (String) -> Unit) {
+            this.listener = listener
+        }
+
+        override fun publish(requestId: String, eventJson: String) {
+            publishError?.let { throw it }
+            publishedEvents += eventJson
+        }
+
+        override fun cancel(requestId: String) {
+            cancelledRequestIds += requestId
+        }
+
+        override fun close() {
+            closed = true
+        }
+
+        fun deliver(eventJson: String) {
+            listener(eventJson)
+        }
+    }
+
+    private companion object {
+        const val CREATED_AT = 1_700_000_000L
+        const val PAIRING_SECRET = "pairing-secret-value"
+        const val AUTH_URL = "https://signer.example/approve/session"
+    }
+}

package/android-template/gradle/libs.versions.toml

@@ -13,6 +13,10 @@ composeBom = "2024.09.00"
 nanohttpd = "2.3.1"
 activityKtx = "1.9.3"
 material = "1.14.0"
+json = "20250517"
+okhttp = "4.12.0"
+securityCrypto = "1.1.0"
+zxingCore = "3.5.3"
 
 [libraries]
 androidx-appcompat = { module = "androidx.appcompat:appcompat", version.ref = "appcompat" }
@@ -34,6 +38,10 @@ androidx-compose-material3 = { group = "androidx.compose.material3", name = "mat
 nanohttpd = { module = "org.nanohttpd:nanohttpd", version.ref = "nanohttpd" }
 androidx-activity-ktx = { module = "androidx.activity:activity-ktx", version.ref = "activityKtx" }
 material = { module = "com.google.android.material:material", version.ref = "material" }
+json = { module = "org.json:json", version.ref = "json" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+androidx-security-crypto = { module = "androidx.security:security-crypto", version.ref = "securityCrypto" }
+zxing-core = { module = "com.google.zxing:core", version.ref = "zxingCore" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }

package/package.json

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