pakstr 0.26.0 → 0.28.0

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

@@ -42,7 +42,9 @@ import com.pakstr.app.permissions.interfaces.PermissionHandler
 import com.pakstr.app.signer.SignerManager
 import com.pakstr.app.signer.SignerType
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import com.pakstr.app.utils.AppPreferences
 import com.pakstr.app.utils.BunkerPairingDialog
 import com.pakstr.app.utils.SignerPickerBottomSheet
@@ -61,6 +63,7 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     private lateinit var fab: FloatingActionButton
     private lateinit var supportUnlockGestureLayout: SupportUnlockGestureLayout
     private var bunkerPairingDialog: AlertDialog? = null
+    private var signerSetupInProgress = false
 
     private val diagnosticsHandler = Handler(Looper.getMainLooper())
     private val diagnosticsExpiryCheck = Runnable {
@@ -128,12 +131,6 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             }
 
         initSigner()
-        if (
-            savedInstanceState == null &&
-            AppPreferences.getBoolean("isFirstRun", true)
-        ) {
-            container.post(::showSignerPicker)
-        }
 
         ViewCompat.setOnApplyWindowInsetsListener(
 
@@ -269,8 +266,26 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             SignerManager(
                 this,
                 amberLauncher,
-                bunkerAuthChallengeHandler = ::openBunkerAuthChallenge
+                bunkerAuthChallengeHandler = ::openBunkerAuthChallenge,
+                signerPickerRequestHandler = ::requestSignerPicker
             )
+        signerManager.migrateLegacySignerConfiguration(
+            setupCompleted = !AppPreferences.getBoolean("isFirstRun", true)
+        )
+    }
+
+    private fun requestSignerPicker() {
+        runOnUiThread {
+            if (
+                isFinishing ||
+                isDestroyed ||
+                supportFragmentManager.isStateSaved
+            ) {
+                signerManager.cancelSignerSelection()
+                return@runOnUiThread
+            }
+            showSignerPicker()
+        }
     }
 
     private fun openBunkerAuthChallenge(value: String) {
@@ -408,6 +423,11 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     }
 
     private fun showSignerPicker() {
+        if (
+            supportFragmentManager.findFragmentByTag(SIGNER_PICKER_TAG) != null
+        ) {
+            return
+        }
         SignerPickerBottomSheet(
             hasBunkerSession = signerManager.hasBunkerSession(),
             onAmberSelected = {
@@ -423,7 +443,14 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                     false
                 }
             },
-            onSharePairing = ::shareBunkerPairing,
+            onLocalSelected = {
+                signerSetupInProgress = true
+                createLocalAccount()
+            },
+            onSharePairing = { relayUrls ->
+                signerSetupInProgress = true
+                shareBunkerPairing(relayUrls)
+            },
             onBunkerLogout = {
                 signerManager.logoutBunker()
                 Toast.makeText(
@@ -431,13 +458,45 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                     R.string.signer_picker_disconnected,
                     Toast.LENGTH_SHORT
                 ).show()
+            },
+            onDismissed = {
+                if (!signerSetupInProgress) {
+                    signerManager.cancelSignerSelection()
+                }
             }
         ).show(
             supportFragmentManager,
-            "SignerPicker"
+            SIGNER_PICKER_TAG
         )
     }
 
+    private fun createLocalAccount() {
+        lifecycleScope.launch {
+            val created =
+                withContext(Dispatchers.IO) {
+                    try {
+                        signerManager.createLocalAccount()
+                        true
+                    } catch (cancelled: CancellationException) {
+                        throw cancelled
+                    } catch (_: Exception) {
+                        false
+                    }
+                }
+            signerSetupInProgress = false
+            if (created) {
+                handleSignerSetup()
+            } else {
+                signerManager.cancelSignerSelection()
+                Toast.makeText(
+                    this@MainActivity,
+                    R.string.signer_picker_local_failed,
+                    Toast.LENGTH_LONG
+                ).show()
+            }
+        }
+    }
+
     private fun shareBunkerPairing(relayUrls: List<String>) {
         lifecycleScope.launch {
             val pairingUri =
@@ -446,6 +505,8 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                 } catch (cancelled: CancellationException) {
                     throw cancelled
                 } catch (_: Exception) {
+                    signerSetupInProgress = false
+                    signerManager.cancelSignerSelection()
                     Toast.makeText(
                         this@MainActivity,
                         R.string.signer_picker_connection_failed,
@@ -469,7 +530,18 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                 R.string.signer_picker_pairing_waiting,
                 Toast.LENGTH_LONG
             ).show()
-            val connected = signerManager.finishBunkerPairing()
+            val connected =
+                try {
+                    signerManager.finishBunkerPairing()
+                } catch (cancelled: CancellationException) {
+                    throw cancelled
+                } catch (_: Exception) {
+                    false
+                }
+            signerSetupInProgress = false
+            if (!connected) {
+                signerManager.cancelSignerSelection()
+            }
             if (pairingDialog.isShowing) {
                 pairingDialog.dismiss()
             }
@@ -510,4 +582,8 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         DebugReportShare.share(this)
 
     }
-}
+
+    private companion object {
+        const val SIGNER_PICKER_TAG = "SignerPicker"
+    }
+}

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

@@ -0,0 +1,100 @@
+package com.pakstr.app.signer
+
+import com.pakstr.app.crypto.Bip340Hash
+import com.pakstr.app.crypto.Nip46ClientKey
+import com.pakstr.app.crypto.NostrEventVerifier
+import com.pakstr.app.signer.interfaces.NostrSigner
+import com.pakstr.app.signer.local.LocalAccountStore
+import org.json.JSONObject
+
+internal class LocalSigner(
+    private val keyLoader: () -> Nip46ClientKey
+) : NostrSigner {
+    constructor(store: LocalAccountStore) : this(
+        keyLoader = {
+            store.loadKey()
+                ?: throw IllegalStateException(
+                    "Local account has not been created"
+                )
+        }
+    )
+    override suspend fun getPublicKey(): String {
+        return requireKey().use { key ->
+            key.publicKeyHex
+        }
+    }
+
+    override suspend fun signEvent(eventJson: String): String {
+        return requireKey().use { key ->
+            val event = JSONObject(eventJson)
+            val publicKey = key.publicKeyHex
+            val suppliedPublicKey = event.optString("pubkey")
+            require(
+                suppliedPublicKey.isBlank() ||
+                        suppliedPublicKey == publicKey
+            ) {
+                "Event public key does not match local signer"
+            }
+            event.put("pubkey", publicKey)
+            NostrEventBuilder.addId(event)
+
+            val eventId =
+                Bip340Hash.hexToBytes(
+                    event.getString("id")
+                )
+            val signature = key.sign(eventId)
+            try {
+                event.put(
+                    "sig",
+                    Bip340Hash.bytesToHex(signature)
+                )
+            } finally {
+                eventId.fill(0)
+                signature.fill(0)
+            }
+
+            check(NostrEventVerifier.verify(event)) {
+                "Generated signature failed verification"
+            }
+            event.toString()
+        }
+    }
+
+    override suspend fun nip04Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        throw UnsupportedOperationException(
+            "NIP-04 is not supported by the local signer"
+        )
+    }
+
+    override suspend fun nip04Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        throw UnsupportedOperationException(
+            "NIP-04 is not supported by the local signer"
+        )
+    }
+
+    override suspend fun nip44Encrypt(
+        pubkey: String,
+        plaintext: String
+    ): String {
+        return requireKey().use { key ->
+            key.encryptNip44(plaintext, pubkey)
+        }
+    }
+
+    override suspend fun nip44Decrypt(
+        pubkey: String,
+        ciphertext: String
+    ): String {
+        return requireKey().use { key ->
+            key.decryptNip44(ciphertext, pubkey)
+        }
+    }
+
+    private fun requireKey() = keyLoader()
+}

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

@@ -48,7 +48,7 @@ class NostrBridge(
                     try {
                         val pk =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .getPublicKey()
                         resolve(
                             callbackId,
@@ -107,7 +107,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .signEvent(
                                     payload
                                 )
@@ -180,7 +180,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip04Encrypt(
                                     pubkey,
                                     plaintext
@@ -254,7 +254,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip04Decrypt(
                                     pubkey,
                                     ciphertext
@@ -318,7 +318,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip44Encrypt(
                                     json.getString("pubkey"),
                                     json.getString("plaintext")
@@ -373,7 +373,7 @@ class NostrBridge(
 
                         val result =
                             signerManager
-                                .getSigner()
+                                .getConfiguredSigner()
                                 .nip44Decrypt(
                                     json.getString("pubkey"),
                                     json.getString("ciphertext")

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

@@ -14,12 +14,15 @@ import com.pakstr.app.signer.bunker.Nip46PairingUri
 import com.pakstr.app.signer.bunker.RelayNip46Client
 import com.pakstr.app.signer.exceptions.SignerUnavailableException
 import com.pakstr.app.signer.interfaces.NostrSigner
+import com.pakstr.app.signer.local.LocalAccountStore
+import kotlinx.coroutines.CompletableDeferred
 import org.json.JSONObject
 
 class SignerManager(
     context: Context,
     private val amberLauncher: ActivityResultLauncher<Intent>,
-    private val bunkerAuthChallengeHandler: ((String) -> Unit)? = null
+    private val bunkerAuthChallengeHandler: ((String) -> Unit)? = null,
+    private val signerPickerRequestHandler: (() -> Unit)? = null
 ) {
     private val context = context.applicationContext
     private val prefs =
@@ -30,10 +33,14 @@ class SignerManager(
     private val bunkerStore by lazy {
         BunkerConnectionStore(this.context)
     }
+    private val localAccountStore by lazy {
+        LocalAccountStore(this.context)
+    }
 
     private var activeSigner: NostrSigner? = null
     private var currentUserPubkey: String? = null
     private var pendingPairing: PendingPairing? = null
+    private var pendingSignerSelection: CompletableDeferred<Boolean>? = null
 
     init {
         AppDebugLogger.log(
@@ -44,7 +51,7 @@ class SignerManager(
     }
 
     fun getActiveType(): SignerType? {
-        val value = prefs.getString("type", SignerType.AMBER.name)
+        val value = prefs.getString(KEY_SIGNER_TYPE, SignerType.AMBER.name)
         return try {
             SignerType.valueOf(value.toString())
         } catch (_: IllegalArgumentException) {
@@ -52,6 +59,20 @@ class SignerManager(
         }
     }
 
+    fun isSignerConfigured(): Boolean =
+        prefs.getBoolean(KEY_SIGNER_CONFIGURED, false)
+
+    fun migrateLegacySignerConfiguration(setupCompleted: Boolean) {
+        if (prefs.contains(KEY_SIGNER_CONFIGURED)) {
+            return
+        }
+        if (setupCompleted || prefs.contains(KEY_SIGNER_TYPE)) {
+            prefs.edit {
+                putBoolean(KEY_SIGNER_CONFIGURED, true)
+            }
+        }
+    }
+
     fun hasBunkerSession(): Boolean {
         return try {
             val connection = bunkerStore.restore() ?: return false
@@ -169,6 +190,12 @@ class SignerManager(
         setActiveTypeWithoutClosing(type)
     }
 
+    fun createLocalAccount() {
+        localAccountStore.createAccount()
+        closeActiveSigner()
+        setActiveTypeWithoutClosing(SignerType.LOCAL)
+    }
+
     fun logoutBunker() {
         try {
             (activeSigner as? BunkerSigner)?.disconnect()
@@ -182,6 +209,56 @@ class SignerManager(
         }
     }
 
+    suspend fun getConfiguredSigner(): NostrSigner {
+        if (isSignerConfigured()) {
+            return getSigner()
+        }
+
+        var shouldRequestPicker = false
+        val selection =
+            synchronized(this) {
+                if (isSignerConfigured()) {
+                    null
+                } else {
+                    pendingSignerSelection
+                        ?: CompletableDeferred<Boolean>().also {
+                            pendingSignerSelection = it
+                            shouldRequestPicker = true
+                        }
+                }
+            }
+
+        if (selection == null) {
+            return getSigner()
+        }
+        if (shouldRequestPicker) {
+            val handler = signerPickerRequestHandler
+            if (handler == null) {
+                cancelSignerSelection()
+            } else {
+                try {
+                    handler()
+                } catch (_: Exception) {
+                    cancelSignerSelection()
+                }
+            }
+        }
+        if (!selection.await()) {
+            throw SignerUnavailableException("Signer selection was dismissed")
+        }
+        return getSigner()
+    }
+
+    fun cancelSignerSelection() {
+        val selection =
+            synchronized(this) {
+                pendingSignerSelection.also {
+                    pendingSignerSelection = null
+                }
+            }
+        selection?.complete(false)
+    }
+
     fun getSigner(): NostrSigner {
         activeSigner?.let { return it }
         val activeType = getActiveType()
@@ -195,6 +272,7 @@ class SignerManager(
             when (activeType) {
                 SignerType.AMBER -> createAmberSigner()
                 SignerType.BUNKER -> createBunkerSigner()
+                SignerType.LOCAL -> createLocalSigner()
                 SignerType.FAKE -> FakeSigner()
                 null -> throw IllegalStateException("No signer selected")
             }
@@ -204,6 +282,7 @@ class SignerManager(
 
     fun close() {
         cancelBunkerPairing()
+        cancelSignerSelection()
         closeActiveSigner()
     }
 
@@ -289,10 +368,36 @@ class SignerManager(
         return BunkerSigner(context, client)
     }
 
+    private fun createLocalSigner(): LocalSigner {
+        try {
+            localAccountStore.loadKey()?.use { key ->
+                currentUserPubkey = key.publicKeyHex
+            } ?: throw SignerUnavailableException(
+                "Local account has not been created"
+            )
+        } catch (error: SignerUnavailableException) {
+            throw error
+        } catch (error: Exception) {
+            throw IllegalStateException(
+                "Unable to restore local account",
+                error
+            )
+        }
+        return LocalSigner(localAccountStore)
+    }
+
     private fun setActiveTypeWithoutClosing(type: SignerType) {
         prefs.edit {
-            putString("type", type.name)
+            putString(KEY_SIGNER_TYPE, type.name)
+            putBoolean(KEY_SIGNER_CONFIGURED, true)
         }
+        val selection =
+            synchronized(this) {
+                pendingSignerSelection.also {
+                    pendingSignerSelection = null
+                }
+            }
+        selection?.complete(true)
     }
 
     private fun closeActiveSigner() {
@@ -319,6 +424,8 @@ class SignerManager(
     }
 
     private companion object {
+        const val KEY_SIGNER_TYPE = "type"
+        const val KEY_SIGNER_CONFIGURED = "signer_configured"
         const val BUNKER_PERMISSIONS =
             "sign_event,nip04_encrypt,nip04_decrypt," +
                     "nip44_encrypt,nip44_decrypt"

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

@@ -3,6 +3,7 @@ package com.pakstr.app.signer
 enum class SignerType {
     AMBER,
     BUNKER,
+    LOCAL,
     FAKE
 
 }