pakstr 0.28.0 → 0.29.0

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

@@ -22,6 +22,7 @@ import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNull
+import org.junit.Assert.assertThrows
 import org.junit.Assert.assertTrue
 import org.junit.Assert.fail
 import org.junit.Test
@@ -289,6 +290,64 @@ class SignerManagerTest {
         }
     }
 
+    @Test
+    fun imported_local_account_survives_manager_recreation() = runBlocking {
+        clearLocalAccount(context)
+        val first = SignerManager(context, NoOpLauncher())
+        try {
+            val candidate = first.prepareLocalAccountImport(NSEC_ONE)
+            assertEquals(NPUB_ONE, candidate.npub)
+            first.importLocalAccount(candidate)
+
+            assertTrue(first.hasLocalAccount())
+            assertEquals(SignerType.LOCAL, first.getActiveType())
+            assertEquals(PUBLIC_KEY_ONE, first.getCurrentUserPubkey())
+            first.close()
+
+            val restored = SignerManager(context, NoOpLauncher())
+            try {
+                assertEquals(SignerType.LOCAL, restored.getActiveType())
+                assertEquals(PUBLIC_KEY_ONE, restored.getCurrentUserPubkey())
+                val event =
+                    restored.getSigner().signEvent(
+                        "{\"kind\":1,\"created_at\":1," +
+                                "\"tags\":[],\"content\":\"imported\"}"
+                    )
+                assertTrue(event.contains(PUBLIC_KEY_ONE))
+            } finally {
+                restored.close()
+            }
+        } finally {
+            first.close()
+            clearLocalAccount(context)
+        }
+    }
+
+    @Test
+    fun invalid_or_duplicate_import_does_not_change_signer() = runBlocking {
+        clearLocalAccount(context)
+        val manager = SignerManager(context, NoOpLauncher())
+        try {
+            manager.setActiveType(SignerType.FAKE)
+            assertThrows(IllegalArgumentException::class.java) {
+                manager.prepareLocalAccountImport("not-an-nsec")
+            }
+            assertEquals(SignerType.FAKE, manager.getActiveType())
+            assertFalse(manager.hasLocalAccount())
+
+            manager.createLocalAccount()
+            val publicKey = manager.getCurrentUserPubkey()
+            assertThrows(IllegalStateException::class.java) {
+                manager.prepareLocalAccountImport(NSEC_ONE)
+            }
+            assertEquals(SignerType.LOCAL, manager.getActiveType())
+            assertEquals(publicKey, manager.getCurrentUserPubkey())
+        } finally {
+            manager.close()
+            clearLocalAccount(context)
+        }
+    }
+
     @Test
     fun switching_from_bunker_disconnects_and_closes_client() {
         val context =
@@ -458,6 +517,12 @@ class SignerManagerTest {
         const val VALID_PUBKEY =
             "cb227f60cb2a6d982ecbfc51b9199d340afc00b1ef81b67d8e3778e097e70d2c"
         const val PAIRING_SECRET = "pending-pairing-secret"
+        const val NSEC_ONE =
+            "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqsmhltgl"
+        const val NPUB_ONE =
+            "npub10xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqpkge6d"
+        const val PUBLIC_KEY_ONE =
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
     }
 
     private class NoOpLauncher : ActivityResultLauncher<Intent>() {

package/android-template/app/src/androidTest/java/com/pakstr/app/signer/local/LocalAccountStoreTest.kt

@@ -9,6 +9,7 @@ import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotEquals
 import org.junit.Assert.assertThrows
+import org.junit.Assert.assertNull
 import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
@@ -60,6 +61,81 @@ class LocalAccountStoreTest {
         assertEquals(first, second)
     }
 
+    @Test
+    fun imported_account_survives_store_recreation() {
+        val privateKey = ByteArray(32).also { it[31] = 1 }
+
+        try {
+            val importedPublicKey = store.importAccount(privateKey)
+            val restored =
+                LocalAccountStore(
+                    context,
+                    PREFERENCES_NAME,
+                    KEY_ALIAS
+                ).loadKey()
+
+            requireNotNull(restored).use { key ->
+                assertEquals(importedPublicKey, key.publicKeyHex)
+                assertEquals(PUBLIC_KEY_ONE, key.publicKeyHex)
+            }
+            assertFalse(
+                preferences().all.values.any { value ->
+                    value.toString().contains(
+                        Base64.encodeToString(
+                            privateKey,
+                            Base64.NO_WRAP
+                        )
+                    )
+                }
+            )
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    @Test
+    fun import_rejects_existing_account_without_changing_it() {
+        val existingPublicKey = store.createAccount()
+        val preferences = preferences()
+        val existingIv =
+            preferences.getString(LocalAccountStore.KEY_IV, null)
+        val existingCiphertext =
+            preferences.getString(LocalAccountStore.KEY_CIPHERTEXT, null)
+        val privateKey = ByteArray(32).also { it[31] = 1 }
+
+        try {
+            assertThrows(LocalAccountAlreadyExistsException::class.java) {
+                store.importAccount(privateKey)
+            }
+            assertEquals(existingIv, preferences.getString(LocalAccountStore.KEY_IV, null))
+            assertEquals(
+                existingCiphertext,
+                preferences.getString(LocalAccountStore.KEY_CIPHERTEXT, null)
+            )
+            requireNotNull(store.loadKey()).use { key ->
+                assertEquals(existingPublicKey, key.publicKeyHex)
+            }
+        } finally {
+            privateKey.fill(0)
+        }
+    }
+
+    @Test
+    fun invalid_import_persists_nothing() {
+        val privateKey = ByteArray(32)
+
+        assertThrows(IllegalArgumentException::class.java) {
+            store.importAccount(privateKey)
+        }
+        assertNull(preferences().getString(LocalAccountStore.KEY_IV, null))
+        assertNull(
+            preferences().getString(
+                LocalAccountStore.KEY_CIPHERTEXT,
+                null
+            )
+        )
+    }
+
     @Test
     fun persisted_value_is_not_plaintext_private_key() {
         store.createAccount()
@@ -190,5 +266,7 @@ class LocalAccountStoreTest {
     private companion object {
         const val PREFERENCES_NAME = "local_signer_account_test"
         const val KEY_ALIAS = "pakstr_local_signer_wrapping_key_test"
+        const val PUBLIC_KEY_ONE =
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
     }
 }

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

@@ -5,8 +5,10 @@ import androidx.test.core.app.ActivityScenario
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.espresso.Espresso.onView
 import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.action.ViewActions.replaceText
 import androidx.test.espresso.assertion.ViewAssertions.matches
 import androidx.test.espresso.matcher.ViewMatchers.isDisplayed
+import androidx.test.espresso.matcher.ViewMatchers.isChecked
 import androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility
 import androidx.test.espresso.matcher.ViewMatchers.withId
 import androidx.test.espresso.matcher.ViewMatchers.Visibility.GONE
@@ -75,16 +77,13 @@ class SignerPickerBottomSheetTest {
     @Test
     fun local_option_creates_and_selects_local_signer() {
         ActivityScenario.launch(MainActivity::class.java).use { scenario ->
-            scenario.onActivity { activity ->
-                MainActivity::class.java
-                    .getDeclaredMethod("showSignerPicker")
-                    .apply { isAccessible = true }
-                    .invoke(activity)
-            }
+            showPicker(scenario)
 
             onView(withId(R.id.radio_option_three))
                 .check(matches(isDisplayed()))
                 .perform(click())
+            onView(withId(R.id.radio_local_create))
+                .check(matches(isChecked()))
             onView(withId(R.id.bunker_uri_container))
                 .check(matches(withEffectiveVisibility(GONE)))
             onView(withId(R.id.button_share_pairing))
@@ -95,6 +94,36 @@ class SignerPickerBottomSheetTest {
         }
     }
 
+    @Test
+    fun local_import_can_be_cancelled_before_persistence() {
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            showPicker(scenario)
+
+            onView(withId(R.id.radio_option_three)).perform(click())
+            onView(withId(R.id.radio_local_import)).perform(click())
+            onView(withId(R.id.local_nsec_container))
+                .check(matches(isDisplayed()))
+            onView(withId(R.id.local_nsec)).perform(replaceText(NSEC_ONE))
+            onView(withId(R.id.button_confirm)).perform(click())
+            onView(withId(android.R.id.button2)).perform(click())
+
+            scenario.onActivity { activity ->
+                assertTrue(!signerManager(activity).hasLocalAccount())
+            }
+        }
+    }
+
+    private fun showPicker(
+        scenario: ActivityScenario<MainActivity>
+    ) {
+        scenario.onActivity { activity ->
+            MainActivity::class.java
+                .getDeclaredMethod("showSignerPicker")
+                .apply { isAccessible = true }
+                .invoke(activity)
+        }
+    }
+
     private fun waitForLocalSelection(
         scenario: ActivityScenario<MainActivity>
     ) {
@@ -128,4 +157,9 @@ class SignerPickerBottomSheetTest {
             .apply { load(null) }
             .deleteEntry(LocalAccountStore.KEY_ALIAS)
     }
+
+    private companion object {
+        const val NSEC_ONE =
+            "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqsmhltgl"
+    }
 }

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

@@ -9,6 +9,7 @@ import android.os.Handler
 import android.os.Looper
 
 import android.view.View
+import android.view.WindowManager
 import android.webkit.PermissionRequest
 import android.webkit.WebView
 import android.widget.FrameLayout
@@ -41,6 +42,7 @@ import com.pakstr.app.permissions.interfaces.PermissionHandler
 
 import com.pakstr.app.signer.SignerManager
 import com.pakstr.app.signer.SignerType
+import com.pakstr.app.signer.local.LocalAccountImportCandidate
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
@@ -63,6 +65,8 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     private lateinit var fab: FloatingActionButton
     private lateinit var supportUnlockGestureLayout: SupportUnlockGestureLayout
     private var bunkerPairingDialog: AlertDialog? = null
+    private var localImportDialog: AlertDialog? = null
+    private var localImportCandidate: LocalAccountImportCandidate? = null
     private var signerSetupInProgress = false
 
     private val diagnosticsHandler = Handler(Looper.getMainLooper())
@@ -375,6 +379,11 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
 
         bunkerPairingDialog?.dismiss()
         bunkerPairingDialog = null
+        localImportDialog?.setOnDismissListener(null)
+        localImportDialog?.dismiss()
+        localImportDialog = null
+        localImportCandidate?.close()
+        localImportCandidate = null
 
         if (::signerManager.isInitialized) {
             signerManager.close()
@@ -428,8 +437,21 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         ) {
             return
         }
+        val hasLocalAccount =
+            try {
+                signerManager.hasLocalAccount()
+            } catch (_: Exception) {
+                Toast.makeText(
+                    this,
+                    R.string.signer_picker_local_status_failed,
+                    Toast.LENGTH_LONG
+                ).show()
+                signerManager.cancelSignerSelection()
+                return
+            }
         SignerPickerBottomSheet(
             hasBunkerSession = signerManager.hasBunkerSession(),
+            hasLocalAccount = hasLocalAccount,
             onAmberSelected = {
                 signerManager.setActiveType(SignerType.AMBER)
                 handleSignerSetup()
@@ -447,6 +469,23 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                 signerSetupInProgress = true
                 createLocalAccount()
             },
+            onLocalImportSelected = { nsec ->
+                val candidate =
+                    try {
+                        signerManager.prepareLocalAccountImport(nsec)
+                    } catch (_: Exception) {
+                        null
+                    }
+                if (candidate == null) {
+                    false
+                } else {
+                    signerSetupInProgress = true
+                    localImportCandidate?.close()
+                    localImportCandidate = candidate
+                    showLocalImportConfirmation(candidate)
+                    true
+                }
+            },
             onSharePairing = { relayUrls ->
                 signerSetupInProgress = true
                 shareBunkerPairing(relayUrls)
@@ -497,6 +536,91 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
         }
     }
 
+    private fun showLocalImportConfirmation(
+        candidate: LocalAccountImportCandidate
+    ) {
+        if (localImportCandidate !== candidate) {
+            return
+        }
+        if (isFinishing || isDestroyed) {
+            discardLocalAccountImport()
+            return
+        }
+        var confirmed = false
+        val dialog =
+            AlertDialog.Builder(this)
+                .setTitle(R.string.signer_picker_local_confirm_title)
+                .setMessage(
+                    getString(
+                        R.string.signer_picker_local_confirm_message,
+                        candidate.npub
+                    )
+                )
+                .setPositiveButton(
+                    R.string.signer_picker_local_confirm
+                ) { _, _ ->
+                    confirmed = true
+                    confirmLocalAccountImport(candidate)
+                }
+                .setNegativeButton(
+                    R.string.signer_picker_local_cancel,
+                    null
+                )
+                .create()
+        dialog.setOnDismissListener {
+            if (!confirmed) {
+                discardLocalAccountImport()
+            }
+            if (localImportDialog === dialog) {
+                localImportDialog = null
+            }
+        }
+        localImportDialog = dialog
+        dialog.show()
+        dialog.window?.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    }
+
+    private fun confirmLocalAccountImport(
+        candidate: LocalAccountImportCandidate
+    ) {
+        if (localImportCandidate !== candidate) {
+            return
+        }
+        localImportCandidate = null
+        lifecycleScope.launch {
+            val imported =
+                withContext(Dispatchers.IO) {
+                    try {
+                        signerManager.importLocalAccount(candidate)
+                        true
+                    } catch (cancelled: CancellationException) {
+                        candidate.close()
+                        throw cancelled
+                    } catch (_: Exception) {
+                        false
+                    }
+                }
+            signerSetupInProgress = false
+            if (imported) {
+                handleSignerSetup()
+            } else {
+                signerManager.cancelSignerSelection()
+                Toast.makeText(
+                    this@MainActivity,
+                    R.string.signer_picker_local_import_failed,
+                    Toast.LENGTH_LONG
+                ).show()
+            }
+        }
+    }
+
+    private fun discardLocalAccountImport() {
+        localImportCandidate?.close()
+        localImportCandidate = null
+        signerSetupInProgress = false
+        signerManager.cancelSignerSelection()
+    }
+
     private fun shareBunkerPairing(relayUrls: List<String>) {
         lifecycleScope.launch {
             val pairingUri =

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

@@ -0,0 +1,181 @@
+package com.pakstr.app.crypto
+
+internal class InvalidNsecException : IllegalArgumentException(
+    "Invalid nsec"
+)
+
+internal object Nip19Codec {
+    private const val NSEC_HRP = "nsec"
+    private const val NPUB_HRP = "npub"
+    private const val PAYLOAD_SIZE = 32
+    private const val CHECKSUM_SIZE = 6
+    private const val MAX_ENCODED_LENGTH = 90
+    private const val BECH32_CONSTANT = 1
+    private const val CHARSET =
+        "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+    private val reverseCharset = IntArray(128) { -1 }.apply {
+        CHARSET.forEachIndexed { index, character ->
+            this[character.code] = index
+        }
+    }
+
+    fun decodeNsec(value: String): ByteArray {
+        if (
+            value.isEmpty() ||
+            value.length > MAX_ENCODED_LENGTH ||
+            value != value.lowercase()
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val separator = value.lastIndexOf('1')
+        if (
+            separator < 1 ||
+            separator + CHECKSUM_SIZE + 1 > value.length
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val hrp = value.substring(0, separator)
+        if (
+            hrp != NSEC_HRP ||
+            hrp.any { it.code !in 33..126 }
+        ) {
+            throw InvalidNsecException()
+        }
+
+        val data = IntArray(value.length - separator - 1)
+        value.substring(separator + 1).forEachIndexed { index, character ->
+            val decoded =
+                if (character.code < reverseCharset.size) {
+                    reverseCharset[character.code]
+                } else {
+                    -1
+                }
+            if (decoded < 0) {
+                throw InvalidNsecException()
+            }
+            data[index] = decoded
+        }
+        if (polymod(hrpExpand(hrp) + data) != BECH32_CONSTANT) {
+            throw InvalidNsecException()
+        }
+
+        val decoded = convertBits(
+            data.copyOf(data.size - CHECKSUM_SIZE),
+            fromBits = 5,
+            toBits = 8,
+            pad = false
+        )
+        if (decoded.size != PAYLOAD_SIZE) {
+            decoded.fill(0)
+            throw InvalidNsecException()
+        }
+        return ByteArray(decoded.size) { index ->
+            decoded[index].toByte()
+        }.also {
+            decoded.fill(0)
+        }
+    }
+
+    fun encodeNpub(publicKey: ByteArray): String {
+        require(publicKey.size == PAYLOAD_SIZE) {
+            "Public key must be exactly 32 bytes"
+        }
+        val data = convertBits(
+            IntArray(publicKey.size) { index ->
+                publicKey[index].toInt() and 0xff
+            },
+            fromBits = 8,
+            toBits = 5,
+            pad = true
+        )
+        val checksum = createChecksum(NPUB_HRP, data)
+        return buildString {
+            append(NPUB_HRP)
+            append('1')
+            (data + checksum).forEach { append(CHARSET[it]) }
+        }
+    }
+
+    private fun createChecksum(
+        hrp: String,
+        data: IntArray
+    ): IntArray {
+        val values = hrpExpand(hrp) + data + IntArray(CHECKSUM_SIZE)
+        val remainder = polymod(values) xor BECH32_CONSTANT
+        return IntArray(CHECKSUM_SIZE) { index ->
+            (remainder shr (5 * (CHECKSUM_SIZE - 1 - index))) and 31
+        }
+    }
+
+    private fun hrpExpand(hrp: String): IntArray {
+        val result = IntArray(hrp.length * 2 + 1)
+        hrp.forEachIndexed { index, character ->
+            result[index] = character.code shr 5
+            result[hrp.length + 1 + index] = character.code and 31
+        }
+        return result
+    }
+
+    private fun polymod(values: IntArray): Int {
+        var checksum = 1
+        val generators = intArrayOf(
+            0x3b6a57b2,
+            0x26508e6d,
+            0x1ea119fa,
+            0x3d4233dd,
+            0x2a1462b3
+        )
+        values.forEach { value ->
+            val top = checksum ushr 25
+            checksum = (checksum and 0x1ffffff) shl 5 xor value
+            generators.forEachIndexed { index, generator ->
+                if ((top shr index) and 1 != 0) {
+                    checksum = checksum xor generator
+                }
+            }
+        }
+        return checksum
+    }
+
+    private fun convertBits(
+        values: IntArray,
+        fromBits: Int,
+        toBits: Int,
+        pad: Boolean
+    ): IntArray {
+        var accumulator = 0
+        var bitCount = 0
+        val output = ArrayList<Int>()
+        val fromMask = (1 shl fromBits) - 1
+        val toMask = (1 shl toBits) - 1
+
+        values.forEach { value ->
+            if (value < 0 || value ushr fromBits != 0) {
+                throw InvalidNsecException()
+            }
+            accumulator =
+                ((accumulator and ((1 shl (fromBits + toBits - 1)) - 1))
+                        shl fromBits) or (value and fromMask)
+            bitCount += fromBits
+            while (bitCount >= toBits) {
+                bitCount -= toBits
+                output += (accumulator ushr bitCount) and toMask
+            }
+        }
+
+        if (pad) {
+            if (bitCount > 0) {
+                output += (accumulator shl (toBits - bitCount)) and toMask
+            }
+        } else if (
+            bitCount >= fromBits ||
+            ((accumulator shl (toBits - bitCount)) and toMask) != 0
+        ) {
+            throw InvalidNsecException()
+        }
+
+        return output.toIntArray()
+    }
+}

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

@@ -14,6 +14,8 @@ 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.LocalAccountAlreadyExistsException
+import com.pakstr.app.signer.local.LocalAccountImportCandidate
 import com.pakstr.app.signer.local.LocalAccountStore
 import kotlinx.coroutines.CompletableDeferred
 import org.json.JSONObject
@@ -196,6 +198,29 @@ class SignerManager(
         setActiveTypeWithoutClosing(SignerType.LOCAL)
     }
 
+    fun hasLocalAccount(): Boolean = localAccountStore.hasAccount()
+
+    internal fun prepareLocalAccountImport(
+        nsec: String
+    ): LocalAccountImportCandidate {
+        if (localAccountStore.hasAccount()) {
+            throw LocalAccountAlreadyExistsException()
+        }
+        return LocalAccountImportCandidate.parse(nsec)
+    }
+
+    internal fun importLocalAccount(
+        candidate: LocalAccountImportCandidate
+    ) {
+        try {
+            candidate.withPrivateKey(localAccountStore::importAccount)
+            closeActiveSigner()
+            setActiveTypeWithoutClosing(SignerType.LOCAL)
+        } finally {
+            candidate.close()
+        }
+    }
+
     fun logoutBunker() {
         try {
             (activeSigner as? BunkerSigner)?.disconnect()

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

@@ -0,0 +1,42 @@
+package com.pakstr.app.signer.local
+
+import com.pakstr.app.crypto.Nip19Codec
+import com.pakstr.app.crypto.Nip46ClientKey
+
+internal class LocalAccountImportCandidate private constructor(
+    private val key: Nip46ClientKey,
+    val npub: String
+) : AutoCloseable {
+
+    internal fun <T> withPrivateKey(
+        block: (ByteArray) -> T
+    ): T = key.withPrivateKey(block)
+
+    override fun close() {
+        key.close()
+    }
+
+    companion object {
+        fun parse(nsec: String): LocalAccountImportCandidate {
+            val privateKey = Nip19Codec.decodeNsec(nsec)
+            return try {
+                val key = Nip46ClientKey.fromPrivateKey(privateKey)
+                try {
+                    val publicKey = key.publicKey
+                    val npub =
+                        try {
+                            Nip19Codec.encodeNpub(publicKey)
+                        } finally {
+                            publicKey.fill(0)
+                        }
+                    LocalAccountImportCandidate(key, npub)
+                } catch (error: Exception) {
+                    key.close()
+                    throw error
+                }
+            } finally {
+                privateKey.fill(0)
+            }
+        }
+    }
+}

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

@@ -16,6 +16,9 @@ internal class LocalAccountStorageException(
     cause: Throwable? = null
 ) : Exception(message, cause)
 
+internal class LocalAccountAlreadyExistsException :
+    IllegalStateException("Local account already exists")
+
 internal class LocalAccountStore(
     context: Context,
     private val preferencesName: String = PREFERENCES_NAME,
@@ -47,6 +50,18 @@ internal class LocalAccountStore(
             }
         }
 
+    fun importAccount(privateKey: ByteArray): String =
+        synchronized(STORAGE_LOCK) {
+            if (hasAccountLocked()) {
+                throw LocalAccountAlreadyExistsException()
+            }
+
+            Nip46ClientKey.fromPrivateKey(privateKey).use { key ->
+                key.withPrivateKey(::saveNewKey)
+                key.publicKeyHex
+            }
+        }
+
     fun hasAccount(): Boolean =
         synchronized(STORAGE_LOCK) {
             hasAccountLocked()
@@ -105,8 +120,8 @@ internal class LocalAccountStore(
     }
 
     private fun saveNewKey(privateKey: ByteArray) {
-        check(!hasAccountLocked()) {
-            "Local account already exists"
+        if (hasAccountLocked()) {
+            throw LocalAccountAlreadyExistsException()
         }
 
         val wrappingKey = getOrCreateWrappingKey()

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

@@ -5,6 +5,7 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import android.view.WindowManager
 import android.widget.Button
 import android.widget.RadioGroup
 import com.google.android.material.bottomsheet.BottomSheetDialogFragment
@@ -14,9 +15,11 @@ import com.pakstr.app.R
 
 class SignerPickerBottomSheet(
     private val hasBunkerSession: Boolean,
+    private val hasLocalAccount: Boolean,
     private val onAmberSelected: () -> Unit,
     private val onBunkerSelected: (String) -> Boolean,
     private val onLocalSelected: () -> Unit,
+    private val onLocalImportSelected: (String) -> Boolean,
     private val onSharePairing: (List<String>) -> Unit,
     private val onBunkerLogout: () -> Unit,
     private val onDismissed: () -> Unit = {}
@@ -34,6 +37,11 @@ class SignerPickerBottomSheet(
         )
     }
 
+    override fun onStart() {
+        super.onStart()
+        dialog?.window?.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
+    }
+
     override fun onViewCreated(
         view: View,
         savedInstanceState: Bundle?
@@ -42,6 +50,11 @@ class SignerPickerBottomSheet(
         val radioGroup = view.findViewById<RadioGroup>(R.id.options_radio_group)
         val uriContainer = view.findViewById<TextInputLayout>(R.id.bunker_uri_container)
         val uriInput = view.findViewById<TextInputEditText>(R.id.bunker_uri)
+        val localActions = view.findViewById<View>(R.id.local_account_actions)
+        val localExisting = view.findViewById<View>(R.id.local_account_existing)
+        val localActionGroup = view.findViewById<RadioGroup>(R.id.local_action_radio_group)
+        val nsecContainer = view.findViewById<TextInputLayout>(R.id.local_nsec_container)
+        val nsecInput = view.findViewById<TextInputEditText>(R.id.local_nsec)
         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)
@@ -49,19 +62,58 @@ class SignerPickerBottomSheet(
         logout.visibility =
             if (hasBunkerSession) View.VISIBLE else View.GONE
 
-        fun updateBunkerControls() {
+        fun updateControls() {
             val bunkerSelected =
                 radioGroup.checkedRadioButtonId == R.id.radio_option_two
+            val localSelected =
+                radioGroup.checkedRadioButtonId == R.id.radio_option_three
             uriContainer.visibility =
                 if (bunkerSelected) View.VISIBLE else View.GONE
             sharePairing.visibility =
                 if (bunkerSelected) View.VISIBLE else View.GONE
+            localActions.visibility =
+                if (localSelected && !hasLocalAccount) {
+                    View.VISIBLE
+                } else {
+                    View.GONE
+                }
+            localExisting.visibility =
+                if (localSelected && hasLocalAccount) {
+                    View.VISIBLE
+                } else {
+                    View.GONE
+                }
+            nsecContainer.visibility =
+                if (
+                    localSelected &&
+                    !hasLocalAccount &&
+                    localActionGroup.checkedRadioButtonId ==
+                    R.id.radio_local_import
+                ) {
+                    View.VISIBLE
+                } else {
+                    View.GONE
+                }
         }
         radioGroup.setOnCheckedChangeListener { _, _ ->
             uriContainer.error = null
-            updateBunkerControls()
+            nsecContainer.error = null
+            if (radioGroup.checkedRadioButtonId != R.id.radio_option_three) {
+                nsecInput.text?.clear()
+            }
+            updateControls()
         }
-        updateBunkerControls()
+        localActionGroup.setOnCheckedChangeListener { _, _ ->
+            nsecContainer.error = null
+            if (
+                localActionGroup.checkedRadioButtonId !=
+                R.id.radio_local_import
+            ) {
+                nsecInput.text?.clear()
+            }
+            updateControls()
+        }
+        updateControls()
 
         confirm.setOnClickListener {
             when (radioGroup.checkedRadioButtonId) {
@@ -73,7 +125,24 @@ class SignerPickerBottomSheet(
                         return@setOnClickListener
                     }
                 }
-                R.id.radio_option_three -> onLocalSelected()
+                R.id.radio_option_three -> {
+                    val importing =
+                        !hasLocalAccount &&
+                                localActionGroup.checkedRadioButtonId ==
+                                R.id.radio_local_import
+                    if (importing) {
+                        val value =
+                            nsecInput.text?.toString().orEmpty().trim()
+                        if (!onLocalImportSelected(value)) {
+                            nsecContainer.error =
+                                getString(R.string.signer_picker_local_invalid)
+                            return@setOnClickListener
+                        }
+                        nsecInput.text?.clear()
+                    } else {
+                        onLocalSelected()
+                    }
+                }
                 else -> onAmberSelected()
             }
             dismiss()
@@ -104,6 +173,13 @@ class SignerPickerBottomSheet(
         }
     }
 
+    override fun onDestroyView() {
+        view?.findViewById<TextInputEditText>(R.id.local_nsec)
+            ?.text
+            ?.clear()
+        super.onDestroyView()
+    }
+
     override fun onDismiss(dialog: DialogInterface) {
         super.onDismiss(dialog)
         onDismissed()

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

@@ -208,6 +208,21 @@
                             android:layout_height="wrap_content"
                             android:textColor="?android:attr/textColorSecondary" />
                     </LinearLayout>
+
+                    <TextView
+                        style="@style/TextAppearance.MaterialComponents.Subtitle2"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="12dp"
+                        android:text="@string/developer_tools_chrome_webview_inspection" />
+
+                    <TextView
+                        style="@style/TextAppearance.MaterialComponents.Caption"
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:layout_marginTop="4dp"
+                        android:text="@string/developer_tools_chrome_webview_inspection_note"
+                        android:textColor="?android:attr/textColorSecondary" />
                 </LinearLayout>
             </com.google.android.material.card.MaterialCardView>
 

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

@@ -97,6 +97,68 @@
             android:textSize="16sp" />
     </RadioGroup>
 
+    <LinearLayout
+        android:id="@+id/local_account_actions"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="12dp"
+        android:orientation="vertical"
+        android:paddingStart="16dp"
+        android:paddingEnd="16dp"
+        android:visibility="gone">
+
+        <RadioGroup
+            android:id="@+id/local_action_radio_group"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+
+            <RadioButton
+                android:id="@+id/radio_local_create"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:checked="true"
+                android:text="@string/signer_picker_local_create" />
+
+            <RadioButton
+                android:id="@+id/radio_local_import"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:text="@string/signer_picker_local_import" />
+        </RadioGroup>
+
+        <com.google.android.material.textfield.TextInputLayout
+            android:id="@+id/local_nsec_container"
+            style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="8dp"
+            android:hint="@string/signer_picker_local_nsec_hint"
+            android:visibility="gone"
+            app:endIconMode="password_toggle">
+
+            <com.google.android.material.textfield.TextInputEditText
+                android:id="@+id/local_nsec"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:importantForAutofill="no"
+                android:inputType="textPassword|textNoSuggestions"
+                android:maxLines="1"
+                android:saveEnabled="false" />
+        </com.google.android.material.textfield.TextInputLayout>
+    </LinearLayout>
+
+    <TextView
+        android:id="@+id/local_account_existing"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="12dp"
+        android:paddingStart="16dp"
+        android:paddingEnd="16dp"
+        android:text="@string/signer_picker_local_existing"
+        android:textColor="#4B5563"
+        android:visibility="gone" />
+
     <com.google.android.material.textfield.TextInputLayout
         android:id="@+id/bunker_uri_container"
         style="@style/Widget.MaterialComponents.TextInputLayout.OutlinedBox"

package/android-template/app/src/main/res/values/strings.xml

@@ -32,6 +32,8 @@
     <string name="developer_tools_api_base_save_failed">Unable to persist the API Base URL setting.</string>
     <string name="developer_tools_api_base_invalid">Enter an absolute HTTPS URL without credentials, query, or fragment.</string>
     <string name="developer_tools_webview_debug">WebView Debug</string>
+    <string name="developer_tools_chrome_webview_inspection">Chrome WebView Inspection</string>
+    <string name="developer_tools_chrome_webview_inspection_note">To inspect this app in Chrome DevTools, enable Developer options → USB debugging on your Android device. This is required even when connecting over Wi-Fi.</string>
     <string name="developer_tools_enabled">Enabled</string>
     <string name="developer_tools_disabled">Disabled</string>
 
@@ -66,11 +68,22 @@
 
     <string name="signer_settings">Signer settings</string>
     <string name="signer_picker_title">Choose a signer</string>
-    <string name="signer_picker_subtitle">Use Amber, connect to a remote signer, or create an app-local account.</string>
+    <string name="signer_picker_subtitle">Use Amber, connect to a remote signer, or use an app-local account.</string>
     <string name="signer_picker_amber">Continue with Amber</string>
     <string name="signer_picker_bunker">Connect to remote signer (Bunker)</string>
-    <string name="signer_picker_local">Create app-local account</string>
+    <string name="signer_picker_local">App-local account</string>
+    <string name="signer_picker_local_create">Create new account</string>
+    <string name="signer_picker_local_import">Import existing account</string>
+    <string name="signer_picker_local_nsec_hint">Enter your nsec</string>
+    <string name="signer_picker_local_existing">Use the existing app-local account on this device.</string>
+    <string name="signer_picker_local_invalid">Enter a valid lowercase nsec.</string>
+    <string name="signer_picker_local_confirm_title">Confirm account import</string>
+    <string name="signer_picker_local_confirm_message">Import this account?\n\n%1$s</string>
+    <string name="signer_picker_local_confirm">Import</string>
+    <string name="signer_picker_local_cancel">Cancel</string>
     <string name="signer_picker_local_failed">Unable to create the app-local account.</string>
+    <string name="signer_picker_local_status_failed">Unable to check the app-local account.</string>
+    <string name="signer_picker_local_import_failed">Unable to import the app-local account.</string>
     <string name="signer_picker_bunker_hint">Paste a bunker:// connection</string>
     <string name="signer_picker_share_pairing">Share a nostrconnect:// pairing</string>
     <string name="signer_picker_logout_bunker">Disconnect remote signer</string>

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

@@ -0,0 +1,178 @@
+package com.pakstr.app.crypto
+
+import com.pakstr.app.signer.local.LocalAccountImportCandidate
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class Nip19CodecTest {
+
+    @Test
+    fun decodes_known_nsec_vector() {
+        val decoded = Nip19Codec.decodeNsec(NSEC_ONE)
+
+        assertArrayEquals(
+            ByteArray(32).also { it[31] = 1 },
+            decoded
+        )
+        decoded.fill(0)
+    }
+
+    @Test
+    fun encodes_known_npub_vector() {
+        val publicKey = Bip340Hash.hexToBytes(PUBLIC_KEY_ONE)
+
+        try {
+            assertEquals(NPUB_ONE, Nip19Codec.encodeNpub(publicKey))
+        } finally {
+            publicKey.fill(0)
+        }
+    }
+
+    @Test
+    fun import_candidate_derives_expected_npub_and_closes_key() {
+        val candidate = LocalAccountImportCandidate.parse(NSEC_ONE)
+
+        assertEquals(NPUB_ONE, candidate.npub)
+        assertFalse(candidate.toString().contains(NSEC_ONE))
+        candidate.close()
+        assertThrows(IllegalStateException::class.java) {
+            candidate.withPrivateKey { }
+        }
+    }
+
+    @Test
+    fun rejects_noncanonical_or_corrupt_nsec() {
+        val invalid = listOf(
+            NSEC_ONE.uppercase(),
+            "Nsec" + NSEC_ONE.substring(4),
+            "xsec" + NSEC_ONE.substring(4),
+            NSEC_ONE.dropLast(1) + "q",
+            NSEC_ONE.replaceRange(8, 9, "i"),
+            NSEC_ONE.dropLast(1),
+            NSEC_ONE + "q"
+        )
+
+        invalid.forEach { value ->
+            assertThrows(InvalidNsecException::class.java) {
+                Nip19Codec.decodeNsec(value)
+            }
+        }
+    }
+
+    @Test
+    fun rejects_invalid_private_scalars() {
+        val zero = encodeNsecForTest(ByteArray(32))
+        val order = Bip340Hash.hexToBytes(SECP256K1_ORDER)
+        val aboveOrder = order.copyOf().also {
+            it[it.lastIndex] = (it.last().toInt() + 1).toByte()
+        }
+
+        try {
+            assertThrows(IllegalArgumentException::class.java) {
+                LocalAccountImportCandidate.parse(zero)
+            }
+            assertThrows(IllegalArgumentException::class.java) {
+                LocalAccountImportCandidate.parse(
+                    encodeNsecForTest(order)
+                )
+            }
+            assertThrows(IllegalArgumentException::class.java) {
+                LocalAccountImportCandidate.parse(
+                    encodeNsecForTest(aboveOrder)
+                )
+            }
+        } finally {
+            order.fill(0)
+            aboveOrder.fill(0)
+        }
+    }
+
+    @Test
+    fun rejects_wrong_payload_lengths_and_accepts_leading_zero() {
+        assertThrows(InvalidNsecException::class.java) {
+            Nip19Codec.decodeNsec(encodeNsecForTest(ByteArray(31)))
+        }
+        assertThrows(InvalidNsecException::class.java) {
+            Nip19Codec.decodeNsec(encodeNsecForTest(ByteArray(33)))
+        }
+
+        LocalAccountImportCandidate.parse(NSEC_ONE).use { candidate ->
+            assertEquals(NPUB_ONE, candidate.npub)
+        }
+    }
+
+    private fun encodeNsecForTest(bytes: ByteArray): String {
+        val data = convertBits(bytes)
+        val values = hrpExpand("nsec") + data + IntArray(6)
+        val checksum = polymod(values) xor 1
+        val check = IntArray(6) { index ->
+            (checksum shr (5 * (5 - index))) and 31
+        }
+        return "nsec1" + (data + check).joinToString("") {
+            CHARSET[it].toString()
+        }
+    }
+
+    private fun convertBits(bytes: ByteArray): IntArray {
+        var accumulator = 0
+        var bits = 0
+        val output = ArrayList<Int>()
+        bytes.forEach { byte ->
+            accumulator = (accumulator shl 8) or (byte.toInt() and 0xff)
+            bits += 8
+            while (bits >= 5) {
+                bits -= 5
+                output += (accumulator shr bits) and 31
+            }
+        }
+        if (bits > 0) {
+            output += (accumulator shl (5 - bits)) and 31
+        }
+        return output.toIntArray()
+    }
+
+    private fun hrpExpand(hrp: String): IntArray =
+        IntArray(hrp.length * 2 + 1).also { result ->
+            hrp.forEachIndexed { index, character ->
+                result[index] = character.code shr 5
+                result[hrp.length + 1 + index] = character.code and 31
+            }
+        }
+
+    private fun polymod(values: IntArray): Int {
+        var checksum = 1
+        val generators = intArrayOf(
+            0x3b6a57b2,
+            0x26508e6d,
+            0x1ea119fa,
+            0x3d4233dd,
+            0x2a1462b3
+        )
+        values.forEach { value ->
+            val top = checksum ushr 25
+            checksum = (checksum and 0x1ffffff) shl 5 xor value
+            generators.forEachIndexed { index, generator ->
+                if ((top shr index) and 1 != 0) {
+                    checksum = checksum xor generator
+                }
+            }
+        }
+        return checksum
+    }
+
+    private companion object {
+        const val CHARSET =
+            "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
+        const val NSEC_ONE =
+            "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqsmhltgl"
+        const val PUBLIC_KEY_ONE =
+            "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
+        const val NPUB_ONE =
+            "npub10xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqpkge6d"
+        const val SECP256K1_ORDER =
+            "fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pakstr",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "CLI for packaging Nostr web apps into Android APKs",
   "type": "commonjs",
   "main": "dist/index.js",
@@ -54,9 +54,9 @@
     "applesauce-core": "^6.2.0",
     "applesauce-signers": "^6.2.2",
     "fs-extra": "^11.3.6",
-    "js-yaml": "^5.3.0",
+    "js-yaml": "^5.4.1",
     "node-fetch": "^3.3.2",
-    "sharp": "^0.35.3",
+    "sharp": "^0.35.5",
     "unzipper": "^0.12.5"
   },
   "repository": {