fix: align currency and calc widget with ios

app/src/main/java/to/bitkit/data/WidgetsStore.kt

@@ -146,7 +146,11 @@ class WidgetsStore @Inject constructor(
         if (!store.data.first().widgets.map { it.type }.contains(type)) return
 
         store.updateData { data ->
-            data.copy(widgets = data.widgets.filterNot { it.type == type })
+            val updated = data.copy(widgets = data.widgets.filterNot { it.type == type })
+            when (type) {
+                WidgetType.CALCULATOR -> updated.copy(calculatorValues = CalculatorValues())
+                else -> updated
+            }
         }
     }
 

app/src/main/java/to/bitkit/models/widget/CalculatorValues.kt

@@ -4,6 +4,6 @@ import kotlinx.serialization.Serializable
 
 @Serializable
 data class CalculatorValues(
-    val btcValue: String = "",
+    val btcValue: String = "10000",
     val fiatValue: String = "",
 )

app/src/main/java/to/bitkit/ui/screens/widgets/calculator/components/CalculatorCard.kt

@@ -15,18 +15,19 @@ import androidx.compose.foundation.layout.width
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.clip
-import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.res.painterResource
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.hilt.lifecycle.viewmodel.compose.hiltViewModel
@@ -43,6 +44,9 @@ import to.bitkit.ui.utils.visualTransformation.BitcoinVisualTransformation
 import to.bitkit.ui.utils.visualTransformation.CalculatorFormatter
 import to.bitkit.ui.utils.visualTransformation.MonetaryVisualTransformation
 import to.bitkit.viewmodels.CurrencyViewModel
+import java.math.BigDecimal
+
+private const val FIAT_DECIMAL_PLACES = 2
 
 @Composable
 fun CalculatorCard(
@@ -55,34 +59,104 @@ fun CalculatorCard(
     val calculatorValues by calculatorViewModel.calculatorValues.collectAsStateWithLifecycle()
     var btcValue: String by rememberSaveable { mutableStateOf(calculatorValues.btcValue) }
     var fiatValue: String by rememberSaveable { mutableStateOf(calculatorValues.fiatValue) }
+    val displayedBtcValue = btcValue.ifEmpty { calculatorValues.btcValue }
+    val displayedFiatValue = fiatValue
+
+    LaunchedEffect(
+        calculatorValues.btcValue,
+        calculatorValues.fiatValue,
+        currencyUiState.displayUnit,
+        currencyUiState.selectedCurrency,
+    ) {
+        if (!shouldHydrateFiatFromStoredBtc(
+                storedBtcValue = calculatorValues.btcValue,
+                storedFiatValue = calculatorValues.fiatValue,
+                currentFiatValue = fiatValue,
+                displayUnit = currencyUiState.displayUnit,
+            )
+        ) {
+            return@LaunchedEffect
+        }
+        val convertedFiat = CalculatorFormatter.convertBtcToFiat(
+            btcValue = calculatorValues.btcValue,
+            displayUnit = currencyUiState.displayUnit,
+            currencyViewModel = currencyViewModel,
+        ).orEmpty()
+        if (convertedFiat.isEmpty()) {
+            return@LaunchedEffect
+        }
+        fiatValue = convertedFiat
+        calculatorViewModel.updateCalculatorValues(
+            fiatValue = convertedFiat,
+            btcValue = calculatorValues.btcValue,
+        )
+    }
+
+    LaunchedEffect(currencyUiState.selectedCurrency, currencyUiState.displayUnit) {
+        val sourceBtc = btcValue.ifEmpty { calculatorValues.btcValue }
+        if (sourceBtc.isEmpty() || isZeroBtcValue(sourceBtc, currencyUiState.displayUnit)) {
+            return@LaunchedEffect
+        }
+        val convertedFiat = CalculatorFormatter.convertBtcToFiat(
+            btcValue = sourceBtc,
+            displayUnit = currencyUiState.displayUnit,
+            currencyViewModel = currencyViewModel,
+        ).orEmpty()
+        if (convertedFiat.isEmpty()) {
+            return@LaunchedEffect
+        }
+        fiatValue = convertedFiat
+        calculatorViewModel.updateCalculatorValues(
+            fiatValue = convertedFiat,
+            btcValue = sourceBtc,
+        )
+    }
 
     CalculatorCardContent(
         modifier = modifier,
         showWidgetTitle = showWidgetTitle,
         btcPrimaryDisplayUnit = currencyUiState.displayUnit,
-        btcValue = btcValue.ifEmpty { calculatorValues.btcValue },
-        onBtcChange = { newValue ->
-            btcValue = newValue
-            val convertedFiat = CalculatorFormatter.convertBtcToFiat(
-                btcValue = btcValue,
-                displayUnit = currencyUiState.displayUnit,
-                currencyViewModel = currencyViewModel
-            )
-            fiatValue = convertedFiat.orEmpty()
+        btcValue = displayedBtcValue,
+        onBtcChange = { rawValue ->
+            val sanitized = if (currencyUiState.displayUnit.isModern()) {
+                sanitizeIntegerInput(rawValue)
+            } else {
+                sanitizeDecimalInput(rawValue)
+            }
+            btcValue = sanitized
+            fiatValue = if (sanitized.isEmpty()) {
+                ""
+            } else {
+                CalculatorFormatter.convertBtcToFiat(
+                    btcValue = btcValue,
+                    displayUnit = currencyUiState.displayUnit,
+                    currencyViewModel = currencyViewModel,
+                ).orEmpty()
+            }
             calculatorViewModel.updateCalculatorValues(fiatValue = fiatValue, btcValue = btcValue)
         },
         fiatSymbol = currencyUiState.currencySymbol,
         fiatName = currencyUiState.selectedCurrency,
-        fiatValue = fiatValue.ifEmpty { calculatorValues.fiatValue },
-        onFiatChange = { newValue ->
-            fiatValue = newValue
-            btcValue = CalculatorFormatter.convertFiatToBtc(
-                fiatValue = fiatValue,
-                displayUnit = currencyUiState.displayUnit,
-                currencyViewModel = currencyViewModel
-            )
+        fiatValue = displayedFiatValue,
+        onFiatChange = { rawValue ->
+            val sanitized = sanitizeDecimalInput(rawValue, maxDecimalPlaces = FIAT_DECIMAL_PLACES)
+            fiatValue = sanitized
+            btcValue = if (sanitized.isEmpty()) {
+                ""
+            } else {
+                val converted = CalculatorFormatter.convertFiatToBtc(
+                    fiatValue = fiatValue,
+                    displayUnit = currencyUiState.displayUnit,
+                    currencyViewModel = currencyViewModel,
+                )
+                if (currencyUiState.displayUnit.isModern()) {
+                    converted.filter { it.isDigit() }
+                } else {
+                    converted
+                }
+            }
             calculatorViewModel.updateCalculatorValues(fiatValue = fiatValue, btcValue = btcValue)
-        }
+        },
     )
 }
 
@@ -115,14 +189,13 @@ fun CalculatorCardContent(
 
             // Bitcoin input with visual transformation
             CalculatorInput(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .onFocusChanged { focusState -> if (focusState.hasFocus) onBtcChange("") },
                 value = btcValue,
                 onValueChange = onBtcChange,
                 currencySymbol = BITCOIN_SYMBOL,
                 currencyName = stringResource(R.string.settings__general__unit_bitcoin),
-                visualTransformation = BitcoinVisualTransformation(btcPrimaryDisplayUnit)
+                keyboardType = if (btcPrimaryDisplayUnit.isModern()) KeyboardType.Number else KeyboardType.Decimal,
+                visualTransformation = BitcoinVisualTransformation(btcPrimaryDisplayUnit),
+                modifier = Modifier.fillMaxWidth()
             )
 
             VerticalSpacer(16.dp)
@@ -133,15 +206,40 @@ fun CalculatorCardContent(
                 onValueChange = onFiatChange,
                 currencySymbol = fiatSymbol,
                 currencyName = fiatName,
-                visualTransformation = MonetaryVisualTransformation(decimalPlaces = 2),
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .onFocusChanged { focusState -> if (focusState.hasFocus) onFiatChange("") }
+                keyboardType = KeyboardType.Decimal,
+                visualTransformation = MonetaryVisualTransformation(decimalPlaces = FIAT_DECIMAL_PLACES),
+                modifier = Modifier.fillMaxWidth()
             )
         }
     }
 }
 
+internal fun shouldHydrateFiatFromStoredBtc(
+    storedBtcValue: String,
+    storedFiatValue: String,
+    currentFiatValue: String,
+    displayUnit: BitcoinDisplayUnit,
+): Boolean {
+    if (storedBtcValue.isEmpty()) {
+        return false
+    }
+    if (isZeroBtcValue(storedBtcValue, displayUnit)) {
+        return false
+    }
+    if (storedFiatValue.isNotEmpty()) {
+        return false
+    }
+    return currentFiatValue.isEmpty()
+}
+
+internal fun isZeroBtcValue(
+    btcValue: String,
+    displayUnit: BitcoinDisplayUnit,
+): Boolean = when (displayUnit) {
+    BitcoinDisplayUnit.MODERN -> btcValue == "0"
+    BitcoinDisplayUnit.CLASSIC -> btcValue.toBigDecimalOrNull()?.compareTo(BigDecimal.ZERO) == 0
+}
+
 @Composable
 private fun WidgetTitleRow() {
     Row(

app/src/main/java/to/bitkit/ui/screens/widgets/calculator/components/CalculatorInput.kt

@@ -23,6 +23,8 @@ import to.bitkit.ui.components.TextInput
 import to.bitkit.ui.theme.AppTextFieldDefaults
 import to.bitkit.ui.theme.AppThemeSurface
 import to.bitkit.ui.theme.Colors
+import java.text.DecimalFormatSymbols
+import java.util.Locale
 
 @Composable
 fun CalculatorInput(
@@ -31,8 +33,11 @@ fun CalculatorInput(
     currencySymbol: String,
     currencyName: String,
     modifier: Modifier = Modifier,
+    keyboardType: KeyboardType = KeyboardType.Number,
     visualTransformation: VisualTransformation = VisualTransformation.None,
 ) {
+    val displayCurrencySymbol = currencySymbol.toCalculatorDisplaySymbol()
+
     TextInput(
         value = value,
         singleLine = true,
@@ -44,11 +49,11 @@ fun CalculatorInput(
                     .background(color = Colors.Gray6, shape = CircleShape)
                     .size(32.dp)
             ) {
-                BodyMSB(currencySymbol, color = Colors.Brand)
+                BodyMSB(displayCurrencySymbol, color = Colors.Brand)
             }
         },
         keyboardOptions = KeyboardOptions(
-            keyboardType = KeyboardType.Number
+            keyboardType = keyboardType,
         ),
         suffix = { CaptionB(currencyName.uppercase(), color = Colors.Gray1) },
         colors = AppTextFieldDefaults.noIndicatorColors.copy(
@@ -60,6 +65,44 @@ fun CalculatorInput(
     )
 }
 
+internal fun sanitizeIntegerInput(raw: String): String {
+    val digits = raw.filter { it.isDigit() }
+    if (digits.isEmpty()) return digits
+    return digits.trimStart('0').ifEmpty { "0" }
+}
+
+internal fun sanitizeDecimalInput(
+    raw: String,
+    locale: Locale = Locale.getDefault(),
+    maxDecimalPlaces: Int? = null,
+): String {
+    val localDecimal = DecimalFormatSymbols.getInstance(locale).decimalSeparator
+    val normalized = if (localDecimal == ',') raw.replace(',', '.') else raw
+    val filtered = normalized.filter { it.isDigit() || it == '.' }
+    val dotIndex = filtered.indexOf('.')
+    val singleDot = if (dotIndex == -1) {
+        filtered
+    } else {
+        filtered.substring(0, dotIndex + 1) +
+            filtered.substring(dotIndex + 1).replace(".", "")
+    }
+    if (maxDecimalPlaces == null) return singleDot
+    val cappedDot = singleDot.indexOf('.')
+    if (cappedDot == -1) return singleDot
+    val fraction = singleDot.substring(cappedDot + 1)
+    if (fraction.length <= maxDecimalPlaces) return singleDot
+    return singleDot.substring(0, cappedDot + 1) + fraction.take(maxDecimalPlaces)
+}
+
+internal fun String.toCalculatorDisplaySymbol(): String {
+    val symbol = trim()
+    return if (symbol.length >= 3) {
+        symbol.take(1)
+    } else {
+        symbol
+    }
+}
+
 @Preview(showBackground = true)
 @Composable
 private fun Preview() {

app/src/main/java/to/bitkit/ui/settings/general/LocalCurrencySettingsScreen.kt

@@ -122,7 +122,7 @@ fun LocalCurrencySettingsContent(
                     }
                     items(mostUsedRates) { rate ->
                         SettingsButtonRow(
-                            title = "${rate.quote} (${rate.currencySymbol})",
+                            title = formatCurrencyTitle(rate),
                             value = SettingsButtonValue.BooleanValue(selectedCurrency == rate.quote),
                             onClick = { onCurrencyClick(rate.quote) },
                         )
@@ -135,7 +135,7 @@ fun LocalCurrencySettingsContent(
 
                 items(otherCurrencies) { rate ->
                     SettingsButtonRow(
-                        title = rate.quote,
+                        title = formatCurrencyTitle(rate),
                         value = SettingsButtonValue.BooleanValue(selectedCurrency == rate.quote),
                         onClick = { onCurrencyClick(rate.quote) },
                     )
@@ -150,6 +150,11 @@ fun LocalCurrencySettingsContent(
     }
 }
 
+private fun formatCurrencyTitle(rate: FxRate): String {
+    val symbol = rate.currencySymbol.trim()
+    return if (symbol.isNotEmpty()) "${rate.quote} ($symbol)" else rate.quote
+}
+
 @Preview(showSystemUi = true)
 @Composable
 private fun Preview() {