fix(transactions): retry submitIntent on server-side stale state race

Bugsnag reports SubmitIntentError.StaleState errors with reason "race
detected: cached balance version is stale". This is a server-side
optimistic version lock — the client sends no balance version. When
concurrent intents advance the version before the DB transaction commits,
the check fails and the transaction rolls back (no nonces consumed).

- Add isRaceCondition property to StaleState, matching the "race
  detected:" prefix — the only StaleState variant safe to blindly retry
- Wrap submitIntent in retryableOrThrow with retryIf narrowed to race
  conditions only (other StaleState reasons like stale exchange rates,
  closed accounts, or claimed gift cards require client-side state
  refresh and would fail identically on retry)
- Move gift-card-claimed Bugsnag suppression from
  InternalTransactionRepository to ReceiveGiftCardTransactor where the
  context-specific handling belongs

Signed-off-by: Brandon McAnsh <git@bmcreations.dev>

Author: bmc08gt

libs/network/connectivity/public/src/main/kotlin/com/getcode/utils/network/Retry.kt

@@ -10,7 +10,7 @@ import kotlin.time.TimeSource
 suspend fun <T> retryable(
     maxRetries: Int = 3,
     delayDuration: Duration = 2.seconds,
-    retryIf: (Exception) -> Boolean = { true },
+    retryIf: (Throwable) -> Boolean = { true },
     onRetry: (Int) -> Unit = { currentAttempt ->
         trace(
             message = "Retrying call",
@@ -34,7 +34,7 @@ suspend fun <T> retryable(
     while (currentAttempt < maxRetries) {
         val result = try {
             call()
-        } catch (e: Exception) {
+        } catch (e: Throwable) {
             if (!retryIf(e)) throw e
             trace(
                 message = "Attempt $currentAttempt failed with exception: ${e.message}",
@@ -66,7 +66,7 @@ suspend fun <T> retryable(
 suspend fun <T> retryableOrThrow(
     maxRetries: Int = 3,
     delayDuration: Duration = 2.seconds,
-    retryIf: (Exception) -> Boolean = { true },
+    retryIf: (Throwable) -> Boolean = { true },
     onRetry: (Int) -> Unit = { currentAttempt ->
         trace(
             message = "Retrying call",
@@ -85,13 +85,13 @@ suspend fun <T> retryableOrThrow(
     call: suspend () -> T,
 ): T {
     var currentAttempt = 0
-    var lastException: Exception? = null
+    var lastException: Throwable? = null
     val startTime = TimeSource.Monotonic.markNow()
 
     while (currentAttempt < maxRetries) {
         try {
             return call()
-        } catch (e: Exception) {
+        } catch (e: Throwable) {
             if (!retryIf(e)) throw e
             lastException = e
             trace(

services/opencode/src/main/kotlin/com/getcode/opencode/internal/domain/repositories/InternalTransactionRepository.kt

@@ -18,8 +18,10 @@ import com.getcode.opencode.solana.intents.IntentType
 import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.PublicKey
 import com.getcode.utils.ErrorUtils
+import com.getcode.utils.network.retryableOrThrow
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.datetime.Instant
+import kotlin.time.Duration.Companion.seconds
 import javax.inject.Inject
 
 internal class InternalTransactionRepository @Inject constructor(
@@ -29,13 +31,17 @@ internal class InternalTransactionRepository @Inject constructor(
         scope: CoroutineScope,
         intent: IntentType,
         owner: Ed25519.KeyPair
-    ): Result<IntentType> = service.submitIntent(scope, intent, owner)
-        .onFailure {
-            // Expected race: pre-claim check passes but the gift card is claimed
-            // before the intent is submitted. Not a bug — skip Bugsnag reporting.
-            if (it is SubmitIntentError.StaleState && it.isGiftCardAlreadyClaimed) return@onFailure
-            ErrorUtils.handleError(it)
+    ): Result<IntentType> = runCatching {
+        retryableOrThrow(
+            maxRetries = 3,
+            delayDuration = 1.seconds,
+            retryIf = { it is SubmitIntentError.StaleState && it.isRaceCondition },
+        ) {
+            service.submitIntent(scope, intent, owner).getOrThrow()
         }
+    }.onFailure {
+        ErrorUtils.handleError(it)
+    }
 
     override suspend fun getIntentMetadata(
         intentId: PublicKey,

services/opencode/src/main/kotlin/com/getcode/opencode/internal/transactors/ReceiveGiftCardTransactor.kt

@@ -14,6 +14,7 @@ import com.getcode.opencode.model.accounts.GiftCardAccount
 import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.financial.Token
 import com.getcode.opencode.providers.TokenMetadataProvider
+import com.getcode.opencode.model.core.errors.SubmitIntentError
 import com.getcode.utils.CodeServerError
 import com.getcode.utils.NotifiableError
 import com.getcode.utils.timedTraceSuspend
@@ -146,9 +147,13 @@ internal class ReceiveGiftCardTransactor(
                     onStep("intent")
                     Result.success(token to amount)
                 },
-                onFailure = {
+                onFailure = { error ->
                     onStep("intent")
-                    logAndFail(it)
+                    if (error is SubmitIntentError.StaleState && error.isGiftCardAlreadyClaimed) {
+                        Result.failure(error)
+                    } else {
+                        logAndFail(error)
+                    }
                 }
             )
         }

services/opencode/src/main/kotlin/com/getcode/opencode/model/core/errors/Errors.kt

@@ -123,6 +123,8 @@ sealed class SubmitIntentError(
         }), NotifiableError
     data class StaleState(private val reasons: List<String>) :
         SubmitIntentError(message = reasons.joinToString()), NotifiableError {
+        val isRaceCondition: Boolean
+            get() = reasons.any { it.startsWith("race detected:") }
         val isGiftCardAlreadyClaimed: Boolean
             get() = reasons.any { it.contains("gift card balance has already been claimed") }
     }

services/opencode/src/test/kotlin/com/getcode/opencode/model/core/errors/SubmitIntentErrorTest.kt

@@ -171,6 +171,30 @@ class SubmitIntentErrorTest {
         assertFalse(error.isGiftCardAlreadyClaimed)
     }
 
+    @Test
+    fun staleStateWithRaceDetectedIsRaceCondition() {
+        val error = SubmitIntentError.typed(
+            buildError(
+                SubmitIntentResponse.Error.Code.STALE_STATE,
+                reasonStrings = listOf("race detected: cached balance version is stale")
+            )
+        )
+        assertIs<SubmitIntentError.StaleState>(error)
+        assertTrue(error.isRaceCondition)
+    }
+
+    @Test
+    fun staleStateWithOtherReasonIsNotRaceCondition() {
+        val error = SubmitIntentError.typed(
+            buildError(
+                SubmitIntentResponse.Error.Code.STALE_STATE,
+                reasonStrings = listOf("intent already exists")
+            )
+        )
+        assertIs<SubmitIntentError.StaleState>(error)
+        assertFalse(error.isRaceCondition)
+    }
+
     @Test
     fun otherWrausesCause() {
         val cause = RuntimeException("root cause")