pakstr 0.27.0 → 0.29.0

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

@@ -0,0 +1,165 @@
+package com.pakstr.app.utils
+
+import android.content.Context
+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
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.pakstr.app.MainActivity
+import com.pakstr.app.R
+import com.pakstr.app.signer.SignerManager
+import com.pakstr.app.signer.SignerType
+import com.pakstr.app.signer.local.LocalAccountStore
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import java.security.KeyStore
+
+@RunWith(AndroidJUnit4::class)
+class SignerPickerBottomSheetTest {
+    private lateinit var context: Context
+
+    @Before
+    fun setup() {
+        context = ApplicationProvider.getApplicationContext()
+        AppPreferences.init(context)
+        AppPreferences.saveBoolean("isFirstRun", false)
+        clearLocalAccount()
+    }
+
+    @After
+    fun teardown() {
+        clearLocalAccount()
+        context.getSharedPreferences("signer", Context.MODE_PRIVATE)
+            .edit()
+            .clear()
+            .commit()
+        AppPreferences.saveBoolean("isFirstRun", true)
+    }
+
+    @Test
+    fun cold_start_does_not_show_signer_picker() {
+        AppPreferences.saveBoolean("isFirstRun", true)
+
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            scenario.onActivity { activity ->
+                assertNull(
+                    activity.supportFragmentManager
+                        .findFragmentByTag("SignerPicker")
+                )
+            }
+        }
+    }
+
+    @Test
+    fun completed_legacy_setup_migrates_signer_configuration() {
+        AppPreferences.saveBoolean("isFirstRun", false)
+
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            scenario.onActivity { activity ->
+                assertTrue(signerManager(activity).isSignerConfigured())
+            }
+        }
+    }
+
+    @Test
+    fun local_option_creates_and_selects_local_signer() {
+        ActivityScenario.launch(MainActivity::class.java).use { scenario ->
+            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))
+                .check(matches(withEffectiveVisibility(GONE)))
+            onView(withId(R.id.button_confirm)).perform(click())
+
+            waitForLocalSelection(scenario)
+        }
+    }
+
+    @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>
+    ) {
+        repeat(50) {
+            var activeType: SignerType? = null
+            scenario.onActivity { activity ->
+                activeType = signerManager(activity).getActiveType()
+            }
+            if (activeType == SignerType.LOCAL) {
+                assertEquals(SignerType.LOCAL, activeType)
+                return
+            }
+            Thread.sleep(100)
+        }
+        throw AssertionError("LOCAL signer was not selected")
+    }
+
+    private fun signerManager(activity: MainActivity): SignerManager {
+        return MainActivity::class.java
+            .getDeclaredField("signerManager")
+            .apply { isAccessible = true }
+            .get(activity) as SignerManager
+    }
+
+    private fun clearLocalAccount() {
+        context.getSharedPreferences(
+            LocalAccountStore.PREFERENCES_NAME,
+            Context.MODE_PRIVATE
+        ).edit().clear().commit()
+        KeyStore.getInstance("AndroidKeyStore")
+            .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,8 +42,11 @@ 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
+import kotlinx.coroutines.withContext
 import com.pakstr.app.utils.AppPreferences
 import com.pakstr.app.utils.BunkerPairingDialog
 import com.pakstr.app.utils.SignerPickerBottomSheet
@@ -61,6 +65,9 @@ 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())
     private val diagnosticsExpiryCheck = Runnable {
@@ -128,12 +135,6 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
             }
 
         initSigner()
-        if (
-            savedInstanceState == null &&
-            AppPreferences.getBoolean("isFirstRun", true)
-        ) {
-            container.post(::showSignerPicker)
-        }
 
         ViewCompat.setOnApplyWindowInsetsListener(
 
@@ -269,8 +270,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) {
@@ -360,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()
@@ -408,8 +432,26 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
     }
 
     private fun showSignerPicker() {
+        if (
+            supportFragmentManager.findFragmentByTag(SIGNER_PICKER_TAG) != null
+        ) {
+            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()
@@ -423,7 +465,31 @@ class MainActivity : AppCompatActivity(), PermissionHandler {
                     false
                 }
             },
-            onSharePairing = ::shareBunkerPairing,
+            onLocalSelected = {
+                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)
+            },
             onBunkerLogout = {
                 signerManager.logoutBunker()
                 Toast.makeText(
@@ -431,13 +497,130 @@ 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 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 =
@@ -446,6 +629,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 +654,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 +706,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/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()
+    }
+}