feat(tokens): add GiveUsdf flag with auto-switch on disable

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

Author: bmc08gt

apps/flipcash/shared/featureflags/src/main/kotlin/com/flipcash/app/featureflags/FeatureFlag.kt

@@ -216,6 +216,15 @@ sealed interface FeatureFlag<T: Any> {
         override val persistLogOut: Boolean = false
     }
 
+    @FeatureFlagMarker
+    data object GiveUsdf: FeatureFlag<Boolean> {
+        override val key: String = "give_usdf_enabled"
+        override val default: Boolean = false
+        override val launched: Boolean = false
+        override val visible: Boolean = true
+        override val persistLogOut: Boolean = false
+    }
+
     @FeatureFlagMarker
     data object NavBar : FeatureFlag<NavBarConfig> {
         override val key: String = "nav_bar_config"
@@ -260,6 +269,7 @@ val FeatureFlag<*>.title: String
         FeatureFlag.OnboardingPhoneVerification -> "Onboarding Phone Verification"
         FeatureFlag.Messenger -> "Messenger"
         FeatureFlag.NavBar -> "Navigation Bar"
+        FeatureFlag.GiveUsdf -> "Give USDF"
     }
 
 val FeatureFlag<*>.message: String
@@ -285,6 +295,7 @@ val FeatureFlag<*>.message: String
         FeatureFlag.OnboardingPhoneVerification -> "When enabled, new accounts will be prompted to verify their phone number during onboarding"
         FeatureFlag.Messenger -> "When enabled, tapping a contact will open the chat messenger instead of navigating directly to send"
         FeatureFlag.NavBar -> "Customize the order and labels of navigation bar buttons"
+        FeatureFlag.GiveUsdf -> "When enabled, you'll gain the ability to send USDF directly"
     }
 
 

apps/flipcash/shared/tokens/src/main/kotlin/com/flipcash/app/tokens/TokenCoordinator.kt

@@ -10,6 +10,8 @@ import androidx.datastore.preferences.preferencesDataStoreFile
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.ProcessLifecycleOwner
+import com.flipcash.app.featureflags.FeatureFlag
+import com.flipcash.app.featureflags.FeatureFlagController
 import com.flipcash.app.persistence.sources.TokenDataSource
 import com.flipcash.app.tokens.core.ReservesBalanceProvider
 import com.getcode.opencode.controllers.AccountController
@@ -85,6 +87,7 @@ class TokenCoordinator @Inject constructor(
     private val exchange: Exchange,
     private val verifiedFiatCalculator: VerifiedFiatCalculator,
     private val dataSource: TokenDataSource,
+    private val featureFlags: FeatureFlagController,
 ) : TokenMetadataProvider, SessionListener, DefaultLifecycleObserver, ReservesBalanceProvider {
 
     companion object {
@@ -166,6 +169,12 @@ class TokenCoordinator @Inject constructor(
                 exchange.updateUserMints(mints)
             }
             .launchIn(scope)
+
+        // Re-evaluate selected token when GiveUsdf flag changes
+        featureFlags.observe(FeatureFlag.GiveUsdf)
+            .filter { _hydrated.value }
+            .onEach { ensureValidTokenSelection() }
+            .launchIn(scope)
     }
 
     override fun onStart(owner: LifecycleOwner) {
@@ -516,10 +525,14 @@ class TokenCoordinator @Inject constructor(
             ?.get(mintPreferenceKey)
             ?.let { Mint(it) }
 
+        val canGiveUsdf = featureFlags.get(FeatureFlag.GiveUsdf)
+        val excludedMints = if (!canGiveUsdf) setOf(Mint.usdf) else emptySet()
+
         val resolved = resolveTokenSelection(
             balances = _state.value.balances,
             currentSelection = currentSelection,
             rate = exchange.preferredRate,
+            excludedMints = excludedMints,
         )
 
         if (resolved != null && resolved != currentSelection) {

apps/flipcash/shared/tokens/src/main/kotlin/com/flipcash/app/tokens/TokenSelectionResolver.kt

@@ -15,9 +15,12 @@ internal fun resolveTokenSelection(
     balances: Map<Mint, Fiat>,
     currentSelection: Mint?,
     rate: Rate,
+    excludedMints: Set<Mint> = emptySet(),
 ): Mint? {
     if (balances.isEmpty()) return null
 
+    val eligible = balances.filterKeys { it !in excludedMints }
+
     val baseline = 0.01.toFiat(rate.currency)
 
     fun Fiat.meetsThreshold(): Boolean {
@@ -26,15 +29,15 @@ internal fun resolveTokenSelection(
     }
 
     // Keep current selection if it still meets the threshold
-    if (currentSelection != null) {
-        val balance = balances[currentSelection]
+    if (currentSelection != null && currentSelection !in excludedMints) {
+        val balance = eligible[currentSelection]
         if (balance != null && balance.meetsThreshold()) {
             return currentSelection
         }
     }
 
     // Fall back to the highest balance that meets the threshold
-    return balances
+    return eligible
         .filter { it.value.meetsThreshold() }
         .maxByOrNull { it.value }
         ?.key

apps/flipcash/shared/tokens/src/main/kotlin/com/flipcash/app/tokens/ui/SelectTokenViewModel.kt

@@ -43,6 +43,7 @@ class SelectTokenViewModel @Inject constructor(
     exchange: Exchange,
     resources: ResourceHelper,
     dispatchers: DispatcherProvider,
+    featureFlags: FeatureFlagController,
 ) : BaseViewModel<SelectTokenViewModel.State, SelectTokenViewModel.Event>(
     initialState = State(purpose = TokenPurpose.Balance),
     updateStateForEvent = updateStateForEvent,
@@ -52,6 +53,7 @@ class SelectTokenViewModel @Inject constructor(
     data class State(
         val purpose: TokenPurpose,
         val rate: Rate = Rate.oneToOne,
+        val canGiveUsdf: Boolean = false,
         val discoveryEnabled: Boolean = false,
         val tokens: List<TokenWithLocalizedBalance>? = null,
         val selectedToken: Mint? = null,
@@ -85,6 +87,8 @@ class SelectTokenViewModel @Inject constructor(
         data object OnTokenChanged : Event
 
         data class OpenScreen(val route: AppRoute) : Event
+
+        data class OnCanGiveUsdf(val enabled: Boolean): Event
     }
 
     init {
@@ -93,6 +97,10 @@ class SelectTokenViewModel @Inject constructor(
             .onEach { dispatchEvent(Event.OnRateChanged(it)) }
             .launchIn(viewModelScope)
 
+        featureFlags.observe(FeatureFlag.GiveUsdf)
+            .onEach { dispatchEvent(Event.OnCanGiveUsdf(it)) }
+            .launchIn(viewModelScope)
+
         eventFlow
             .filterIsInstance<Event.OnPurposeChanged>()
             .map { it.purpose }
@@ -156,6 +164,13 @@ class SelectTokenViewModel @Inject constructor(
                             when (purpose) {
                                 // show all tokens we have accounts for as deposit targets
                                 TokenPurpose.Deposit -> true
+                                TokenPurpose.Select -> {
+                                    if (it.token.address == Mint.usdf) {
+                                        stateFlow.value.canGiveUsdf && hasBalance
+                                    } else {
+                                        hasBalance
+                                    }
+                                }
                                 // show all tokens with non-zero balance
                                 else -> hasBalance
                             }
@@ -191,6 +206,7 @@ class SelectTokenViewModel @Inject constructor(
                 is Event.OnTokenSelected -> { state -> state.copy(selectedToken = event.mint) }
                 is Event.OnTokenChanged -> { state -> state }
                 is Event.OpenScreen -> { state -> state }
+                is Event.OnCanGiveUsdf -> { state -> state.copy(canGiveUsdf = event.enabled) }
             }
         }
     }