fix: match cjit from cached state, refresh on miss

Author: jvsena42

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

@@ -130,18 +130,34 @@ class BlocktankRepo @Inject constructor(
     suspend fun getCjitEntry(channel: ChannelDetails): IcJitEntry? = withContext(bgDispatcher) {
         val fundingTxId = channel.fundingTxo?.txid ?: return@withContext null
 
-        // Refresh from the server so a freshly opened CJIT channel association is up to date before matching.
-        val entries = runCatching {
-            withTimeout(CJIT_REFRESH_TIMEOUT) {
-                coreService.blocktank.cjitEntries(refresh = true)
-            }
-        }.getOrElse {
-            if (it is CancellationException && it !is TimeoutCancellationException) throw it
-            Logger.warn("Failed to refresh CJIT entries; using cached state", it, context = TAG)
-            _blocktankState.value.cjitEntries
+        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()
         }
+    }
 
-        return@withContext entries.firstOrNull { it.channel?.fundingTx?.id == fundingTxId }
+    private suspend fun refreshCjitEntries() {
+        repeat(CJIT_REFRESH_ATTEMPTS) { attempt ->
+            runCatching {
+                withTimeout(CJIT_REFRESH_TIMEOUT) {
+                    coreService.blocktank.cjitEntries(refresh = true)
+                }
+            }.onSuccess { entries ->
+                _blocktankState.update { it.copy(cjitEntries = entries.toImmutableList()) }
+                return
+            }.onFailure {
+                if (it is CancellationException && it !is TimeoutCancellationException) throw it
+                if (attempt == CJIT_REFRESH_ATTEMPTS - 1) {
+                    Logger.warn("Failed to refresh CJIT entries; using cached state", it, context = TAG)
+                    return
+                }
+            }
+            delay(CJIT_REFRESH_RETRY_DELAY)
+        }
     }
 
     suspend fun refreshInfo() = withContext(bgDispatcher) {
@@ -566,7 +582,9 @@ class BlocktankRepo @Inject constructor(
         private const val PEER_CONNECTION_DELAY_MS = 2_000L
         private val TIMEOUT_GIFT_CODE = 30.seconds
         private val GIFT_PAYMENT_RECEIVE_TIMEOUT = 45.seconds
+        private const val CJIT_REFRESH_ATTEMPTS = 3
         private val CJIT_REFRESH_TIMEOUT = 5.seconds
+        private val CJIT_REFRESH_RETRY_DELAY = 1.seconds
     }
 }
 

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

@@ -259,7 +259,7 @@ class BlocktankRepoTest : BaseUnitTest() {
     }
 
     @Test
-    fun `getCjitEntry falls back to cached entries when refresh fails`() = test {
+    fun `getCjitEntry returns cached entry without refreshing when already associated`() = test {
         sut = createSut()
         val fundingTxId = "cached-funding-tx"
         val channel = mock<IBtChannel>()
@@ -271,11 +271,40 @@ class BlocktankRepoTest : BaseUnitTest() {
             BlocktankBackupV1(createdAt = 0L, orders = emptyList(), cjitEntries = listOf(cachedEntry)),
         )
 
+        val channelDetails = mock<ChannelDetails>()
+        whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = fundingTxId, vout = 0u))
+
+        // A server refresh would return no entries (setUp default), so a non-null result can only come
+        // from the cached state short-circuit, proving the server is not hit when the entry is already known.
+        assertEquals(cachedEntry, sut.getCjitEntry(channelDetails))
+    }
+
+    @Test
+    fun `getCjitEntry returns null when cache misses and refresh fails`() = test {
+        sut = createSut()
         whenever(coreService.blocktank.cjitEntries(refresh = true)).thenThrow(RuntimeException("Network error"))
 
+        val channelDetails = mock<ChannelDetails>()
+        whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = "missing-funding-tx", vout = 0u))
+
+        assertNull(sut.getCjitEntry(channelDetails))
+    }
+
+    @Test
+    fun `getCjitEntry retries the refresh and matches after a transient failure`() = test {
+        sut = createSut()
+        val fundingTxId = "cjit-funding-tx"
+        val channel = mock<IBtChannel>()
+        whenever(channel.fundingTx).thenReturn(FundingTx(id = fundingTxId, vout = 0u))
+        val entry = mock<IcJitEntry>()
+        whenever(entry.channel).thenReturn(channel)
+        whenever(coreService.blocktank.cjitEntries(refresh = true))
+            .thenThrow(RuntimeException("transient"))
+            .thenReturn(listOf(entry))
+
         val channelDetails = mock<ChannelDetails>()
         whenever(channelDetails.fundingTxo).thenReturn(OutPoint(txid = fundingTxId, vout = 0u))
 
-        assertEquals(cachedEntry, sut.getCjitEntry(channelDetails))
+        assertEquals(entry, sut.getCjitEntry(channelDetails))
     }
 }