feat: retry usdc sweep to allow funds to land post deposit

bmc08gt · bmc08gt · commit 304a012aa868 · 2026-05-19T20:35:46.000-04:00
Signed-off-by: Brandon McAnsh &lt;git@bmcreations.dev&gt;
diff --git a/apps/flipcash/shared/tokens/src/main/kotlin/com/flipcash/app/tokens/UsdcDepositSweep.kt b/apps/flipcash/shared/tokens/src/main/kotlin/com/flipcash/app/tokens/UsdcDepositSweep.kt
@@ -7,49 +7,68 @@ import com.getcode.opencode.model.accounts.AccountFilter
 import com.getcode.opencode.model.accounts.AccountType
 import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.base58
-import com.getcode.utils.ErrorUtils
 import com.getcode.utils.TraceType
+import com.getcode.utils.network.retryable
 import com.getcode.utils.trace
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.launch
 import javax.inject.Inject
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.seconds
 
-class UsdcDepositSweep @Inject constructor(
+class UsdcDepositSweep(
     private val transactionOperations: TransactionOperations,
     private val accountController: AccountController,
     private val tokenCoordinator: TokenCoordinator,
+    private val maxRetries: Int = MAX_RETRIES,
+    private val initialDelay: Duration = INITIAL_DELAY,
+    private val backoffFactor: Double = BACKOFF_FACTOR,
 ) {
+    @Inject constructor(
+        transactionOperations: TransactionOperations,
+        accountController: AccountController,
+        tokenCoordinator: TokenCoordinator,
+    ) : this(
+        transactionOperations = transactionOperations,
+        accountController = accountController,
+        tokenCoordinator = tokenCoordinator,
+        maxRetries = MAX_RETRIES,
+        initialDelay = INITIAL_DELAY,
+        backoffFactor = BACKOFF_FACTOR
+    )
+
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     private var activeJob: Job? = null
 
     fun execute(owner: AccountCluster) {
         if (activeJob?.isActive == true) return
         activeJob = scope.launch {
-            val usdcAccount = accountController.getAccount(
-                accountOwner = owner,
-                requestingOwner = owner,
-                filter = AccountFilter.MintAddress(Mint.usdc),
-            ).getOrNull()?.takeIf { account ->
-                account.accountType == AccountType.AssociatedToken
-            }
+            val amount = retryable(
+                maxRetries = maxRetries,
+                delayDuration = initialDelay,
+                backoffFactor = backoffFactor,
+            ) {
+                val usdcAccount = accountController.getAccount(
+                    accountOwner = owner,
+                    requestingOwner = owner,
+                    filter = AccountFilter.MintAddress(Mint.usdc),
+                ).getOrNull()?.takeIf { account ->
+                    account.accountType == AccountType.AssociatedToken
+                }
 
-            usdcAccount?.let {
-                trace(tag = TAG, message = "USDC ATA found. => ${it.address.base58()}")
-            } ?: trace(tag = TAG, message = "USDC ATA not found")
-
-            val amount = usdcAccount?.balance ?: 0L
-            if (amount <= 0L) {
-                trace(tag = TAG, message = "USDC balance <= 0. nothing to sweep")
-                return@launch
-            }
+                usdcAccount?.let {
+                    trace(tag = TAG, message = "USDC ATA found. => ${it.address.base58()}")
+                } ?: trace(tag = TAG, message = "USDC ATA not found")
 
-            coroutineContext.ensureActive()
+                val balance = usdcAccount?.balance ?: 0L
+                check(balance > 0L) { "USDC balance <= 0. nothing to sweep" }
+                balance
+            } ?: return@launch
 
-            trace(tag = TAG, message = "Swapping $amount USDC quarks to USDF", type = TraceType.Process)
+            trace(tag = TAG, message = "Swapping $amount USDC to USDF", type = TraceType.Process)
 
             transactionOperations.swapUsdc(
                 owner = owner,
@@ -70,5 +89,8 @@ class UsdcDepositSweep @Inject constructor(
 
     companion object {
         private const val TAG = "UsdcDepositSweep"
+        private const val MAX_RETRIES = 5
+        private val INITIAL_DELAY = 5.seconds
+        private const val BACKOFF_FACTOR = 2.0
     }
 }
diff --git a/apps/flipcash/shared/tokens/src/test/kotlin/com/flipcash/app/tokens/UsdcDepositSweepTest.kt b/apps/flipcash/shared/tokens/src/test/kotlin/com/flipcash/app/tokens/UsdcDepositSweepTest.kt
@@ -16,6 +16,7 @@ import kotlinx.coroutines.test.runTest
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
+import kotlin.time.Duration.Companion.milliseconds
 
 @OptIn(ExperimentalCoroutinesApi::class)
 class UsdcDepositSweepTest {
@@ -34,6 +35,9 @@ class UsdcDepositSweepTest {
             transactionOperations = transactionOperations,
             accountController = accountController,
             tokenCoordinator = tokenCoordinator,
+            maxRetries = 3,
+            initialDelay = 10.milliseconds,
+            backoffFactor = 1.0,
         )
     }
 
@@ -60,56 +64,67 @@ class UsdcDepositSweepTest {
     }
 
     @Test
-    fun `skips swap when USDC account is not found`() = runTest {
+    fun `gives up after max retries when USDC account is not found`() = runTest {
         stubNoUsdcAccount()
 
         sweep.execute(owner)
         advanceUntilIdle()
-
-        // Give the internal scope time to complete
-        Thread.sleep(100)
+        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `skips swap when USDC account type is not AssociatedToken`() = runTest {
+    fun `gives up after max retries when account type is not AssociatedToken`() = runTest {
         stubUsdcAccount(balance = 1_000_000L, type = AccountType.Primary)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(100)
+        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `skips swap when USDC balance is zero`() = runTest {
+    fun `gives up after max retries when USDC balance stays zero`() = runTest {
         stubUsdcAccount(balance = 0L)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(100)
+        Thread.sleep(200)
 
         coVerify(exactly = 0) {
             transactionOperations.swapUsdc(any(), any())
         }
     }
 
     @Test
-    fun `skips swap when USDC balance is negative`() = runTest {
-        stubUsdcAccount(balance = -1L)
+    fun `retries until balance appears then sweeps`() = runTest {
+        var callCount = 0
+        coEvery {
+            accountController.getAccount(any(), any(), any())
+        } coAnswers {
+            callCount++
+            val balance = if (callCount >= 3) 2_000_000L else 0L
+            val accountInfo = mockk<AccountInfo> {
+                every { accountType } returns AccountType.AssociatedToken
+                every { this@mockk.balance } returns balance
+                every { address } returns mockk<PublicKey>(relaxed = true)
+            }
+            Result.success(accountInfo)
+        }
+        coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
 
         sweep.execute(owner)
         advanceUntilIdle()
-        Thread.sleep(100)
+        Thread.sleep(300)
 
-        coVerify(exactly = 0) {
-            transactionOperations.swapUsdc(any(), any())
+        coVerify {
+            transactionOperations.swapUsdc(owner, 2_000_000L)
         }
     }
 
@@ -166,9 +181,7 @@ class UsdcDepositSweepTest {
             Result.success(Unit)
         }
 
-        // First call starts the job
         sweep.execute(owner)
-        // Second call should be ignored since the first is still active
         sweep.execute(owner)
 
         Thread.sleep(700)
@@ -180,7 +193,6 @@ class UsdcDepositSweepTest {
 
     @Test
     fun `cancel stops active job`() = runTest {
-        // Make getAccount slow so we can cancel before swapUsdc is reached
         coEvery {
             accountController.getAccount(any(), any(), any())
         } coAnswers {
@@ -195,7 +207,7 @@ class UsdcDepositSweepTest {
         coEvery { transactionOperations.swapUsdc(any(), any()) } returns Result.success(Unit)
 
         sweep.execute(owner)
-        Thread.sleep(50) // Let the coroutine start
+        Thread.sleep(50)
         sweep.cancel()
         Thread.sleep(100)
 
diff --git a/libs/network/connectivity/public/src/main/kotlin/com/getcode/utils/network/Retry.kt b/libs/network/connectivity/public/src/main/kotlin/com/getcode/utils/network/Retry.kt
@@ -3,13 +3,15 @@ package com.getcode.utils.network
 import com.getcode.utils.TraceType
 import com.getcode.utils.trace
 import kotlinx.coroutines.delay
+import kotlin.math.pow
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
 import kotlin.time.TimeSource
 
-suspend fun <T> retryable(
+suspend inline fun <T> retryable(
     maxRetries: Int = 3,
     delayDuration: Duration = 2.seconds,
+    backoffFactor: Double = 1.0,
     retryIf: (Throwable) -> Boolean = { true },
     onRetry: (Int) -> Unit = { currentAttempt ->
         trace(
@@ -36,11 +38,6 @@ suspend fun <T> retryable(
             call()
         } catch (e: Throwable) {
             if (!retryIf(e)) throw e
-            trace(
-                message = "Attempt $currentAttempt failed with exception: ${e.message}",
-                error = e,
-                type = TraceType.Error
-            )
             null
         }
 
@@ -50,7 +47,8 @@ suspend fun <T> retryable(
             currentAttempt++
             if (currentAttempt < maxRetries) {
                 onRetry(currentAttempt)
-                delay(delayDuration.inWholeMilliseconds)
+                val actualDelay = delayDuration * backoffFactor.pow(currentAttempt - 1)
+                delay(actualDelay.inWholeMilliseconds)
             }
         }
     }
@@ -66,6 +64,7 @@ suspend fun <T> retryable(
 suspend fun <T> retryableOrThrow(
     maxRetries: Int = 3,
     delayDuration: Duration = 2.seconds,
+    backoffFactor: Double = 1.0,
     retryIf: (Throwable) -> Boolean = { true },
     onRetry: (Int) -> Unit = { currentAttempt ->
         trace(
@@ -102,7 +101,8 @@ suspend fun <T> retryableOrThrow(
             currentAttempt++
             if (currentAttempt < maxRetries) {
                 onRetry(currentAttempt)
-                delay(delayDuration.inWholeMilliseconds)
+                val actualDelay = delayDuration * backoffFactor.pow(currentAttempt - 1)
+                delay(actualDelay.inWholeMilliseconds)
             }
         }
     }
diff --git a/libs/network/connectivity/public/src/test/kotlin/com/getcode/utils/network/RetryTest.kt b/libs/network/connectivity/public/src/test/kotlin/com/getcode/utils/network/RetryTest.kt
@@ -73,6 +73,38 @@ class RetryTest {
 
     // endregion
 
+    @Test
+    fun `retryable with backoffFactor retries and succeeds`() = runTest {
+        var attempts = 0
+        val result = retryable(
+            maxRetries = 4,
+            delayDuration = 100.milliseconds,
+            backoffFactor = 2.0,
+        ) {
+            attempts++
+            if (attempts < 4) throw RuntimeException("retry")
+            "ok"
+        }
+        assertEquals("ok", result)
+        assertEquals(4, attempts)
+    }
+
+    @Test
+    fun `retryable with backoffFactor 1 behaves like fixed delay`() = runTest {
+        var attempts = 0
+        val result = retryable(
+            maxRetries = 3,
+            delayDuration = 1.milliseconds,
+            backoffFactor = 1.0,
+        ) {
+            attempts++
+            if (attempts < 3) throw RuntimeException("retry")
+            "ok"
+        }
+        assertEquals("ok", result)
+        assertEquals(3, attempts)
+    }
+
     // region retryableOrThrow
 
     @Test
