Add migration to track balance confirmation for pending transactions

oleonov · oleonov · commit 736e0318c17a · 2026-05-28T23:08:49.000+07:00
diff --git a/app/src/main/java/cash/p/terminal/core/managers/PendingBalanceCalculator.kt b/app/src/main/java/cash/p/terminal/core/managers/PendingBalanceCalculator.kt
@@ -9,6 +9,7 @@ import cash.p.terminal.wallet.Wallet
 import cash.p.terminal.wallet.isLitecoinMweb
 import cash.p.terminal.wallet.entities.BalanceData
 import io.horizontalsystems.core.DispatcherProvider
+import io.horizontalsystems.core.entities.BlockchainType
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
@@ -25,6 +26,10 @@ class PendingBalanceCalculator(
     private val pendingRepository: PendingTransactionRepository,
     dispatcherProvider: DispatcherProvider
 ) : Clearable {
+    private companion object {
+        val CONFIRMATION_BALANCE_TOLERANCE_RATE = BigDecimal("0.05")
+    }
+
     private val pendingCache = ConcurrentHashMap<String, List<PendingTransactionEntity>>()
     private val observingJobs = ConcurrentHashMap<String, Job>()
     private val scope = CoroutineScope(SupervisorJob() + dispatcherProvider.io)
@@ -81,29 +86,20 @@ class PendingBalanceCalculator(
         token: Token,
         currentSdkBalance: BigDecimal
     ): BigDecimal {
-        val relevantPending = pendingList.filter {
-            it.coinUid == token.coin.uid &&
-                it.tokenTypeId == token.type.id &&
-                it.blockchainTypeUid == token.blockchainType.uid
-        }
+        val relevantPending = pendingList.filter { it.matches(token) }
         if (relevantPending.isEmpty()) return currentSdkBalance
 
         // Fee is only deducted from native token balance (not ERC-20/TRC-20/Jetton)
         val isNativeToken = token.type.isNative
 
         // 1. Calculate total pending amount (amount + fee for native tokens only)
-        val totalPendingAmount = relevantPending.sumOf { entity ->
-            val amount = entity.amountAtomic.toBigDecimal().movePointLeft(token.decimals)
-            val fee = if (isNativeToken) {
-                entity.feeAtomic?.toBigDecimal()?.movePointLeft(token.decimals)
-                    ?: BigDecimal.ZERO
-            } else BigDecimal.ZERO
-            amount + fee
+        val totalPendingAmount = relevantPending.sumOf {
+            it.amountWithFee(token.decimals, isNativeToken)
         }
 
         // 2. Get baseline SDK balance (max from all pending - earliest "clean" balance)
         val baselineSdkBalance = relevantPending.maxOf { entity ->
-            entity.sdkBalanceAtCreationAtomic.toBigDecimal().movePointLeft(token.decimals)
+            entity.sdkBalanceAtCreation(token.decimals)
         }
 
         // 3. How much has SDK already deducted from baseline?
@@ -116,7 +112,8 @@ class PendingBalanceCalculator(
         val ourDeduction = (totalPendingAmount - sdkAlreadyDeducted)
             .coerceAtLeast(BigDecimal.ZERO)
         val adjustedAfterDeduction = currentSdkBalance - ourDeduction.coerceAtMost(currentSdkBalance)
-        val expectedMwebAvailable = if (token.isLitecoinMweb) {
+        val isLitecoinMweb = token.isLitecoinMweb
+        val expectedMwebAvailable = if (isLitecoinMweb) {
             (baselineSdkBalance - totalPendingAmount).coerceAtLeast(BigDecimal.ZERO)
         } else {
             null
@@ -125,37 +122,90 @@ class PendingBalanceCalculator(
             currentSdkBalance.signum() == 0 && it.signum() > 0
         }
 
-        // 5. Check for confirmed TXs to cleanup (per-TX confirmation detection)
-        // Collect IDs first to avoid race condition during async deletion
-        val idsToDelete = if (expectedMwebAvailable != null) {
+        cleanupConfirmedPending(
+            relevantPending = relevantPending,
+            decimals = token.decimals,
+            isNativeToken = isNativeToken,
+            currentSdkBalance = currentSdkBalance,
+            skipCleanupForMweb = isLitecoinMweb,
+        )
+
+        return mwebZeroSnapshotFallbackAvailable ?: adjustedAfterDeduction
+    }
+
+    private fun cleanupConfirmedPending(
+        relevantPending: List<PendingTransactionEntity>,
+        decimals: Int,
+        isNativeToken: Boolean,
+        currentSdkBalance: BigDecimal,
+        skipCleanupForMweb: Boolean,
+    ) {
+        if (skipCleanupForMweb) {
             // MWEB replaces spent confirmed inputs with unconfirmed change right after broadcast.
-            emptyList()
-        } else {
-            relevantPending.filter { entity ->
-                // Without a tx hash, this pending entry is the only link used to mark
-                // the later real transaction as locally created.
-                if (entity.txHash.isNullOrBlank()) {
-                    return@filter false
-                }
+            return
+        }
 
-                val amount = entity.amountAtomic.toBigDecimal().movePointLeft(token.decimals)
-                val fee = if (isNativeToken) {
-                    entity.feeAtomic?.toBigDecimal()?.movePointLeft(token.decimals)
-                        ?: BigDecimal.ZERO
-                } else BigDecimal.ZERO
-                val sdkAtCreation = entity.sdkBalanceAtCreationAtomic.toBigDecimal()
-                    .movePointLeft(token.decimals)
-                val expectedAfterConfirm = sdkAtCreation - amount - fee
-                val tolerance = (amount + fee) * BigDecimal("0.05") // 5% tolerance
-                (currentSdkBalance - expectedAfterConfirm).abs() <= tolerance
-            }.map { it.id }
+        val idsToDelete = mutableListOf<String>()
+        val idsToMarkBalanceConfirmed = mutableListOf<String>()
+
+        relevantPending.forEach { entity ->
+            if (!entity.isConfirmedByBalance(decimals, isNativeToken, currentSdkBalance)) {
+                return@forEach
+            }
+
+            if (entity.txHash.isNullOrBlank()) {
+                if (entity.blockchainTypeUid == BlockchainType.Ton.uid) {
+                    // TON does not return a hash at broadcast, so the row must remain matchable.
+                    idsToMarkBalanceConfirmed.add(entity.id)
+                }
+            } else {
+                idsToDelete.add(entity.id)
+            }
         }
-        if (idsToDelete.isNotEmpty()) {
-            scope.launch {
+
+        if (idsToDelete.isEmpty() && idsToMarkBalanceConfirmed.isEmpty()) return
+
+        scope.launch {
+            if (idsToDelete.isNotEmpty()) {
                 tryOrNull { pendingRepository.deleteByIds(idsToDelete) }
             }
+            if (idsToMarkBalanceConfirmed.isNotEmpty()) {
+                tryOrNull { pendingRepository.markBalanceConfirmed(idsToMarkBalanceConfirmed) }
+            }
         }
+    }
 
-        return mwebZeroSnapshotFallbackAvailable ?: adjustedAfterDeduction
+    private fun PendingTransactionEntity.matches(token: Token): Boolean {
+        return coinUid == token.coin.uid &&
+            tokenTypeId == token.type.id &&
+            blockchainTypeUid == token.blockchainType.uid
+    }
+
+    private fun PendingTransactionEntity.isConfirmedByBalance(
+        decimals: Int,
+        isNativeToken: Boolean,
+        currentSdkBalance: BigDecimal,
+    ): Boolean {
+        val amountWithFee = amountWithFee(decimals, isNativeToken)
+        val expectedAfterConfirm = sdkBalanceAtCreation(decimals) - amountWithFee
+        val tolerance = amountWithFee * CONFIRMATION_BALANCE_TOLERANCE_RATE
+        return (currentSdkBalance - expectedAfterConfirm).abs() <= tolerance
+    }
+
+    private fun PendingTransactionEntity.amountWithFee(
+        decimals: Int,
+        isNativeToken: Boolean,
+    ): BigDecimal {
+        val amount = amountAtomic.toBigDecimal().movePointLeft(decimals)
+        val fee = if (isNativeToken) {
+            feeAtomic?.toBigDecimal()?.movePointLeft(decimals) ?: BigDecimal.ZERO
+        } else {
+            BigDecimal.ZERO
+        }
+        return amount + fee
+    }
+
+    private fun PendingTransactionEntity.sdkBalanceAtCreation(decimals: Int): BigDecimal {
+        return sdkBalanceAtCreationAtomic.toBigDecimal().movePointLeft(decimals)
     }
 }
diff --git a/app/src/main/java/cash/p/terminal/core/managers/PendingTransactionRepository.kt b/app/src/main/java/cash/p/terminal/core/managers/PendingTransactionRepository.kt
@@ -73,6 +73,13 @@ class PendingTransactionRepository(
             storage.getPendingForWallet(walletId)
         }
 
+    suspend fun markBalanceConfirmed(ids: List<String>) = mutex.withLock {
+        withContext(dispatcherProvider.io) {
+            storage.markBalanceConfirmed(ids, System.currentTimeMillis())
+            startCleanupJob()
+        }
+    }
+
     suspend fun deleteById(id: String) = mutex.withLock {
         withContext(dispatcherProvider.io) {
             storage.deleteById(id)
@@ -106,7 +113,7 @@ class PendingTransactionRepository(
             nonce = draft.nonce,
             memo = draft.memo,
             createdAt = draft.timestamp,
-            expiresAt = draft.timestamp + TimeUnit.HOURS.toMillis(1)
+            expiresAt = draft.timestamp + TimeUnit.HOURS.toMillis(1),
         )
     }
 
diff --git a/app/src/main/java/cash/p/terminal/core/storage/AppDatabase.kt b/app/src/main/java/cash/p/terminal/core/storage/AppDatabase.kt
@@ -76,6 +76,7 @@ import cash.p.terminal.core.storage.migrations.Migration_98_99
 import cash.p.terminal.core.storage.migrations.Migration_99_100
 import cash.p.terminal.core.storage.migrations.Migration_100_101
 import cash.p.terminal.core.storage.migrations.Migration_101_102
+import cash.p.terminal.core.storage.migrations.Migration_102_103
 import cash.p.terminal.core.storage.typeconverter.DatabaseConverters
 import cash.p.terminal.entities.ActiveAccount
 import cash.p.terminal.entities.BlockchainSettingRecord
@@ -114,7 +115,7 @@ import io.horizontalsystems.core.storage.LogEntry
 import io.horizontalsystems.core.storage.LogsDao
 
 @Database(
-    version = 102,
+    version = 103,
     exportSchema = false,
     entities = [
         EnabledWallet::class,
@@ -267,7 +268,8 @@ abstract class AppDatabase : RoomDatabase() {
                     Migration_98_99,
                     Migration_99_100,
                     Migration_100_101,
-                    Migration_101_102
+                    Migration_101_102,
+                    Migration_102_103
                 )
                 .build()
         }
diff --git a/app/src/main/java/cash/p/terminal/core/storage/PendingTransactionDao.kt b/app/src/main/java/cash/p/terminal/core/storage/PendingTransactionDao.kt
@@ -18,12 +18,22 @@ interface PendingTransactionDao {
     @Query("SELECT * FROM PendingTransaction WHERE id = :id")
     suspend fun getById(id: String): PendingTransactionEntity?
 
-    @Query("SELECT * FROM PendingTransaction WHERE expiresAt > :now AND walletId = :walletId")
+    @Query(
+        """
+        SELECT * FROM PendingTransaction
+        WHERE expiresAt > :now
+          AND walletId = :walletId
+          AND balanceConfirmedAt IS NULL
+        """
+    )
     fun getActivePendingFlow(now: Long, walletId: String): Flow<List<PendingTransactionEntity>>
 
     @Query("SELECT * FROM PendingTransaction WHERE walletId = :walletId AND expiresAt > :now")
     suspend fun getPendingForWallet(walletId: String, now: Long): List<PendingTransactionEntity>
 
+    @Query("UPDATE PendingTransaction SET balanceConfirmedAt = :confirmedAt WHERE id IN (:ids)")
+    suspend fun markBalanceConfirmed(ids: List<String>, confirmedAt: Long)
+
     @Query("SELECT * FROM PendingTransaction")
     suspend fun getAllPending(): List<PendingTransactionEntity>
 
diff --git a/app/src/main/java/cash/p/terminal/core/storage/PendingTransactionStorage.kt b/app/src/main/java/cash/p/terminal/core/storage/PendingTransactionStorage.kt
@@ -2,7 +2,6 @@ package cash.p.terminal.core.storage
 
 import cash.p.terminal.entities.PendingTransactionEntity
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
 
 class PendingTransactionStorage(appDatabase: AppDatabase) {
     private val dao = appDatabase.pendingTransactionDao()
@@ -19,6 +18,11 @@ class PendingTransactionStorage(appDatabase: AppDatabase) {
     suspend fun getPendingForWallet(walletId: String): List<PendingTransactionEntity> =
         dao.getPendingForWallet(walletId, System.currentTimeMillis())
 
+    suspend fun markBalanceConfirmed(ids: List<String>, confirmedAt: Long) {
+        if (ids.isEmpty()) return
+        dao.markBalanceConfirmed(ids, confirmedAt)
+    }
+
     suspend fun deleteById(id: String) = dao.deleteById(id)
 
     suspend fun getExpired(): List<PendingTransactionEntity> =
diff --git a/app/src/main/java/cash/p/terminal/core/storage/migrations/Migration_102_103.kt b/app/src/main/java/cash/p/terminal/core/storage/migrations/Migration_102_103.kt
@@ -0,0 +1,13 @@
+package cash.p.terminal.core.storage.migrations
+
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+/**
+ * Keeps hashless pending rows available for transaction matching after balance-side confirmation.
+ */
+object Migration_102_103 : Migration(102, 103) {
+    override fun migrate(db: SupportSQLiteDatabase) {
+        db.execSQL("ALTER TABLE PendingTransaction ADD COLUMN balanceConfirmedAt INTEGER")
+    }
+}
diff --git a/app/src/main/java/cash/p/terminal/entities/PendingTransactionEntity.kt b/app/src/main/java/cash/p/terminal/entities/PendingTransactionEntity.kt
@@ -31,5 +31,6 @@ data class PendingTransactionEntity(
 
     // Lifecycle
     val createdAt: Long,
-    val expiresAt: Long
+    val expiresAt: Long,
+    val balanceConfirmedAt: Long? = null
 )
diff --git a/app/src/test/java/cash/p/terminal/core/managers/PendingBalanceCalculatorTest.kt b/app/src/test/java/cash/p/terminal/core/managers/PendingBalanceCalculatorTest.kt
@@ -163,6 +163,7 @@ class PendingBalanceCalculatorTest {
         advanceUntilIdle()
 
         coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 0) { pendingRepository.markBalanceConfirmed(any()) }
     }
 
     @Test
@@ -188,6 +189,7 @@ class PendingBalanceCalculatorTest {
             adjusted.available.stripTrailingZeros()
         )
         coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 0) { pendingRepository.markBalanceConfirmed(any()) }
     }
 
     @Test
@@ -206,11 +208,14 @@ class PendingBalanceCalculatorTest {
         val rawBalance = BalanceData(available = BigDecimal("0.014"))
 
         val adjusted = calculator.adjustBalance(wallet, rawBalance)
+        advanceUntilIdle()
 
         assertEquals(
             BigDecimal("0.014").stripTrailingZeros(),
             adjusted.available.stripTrailingZeros()
         )
+        coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 0) { pendingRepository.markBalanceConfirmed(any()) }
     }
 
     @Test
@@ -231,25 +236,58 @@ class PendingBalanceCalculatorTest {
         val rawBalance = BalanceData(available = BigDecimal("0.015"))
 
         val adjusted = calculator.adjustBalance(wallet, rawBalance)
+        advanceUntilIdle()
 
         assertEquals(
             BigDecimal("0.015").stripTrailingZeros(),
             adjusted.available.stripTrailingZeros()
         )
+        coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 0) { pendingRepository.markBalanceConfirmed(any()) }
     }
 
     @Test
-    fun adjustBalance_pendingWithoutTxHashSdkDeductedImmediately_doesNotDeletePending() = runTest(dispatcher) {
+    fun adjustBalance_hashlessTonSdkDeductedImmediately_marksBalanceConfirmed() = runTest(dispatcher) {
         val calculator = PendingBalanceCalculator(pendingRepository, dispatcherProvider)
         calculator.onPendingInserted(createPendingEntity("ton-pending-without-hash"))
 
         val wallet = createMockWallet()
         val rawBalance = BalanceData(available = BigDecimal("7.2657"))
 
-        calculator.adjustBalance(wallet, rawBalance)
+        val adjusted = calculator.adjustBalance(wallet, rawBalance)
         advanceUntilIdle()
 
+        assertEquals(
+            rawBalance.available.stripTrailingZeros(),
+            adjusted.available.stripTrailingZeros()
+        )
+        coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 1) { pendingRepository.markBalanceConfirmed(listOf("ton-pending-without-hash")) }
+    }
+
+    @Test
+    fun adjustBalance_afterBalanceConfirmed_subsequentIncomingNotAbsorbed() = runTest(dispatcher) {
+        val calculator = PendingBalanceCalculator(pendingRepository, dispatcherProvider)
+        val wallet = createMockWallet()
+
+        calculator.startObserving("account-1")
+        pendingFlow.value = listOf(createPendingEntity("ton-pending-without-hash"))
+        advanceUntilIdle()
+
+        calculator.adjustBalance(wallet, BalanceData(available = BigDecimal("7.2657")))
+        advanceUntilIdle()
+
+        pendingFlow.value = emptyList()
+        advanceUntilIdle()
+
+        val afterIncoming = calculator.adjustBalance(wallet, BalanceData(available = BigDecimal("12.2657")))
+
+        assertEquals(
+            BigDecimal("12.2657").stripTrailingZeros(),
+            afterIncoming.available.stripTrailingZeros()
+        )
         coVerify(exactly = 0) { pendingRepository.deleteByIds(any()) }
+        coVerify(exactly = 1) { pendingRepository.markBalanceConfirmed(listOf("ton-pending-without-hash")) }
     }
 
     @Test
@@ -269,6 +307,7 @@ class PendingBalanceCalculatorTest {
         advanceUntilIdle()
 
         coVerify(exactly = 1) { pendingRepository.deleteByIds(listOf("ton-pending-with-hash")) }
+        coVerify(exactly = 0) { pendingRepository.markBalanceConfirmed(any()) }
     }
 
     private fun createMockWallet(): Wallet {

Original file line number	Diff line number	Diff line change
`@@ -31,5 +31,6 @@ data class PendingTransactionEntity(`
`31`	`31`
`32`	`32`	`// Lifecycle`
`33`	`33`	`val createdAt: Long,`
`34`		`- val expiresAt: Long`
	`34`	`+ val expiresAt: Long,`
	`35`	`+ val balanceConfirmedAt: Long? = null`
`35`	`36`	`)`