fix: guard cjit refresh to non-terminal pending entries

Author: jvsena42

app/src/main/java/to/bitkit/repositories/BlocktankRepo.kt

@@ -2,6 +2,7 @@ package to.bitkit.repositories
 
 import androidx.compose.runtime.Stable
 import com.synonym.bitkitcore.BtOrderState2
+import com.synonym.bitkitcore.CJitStateEnum
 import com.synonym.bitkitcore.ChannelLiquidityOptions
 import com.synonym.bitkitcore.ChannelLiquidityParams
 import com.synonym.bitkitcore.CreateCjitOptions
@@ -133,11 +134,17 @@ class BlocktankRepo @Inject constructor(
         fun cachedMatch(): IcJitEntry? = _blocktankState.value.cjitEntries
             .firstOrNull { it.channel?.fundingTx?.id == fundingTxId }
 
-        // Use cached state first; only refresh from the server when the freshly opened channel isn't associated yet.
-        return@withContext cachedMatch() ?: run {
-            refreshCjitEntries()
-            cachedMatch()
+        cachedMatch()?.let { return@withContext it }
+
+        // A ChannelReady can only be a CJIT if a live cached entry is still awaiting its channel; otherwise skip
+        // the server round-trip so a non-CJIT transfer confirmation isn't delayed by a slow Blocktank API.
+        val hasPendingCjit = _blocktankState.value.cjitEntries.any {
+            it.channel == null && it.state != CJitStateEnum.EXPIRED && it.state != CJitStateEnum.FAILED
         }
+        if (!hasPendingCjit) return@withContext null
+
+        refreshCjitEntries()
+        return@withContext cachedMatch()
     }
 
     private suspend fun refreshCjitEntries() {

app/src/test/java/to/bitkit/repositories/BlocktankRepoTest.kt

@@ -1,6 +1,7 @@
 package to.bitkit.repositories
 
 import app.cash.turbine.test
+import com.synonym.bitkitcore.CJitStateEnum
 import com.synonym.bitkitcore.FundingTx
 import com.synonym.bitkitcore.IBtChannel
 import com.synonym.bitkitcore.IBtInfo
@@ -215,6 +216,8 @@ class BlocktankRepoTest : BaseUnitTest() {
         // but it never opened a channel. It must not be mistaken for the freshly opened channel.
         val staleEntry = mock<IcJitEntry>()
         whenever(staleEntry.channel).thenReturn(null)
+        whenever(staleEntry.state).thenReturn(CJitStateEnum.CREATED)
+        seedCjitEntries(staleEntry)
         whenever(coreService.blocktank.cjitEntries(refresh = true)).thenReturn(listOf(staleEntry))
 
         val channelDetails = mock<ChannelDetails>()
@@ -226,6 +229,7 @@ class BlocktankRepoTest : BaseUnitTest() {
     @Test
     fun `getCjitEntry matches the entry whose channel funding tx matches`() = test {
         sut = createSut()
+        seedCjitEntries(pendingCjitEntry())
         val fundingTxId = "cjit-funding-tx"
         val matchingChannel = mock<IBtChannel>()
         whenever(matchingChannel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
@@ -246,6 +250,7 @@ class BlocktankRepoTest : BaseUnitTest() {
     @Test
     fun `getCjitEntry returns null when no CJIT channel funding tx matches`() = test {
         sut = createSut()
+        seedCjitEntries(pendingCjitEntry())
         val channel = mock<IBtChannel>()
         whenever(channel.fundingTx).thenReturn(FundingTx(id = "cjit-funding-tx", vout = 0u))
         val entry = mock<IcJitEntry>()
@@ -258,6 +263,53 @@ class BlocktankRepoTest : BaseUnitTest() {
         assertNull(sut.getCjitEntry(channelDetails))
     }
 
+    @Test
+    fun `getCjitEntry does not refresh when no cached CJIT entry is awaiting a channel`() = test {
+        sut = createSut()
+        // Only an already-associated entry is cached (none awaiting a channel), so this ChannelReady cannot be a
+        // CJIT: the server must not be hit even though a refresh would return a matching entry.
+        val associatedChannel = mock<IBtChannel>()
+        whenever(associatedChannel.fundingTx).thenReturn(FundingTx(id = "other-funding-tx", vout = 0u))
+        val associatedEntry = mock<IcJitEntry>()
+        whenever(associatedEntry.channel).thenReturn(associatedChannel)
+        seedCjitEntries(associatedEntry)
+
+        val fundingTxId = "channel-order-funding-tx"
+        val matchingChannel = mock<IBtChannel>()
+        whenever(matchingChannel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
+        val matchingEntry = mock<IcJitEntry>()
+        whenever(matchingEntry.channel).thenReturn(matchingChannel)
+        whenever(coreService.blocktank.cjitEntries(refresh = true)).thenReturn(listOf(matchingEntry))
+
+        val channelDetails = mock<ChannelDetails>()
+        whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = fundingTxId, vout = 0u))
+
+        assertNull(sut.getCjitEntry(channelDetails))
+    }
+
+    @Test
+    fun `getCjitEntry does not refresh for an expired CJIT entry awaiting no channel`() = test {
+        sut = createSut()
+        // An expired entry has no channel but can never open one, so it must not trigger a server refresh
+        // even though a refresh would surface a matching entry.
+        val expiredEntry = mock<IcJitEntry>()
+        whenever(expiredEntry.channel).thenReturn(null)
+        whenever(expiredEntry.state).thenReturn(CJitStateEnum.EXPIRED)
+        seedCjitEntries(expiredEntry)
+
+        val fundingTxId = "channel-order-funding-tx"
+        val matchingChannel = mock<IBtChannel>()
+        whenever(matchingChannel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
+        val matchingEntry = mock<IcJitEntry>()
+        whenever(matchingEntry.channel).thenReturn(matchingChannel)
+        whenever(coreService.blocktank.cjitEntries(refresh = true)).thenReturn(listOf(matchingEntry))
+
+        val channelDetails = mock<ChannelDetails>()
+        whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = fundingTxId, vout = 0u))
+
+        assertNull(sut.getCjitEntry(channelDetails))
+    }
+
     @Test
     fun `getCjitEntry returns cached entry without refreshing when already associated`() = test {
         sut = createSut()
@@ -266,10 +318,7 @@ class BlocktankRepoTest : BaseUnitTest() {
         whenever(channel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
         val cachedEntry = mock<IcJitEntry>()
         whenever(cachedEntry.channel).thenReturn(channel)
-
-        sut.restoreFromBackup(
-            BlocktankBackupV1(createdAt = 0L, orders = emptyList(), cjitEntries = listOf(cachedEntry)),
-        )
+        seedCjitEntries(cachedEntry)
 
         val channelDetails = mock<ChannelDetails>()
         whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = fundingTxId, vout = 0u))
@@ -280,8 +329,9 @@ class BlocktankRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `getCjitEntry returns null when cache misses and refresh fails`() = test {
+    fun `getCjitEntry returns null when a pending CJIT is awaiting but refresh fails`() = test {
         sut = createSut()
+        seedCjitEntries(pendingCjitEntry())
         whenever(coreService.blocktank.cjitEntries(refresh = true)).thenThrow(RuntimeException("Network error"))
 
         val channelDetails = mock<ChannelDetails>()
@@ -293,6 +343,7 @@ class BlocktankRepoTest : BaseUnitTest() {
     @Test
     fun `getCjitEntry retries the refresh and matches after a transient failure`() = test {
         sut = createSut()
+        seedCjitEntries(pendingCjitEntry())
         val fundingTxId = "cjit-funding-tx"
         val channel = mock<IBtChannel>()
         whenever(channel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
@@ -307,4 +358,15 @@ class BlocktankRepoTest : BaseUnitTest() {
 
         assertEquals(entry, sut.getCjitEntry(channelDetails))
     }
+
+    private fun pendingCjitEntry(): IcJitEntry = mock<IcJitEntry>().apply {
+        whenever(channel).thenReturn(null)
+        whenever(state).thenReturn(CJitStateEnum.CREATED)
+    }
+
+    private suspend fun seedCjitEntries(vararg entries: IcJitEntry) {
+        sut.restoreFromBackup(
+            BlocktankBackupV1(createdAt = 0L, orders = emptyList(), cjitEntries = entries.toList()),
+        )
+    }
 }