refactor(ui): extract shared AmountEntryScreen and AmountEntryDelegate

Extract duplicated amount-entry UI and ViewModel logic into a shared
module (apps/flipcash/shared/amount-entry). The new AmountEntryDelegate
encapsulates NumberInputHelper, currency observation, and animated model
management. The new AmountEntryScreen composable provides the unified
Column { AmountWithKeypad + CodeButton/SlideToConfirm } layout.

Migrated Cash (Give), Swap (Buy/Sell), and Withdrawal features to use
the shared components, eliminating ~250 lines of duplicated code.

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

Author: bmc08gt

apps/flipcash/features/cash/build.gradle.kts

@@ -14,6 +14,7 @@ dependencies {
     testImplementation(project(":libs:test-utils"))
 
     implementation(libs.kotlin.stdlib)
+    implementation(project(":apps:flipcash:shared:amount-entry"))
     implementation(project(":apps:flipcash:shared:analytics"))
     implementation(project(":apps:flipcash:shared:session"))
     implementation(project(":apps:flipcash:shared:tokens"))

apps/flipcash/features/cash/src/main/kotlin/com/flipcash/app/cash/internal/CashScreenContent.kt

@@ -1,73 +1,21 @@
 package com.flipcash.app.cash.internal
 
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.navigationBarsPadding
-import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.stringResource
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.flipcash.app.core.AppRoute
-import com.flipcash.app.core.ui.AmountWithKeypad
-import com.flipcash.features.cash.R
+import com.flipcash.shared.amountentry.AmountEntryScreen
 import com.getcode.navigation.core.LocalCodeNavigator
-import com.getcode.theme.CodeTheme
-import com.getcode.ui.theme.ButtonState
-import com.getcode.ui.theme.CodeButton
 
 @Composable
 internal fun GiveScreenContent(viewModel: CashScreenViewModel) {
     val navigator = LocalCodeNavigator.current
-    val state by viewModel.stateFlow.collectAsState()
-    Column(
-        modifier = Modifier.fillMaxSize(),
-    ) {
-        AmountWithKeypad(
-            modifier = Modifier
-                .fillMaxWidth()
-                .weight(1f),
-            amountAnimatedModel = state.amountAnimatedModel,
-            currencyFlag = state.currencyModel.selected?.resId,
-            prefix = state.currencyModel.selected?.symbol.orEmpty(),
-            placeholder = "0",
-            decimalPlaces = state.currencyModel.fractionUnits,
-            hint = if (state.isError) {
-                stringResource(
-                    R.string.subtitle_giveCashHintLimitExceeded,
-                    state.maxAvailableForGive
-                )
-            } else {
-                stringResource(R.string.subtitle_giveCashHint, state.maxAvailableForGive)
-            },
-            isClickable = true,
-            onAmountClicked = {
-                navigator.push(AppRoute.Main.RegionSelection)
-            },
-            isError = state.isError,
-            onNumberPressed = { viewModel.dispatchEvent(CashScreenViewModel.Event.OnNumberPressed(it)) },
-            onBackspace = { viewModel.dispatchEvent(CashScreenViewModel.Event.OnBackspace) },
-            onDecimal = { viewModel.dispatchEvent(CashScreenViewModel.Event.OnDecimalPressed) }
-        )
+    val config by viewModel.config.collectAsStateWithLifecycle()
 
-        Box(modifier = Modifier.fillMaxWidth()) {
-            CodeButton(
-                enabled = state.canGive,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = CodeTheme.dimens.inset)
-                    .padding(bottom = CodeTheme.dimens.grid.x2)
-                    .navigationBarsPadding(),
-                buttonState = ButtonState.Filled,
-                isLoading = state.generatingBill.loading,
-                isSuccess = state.generatingBill.success,
-                text = stringResource(R.string.action_next),
-            ) {
-                viewModel.dispatchEvent(CashScreenViewModel.Event.OnGive)
-            }
-        }
-    }
+    AmountEntryScreen(
+        delegate = viewModel.amountDelegate,
+        config = config,
+        onConfirm = { viewModel.dispatchEvent(CashScreenViewModel.Event.OnGive) },
+        onChangeCurrency = { navigator.push(AppRoute.Main.RegionSelection) },
+    )
 }

apps/flipcash/features/cash/src/main/kotlin/com/flipcash/app/cash/internal/CashScreenViewModel.kt

@@ -8,13 +8,16 @@ import com.flipcash.app.core.ui.CurrencyHolder
 import com.flipcash.app.tokens.TokenCoordinator
 import com.flipcash.features.cash.R
 import com.flipcash.libs.coroutines.DispatcherProvider
+import com.flipcash.shared.amountentry.AmountEntryAction
+import com.flipcash.shared.amountentry.AmountEntryConfig
+import com.flipcash.shared.amountentry.AmountEntryDelegate
+import com.flipcash.shared.amountentry.AmountEntryHint
 import com.getcode.manager.BottomBarAction
 import com.getcode.manager.BottomBarManager
 import com.getcode.opencode.controllers.TransactionOperations
 import com.getcode.opencode.exchange.Exchange
 import com.getcode.opencode.exchange.VerifiedFiatCalculator
 import com.getcode.opencode.model.core.errors.ComputeVerifiedFiatError
-import com.getcode.opencode.model.financial.Currency
 import com.getcode.opencode.model.financial.CurrencyCode
 import com.getcode.opencode.model.financial.Fiat
 import com.getcode.opencode.model.financial.Limits
@@ -23,13 +26,12 @@ import com.getcode.opencode.model.financial.SendLimit
 import com.getcode.opencode.model.financial.TokenWithLocalizedBalance
 import com.getcode.opencode.model.financial.minus
 import com.getcode.solana.keys.Mint
-import com.getcode.ui.components.text.AmountAnimatedInputUiModel
-import com.getcode.ui.components.text.NumberInputHelper
 import com.getcode.util.resources.ResourceHelper
 import com.getcode.view.BaseViewModel
 import com.getcode.view.LoadingSuccessState
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.drop
@@ -41,6 +43,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.mapNotNull
 import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.take
 import kotlinx.coroutines.launch
 import javax.inject.Inject
@@ -60,59 +63,31 @@ internal class CashScreenViewModel @Inject constructor(
     defaultDispatcher = dispatchers.Default,
 ) {
 
-    private val numberInputHelper = NumberInputHelper()
+    val amountDelegate = AmountEntryDelegate(exchange, viewModelScope)
     private val tokenInitialized = CompletableDeferred<Mint?>()
 
     internal data class State(
         val selectedTokenAddress: Mint? = null,
         val token: TokenWithLocalizedBalance? = null,
         val currencyModel: CurrencyHolder = CurrencyHolder(),
-        val amountAnimatedModel: AmountAnimatedInputUiModel = AmountAnimatedInputUiModel(),
         val limits: Limits? = null,
         val maxForGive: Pair<Double, CurrencyCode>? = null,
         val generatingBill: LoadingSuccessState = LoadingSuccessState(),
     ) {
-        val canGive: Boolean
-            get() = (amountAnimatedModel.amountData.amount) > 0.00
-
         val maxAvailableForGive: String
             get() = maxForGive?.let { Fiat(it.first, it.second).formatted() }.orEmpty()
-
-
-        val isError: Boolean
-            get() {
-                if (amountAnimatedModel.amountData.isEmpty()) return false
-                if (maxForGive != null) {
-                    val enteredAmount = Fiat(
-                        fiat = amountAnimatedModel.amountData.amount,
-                        currencyCode = maxForGive.second
-                    )
-                    val limit = Fiat(maxForGive.first, maxForGive.second)
-                    if (enteredAmount.valueLessThanOrEqualTo(limit)) {
-                        return false
-                    }
-                }
-
-                return true
-            }
     }
 
     sealed interface Event {
         data class InitializeToken(val mint: Mint?) : Event
         data class OnTokenSelected(val address: Mint) : Event
         data class OnTokenUpdated(val token: TokenWithLocalizedBalance) : Event
-        data class OnNumberPressed(val number: Int) : Event
-        data object OnDecimalPressed : Event
-        data object OnBackspace : Event
-        data class OnEnteredNumberChanged(val backspace: Boolean = false) : Event
-        data class OnAmountChanged(val amountAnimatedModel: AmountAnimatedInputUiModel) : Event
-        data class OnCurrencyChanged(val model: Currency) : Event
+        data class OnCurrencyChanged(val model: com.getcode.opencode.model.financial.Currency) : Event
         data class OnMaxDetermined(val max: Double, val currencyCode: CurrencyCode) : Event
         data class OnLimitsChanged(val limits: Limits?) : Event
         data object OnGive : Event
         data class PresentBill(val bill: Bill.Cash) : Event
 
-
         data class AddCashToWallet(val amount: Fiat) : Event
         data class UpdateLoadingState(val loading: Boolean = false, val success: Boolean = false) :
             Event
@@ -123,7 +98,7 @@ internal class CashScreenViewModel @Inject constructor(
     val checkBalanceLimit: () -> Boolean = {
         // this balance check differs from withdrawal due to the fact this is a localized check
         // whereas withdrawal is USD locked
-        val amount = stateFlow.value.amountAnimatedModel.amountData.amount
+        val amount = amountDelegate.state.value.enteredAmount
         val enteredAmount = Fiat(
             fiat = amount,
             currencyCode = stateFlow.value.currencyModel.code ?: CurrencyCode.USD
@@ -170,7 +145,7 @@ internal class CashScreenViewModel @Inject constructor(
         isOverBalance
     }
     val checkSendLimit: () -> Boolean = {
-        val amount = stateFlow.value.amountAnimatedModel.amountData.amount
+        val amount = amountDelegate.state.value.enteredAmount
         val currency = stateFlow.value.currencyModel
         val sendLimit =
             currency.code?.let { stateFlow.value.limits?.sendLimitFor(it) } ?: SendLimit.Zero
@@ -185,8 +160,6 @@ internal class CashScreenViewModel @Inject constructor(
     }
 
     init {
-        numberInputHelper.reset()
-
         eventFlow
             .filterIsInstance<Event.InitializeToken>()
             .take(1)
@@ -230,68 +203,13 @@ internal class CashScreenViewModel @Inject constructor(
                 exchange.getCurrency(balance.rate.currency.name)
             }.onEach {
                 dispatchEvent(Event.OnCurrencyChanged(it))
-            }.launchIn(viewModelScope)
-
-        exchange.observePreferredRate()
-            .onEach {
-                // reset when entry rate changes
-                numberInputHelper.reset()
-                dispatchEvent(Event.OnAmountChanged(AmountAnimatedInputUiModel()))
+                amountDelegate.onCurrencyChanged(it)
             }.launchIn(viewModelScope)
 
         transactionController.limits
             .onEach { dispatchEvent(Event.OnLimitsChanged(it)) }
             .launchIn(viewModelScope)
 
-        eventFlow
-            .filterIsInstance<Event.OnCurrencyChanged>()
-            .map { it.model }
-            .onEach {
-                numberInputHelper.fractionUnits = it.fractionUnits
-            }.launchIn(viewModelScope)
-
-        eventFlow
-            .filterIsInstance<Event.OnNumberPressed>()
-            .map { it.number }
-            .onEach { number ->
-                numberInputHelper.fractionUnits = stateFlow.value.currencyModel.fractionUnits
-                numberInputHelper.maxLength = 10 // 1 billion dollars
-                numberInputHelper.onNumber(number)
-                dispatchEvent(Event.OnEnteredNumberChanged())
-            }.launchIn(viewModelScope)
-
-        eventFlow
-            .filterIsInstance<Event.OnDecimalPressed>()
-            .onEach {
-                numberInputHelper.onDot()
-                dispatchEvent(Event.OnEnteredNumberChanged())
-            }
-            .launchIn(viewModelScope)
-
-        eventFlow
-            .filterIsInstance<Event.OnBackspace>()
-            .onEach {
-                numberInputHelper.onBackspace()
-                dispatchEvent(Event.OnEnteredNumberChanged(true))
-            }.launchIn(viewModelScope)
-
-        eventFlow
-            .filterIsInstance<Event.OnEnteredNumberChanged>()
-            .map { it.backspace }
-            .onEach { backspace ->
-                val current = stateFlow.value.amountAnimatedModel
-                val model = stateFlow.value.amountAnimatedModel
-                val amount = numberInputHelper.getFormattedStringForAnimation(includeCommas = true)
-
-                val updated = model.copy(
-                    amountDataLast = current.amountData,
-                    amountData = amount,
-                    lastPressedBackspace = backspace
-                )
-
-                dispatchEvent(Event.OnAmountChanged(updated))
-            }.launchIn(viewModelScope)
-
         stateFlow
             .filter { it.limits != null }
             .map { it.limits to (it.token?.balance ?: LocalFiat.Zero) }
@@ -304,15 +222,15 @@ internal class CashScreenViewModel @Inject constructor(
 
         eventFlow
             .filterIsInstance<Event.OnGive>()
-            .map { stateFlow.value.amountAnimatedModel }
             .filter { !(checkBalanceLimit() || checkSendLimit()) }
-            .onEach { data ->
+            .onEach {
                 dispatchEvent(Event.UpdateLoadingState(loading = true))
                 val (token, balance) = stateFlow.value.token!!
                 val rate = exchange.preferredRate
+                val amount = amountDelegate.state.value.enteredAmount
 
                 val result = verifiedFiatCalculator.compute(
-                    amount = Fiat(data.amountData.amount, rate.currency),
+                    amount = Fiat(amount, rate.currency),
                     token = token,
                     balance = balance.underlyingTokenAmount,
                     rate = rate,
@@ -361,6 +279,45 @@ internal class CashScreenViewModel @Inject constructor(
     }
 
 
+    val config: kotlinx.coroutines.flow.StateFlow<AmountEntryConfig> = combine(
+        amountDelegate.state,
+        stateFlow,
+    ) { delegateState, vmState ->
+        val isError = run {
+            if (delegateState.isEmpty) false
+            else if (vmState.maxForGive != null) {
+                val enteredAmount = Fiat(
+                    fiat = delegateState.enteredAmount,
+                    currencyCode = vmState.maxForGive.second
+                )
+                val limit = Fiat(vmState.maxForGive.first, vmState.maxForGive.second)
+                !enteredAmount.valueLessThanOrEqualTo(limit)
+            } else true
+        }
+
+        AmountEntryConfig(
+            hint = if (isError) {
+                AmountEntryHint.Error(
+                    resources.getString(R.string.subtitle_giveCashHintLimitExceeded, vmState.maxAvailableForGive)
+                )
+            } else {
+                AmountEntryHint.Info(
+                    resources.getString(R.string.subtitle_giveCashHint, vmState.maxAvailableForGive)
+                )
+            },
+            canConfirm = delegateState.enteredAmount > 0.00,
+            canChangeCurrency = true,
+            action = AmountEntryAction(
+                label = resources.getString(R.string.action_next),
+                loadingState = vmState.generatingBill,
+            ),
+        )
+    }.stateIn(
+        viewModelScope,
+        SharingStarted.WhileSubscribed(5000),
+        AmountEntryConfig(action = AmountEntryAction(label = "")),
+    )
+
     internal companion object {
         val updateStateForEvent: (Event) -> ((State) -> State) = { event ->
             when (event) {
@@ -372,22 +329,12 @@ internal class CashScreenViewModel @Inject constructor(
                     state.copy(token = event.token)
                 }
 
-                is Event.OnAmountChanged -> { state ->
-                    state.copy(
-                        amountAnimatedModel = event.amountAnimatedModel
-                    )
-                }
-
                 is Event.InitializeToken -> { state -> state }
 
                 is Event.OpenScreen -> { state -> state }
 
-                Event.OnBackspace,
                 Event.OnGive,
-                is Event.OnEnteredNumberChanged,
-                is Event.PresentBill,
-                is Event.OnNumberPressed,
-                Event.OnDecimalPressed -> { state -> state }
+                is Event.PresentBill -> { state -> state }
 
                 is Event.OnCurrencyChanged -> { state ->
                     state.copy(currencyModel = CurrencyHolder(event.model))