Merge pull request #660 from code-payments/fix/exchange-rate-expired-missing-flags

bmc08gt · web-flow · commit 870856417cc3 · 2026-05-04T13:06:15.000-04:00
fix(auth): prevent exchange rate expired due to missing user flags
diff --git a/apps/flipcash/shared/authentication/src/main/kotlin/com/flipcash/app/auth/AuthManager.kt b/apps/flipcash/shared/authentication/src/main/kotlin/com/flipcash/app/auth/AuthManager.kt
@@ -19,6 +19,7 @@ import com.getcode.opencode.controllers.TokenController
 import com.getcode.opencode.model.core.ID
 import com.getcode.utils.TraceManager
 import com.getcode.utils.TraceType
+import com.getcode.utils.network.retryable
 import com.getcode.utils.trace
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -117,17 +118,23 @@ class AuthManager @Inject constructor(
     suspend fun presentCredentialStorage(): Result<Unit> {
         return credentialManager.presentSaveOption()
             .onSuccess {
-                accountController.getUserFlags().onSuccess { userManager.set(it) }
+                accountController.getUserFlags().onSuccess { flags ->
+                    userManager.set(flags)
+                    if (flags.isRegistered) {
+                        userManager.set(AuthState.LoggedInWithUser)
+                    }
+                }
             }.map { Unit }
     }
 
     suspend fun onAccountPurchased(): Result<Unit> {
         return credentialManager.onAccountPurchased()
             .fold(
                 onSuccess = {
-                    userManager.set(AuthState.LoggedInWithUser)
-                    accountController.getUserFlags()
+                    val flagsResult = accountController.getUserFlags()
                         .onSuccess { userManager.set(it) }
+                    userManager.set(AuthState.LoggedInWithUser)
+                    flagsResult
                 },
                 onFailure = { Result.failure(it) }
             ).onSuccess { savePrefs() }.map { Unit }
@@ -159,14 +166,17 @@ class AuthManager @Inject constructor(
 
                 coroutineScope {
                     launch {
-                        accountController.getUserFlags()
-                            .onSuccess { flags ->
-                                userManager.set(flags)
-                                userManager.set(if (flags.isRegistered) AuthState.LoggedInWithUser else AuthState.Registered())
-                            }.onFailure {
-                                taggedTrace("Failed to get user flags", type = TraceType.Error, cause = it)
-                                userManager.set(authState = AuthState.Registered())
-                            }
+                        val flags = retryable(maxRetries = 3) {
+                            accountController.getUserFlags().getOrNull()
+                        }
+
+                        if (flags != null) {
+                            userManager.set(flags)
+                            userManager.set(if (flags.isRegistered) AuthState.LoggedInWithUser else AuthState.Registered())
+                        } else {
+                            taggedTrace("Failed to get user flags after retries", type = TraceType.Error)
+                            userManager.set(authState = AuthState.Registered())
+                        }
                     }
                     launch { savePrefs() }
                 }
diff --git a/apps/flipcash/shared/authentication/src/test/kotlin/com/flipcash/app/auth/AuthManagerTest.kt b/apps/flipcash/shared/authentication/src/test/kotlin/com/flipcash/app/auth/AuthManagerTest.kt
@@ -12,6 +12,7 @@ import com.flipcash.app.userflags.UserFlagsCoordinator
 import com.flipcash.services.controllers.AccountController
 import com.flipcash.services.controllers.PushController
 import com.flipcash.services.models.UserFlags
+import com.flipcash.services.user.AuthState
 import com.flipcash.services.user.UserManager
 import io.mockk.coEvery
 import io.mockk.coVerify
@@ -215,4 +216,42 @@ class AuthManagerTest {
         val secondRead = authManager.consumePendingSwitchEntropy()
         assertNull(secondRead)
     }
+
+    @Test
+    fun `login retries getUserFlags on failure then succeeds`() = runTest {
+        val entropy = "dGVzdGVudHJvcHkxMjM0NQ=="
+        val accountMetadata: AccountMetadata = mockk(relaxed = true)
+        val testId = listOf<Byte>(1, 2, 3)
+        every { accountMetadata.id } returns testId
+
+        coEvery { credentialManager.login(entropy, any()) } returns Result.success(accountMetadata)
+
+        val flags = UserFlags.Default.copy(isRegistered = true)
+        coEvery { accountController.getUserFlags() } returnsMany listOf(
+            Result.failure(RuntimeException("transient failure")),
+            Result.success(flags)
+        )
+
+        val result = authManager.login(entropyB64 = entropy)
+
+        assertTrue(result.isSuccess)
+        verify { userManager.set(flags) }
+        verify { userManager.set(authState = AuthState.LoggedInWithUser) }
+    }
+
+    @Test
+    fun `login falls back to Registered after all retries exhausted`() = runTest {
+        val entropy = "dGVzdGVudHJvcHkxMjM0NQ=="
+        val accountMetadata: AccountMetadata = mockk(relaxed = true)
+        val testId = listOf<Byte>(1, 2, 3)
+        every { accountMetadata.id } returns testId
+
+        coEvery { credentialManager.login(entropy, any()) } returns Result.success(accountMetadata)
+        coEvery { accountController.getUserFlags() } returns Result.failure(RuntimeException("persistent failure"))
+
+        val result = authManager.login(entropyB64 = entropy)
+
+        assertTrue(result.isSuccess)
+        verify { userManager.set(authState = AuthState.Registered()) }
+    }
 }
diff --git a/apps/flipcash/shared/session/src/main/kotlin/com/flipcash/app/session/internal/RealSessionController.kt b/apps/flipcash/shared/session/src/main/kotlin/com/flipcash/app/session/internal/RealSessionController.kt
@@ -149,7 +149,7 @@ class RealSessionController @Inject constructor(
                         stopPolling()
                         _state.update { SessionState() }
                     }
-                    authState.canAccessAuthenticatedApis -> {
+                    authState.isAtLeastRegistered -> {
                         onAppInForeground()
                     }
                 }
@@ -187,6 +187,17 @@ class RealSessionController @Inject constructor(
             .onEach { tokens ->
                 _state.update { it.copy(tokens = tokens) }
             }.launchIn(scope)
+
+        // Retry updateUserFlags when network is restored
+        networkObserver.state
+            .map { it.connected }
+            .distinctUntilChanged()
+            .filter { connected -> connected }
+            .onEach {
+                if (userManager.authState.isAtLeastRegistered) {
+                    updateUserFlags()
+                }
+            }.launchIn(scope)
     }
 
     /**
@@ -256,10 +267,15 @@ class RealSessionController @Inject constructor(
     }
 
     private fun updateUserFlags() {
-        if (userManager.authState.canAccessAuthenticatedApis) {
+        if (userManager.authState.isAtLeastRegistered) {
             scope.launch {
                 accountController.getUserFlags()
-                    .onSuccess { userManager.set(it) }
+                    .onSuccess { flags ->
+                        userManager.set(flags)
+                        if (flags.isRegistered && !userManager.authState.canAccessAuthenticatedApis) {
+                            userManager.set(authState = AuthState.LoggedInWithUser)
+                        }
+                    }
             }
         }
     }
diff --git a/services/flipcash/src/main/kotlin/com/flipcash/services/user/UserManager.kt b/services/flipcash/src/main/kotlin/com/flipcash/services/user/UserManager.kt
@@ -130,12 +130,17 @@ class UserManager @Inject constructor(
     }
 
     fun set(authState: AuthState) {
+        val previous = _state.value.authState
         _state.update { it.copy(authState = authState) }
 
         when (authState) {
             is AuthState.LoggedIn -> {
                 accountCluster?.let { owner ->
                     eventBus.send(Events.UpdateLimits(owner = owner, force = true))
+                    // Fire OnLoggedIn only on transition INTO LoggedInWithUser
+                    if (authState is AuthState.LoggedInWithUser && previous !is AuthState.LoggedInWithUser) {
+                        eventBus.send(Events.OnLoggedIn(owner))
+                    }
                 }
             }
 
@@ -149,10 +154,6 @@ class UserManager @Inject constructor(
                 flags = userFlags,
             )
         }
-
-        if (userFlags?.isRegistered == true) {
-            accountCluster?.let { eventBus.send(Events.OnLoggedIn(accountCluster!!)) }
-        }
     }
 
     fun set(pushToken: String?) {
diff --git a/services/opencode/src/main/kotlin/com/getcode/opencode/internal/extensions/VerifiedState.kt b/services/opencode/src/main/kotlin/com/getcode/opencode/internal/extensions/VerifiedState.kt
@@ -4,16 +4,29 @@ import com.getcode.opencode.internal.manager.VerifiedState
 import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.transactions.ExchangeData
 import com.getcode.solana.keys.Mint
+import kotlin.time.Clock
 import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Instant
+
+private val DefaultBillExchangeDataTimeout = 15.minutes
 
 fun VerifiedState.exchangeDataFor(
     amount: LocalFiat,
     mint: Mint,
     billExchangeDataTimeout: Duration?
 ): ExchangeData.Verified? {
-    if (billExchangeDataTimeout == null) {
+    val timeout = billExchangeDataTimeout ?: DefaultBillExchangeDataTimeout
+    if (timeout <= Duration.ZERO) return null
+
+    val ts = Instant.fromEpochSeconds(
+        rateProto.exchangeRate.timestamp.seconds,
+        rateProto.exchangeRate.timestamp.nanos
+    )
+    if (Clock.System.now() - ts > timeout) {
         return null
     }
+
     return ExchangeData.Verified(
         mint = mint,
         nativeAmount = amount.nativeAmount.decimalValue,
diff --git a/services/opencode/src/test/kotlin/com/getcode/opencode/internal/extensions/VerifiedStateExtTest.kt b/services/opencode/src/test/kotlin/com/getcode/opencode/internal/extensions/VerifiedStateExtTest.kt
@@ -1,25 +1,48 @@
 package com.getcode.opencode.internal.extensions
 
+import com.codeinc.opencode.gen.currency.v1.coreMintFiatExchangeRate
+import com.codeinc.opencode.gen.currency.v1.verifiedCoreMintFiatExchangeRate
 import com.getcode.opencode.internal.manager.VerifiedState
 import com.getcode.opencode.model.financial.CurrencyCode
 import com.getcode.opencode.model.financial.Fiat
 import com.getcode.opencode.model.financial.LocalFiat
 import com.getcode.opencode.model.financial.Rate
 import com.getcode.opencode.model.transactions.ExchangeData
 import com.getcode.solana.keys.Mint
-import io.mockk.mockk
+import com.google.protobuf.Timestamp
 import org.junit.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertIs
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlin.time.Clock
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.minutes
 import kotlin.time.Duration.Companion.seconds
 
 class VerifiedStateExtTest {
 
-    private val verifiedState = VerifiedState(
-        rateProto = mockk(relaxed = true),
-        reserveProto = null,
-    )
+    private fun verifiedStateAt(epochSeconds: Long): VerifiedState {
+        return VerifiedState(
+            rateProto = verifiedCoreMintFiatExchangeRate {
+                exchangeRate = coreMintFiatExchangeRate {
+                    currencyCode = "usd"
+                    exchangeRate = 1.0
+                    timestamp = Timestamp.newBuilder().setSeconds(epochSeconds).build()
+                }
+            },
+            reserveProto = null,
+        )
+    }
+
+    private fun freshVerifiedState(): VerifiedState {
+        return verifiedStateAt(Clock.System.now().epochSeconds)
+    }
+
+    private fun staleVerifiedState(age: Duration): VerifiedState {
+        val staleEpoch = Clock.System.now().epochSeconds - age.inWholeSeconds
+        return verifiedStateAt(staleEpoch)
+    }
 
     private val amount = LocalFiat(
         underlyingTokenAmount = Fiat(quarks = 500_000L, currencyCode = CurrencyCode.USD),
@@ -29,40 +52,80 @@ class VerifiedStateExtTest {
     )
 
     @Test
-    fun `returns null when timeout is null`() {
-        val result = verifiedState.exchangeDataFor(
+    fun `returns Verified with correct fields when timeout is provided and rate is fresh`() {
+        val state = freshVerifiedState()
+        val result = state.exchangeDataFor(
             amount = amount,
             mint = Mint.usdf,
-            billExchangeDataTimeout = null,
+            billExchangeDataTimeout = 30.seconds,
         )
 
-        assertNull(result)
+        assertIs<ExchangeData.Verified>(result)
+        assertEquals(Mint.usdf, result.mint)
+        assertEquals(amount.nativeAmount.decimalValue, result.nativeAmount)
+        assertEquals(amount.underlyingTokenAmount.quarks, result.quarks)
+        assertEquals(state, result.verifiedState)
     }
 
     @Test
-    fun `returns Verified with correct fields when timeout is provided`() {
-        val result = verifiedState.exchangeDataFor(
+    fun `passes through the verifiedState reference`() {
+        val state = freshVerifiedState()
+        val result = state.exchangeDataFor(
             amount = amount,
             mint = Mint.usdf,
             billExchangeDataTimeout = 30.seconds,
         )
 
         assertIs<ExchangeData.Verified>(result)
-        assertEquals(Mint.usdf, result.mint)
-        assertEquals(amount.nativeAmount.decimalValue, result.nativeAmount)
-        assertEquals(amount.underlyingTokenAmount.quarks, result.quarks)
-        assertEquals(verifiedState, result.verifiedState)
+        assert(result.verifiedState === state)
     }
 
     @Test
-    fun `passes through the verifiedState reference`() {
-        val result = verifiedState.exchangeDataFor(
+    fun `returns null when timeout is zero`() {
+        val state = freshVerifiedState()
+        val result = state.exchangeDataFor(
+            amount = amount,
+            mint = Mint.usdf,
+            billExchangeDataTimeout = Duration.ZERO,
+        )
+
+        assertNull(result)
+    }
+
+    @Test
+    fun `returns null when rate exceeds timeout`() {
+        val state = staleVerifiedState(age = 60.seconds)
+        val result = state.exchangeDataFor(
             amount = amount,
             mint = Mint.usdf,
-            billExchangeDataTimeout = 1.seconds,
+            billExchangeDataTimeout = 30.seconds,
         )
 
+        assertNull(result)
+    }
+
+    @Test
+    fun `uses default timeout when null and rate is fresh`() {
+        val state = freshVerifiedState()
+        val result = state.exchangeDataFor(
+            amount = amount,
+            mint = Mint.usdf,
+            billExchangeDataTimeout = null,
+        )
+
+        assertNotNull(result)
         assertIs<ExchangeData.Verified>(result)
-        assert(result.verifiedState === verifiedState)
+    }
+
+    @Test
+    fun `returns null when null timeout and rate exceeds default 15 minutes`() {
+        val state = staleVerifiedState(age = 16.minutes)
+        val result = state.exchangeDataFor(
+            amount = amount,
+            mint = Mint.usdf,
+            billExchangeDataTimeout = null,
+        )
+
+        assertNull(result)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ class RealSessionController @Inject constructor(`
`149`	`149`	`stopPolling()`
`150`	`150`	`_state.update { SessionState() }`
`151`	`151`	`}`
`152`		`- authState.canAccessAuthenticatedApis -> {`
	`152`	`+ authState.isAtLeastRegistered -> {`
`153`	`153`	`onAppInForeground()`
`154`	`154`	`}`
`155`	`155`	`}`
`@@ -187,6 +187,17 @@ class RealSessionController @Inject constructor(`
`187`	`187`	`.onEach { tokens ->`
`188`	`188`	`_state.update { it.copy(tokens = tokens) }`
`189`	`189`	`}.launchIn(scope)`
	`190`	`+`
	`191`	`+ // Retry updateUserFlags when network is restored`
	`192`	`+ networkObserver.state`
	`193`	`+ .map { it.connected }`
	`194`	`+ .distinctUntilChanged()`
	`195`	`+ .filter { connected -> connected }`
	`196`	`+ .onEach {`
	`197`	`+ if (userManager.authState.isAtLeastRegistered) {`
	`198`	`+ updateUserFlags()`
	`199`	`+ }`
	`200`	`+ }.launchIn(scope)`
`190`	`201`	`}`
`191`	`202`
`192`	`203`	`/**`
`@@ -256,10 +267,15 @@ class RealSessionController @Inject constructor(`
`256`	`267`	`}`
`257`	`268`
`258`	`269`	`private fun updateUserFlags() {`
`259`		`- if (userManager.authState.canAccessAuthenticatedApis) {`
	`270`	`+ if (userManager.authState.isAtLeastRegistered) {`
`260`	`271`	`scope.launch {`
`261`	`272`	`accountController.getUserFlags()`
`262`		`- .onSuccess { userManager.set(it) }`
	`273`	`+ .onSuccess { flags ->`
	`274`	`+ userManager.set(flags)`
	`275`	`+ if (flags.isRegistered && !userManager.authState.canAccessAuthenticatedApis) {`
	`276`	`+ userManager.set(authState = AuthState.LoggedInWithUser)`
	`277`	`+ }`
	`278`	`+ }`
`263`	`279`	`}`
`264`	`280`	`}`
`265`	`281`	`}`
Original file line number	Diff line number	Diff line change
`@@ -130,12 +130,17 @@ class UserManager @Inject constructor(`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`fun set(authState: AuthState) {`
	`133`	`+ val previous = _state.value.authState`
`133`	`134`	`_state.update { it.copy(authState = authState) }`
`134`	`135`
`135`	`136`	`when (authState) {`
`136`	`137`	`is AuthState.LoggedIn -> {`
`137`	`138`	`accountCluster?.let { owner ->`
`138`	`139`	`eventBus.send(Events.UpdateLimits(owner = owner, force = true))`
	`140`	`+ // Fire OnLoggedIn only on transition INTO LoggedInWithUser`
	`141`	`+ if (authState is AuthState.LoggedInWithUser && previous !is AuthState.LoggedInWithUser) {`
	`142`	`+ eventBus.send(Events.OnLoggedIn(owner))`
	`143`	`+ }`
`139`	`144`	`}`
`140`	`145`	`}`
`141`	`146`
`@@ -149,10 +154,6 @@ class UserManager @Inject constructor(`
`149`	`154`	`flags = userFlags,`
`150`	`155`	`)`
`151`	`156`	`}`
`152`		`-`
`153`		`- if (userFlags?.isRegistered == true) {`
`154`		`- accountCluster?.let { eventBus.send(Events.OnLoggedIn(accountCluster!!)) }`
`155`		`- }`
`156`	`157`	`}`
`157`	`158`
`158`	`159`	`fun set(pushToken: String?) {`