fix: prevent false on-chain send success

app/src/androidTest/java/to/bitkit/services/OnchainBackupRestoreDeviceTest.kt

@@ -0,0 +1,92 @@
+package to.bitkit.services
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.work.Configuration
+import androidx.work.WorkManager
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.junit.Assume.assumeTrue
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import to.bitkit.data.backup.VssBackupClient
+import to.bitkit.data.keychain.Keychain
+import to.bitkit.env.Env
+import to.bitkit.models.BackupCategory
+import to.bitkit.models.WalletBackupV1
+import to.bitkit.repositories.BackupRepo
+import to.bitkit.repositories.OnchainSendAttemptStore
+import javax.inject.Inject
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/** Opt-in remote backup check; run only on an owned funded test wallet. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+class OnchainBackupRestoreDeviceTest {
+    @get:Rule val hiltRule: HiltAndroidRule = HiltAndroidRule(this)
+    @Inject lateinit var backups: BackupRepo
+    @Inject lateinit var vss: VssBackupClient
+    @Inject lateinit var attempts: OnchainSendAttemptStore
+    @Inject lateinit var keychain: Keychain
+
+    @Test
+    fun remoteWalletBackupRestoresTheOriginalAcceptedPayment(): Unit = runBlocking {
+        assumeTrue(InstrumentationRegistry.getArguments().getString("ownedWalletVss") == "true")
+        withTimeout(180_000) {
+            val context = ApplicationProvider.getApplicationContext<Context>()
+            Env.initAppStoragePath(context.filesDir.absolutePath)
+            hiltRule.inject()
+            WorkManager.initialize(context, Configuration.Builder().build())
+            vss.setup().getOrThrow()
+            if (backups.hasPendingWalletRestore()) {
+                backups.performFullRestoreFromLatestBackup().getOrThrow()
+            }
+            val original = assertNotNull(attempts.current())
+            assertTrue(original.hasPositiveEvidence && original.localFollowupComplete)
+            assertTrue(original.requestId == null && !original.isTransfer)
+            vss.setup(original.walletIndex).getOrThrow()
+            try {
+                keychain.upsertString(
+                    Keychain.Key.ONCHAIN_SEND_ATTEMPT.name,
+                    Json.encodeToString(original.copy(localFollowupComplete = false)),
+                    original.walletIndex,
+                )
+                assertTrue(assertNotNull(attempts.current()).blocksNextSend)
+                // Upload the complete owned fixture first: restoring must not rewind unrelated categories.
+                for (category in BackupCategory.entries.filterNot { it == BackupCategory.LIGHTNING_CONNECTIONS }) {
+                    backups.triggerBackup(category).getOrThrow()
+                }
+                val remote = assertNotNull(vss.getObject(BackupCategory.WALLET.name).getOrThrow())
+                val payload = Json.decodeFromString<WalletBackupV1>(remote.value.decodeToString())
+                val wire = assertNotNull(payload.paykitPaymentState?.activeOnchainAttempt)
+                assertEquals(original.attemptId, wire.attemptId)
+                assertEquals(original.txid, wire.txid)
+                keychain.delete(Keychain.Key.ONCHAIN_SEND_ATTEMPT.name, original.walletIndex)
+                assertNull(attempts.current())
+                backups.performFullRestoreFromLatestBackup().getOrThrow()
+                val restored = assertNotNull(attempts.current())
+                assertEquals(original.attemptId, restored.attemptId)
+                assertEquals(original.walletIndex, restored.walletIndex)
+                assertEquals(original.walletId, restored.walletId)
+                assertEquals(original.txid, restored.txid)
+                assertEquals(original.amountSats, restored.amountSats)
+                assertEquals(original.originalInputs, restored.originalInputs)
+                assertEquals(original.candidateTxids, restored.candidateTxids)
+                assertTrue(restored.hasPositiveEvidence && restored.localFollowupComplete)
+            } finally {
+                attempts.restoreActive(original)
+                attempts.markLocalFollowupComplete(original.attemptId, original.walletIndex)
+            }
+        }
+    }
+}

app/src/androidTest/java/to/bitkit/services/PreparedOnchainRecoveryFixtureTest.kt

@@ -0,0 +1,136 @@
+package to.bitkit.services
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import to.bitkit.data.SettingsStore
+import to.bitkit.data.keychain.Keychain
+import to.bitkit.env.Env
+import to.bitkit.models.WalletScope
+import to.bitkit.repositories.OnchainSendAttemptStore
+import to.bitkit.repositories.OnchainSendOutcome
+import to.bitkit.repositories.WalletRepo
+import to.bitkit.test.annotations.CoreServiceIntegration
+import to.bitkit.test.annotations.DeviceIntegration
+import java.io.File
+import javax.inject.Inject
+
+/** Disposable-device fixture: real signed receipt, deliberately seeded Pending, never a native fault claim. */
+@HiltAndroidTest
+@RunWith(AndroidJUnit4::class)
+@DeviceIntegration
+@CoreServiceIntegration
+class PreparedOnchainRecoveryFixtureTest {
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var lightningService: LightningService
+
+    @Inject
+    lateinit var coreService: CoreService
+
+    @Inject
+    lateinit var keychain: Keychain
+
+    @Inject
+    lateinit var walletRepo: WalletRepo
+
+    @Inject
+    lateinit var store: OnchainSendAttemptStore
+
+    @Inject
+    lateinit var settingsStore: SettingsStore
+
+    @Test
+    fun verifySharedVssBindingVectors() {
+        val mnemonic = List(11) { "abandon" }.plus("about").joinToString(" ")
+        val vectors = mapOf(
+            "bitcoin" to "28f258542d91310274942356e7777d8978bac6dbd3fadbfbfe5d663b19f1f6c5",
+            "testnet" to "0ce1e7952991cf5ce84bfa135dbc194b3d55a7f2fc69807091c4ca1d6eaac809",
+            "signet" to "966319adba79fb70afbf6eb1c7bde0cf93433e08d6f2f832c30467b812005fbe",
+            "regtest" to "fe843546f607f38ba7b1e8fe479c3103139ebea5b83628cbaa465e41cf6cb6c0",
+        )
+        vectors.forEach { (network, expected) ->
+            val storeId = com.synonym.vssclient.vssDeriveStoreId("bitkit_v1_$network", mnemonic, null)
+            val binding = java.security.MessageDigest.getInstance("SHA-256")
+                .digest(storeId.toByteArray(Charsets.UTF_8)).joinToString("") { "%02x".format(it) }
+            org.junit.Assert.assertEquals(expected, binding)
+        }
+    }
+
+    @Test
+    fun verifyPersistedOriginalWinnerAfterUi() = runBlocking {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        Env.initAppStoragePath(context.filesDir.absolutePath)
+        hiltRule.inject()
+        val attempt = requireNotNull(store.current())
+        val expectedTxid = requireNotNull(InstrumentationRegistry.getArguments().getString("expectedWinnerTxid"))
+        org.junit.Assert.assertEquals(expectedTxid, attempt.txid)
+        org.junit.Assert.assertTrue(attempt.hasPositiveEvidence)
+        org.junit.Assert.assertTrue(attempt.localFollowupComplete)
+        org.junit.Assert.assertTrue(attempt.candidateTxids.contains(expectedTxid))
+        org.junit.Assert.assertFalse(attempt.originalInputs.isNullOrEmpty())
+        File(context.getExternalFilesDir(null), "recovery-final-native-receipt.json")
+            .writeText(Json.encodeToString(attempt))
+    }
+
+    @Test
+    fun seedPreparedOriginalForRecoveryUi() = runBlocking {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        Env.initAppStoragePath(context.filesDir.absolutePath)
+        hiltRule.inject()
+        // Refuse a pre-existing wallet; the runner must use an owned, disposable app install.
+        check(keychain.loadString(Keychain.Key.BIP39_MNEMONIC.name) == null)
+        walletRepo.createWallet(null).getOrThrow()
+        keychain.upsertString(Keychain.Key.PIN.name, "1234") // Public disposable-fixture PIN only.
+        settingsStore.update {
+            it.copy(
+                isPinEnabled = true,
+                isPinForPaymentsEnabled = true,
+                isBiometricEnabled = false,
+                electrumServer = InstrumentationRegistry.getArguments().getString("fixtureElectrumUrl")
+                    ?: it.electrumServer,
+            )
+        }
+        lightningService.setup(walletIndex = 0)
+        try {
+            lightningService.start()
+            // Let the native initial background sync settle before forcing another sync in this fixture.
+            delay(15_000)
+            lightningService.sync()
+            val depositAddress = lightningService.newAddress()
+            coreService.blocktank.regtestMine(1u)
+            coreService.blocktank.regtestDeposit(depositAddress, 100_000uL)
+            coreService.blocktank.regtestMine(6u)
+            delay(15_000)
+            lightningService.sync()
+            val recipient = "bcrt1qs04g2ka4pr9s3mv73nu32tvfy7r3cxd27wkyu8"
+            val isMax = InstrumentationRegistry.getArguments().getString("recoveryMode") == "max"
+            val original = store.admit(
+                walletId = WalletScope.default, requestId = null, orderId = null, address = recipient,
+                amountSats = 1_000uL, isMaxAmount = isMax, feeRateSatsPerVByte = 1uL,
+                isTransfer = false, channelId = null, tags = emptyList(), beforeSendAttempt = {},
+            )
+            val prepared = lightningService.prepareOnchainSend(recipient, 1_000uL, 1uL, isMaxAmount = isMax)
+            store.retainPreparedReceipt(original.attemptId, 0, prepared.receipt, false)
+            // No original broadcast: this seeds the uncertainty UI using actual native receipt provenance.
+            val pending = store.recordOutcome(original.attemptId, OnchainSendOutcome.Unknown(prepared.receipt.txid), 0)
+            File(context.getExternalFilesDir(null), "recovery-original-native-receipt.json")
+                .writeText(Json.encodeToString(pending))
+        } finally {
+            lightningService.stop()
+        }
+        // Retain this disposable fixture for the real app UI journey; owned-device teardown removes it afterward.
+    }
+}

app/src/androidTest/java/to/bitkit/services/TxBumpingTests.kt

@@ -14,12 +14,14 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.env.Env
+import to.bitkit.repositories.OnchainSendOutcome
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.test.annotations.CoreServiceIntegration
 import to.bitkit.test.annotations.DeviceIntegration
 import javax.inject.Inject
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertIs
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
@@ -148,11 +150,12 @@ class TxBumpingTests {
         val lowFeeRate = 1uL // 1 sat/vbyte (very low)
 
         println("Sending $sendAmount sats to $destinationAddress with low fee rate of $lowFeeRate sat/vbyte")
-        val originalTxId = lightningService.send(
+        val outcome = lightningService.prepareOnchainSend(
             address = destinationAddress,
             sats = sendAmount,
             satsPerVByte = lowFeeRate,
-        )
+        ).broadcast()
+        val originalTxId = assertIs<OnchainSendOutcome.Accepted>(outcome).txid
 
         lightningService.sync()
 

app/src/androidTest/java/to/bitkit/services/UtxoSelectionTests.kt

@@ -15,12 +15,14 @@ import org.junit.runner.RunWith
 import org.lightningdevkit.ldknode.CoinSelectionAlgorithm
 import to.bitkit.data.keychain.Keychain
 import to.bitkit.env.Env
+import to.bitkit.repositories.OnchainSendOutcome
 import to.bitkit.repositories.WalletRepo
 import to.bitkit.test.annotations.CoreServiceIntegration
 import to.bitkit.test.annotations.DeviceIntegration
 import javax.inject.Inject
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertIs
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 import kotlin.test.fail
@@ -203,12 +205,13 @@ class UtxoSelectionTests {
         val feeRate = 1uL // 1 sat/vbyte
 
         println("Sending $sendAmount sats to $destinationAddress using specific UTXOs")
-        val txId = lightningService.send(
+        val outcome = lightningService.prepareOnchainSend(
             address = destinationAddress,
             sats = sendAmount,
             satsPerVByte = feeRate,
             utxosToSpend = utxosToSpend
-        )
+        ).broadcast()
+        val txId = assertIs<OnchainSendOutcome.Accepted>(outcome).txid
 
         assertTrue(txId.isNotEmpty(), "Transaction ID should not be empty")
         println("Transaction sent successfully with txid: $txId")

app/src/androidTest/java/to/bitkit/ui/components/DrawerMenuWidgetsTest.kt

@@ -69,9 +69,9 @@ class DrawerMenuWidgetsTest {
                     rootNavController = navController,
                     hasSeenWidgetsIntro = false,
                     hasSeenShopIntro = true,
+                    profileIdentityExists = flowOf(false),
                     onBeforeNavigate = {},
                     showWidgets = true,
-                    profileIdentityExists = flowOf(false),
                 )
             }
         }
@@ -102,9 +102,9 @@ class DrawerMenuWidgetsTest {
                     rootNavController = navController,
                     hasSeenWidgetsIntro = true,
                     hasSeenShopIntro = true,
+                    profileIdentityExists = flowOf(false),
                     onBeforeNavigate = {},
                     showWidgets = true,
-                    profileIdentityExists = flowOf(false),
                     onOpenWidgetsHome = { openWidgetsHome.value = true },
                 )
                 if (openWidgetsHome.value) {
@@ -139,9 +139,9 @@ class DrawerMenuWidgetsTest {
                     rootNavController = navController,
                     hasSeenWidgetsIntro = true,
                     hasSeenShopIntro = true,
+                    profileIdentityExists = flowOf(false),
                     onBeforeNavigate = {},
                     showWidgets = false,
-                    profileIdentityExists = flowOf(false),
                     onOpenWidgetsHome = { error("Should not request home widgets page") },
                     onOpenWidgetsSheet = { openWidgetsSheet.value = true },
                 )
@@ -179,9 +179,9 @@ class DrawerMenuWidgetsTest {
                     rootNavController = navController,
                     hasSeenWidgetsIntro = true,
                     hasSeenShopIntro = true,
+                    profileIdentityExists = flowOf(true),
                     onBeforeNavigate = {},
                     showWidgets = true,
-                    profileIdentityExists = flowOf(true),
                     isPaykitEnabled = true,
                 )
             }
@@ -204,9 +204,9 @@ class DrawerMenuWidgetsTest {
                     rootNavController = navController,
                     hasSeenWidgetsIntro = true,
                     hasSeenShopIntro = true,
+                    profileIdentityExists = flowOf(true),
                     onBeforeNavigate = {},
                     showWidgets = true,
-                    profileIdentityExists = flowOf(true),
                     isPaykitEnabled = false,
                 )
             }

app/src/androidTest/java/to/bitkit/ui/onboarding/MnemonicInputFieldTest.kt

@@ -61,8 +61,8 @@ class MnemonicInputFieldTest {
                     onPositionChange = {},
                     onBackspaceInEmpty = { backspaceInEmptyCount++ },
                     focusRequester = focusRequester,
-                    isFocused = false,
                     index = 0,
+                    isFocused = true,
                 )
             }
         }