pakstr 0.19.3 → 0.21.0

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

@@ -0,0 +1,403 @@
+package com.pakstr.app.signer.bunker
+
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.signer.exceptions.SignerUnavailableException
+import kotlinx.coroutines.CancellableContinuation
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.suspendCancellableCoroutine
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+
+internal class RelayNip46Client(
+    private val protocol: Nip46Protocol,
+    private val transport: Nip46Transport,
+    private val requestTimeoutMillis: Long = DEFAULT_REQUEST_TIMEOUT_MILLIS,
+    private val scheduler: ScheduledExecutorService =
+        Executors.newSingleThreadScheduledExecutor(),
+    private val ownedClientKey: Nip46ClientKey? = null,
+    private val authChallengeHandler: ((String) -> Unit)? = null,
+    initialUserPubkey: String? = null,
+    private val userPubkeyHandler: ((String) -> Unit)? = null,
+    private val activationHandler: (() -> Unit)? = null,
+    private val authChallengeTimeoutMillis: Long =
+        DEFAULT_AUTH_CHALLENGE_TIMEOUT_MILLIS,
+    private val requestedPermissions: String? = null,
+    private val clientMetadataJson: String? = null,
+    private var connected: Boolean = false
+) : Nip46Client {
+    constructor(
+        config: BunkerConfig,
+        clientKey: Nip46ClientKey = Nip46ClientKey.generate(),
+        connectionFactory: Nip46RelayConnectionFactory =
+            OkHttpNip46RelayConnectionFactory(),
+        requestTimeoutMillis: Long = DEFAULT_REQUEST_TIMEOUT_MILLIS,
+        authChallengeHandler: ((String) -> Unit)? = null,
+        initialUserPubkey: String? = null,
+        userPubkeyHandler: ((String) -> Unit)? = null,
+        activationHandler: (() -> Unit)? = null,
+        authChallengeTimeoutMillis: Long =
+            DEFAULT_AUTH_CHALLENGE_TIMEOUT_MILLIS,
+        requestedPermissions: String? = null,
+        clientMetadataJson: String? = null,
+        connected: Boolean = false
+    ) : this(
+        protocol = Nip46Protocol(clientKey, config),
+        transport =
+            Nip46RelayTransport(
+                relayUrls = config.relayUrls,
+                remoteSignerPubkey = config.remoteSignerPubkey,
+                clientPubkey = clientKey.publicKeyHex,
+                connectionFactory = connectionFactory
+            ),
+        requestTimeoutMillis = requestTimeoutMillis,
+        ownedClientKey = clientKey,
+        authChallengeHandler = authChallengeHandler,
+        initialUserPubkey = initialUserPubkey,
+        userPubkeyHandler = userPubkeyHandler,
+        activationHandler = activationHandler,
+        authChallengeTimeoutMillis = authChallengeTimeoutMillis,
+        requestedPermissions = requestedPermissions,
+        clientMetadataJson = clientMetadataJson,
+        connected = connected
+    )
+    private val lock = Any()
+    private val activationMutex = Mutex()
+    private val pendingRequests = mutableMapOf<String, PendingRequest>()
+    private var userSigningPubkey: String? = initialUserPubkey
+    private var closed = false
+
+    init {
+        transport.start(::receiveEvent)
+    }
+
+    override suspend fun getPublicKey(): String {
+        return activate()
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+        val signingPubkey = activate()
+        return execute(
+            protocol.prepareSignEvent(
+                eventJson,
+                signingPubkey
+            )
+        )
+    }
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        activate()
+        return execute(protocol.prepareNip04Encrypt(pubkey, plaintext))
+    }
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        activate()
+        return execute(protocol.prepareNip04Decrypt(pubkey, ciphertext))
+    }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        activate()
+        return execute(protocol.prepareNip44Encrypt(pubkey, plaintext))
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        activate()
+        return execute(protocol.prepareNip44Decrypt(pubkey, ciphertext))
+    }
+
+    private suspend fun activate(): String {
+        synchronized(lock) {
+            userSigningPubkey?.let { return it }
+            if (closed) {
+                throw closedException()
+            }
+        }
+
+        return activationMutex.withLock {
+            synchronized(lock) {
+                userSigningPubkey?.let { return@withLock it }
+                if (closed) {
+                    throw closedException()
+                }
+            }
+
+            if (!connected) {
+                execute(
+                    protocol.prepareConnect(
+                        requestedPermissions,
+                        clientMetadataJson
+                    )
+                )
+                connected = true
+                activationHandler?.invoke()
+                protocol.clearPairingSecret()
+            }
+            val resolved =
+                try {
+                    execute(protocol.prepareGetPublicKey())
+                } catch (_: Nip46RequestTimeoutException) {
+                    execute(protocol.prepareGetPublicKey())
+                }
+            synchronized(lock) {
+                if (closed) {
+                    throw closedException()
+                }
+                userSigningPubkey = resolved
+            }
+            userPubkeyHandler?.invoke(resolved)
+            resolved
+        }
+    }
+
+    override fun disconnect() {
+        val outbound =
+            synchronized(lock) {
+                if (closed) {
+                    return
+                }
+                try {
+                    protocol.prepareDisconnect()
+                } catch (_: Exception) {
+                    return
+                }
+            }
+        try {
+            transport.publish(
+                outbound.context.id,
+                outbound.eventJson
+            )
+        } catch (_: Exception) {
+            // Disconnect is best-effort; local logout must still complete.
+        } finally {
+            outbound.context.close()
+        }
+    }
+
+    override fun close() {
+        val requests =
+            synchronized(lock) {
+                if (closed) {
+                    return
+                }
+                closed = true
+                userSigningPubkey = null
+                val snapshot = pendingRequests.values.toList()
+                pendingRequests.clear()
+                snapshot
+            }
+        requests.forEach { pending ->
+            pending.timeout.get()?.cancel(false)
+            pending.outbound.context.close()
+            pending.continuation.resumeWithException(closedException())
+        }
+        transport.close()
+        scheduler.shutdownNow()
+        ownedClientKey?.close()
+    }
+
+    private suspend fun execute(
+        outbound: Nip46OutboundRequest
+    ): String {
+        return suspendCancellableCoroutine { continuation ->
+            val timeoutReference = AtomicReference<ScheduledFuture<*>?>()
+            val pending = PendingRequest(
+                outbound,
+                continuation,
+                timeoutReference
+            )
+            val accepted =
+                synchronized(lock) {
+                    if (closed) {
+                        false
+                    } else {
+                        pendingRequests[outbound.context.id] = pending
+                        timeoutReference.set(
+                            scheduler.schedule(
+                                { timeout(outbound.context.id) },
+                                requestTimeoutMillis,
+                                TimeUnit.MILLISECONDS
+                            )
+                        )
+                        true
+                    }
+                }
+            if (!accepted) {
+                outbound.context.close()
+                continuation.resumeWithException(closedException())
+                return@suspendCancellableCoroutine
+            }
+
+            continuation.invokeOnCancellation {
+                cancel(outbound.context.id)
+            }
+            try {
+                transport.publish(
+                    outbound.context.id,
+                    outbound.eventJson
+                )
+            } catch (_: Exception) {
+                fail(
+                    outbound.context.id,
+                    SignerUnavailableException(
+                        "Unable to publish NIP-46 request"
+                    )
+                )
+            }
+        }
+    }
+
+    private fun receiveEvent(eventJson: String) {
+        val verified =
+            try {
+                protocol.decodeResponseEvent(eventJson)
+            } catch (_: Exception) {
+                return
+            }
+        val requestId = verified.response.id
+        val pending =
+            synchronized(lock) {
+                pendingRequests[requestId]
+            } ?: return
+
+        val outcome =
+            try {
+                protocol.correlateResponse(
+                    verified,
+                    pending.outbound.context
+                )
+            } catch (_: Exception) {
+                return
+            }
+        when (outcome) {
+            is Nip46ResponseOutcome.Success ->
+                complete(requestId, outcome.result)
+            is Nip46ResponseOutcome.RemoteError ->
+                fail(
+                    requestId,
+                    Nip46RemoteException()
+                )
+            is Nip46ResponseOutcome.AuthChallenge -> {
+                val handler = authChallengeHandler
+                if (handler == null) {
+                    fail(
+                        requestId,
+                        Nip46AuthChallengeException()
+                    )
+                } else {
+                    try {
+                        extendTimeoutForAuthChallenge(
+                            requestId,
+                            pending
+                        )
+                        handler(outcome.url)
+                    } catch (_: Exception) {
+                        fail(
+                            requestId,
+                            Nip46AuthChallengeException()
+                        )
+                    }
+                }
+            }
+        }
+    }
+
+    private fun extendTimeoutForAuthChallenge(
+        requestId: String,
+        pending: PendingRequest
+    ) {
+        val replacement =
+            scheduler.schedule(
+                { timeout(requestId) },
+                authChallengeTimeoutMillis,
+                TimeUnit.MILLISECONDS
+            )
+        val previous = pending.timeout.getAndSet(replacement)
+        previous?.cancel(false)
+        synchronized(lock) {
+            if (pendingRequests[requestId] !== pending) {
+                replacement.cancel(false)
+            }
+        }
+    }
+
+    private fun complete(
+        requestId: String,
+        result: String
+    ) {
+        val pending = remove(requestId) ?: return
+        pending.continuation.resume(result)
+    }
+
+    private fun fail(
+        requestId: String,
+        error: Exception
+    ) {
+        val pending = remove(requestId) ?: return
+        pending.continuation.resumeWithException(error)
+    }
+
+    private fun timeout(requestId: String) {
+        fail(requestId, Nip46RequestTimeoutException())
+    }
+
+    private fun cancel(requestId: String) {
+        remove(requestId)
+    }
+
+    private fun remove(requestId: String): PendingRequest? {
+        val pending =
+            synchronized(lock) {
+                pendingRequests.remove(requestId)
+            } ?: return null
+        pending.timeout.get()?.cancel(false)
+        transport.cancel(requestId)
+        pending.outbound.context.close()
+        return pending
+    }
+
+    private fun closedException(): SignerUnavailableException {
+        return SignerUnavailableException(
+            "Bunker signer is closed"
+        )
+    }
+
+    private class PendingRequest(
+        val outbound: Nip46OutboundRequest,
+        val continuation: CancellableContinuation<String>,
+        val timeout: AtomicReference<ScheduledFuture<*>?>
+    )
+
+    private companion object {
+        const val DEFAULT_REQUEST_TIMEOUT_MILLIS = 30_000L
+        const val DEFAULT_AUTH_CHALLENGE_TIMEOUT_MILLIS = 5 * 60_000L
+    }
+}
+
+internal class Nip46AuthChallengeException : Exception(
+    "Remote signer requires authorization"
+)
+
+internal class Nip46RemoteException : Exception(
+    "Remote signer rejected the NIP-46 request"
+)
+
+internal class Nip46RequestTimeoutException : Exception(
+    "NIP-46 request timed out"
+)

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

@@ -0,0 +1,82 @@
+package com.pakstr.app.utils
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.view.LayoutInflater
+import android.widget.ImageView
+import android.widget.TextView
+import android.widget.Toast
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import com.google.android.material.button.MaterialButton
+import com.pakstr.app.R
+import com.pakstr.app.signer.bunker.Nip46PairingQrCode
+
+object BunkerPairingDialog {
+    fun show(
+        activity: AppCompatActivity,
+        pairingUri: String,
+        onShare: (String) -> Unit
+    ): AlertDialog {
+        val view = LayoutInflater.from(activity)
+            .inflate(R.layout.dialog_bunker_pairing, null, false)
+        val qrImage = view.findViewById<ImageView>(R.id.bunker_pairing_qr)
+        val uriText = view.findViewById<TextView>(R.id.bunker_pairing_uri)
+        val copy = view.findViewById<MaterialButton>(R.id.button_copy_pairing_uri)
+        val share = view.findViewById<MaterialButton>(R.id.button_share_pairing_uri)
+
+        uriText.text = pairingUri
+        qrImage.setImageBitmap(createQrBitmap(pairingUri, QR_CODE_SIZE_PIXELS))
+
+        copy.setOnClickListener {
+            val clipboard = activity.getSystemService(
+                Context.CLIPBOARD_SERVICE
+            ) as ClipboardManager
+            clipboard.setPrimaryClip(
+                ClipData.newPlainText(
+                    activity.getString(R.string.signer_picker_pairing_clip_label),
+                    pairingUri
+                )
+            )
+            Toast.makeText(
+                activity,
+                R.string.signer_picker_pairing_copied,
+                Toast.LENGTH_SHORT
+            ).show()
+        }
+        share.setOnClickListener {
+            onShare(pairingUri)
+        }
+
+        val dialog =
+            AlertDialog.Builder(activity)
+                .setView(view)
+                .setNegativeButton(android.R.string.cancel, null)
+                .create()
+        dialog.show()
+        return dialog
+    }
+
+    private fun createQrBitmap(
+        value: String,
+        sizePixels: Int
+    ): Bitmap {
+        val matrix = Nip46PairingQrCode.encode(value, sizePixels)
+        val pixels = IntArray(sizePixels * sizePixels) { index ->
+            val x = index % sizePixels
+            val y = index / sizePixels
+            if (matrix[x, y]) Color.BLACK else Color.WHITE
+        }
+        return Bitmap.createBitmap(
+            pixels,
+            sizePixels,
+            sizePixels,
+            Bitmap.Config.ARGB_8888
+        )
+    }
+
+    private const val QR_CODE_SIZE_PIXELS = 768
+}

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

@@ -1,7 +1,5 @@
 package com.pakstr.app.utils
 
-import com.pakstr.app.R
-
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -9,31 +7,94 @@ import android.view.ViewGroup
 import android.widget.Button
 import android.widget.RadioGroup
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment
-import com.pakstr.app.signer.SignerType
+import com.google.android.material.textfield.TextInputEditText
+import com.google.android.material.textfield.TextInputLayout
+import com.pakstr.app.R
 
-class SignerPickerBottomSheet (
-    private val onSignerSelected: (SignerType) -> Unit
+class SignerPickerBottomSheet(
+    private val hasBunkerSession: Boolean,
+    private val onAmberSelected: () -> Unit,
+    private val onBunkerSelected: (String) -> Boolean,
+    private val onSharePairing: (List<String>) -> Unit,
+    private val onBunkerLogout: () -> Unit
 ) : BottomSheetDialogFragment() {
 
     override fun onCreateView(
-        inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
-    ): View? {
-        return inflater.inflate(R.layout.dialog_picker, container, false)
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        return inflater.inflate(
+            R.layout.dialog_picker,
+            container,
+            false
+        )
     }
 
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    override fun onViewCreated(
+        view: View,
+        savedInstanceState: Bundle?
+    ) {
         super.onViewCreated(view, savedInstanceState)
-
         val radioGroup = view.findViewById<RadioGroup>(R.id.options_radio_group)
-        val btnConfirm = view.findViewById<Button>(R.id.button_confirm)
+        val uriContainer = view.findViewById<TextInputLayout>(R.id.bunker_uri_container)
+        val uriInput = view.findViewById<TextInputEditText>(R.id.bunker_uri)
+        val confirm = view.findViewById<Button>(R.id.button_confirm)
+        val sharePairing = view.findViewById<Button>(R.id.button_share_pairing)
+        val logout = view.findViewById<Button>(R.id.button_logout_bunker)
+
+        logout.visibility =
+            if (hasBunkerSession) View.VISIBLE else View.GONE
+
+        fun updateBunkerControls() {
+            val bunkerSelected =
+                radioGroup.checkedRadioButtonId == R.id.radio_option_two
+            uriContainer.visibility =
+                if (bunkerSelected) View.VISIBLE else View.GONE
+            sharePairing.visibility =
+                if (bunkerSelected) View.VISIBLE else View.GONE
+        }
+        radioGroup.setOnCheckedChangeListener { _, _ ->
+            uriContainer.error = null
+            updateBunkerControls()
+        }
+        updateBunkerControls()
 
-        btnConfirm.setOnClickListener {
-            val selectedType = when (radioGroup.checkedRadioButtonId) {
-                R.id.radio_option_one -> SignerType.AMBER
-                R.id.radio_option_two -> SignerType.BUNKER
-                else -> SignerType.AMBER
+        confirm.setOnClickListener {
+            if (radioGroup.checkedRadioButtonId == R.id.radio_option_two) {
+                val value = uriInput.text?.toString().orEmpty().trim()
+                if (!onBunkerSelected(value)) {
+                    uriContainer.error =
+                        getString(R.string.signer_picker_invalid_bunker)
+                    return@setOnClickListener
+                }
+            } else {
+                onAmberSelected()
             }
-            onSignerSelected(selectedType)
+            dismiss()
+        }
+
+        sharePairing.setOnClickListener {
+            val relays =
+                uriInput.text?.toString()
+                    .orEmpty()
+                    .lineSequence()
+                    .map(String::trim)
+                    .filter { it.startsWith("wss://") }
+                    .toList()
+                    .ifEmpty {
+                        getString(R.string.signer_picker_pairing_relays_default)
+                            .lineSequence()
+                            .map(String::trim)
+                            .filter { it.startsWith("wss://") }
+                            .toList()
+                    }
+            onSharePairing(relays)
+            dismiss()
+        }
+
+        logout.setOnClickListener {
+            onBunkerLogout()
             dismiss()
         }
     }

package/android-template/app/src/main/res/layout/activity_layout.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <com.pakstr.app.debug.SupportUnlockGestureLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
     android:id="@+id/mainContainer"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
@@ -18,6 +19,16 @@
         android:layout_gravity="center"
         android:indeterminateDrawable="@drawable/custom_loader" />
 
+    <com.google.android.material.floatingactionbutton.FloatingActionButton
+        android:id="@+id/signerSettingsFab"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="top|end"
+        android:layout_margin="24dp"
+        android:contentDescription="@string/signer_settings"
+        android:src="@android:drawable/ic_menu_manage"
+        app:fabSize="mini" />
+
     <com.google.android.material.floatingactionbutton.FloatingActionButton
         android:id="@+id/developerToolsFab"
         android:layout_width="wrap_content"

package/android-template/app/src/main/res/layout/dialog_bunker_pairing.xml

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:fillViewport="true">
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        android:padding="24dp">
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="@string/signer_picker_pairing_qr_title"
+            android:textColor="#1F2937"
+            android:textSize="20sp"
+            android:textStyle="bold" />
+
+        <TextView
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="8dp"
+            android:text="@string/signer_picker_pairing_qr_instructions"
+            android:textColor="#4B5563"
+            android:textSize="14sp" />
+
+        <ImageView
+            android:id="@+id/bunker_pairing_qr"
+            android:layout_width="280dp"
+            android:layout_height="280dp"
+            android:layout_gravity="center_horizontal"
+            android:layout_marginTop="20dp"
+            android:adjustViewBounds="true"
+            android:contentDescription="@string/signer_picker_pairing_qr_content_description"
+            android:importantForAccessibility="yes"
+            android:scaleType="fitCenter" />
+
+        <TextView
+            android:id="@+id/bunker_pairing_uri"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="16dp"
+            android:background="#F3F4F6"
+            android:ellipsize="end"
+            android:fontFamily="monospace"
+            android:maxLines="4"
+            android:padding="12dp"
+            android:textColor="#1F2937"
+            android:textIsSelectable="true"
+            android:textSize="12sp" />
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/button_copy_pairing_uri"
+            style="@style/Widget.MaterialComponents.Button.OutlinedButton"
+            android:layout_width="match_parent"
+            android:layout_height="48dp"
+            android:layout_marginTop="16dp"
+            android:text="@string/signer_picker_pairing_copy"
+            android:textAllCaps="false" />
+
+        <com.google.android.material.button.MaterialButton
+            android:id="@+id/button_share_pairing_uri"
+            android:layout_width="match_parent"
+            android:layout_height="48dp"
+            android:layout_marginTop="8dp"
+            android:text="@string/signer_picker_pairing_share"
+            android:textAllCaps="false"
+            android:textColor="@android:color/white"
+            app:backgroundTint="#2563EB" />
+
+    </LinearLayout>
+</ScrollView>