pakstr 0.20.0 → 0.21.0

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

@@ -0,0 +1,489 @@
+package com.pakstr.app.signer.bunker
+
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.withTimeoutOrNull
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.LinkedHashMap
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+import kotlin.math.min
+
+internal interface Nip46RelayConnection {
+    fun send(message: String): Boolean
+
+    fun close()
+}
+
+internal fun interface Nip46RelayConnectionFactory : AutoCloseable {
+    fun connect(
+        relayUrl: String,
+        listener: Nip46RelayConnectionListener
+    ): Nip46RelayConnection
+
+    override fun close() = Unit
+}
+
+internal interface Nip46RelayConnectionListener {
+    fun onOpen()
+
+    fun onMessage(message: String)
+
+    fun onClosed()
+
+    fun onFailure()
+}
+
+internal class OkHttpNip46RelayConnectionFactory(
+    private val client: OkHttpClient =
+        OkHttpClient.Builder()
+            .pingInterval(30, TimeUnit.SECONDS)
+            .build(),
+    private val diagnosticLogger: (String) -> Unit = {}
+) : Nip46RelayConnectionFactory {
+    override fun connect(
+        relayUrl: String,
+        listener: Nip46RelayConnectionListener
+    ): Nip46RelayConnection {
+        val connection = OkHttpRelayConnection()
+        val socket =
+            client.newWebSocket(
+                Request.Builder()
+                    .url(relayUrl)
+                    .build(),
+                object : WebSocketListener() {
+                    override fun onOpen(
+                        webSocket: WebSocket,
+                        response: Response
+                    ) {
+                        diagnosticLogger("WebSocket onOpen relay=$relayUrl")
+                        connection.attach(webSocket)
+                        listener.onOpen()
+                    }
+
+                    override fun onMessage(
+                        webSocket: WebSocket,
+                        text: String
+                    ) {
+                        listener.onMessage(text)
+                    }
+
+                    override fun onClosed(
+                        webSocket: WebSocket,
+                        code: Int,
+                        reason: String
+                    ) {
+                        listener.onClosed()
+                    }
+
+                    override fun onFailure(
+                        webSocket: WebSocket,
+                        t: Throwable,
+                        response: Response?
+                    ) {
+                        diagnosticLogger(
+                            "WebSocket onFailure relay=$relayUrl " +
+                                    "exception=${t.javaClass.name}: ${t.message.orEmpty()} " +
+                                    "httpCode=${response?.code ?: "none"}"
+                        )
+                        listener.onFailure()
+                    }
+                }
+            )
+        connection.attach(socket)
+        return connection
+    }
+
+    override fun close() {
+        client.dispatcher.executorService.shutdown()
+        client.connectionPool.evictAll()
+    }
+
+    private class OkHttpRelayConnection : Nip46RelayConnection {
+        @Volatile
+        private var socket: WebSocket? = null
+
+        fun attach(webSocket: WebSocket) {
+            socket = webSocket
+        }
+
+        override fun send(message: String): Boolean {
+            return socket?.send(message) == true
+        }
+
+        override fun close() {
+            socket?.close(NORMAL_CLOSURE, "")
+            socket = null
+        }
+    }
+
+    private companion object {
+        const val NORMAL_CLOSURE = 1000
+    }
+}
+
+internal interface Nip46Transport : AutoCloseable {
+    fun start(listener: (String) -> Unit)
+
+    fun publish(requestId: String, eventJson: String)
+
+    fun cancel(requestId: String)
+}
+
+internal class Nip46RelayTransport(
+    relayUrls: List<String>,
+    private val remoteSignerPubkey: String?,
+    private val clientPubkey: String,
+    private val connectionFactory: Nip46RelayConnectionFactory,
+    private val scheduler: ScheduledExecutorService =
+        Executors.newSingleThreadScheduledExecutor(),
+    private val reconnectBaseDelayMillis: Long = 1_000L,
+    private val reconnectMaximumDelayMillis: Long = 30_000L,
+    private val diagnosticLogger: (String) -> Unit = {}
+) : Nip46Transport {
+    private val lock = Any()
+    private val relays =
+        relayUrls.distinct().associateWith(::RelayState)
+    private val publications = LinkedHashMap<String, String>()
+    private val rememberedEventIds =
+        object : LinkedHashMap<String, Unit>(16, 0.75f, true) {
+            override fun removeEldestEntry(
+                eldest: MutableMap.MutableEntry<String, Unit>
+            ): Boolean {
+                return size > MAXIMUM_REMEMBERED_EVENT_IDS
+            }
+        }
+
+    private val readiness = CompletableDeferred<Boolean>()
+    private var eventListener: ((String) -> Unit)? = null
+    private var closed = false
+
+    override fun start(listener: (String) -> Unit) {
+        val relayStates =
+            synchronized(lock) {
+                check(!closed) { "NIP-46 relay transport is closed" }
+                eventListener = listener
+                relays.values.toList()
+            }
+        relayStates.forEach(::connect)
+    }
+
+    suspend fun awaitReady(timeoutMillis: Long): Boolean {
+        require(timeoutMillis > 0) { "Readiness timeout must be positive" }
+        val result = withTimeoutOrNull(timeoutMillis) {
+            readiness.await()
+        }
+        if (result == null) {
+            diagnosticLogger("Relay readiness timed out after ${timeoutMillis}ms")
+        }
+        return result ?: false
+    }
+
+    override fun publish(
+        requestId: String,
+        eventJson: String
+    ) {
+        val sockets =
+            synchronized(lock) {
+                check(!closed) { "NIP-46 relay transport is closed" }
+                publications[requestId] = eventJson
+                relays.values.mapNotNull { state ->
+                    state.connection.takeIf { state.connected }
+                }
+            }
+        val message = publishMessage(eventJson)
+        sockets.forEach { connection ->
+            connection.send(message)
+        }
+    }
+
+    override fun cancel(requestId: String) {
+        synchronized(lock) {
+            publications.remove(requestId)
+        }
+    }
+
+    override fun close() {
+        val states =
+            synchronized(lock) {
+                if (closed) {
+                    return
+                }
+                closed = true
+                readiness.complete(false)
+                eventListener = null
+                publications.clear()
+                rememberedEventIds.clear()
+                relays.values.toList()
+            }
+        states.forEach { state ->
+            state.reconnect?.cancel(false)
+            state.connection?.send(closeSubscriptionMessage(state.subscriptionId))
+            state.connection?.close()
+        }
+        scheduler.shutdownNow()
+        connectionFactory.close()
+    }
+
+    private fun connect(state: RelayState) {
+        val generation =
+            synchronized(lock) {
+                if (closed || state.connecting || state.connected) {
+                    return
+                }
+                state.connecting = true
+                state.opened = false
+                state.reconnect = null
+                ++state.generation
+            }
+        diagnosticLogger(
+            "Relay connection attempt relay=${state.relayUrl} " +
+                    "attempt=${state.reconnectAttempts + 1}"
+        )
+        val listener = listener(state, generation)
+        val connection =
+            try {
+                connectionFactory.connect(state.relayUrl, listener)
+            } catch (error: Exception) {
+                diagnosticLogger(
+                    "Relay connection failed relay=${state.relayUrl} " +
+                            "exception=${error.javaClass.name}: ${error.message.orEmpty()}"
+                )
+                synchronized(lock) {
+                    if (state.generation == generation) {
+                        state.connecting = false
+                    }
+                }
+                scheduleReconnect(state)
+                return
+            }
+        synchronized(lock) {
+            if (closed || state.generation != generation) {
+                connection.close()
+            } else {
+                state.connection = connection
+                completeOpen(state, connection)
+            }
+        }
+    }
+
+    private fun listener(
+        state: RelayState,
+        generation: Long
+    ): Nip46RelayConnectionListener {
+        return object : Nip46RelayConnectionListener {
+            override fun onOpen() {
+                synchronized(lock) {
+                    if (closed || state.generation != generation) {
+                        return
+                    }
+                    state.opened = true
+                    state.connection?.let { connection ->
+                        completeOpen(state, connection)
+                    }
+                }
+            }
+
+            override fun onMessage(message: String) {
+                receiveRelayMessage(state, generation, message)
+            }
+
+            override fun onClosed() {
+                disconnected(state, generation)
+            }
+
+            override fun onFailure() {
+                disconnected(state, generation)
+            }
+        }
+    }
+
+    private fun completeOpen(
+        state: RelayState,
+        connection: Nip46RelayConnection
+    ) {
+        if (!state.opened || state.connected) {
+            return
+        }
+        val subscribed =
+            try {
+                connection.send(subscriptionMessage(state.subscriptionId)).also { sent ->
+                    diagnosticLogger(
+                        "Pairing REQ send relay=${state.relayUrl} result=$sent"
+                    )
+                }
+            } catch (error: Exception) {
+                diagnosticLogger(
+                    "Pairing REQ send exception relay=${state.relayUrl} " +
+                            "exception=${error.javaClass.name}: ${error.message.orEmpty()}"
+                )
+                false
+            }
+        if (!subscribed) {
+            disconnected(state, state.generation)
+            connection.close()
+            return
+        }
+        state.connecting = false
+        state.connected = true
+        state.reconnectAttempts = 0
+        readiness.complete(true)
+        publications.values.forEach { eventJson ->
+            connection.send(publishMessage(eventJson))
+        }
+    }
+
+    private fun receiveRelayMessage(
+        state: RelayState,
+        generation: Long,
+        message: String
+    ) {
+        val eventJson = parseEventMessage(message, state.subscriptionId)
+            ?: return
+        val eventId =
+            try {
+                JSONObject(eventJson).getString("id")
+            } catch (_: Exception) {
+                return
+            }
+        if (!eventId.matches(EVENT_ID_PATTERN)) {
+            return
+        }
+        val listener =
+            synchronized(lock) {
+                if (
+                    closed ||
+                    state.generation != generation ||
+                    rememberedEventIds.put(eventId, Unit) != null
+                ) {
+                    return
+                }
+                eventListener
+            }
+        listener?.invoke(eventJson)
+    }
+
+    private fun disconnected(
+        state: RelayState,
+        generation: Long
+    ) {
+        val shouldReconnect =
+            synchronized(lock) {
+                if (closed || state.generation != generation) {
+                    false
+                } else {
+                    state.connecting = false
+                    state.opened = false
+                    state.connected = false
+                    state.connection = null
+                    true
+                }
+            }
+        if (shouldReconnect) {
+            scheduleReconnect(state)
+        }
+    }
+
+    private fun scheduleReconnect(state: RelayState) {
+        synchronized(lock) {
+            if (closed || state.reconnect?.isDone == false) {
+                return
+            }
+            val exponent = min(state.reconnectAttempts, MAX_BACKOFF_EXPONENT)
+            val multiplier = 1L shl exponent
+            val delay = min(
+                reconnectMaximumDelayMillis,
+                reconnectBaseDelayMillis * multiplier
+            )
+            state.reconnectAttempts++
+            diagnosticLogger(
+                "Relay reconnect scheduled relay=${state.relayUrl} " +
+                        "attempt=${state.reconnectAttempts + 1} delayMs=$delay"
+            )
+            state.reconnect =
+                scheduler.schedule(
+                    { connect(state) },
+                    delay,
+                    TimeUnit.MILLISECONDS
+                )
+        }
+    }
+
+    private fun subscriptionMessage(subscriptionId: String): String {
+        return JSONArray()
+            .put("REQ")
+            .put(subscriptionId)
+            .put(
+                JSONObject()
+                    .put("kinds", JSONArray().put(NIP46_EVENT_KIND))
+                    .put("#p", JSONArray().put(clientPubkey))
+                    .apply {
+                        remoteSignerPubkey?.let { pubkey ->
+                            put("authors", JSONArray().put(pubkey))
+                        }
+                    }
+            )
+            .toString()
+    }
+
+    private fun publishMessage(eventJson: String): String {
+        return JSONArray()
+            .put("EVENT")
+            .put(JSONObject(eventJson))
+            .toString()
+    }
+
+    private fun closeSubscriptionMessage(subscriptionId: String): String {
+        return JSONArray()
+            .put("CLOSE")
+            .put(subscriptionId)
+            .toString()
+    }
+
+    private fun parseEventMessage(
+        message: String,
+        subscriptionId: String
+    ): String? {
+        return try {
+            val frame = JSONArray(message)
+            if (
+                frame.length() != 3 ||
+                frame.optString(0) != "EVENT" ||
+                frame.optString(1) != subscriptionId
+            ) {
+                null
+            } else {
+                frame.optJSONObject(2)?.toString()
+            }
+        } catch (_: Exception) {
+            null
+        }
+    }
+
+    private class RelayState(
+        val relayUrl: String
+    ) {
+        val subscriptionId = "nip46-${relayUrl.hashCode().toUInt().toString(16)}"
+        var generation = 0L
+        var connection: Nip46RelayConnection? = null
+        var reconnect: ScheduledFuture<*>? = null
+        var reconnectAttempts = 0
+        var connecting = false
+        var opened = false
+        var connected = false
+    }
+
+    private companion object {
+        const val NIP46_EVENT_KIND = 24133
+        const val MAX_BACKOFF_EXPONENT = 20
+        const val MAXIMUM_REMEMBERED_EVENT_IDS = 2_048
+        val EVENT_ID_PATTERN = Regex("[0-9a-f]{64}")
+    }
+}