Autoclose android (#394)

* Add autoclose domain types for perpetual TP/SL modify

* Add autoclose UI model and factory

* Add coordinator support for perpetual modify

* Add shared autoclose UI components

* Add autoclose modify viewmodel and scene

* Wire perpetual position autoclose entry point and route

Also fixes pull-to-refresh indicator showing on first open by
splitting fetch() (initial load, no refresh state) from refresh()
(user gesture, sets refresh state).

* Add open-time autoclose support

* Add modify autoclose summary to confirm screen

* Extract NavEntryViewModelStoreOwner to shared :ui utility

* Suppress autoclose PnL when trigger price is directionally invalid

* Keep GemTextField caret at end on external value updates

* Add asset header and polish AmountAutocloseSheet open flow

* Restructure autoclose modify flow as nested nav graph

* Match autoclose sheet height to modal-sheet convention

* Replace core submodule with main's vendored core (pre-merge, local)

* Fix AppIcons

* Parse Auto Close TP/SL prices locale-aware

Add NumericFormatter.double(from:) and route every take-profit/stop-loss parse through it (modify view model, open-position provider, and sheet), matching iOS which parses numeric input with a locale formatter. The open-position flow previously used toDoubleOrNull(), which dropped the trigger in comma-decimal locales. The typed USD amount now parses via the canonical parseNumber() so the preview matches the built order.

* Consolidate Auto Close scene to single onAction

Replace the per-callback parameters with a sealed AutocloseAction dispatched through onAction, matching PerpetualPositionScene. Use the shared CenterAlignedTopAppBar header so the input title matches the confirm screen.

* Fix Auto Close chevron spacing

The Auto Close rows hand-rolled the chevron with a 12dp spacer, leaving a gap no other row has. Use the standard DataBadgeChevron so the chevron sits flush against the value.

* Defer Auto Close validation until submit

Keep the confirm button enabled while there is a pending change and validate on press (revealing the inline error) instead of disabling on an invalid value, matching iOS's manual-validation behavior.

* Tidy Auto Close estimator and validator

Remove the unused AutocloseValidator.isValid and make AutocloseEstimator.priceChangePercent private (only roe uses it).

* Localize Auto Close trigger errors and separate them from the field

Route the trigger-price errors through the errors.perpetual.* localization keys on both platforms (Android R.string, iOS PerpetualError -> Localized.Errors.Perpetual, dropping the hardcoded TODO), and add a divider before the field error to match iOS.

* Update PerpetualError.swift

* Add Auto Close defaults and suggestion tiers to perpetual config

Expose take-profit/stop-loss percent options, their defaults, and a leverage-tiered get_autoclose_suggestions() helper from the shared perpetual config.

* Source Auto Close suggestions and options from core

Drop the hardcoded leverage->suggestion tiers duplicated in iOS and Android and read them, plus the TP/SL percent options and defaults, through the Gemstone config wrappers.

* Generalize leverage picker into reusable WheelPickerSheet

Replace LeveragePickerSheet/LeveragePickerView with a generic WheelPickerSheet over WheelPickerDisplayable so it can back any wheel-style option, and migrate the leverage selector to it.

* Add default Take Profit and Stop Loss preferences on iOS

Persist default TP/SL percents alongside leverage, add the AutocloseOption type and two picker rows to Preferences, and make the leverage default fall back to the core default via a 0 sentinel.

* Prefill Auto Close from defaults and recompute on leverage change

Seed TP/SL from the saved default percents when opening a position and re-derive the target prices when leverage changes, unless the user has already edited them.

* Add default Take Profit and Stop Loss preferences on Android

Store default TP/SL percents in UserConfig, expose them from SettingsViewModel, and add the rows to Preferences via a generic OptionPickerLinkItem.

* Prefill Auto Close from defaults via trigger flows

Derive TP/SL trigger prices from the saved default percents reactively against market price and leverage, falling back to user edits once a field is touched.

* Show Auto Close suggestions only when the field is empty

Match iOS by gating the suggestions bar on an empty active field, and stop the amount sheet from overwriting in-progress input on every reactive trigger update.

* Support indented LinkItem; reorder Perpetual VM

Add an indented flag to LinkItem (with Spacer import) to reserve the leading icon space when no painter is provided, and enable it in the preferences option picker. Also refactor AmountPerpetualViewModel by moving transferData/leverage properties and autoclose-related methods (onChangeLeverage, updateAutoclose) to a different location for clarity—no behavior changes intended.

* Remove Done button from Auto Close suggestions bar

Android dismisses the keyboard via the system IME affordance, so the suggestions bar no longer needs its own Done button; drop it and the now-unused focus manager wiring.

* Extend stop-loss percent options with 3% and 5%

* Show Perpetuals settings without developer mode on Android

Match iOS: the Perpetuals toggle is always visible in Preferences (no developer-mode gate), and the default leverage/take-profit/stop-loss rows show whenever the toggle is on. Feature visibility elsewhere still uses isPerpetualEnabled && hasPerpetualsSupport, identical to iOS.

* React to Perpetuals toggle for data sync on Android

Match iOS updatePerpetualConnection: observe session + isPerpetualEnabled and (re)sync perpetuals/positions when a perps-capable wallet has the toggle on, instead of snapshotting the flag once at wallet change.

Author: gemdev111

android/app/src/main/kotlin/com/gemwallet/android/ui/navigation/RouteArgumentsNavEntryDecorator.kt

@@ -3,18 +3,11 @@ package com.gemwallet.android.ui.navigation
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.remember
-import androidx.lifecycle.DEFAULT_ARGS_KEY
-import androidx.lifecycle.HasDefaultViewModelProviderFactory
-import androidx.lifecycle.SAVED_STATE_REGISTRY_OWNER_KEY
-import androidx.lifecycle.SavedStateViewModelFactory
-import androidx.lifecycle.VIEW_MODEL_STORE_OWNER_KEY
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.ViewModelProvider
 import androidx.lifecycle.ViewModelStore
 import androidx.lifecycle.ViewModelStoreOwner
-import androidx.lifecycle.enableSavedStateHandles
 import androidx.lifecycle.viewmodel.CreationExtras
-import androidx.lifecycle.viewmodel.MutableCreationExtras
 import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
 import androidx.navigation3.runtime.NavEntry
 import androidx.navigation3.runtime.NavEntryDecorator
@@ -23,12 +16,12 @@ import androidx.navigation3.runtime.NavMetadataKey
 import androidx.navigation3.runtime.get
 import androidx.navigation3.runtime.metadata
 import androidx.savedstate.SavedState
-import androidx.savedstate.SavedStateRegistry
 import androidx.savedstate.SavedStateRegistryOwner
 import androidx.savedstate.compose.LocalSavedStateRegistryOwner
 import androidx.savedstate.savedState
 import com.gemwallet.android.ext.toIdentifier
 import com.gemwallet.android.ui.models.navigation.RouteArgument
+import com.gemwallet.android.ui.viewmodel.NavEntryViewModelStoreOwner
 import com.wallet.core.primitives.AssetId
 import kotlin.reflect.KClass
 
@@ -110,7 +103,7 @@ private fun rememberEntryViewModelStoreOwner(
         entryViewModelStores.store(contentKey)
     }
     return remember(parent, store, defaultArgs, savedStateRegistryOwner) {
-        RouteArgumentsViewModelStoreOwner(
+        NavEntryViewModelStoreOwner(
             parent = parent,
             store = store,
             savedStateRegistryOwner = checkNotNull(savedStateRegistryOwner) {
@@ -158,43 +151,6 @@ private object EntryViewModelStoresFactory : ViewModelProvider.Factory {
     }
 }
 
-private class RouteArgumentsViewModelStoreOwner(
-    private val parent: ViewModelStoreOwner,
-    private val store: ViewModelStore,
-    private val savedStateRegistryOwner: SavedStateRegistryOwner,
-    private val defaultArgs: SavedState,
-) : ViewModelStoreOwner,
-    SavedStateRegistryOwner,
-    HasDefaultViewModelProviderFactory {
-
-    init {
-        enableSavedStateHandles()
-    }
-
-    override val viewModelStore: ViewModelStore
-        get() = store
-
-    override val savedStateRegistry: SavedStateRegistry
-        get() = savedStateRegistryOwner.savedStateRegistry
-
-    override val lifecycle
-        get() = savedStateRegistryOwner.lifecycle
-
-    override val defaultViewModelProviderFactory: ViewModelProvider.Factory
-        get() = (parent as? HasDefaultViewModelProviderFactory)?.defaultViewModelProviderFactory
-            ?: SavedStateViewModelFactory()
-
-    override val defaultViewModelCreationExtras: CreationExtras
-        get() = MutableCreationExtras(
-            (parent as? HasDefaultViewModelProviderFactory)?.defaultViewModelCreationExtras
-                ?: CreationExtras.Empty
-        ).apply {
-            this[SAVED_STATE_REGISTRY_OWNER_KEY] = this@RouteArgumentsViewModelStoreOwner
-            this[VIEW_MODEL_STORE_OWNER_KEY] = this@RouteArgumentsViewModelStoreOwner
-            this[DEFAULT_ARGS_KEY] = defaultArgs
-        }
-}
-
 internal fun NavEntry<NavKey>.withOccurrenceContentKey(
     key: NavKey,
     occurrence: Int,
@@ -209,3 +165,4 @@ internal fun NavEntry<NavKey>.withOccurrenceContentKey(
         entry.Content()
     }
 }
+

android/app/src/main/kotlin/com/gemwallet/android/ui/navigation/routes/Perpetual.kt

@@ -5,6 +5,7 @@ import androidx.navigation3.runtime.NavKey
 import com.gemwallet.android.features.perpetual.views.market.PerpetualMarketNavScreen
 import com.gemwallet.android.features.perpetual.views.position.PerpetualPositionNavScreen
 import com.gemwallet.android.ui.models.actions.AmountTransactionAction
+import com.gemwallet.android.ui.models.actions.AssetIdAction
 import com.gemwallet.android.ui.models.actions.ConfirmTransactionAction
 import com.gemwallet.android.ui.navigation.assetIdArgument
 import com.gemwallet.android.ui.navigation.routeArguments
@@ -20,15 +21,15 @@ data class PerpetualPositionRoute(val assetId: AssetId) : NavKey
 
 fun EntryProviderScope<NavKey>.perpetualScreen(
     onCancel: () -> Unit,
-    onOpenPerpetualDetails: (AssetId) -> Unit,
+    onOpenPerpetualDetails: AssetIdAction,
     amountAction: AmountTransactionAction,
     confirmAction: ConfirmTransactionAction,
     onTransaction: (TransactionId) -> Unit,
 ) {
     entry<PerpetualRoute> {
         PerpetualMarketNavScreen(
             onOpenPerpetualDetails = onOpenPerpetualDetails,
-            onCancel = onCancel
+            onCancel = onCancel,
         )
     }
 

android/data/coordinators/src/main/kotlin/com/gemwallet/android/data/coordinators/perpetuals/BuildPerpetualParamsImpl.kt

@@ -15,6 +15,8 @@ import com.wallet.core.primitives.PerpetualData
 import com.wallet.core.primitives.PerpetualDirection
 import com.wallet.core.primitives.PerpetualId
 import com.wallet.core.primitives.PerpetualMarginType
+import com.wallet.core.primitives.PerpetualModifyConfirmData
+import com.wallet.core.primitives.PerpetualModifyPositionType
 import com.wallet.core.primitives.PerpetualPosition
 import com.wallet.core.primitives.PerpetualType
 import kotlinx.coroutines.flow.firstOrNull
@@ -63,6 +65,27 @@ class BuildPerpetualParamsImpl(
             .perpetual(PerpetualType.Close(confirmData))
     }
 
+    override suspend fun modify(
+        perpetualId: PerpetualId,
+        modifyTypes: List<PerpetualModifyPositionType>,
+        takeProfitOrderId: ULong?,
+        stopLossOrderId: ULong?,
+    ): ConfirmParams.PerpetualParams? {
+        if (modifyTypes.isEmpty()) return null
+        val data = getPerpetual(perpetualId) ?: return null
+        val assetIndex = data.perpetual.identifier.toIntOrNull() ?: return null
+        val account = sessionRepository.session().value?.wallet?.hyperliquidAccount ?: return null
+        val confirmData = PerpetualModifyConfirmData(
+            baseAsset = HypercoreUSDC,
+            assetIndex = assetIndex,
+            modifyTypes = modifyTypes,
+            takeProfitOrderId = takeProfitOrderId?.toLong(),
+            stopLossOrderId = stopLossOrderId?.toLong(),
+        )
+        return ConfirmParams.Builder(data.asset, account)
+            .perpetual(PerpetualType.Modify(confirmData))
+    }
+
     private suspend fun getPerpetual(perpetualId: PerpetualId): PerpetualData? =
         perpetualRepository.getPerpetual(perpetualId).firstOrNull()
 

android/data/repositories/src/main/kotlin/com/gemwallet/android/data/repositories/config/UserConfig.kt

@@ -81,6 +81,24 @@ class UserConfig(
         }
     }
 
+    fun perpetualTakeProfit(): Flow<Int> = context.dataStore.data
+        .map { preferences -> preferences[Key.PerpetualTakeProfit] ?: PerpetualConfig.defaultTakeProfit }
+
+    suspend fun setPerpetualTakeProfit(value: Int) {
+        context.dataStore.edit { preferences ->
+            preferences[Key.PerpetualTakeProfit] = value
+        }
+    }
+
+    fun perpetualStopLoss(): Flow<Int> = context.dataStore.data
+        .map { preferences -> preferences[Key.PerpetualStopLoss] ?: PerpetualConfig.defaultStopLoss }
+
+    suspend fun setPerpetualStopLoss(value: Int) {
+        context.dataStore.edit { preferences ->
+            preferences[Key.PerpetualStopLoss] = value
+        }
+    }
+
     fun getLatestAppUpdate(): Flow<AppUpdateInfo?> = context.dataStore.data
         .map { preferences ->
             val version = preferences[Key.LatestVersion].orEmpty()
@@ -206,6 +224,8 @@ class UserConfig(
         val AskNotifications = longPreferencesKey("ask_notifications")
         val IsPerpetualEnabled = booleanPreferencesKey("is_perpetual_enabled")
         val PerpetualLeverage = intPreferencesKey("perpetual_leverage")
+        val PerpetualTakeProfit = intPreferencesKey("perpetual_take_profit")
+        val PerpetualStopLoss = intPreferencesKey("perpetual_stop_loss")
     }
 
 }

android/data/repositories/src/main/kotlin/com/gemwallet/android/data/repositories/stream/StreamObserverService.kt

@@ -8,6 +8,7 @@ import com.gemwallet.android.application.perpetual.coordinators.SyncPerpetuals
 import com.gemwallet.android.data.repositories.config.UserConfig
 import com.gemwallet.android.data.repositories.session.SessionRepository
 import com.gemwallet.android.ext.hasPerpetualsSupport
+import com.gemwallet.android.model.Session
 import com.gemwallet.android.data.services.gemapi.http.DeviceRequestSigner
 import com.gemwallet.android.serializer.StreamEventSerializer
 import com.gemwallet.android.serializer.jsonEncoder
@@ -28,8 +29,10 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
+import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
 
@@ -64,12 +67,14 @@ class StreamObserverService(
                 subscriptionService.setupAssets(wallet.id)
                 if (connectionJob == null) start()
                 runCatching { syncAssets() }
-                if (wallet.hasPerpetualsSupport && userConfig.isPerpetualEnabled().first()) {
-                    runCatching { syncPerpetuals.syncPerpetuals() }
-                    runCatching { syncPerpetualPositions.syncPerpetualPositions() }
-                }
             }
         }
+        scope.launchPerpetualSync(
+            session = sessionRepository.session(),
+            isPerpetualEnabled = userConfig.isPerpetualEnabled(),
+            syncPerpetuals = syncPerpetuals,
+            syncPerpetualPositions = syncPerpetualPositions,
+        )
     }
 
     fun start() {
@@ -139,3 +144,21 @@ class StreamObserverService(
         private const val PING_INTERVAL_MS = 30_000L
     }
 }
+
+internal fun CoroutineScope.launchPerpetualSync(
+    session: Flow<Session?>,
+    isPerpetualEnabled: Flow<Boolean>,
+    syncPerpetuals: SyncPerpetuals,
+    syncPerpetualPositions: SyncPerpetualPositions,
+): Job = launch {
+    combine(session, isPerpetualEnabled) { current, enabled ->
+        val wallet = current?.wallet
+        if (wallet != null && wallet.hasPerpetualsSupport && enabled) wallet.id.id else null
+    }
+        .distinctUntilChanged()
+        .collectLatest { walletId ->
+            if (walletId == null) return@collectLatest
+            runCatching { syncPerpetuals.syncPerpetuals() }
+            runCatching { syncPerpetualPositions.syncPerpetualPositions() }
+        }
+}

android/features/confirm/presents/src/main/kotlin/com/gemwallet/android/features/confirm/presents/ConfirmScreen.kt

@@ -39,6 +39,7 @@ import com.gemwallet.android.model.AuthRequest
 import com.gemwallet.android.model.ConfirmParams
 import com.gemwallet.android.model.ValueFormatter
 import com.gemwallet.android.ui.R
+import com.gemwallet.android.ui.components.perpetual.AutocloseSummaryRow
 import com.gemwallet.android.ui.components.perpetual.PerpetualDetailsBottomSheet
 import com.gemwallet.android.ui.components.perpetual.PerpetualDetailsSummaryItem
 import com.gemwallet.android.ui.components.perpetual.title
@@ -317,6 +318,11 @@ private fun ConfirmDetailElementRow(
             onClick = onClick,
             listPosition = listPosition,
         )
+        is ConfirmDetailElement.PerpetualModifyAutoclose -> AutocloseSummaryRow(
+            takeProfitText = item.takeProfitText,
+            stopLossText = item.stopLossText,
+            listPosition = listPosition,
+        )
     }
 }
 
@@ -340,6 +346,8 @@ private fun ConfirmDetailElementBottomSheet(
             onDismiss = onDismiss,
         )
 
+        is ConfirmDetailElement.PerpetualModifyAutoclose -> Unit
+
         null -> Unit
     }
 }

android/features/confirm/viewmodels/src/main/kotlin/com/gemwallet/android/features/confirm/models/ConfirmDetailElement.kt

@@ -11,4 +11,9 @@ sealed interface ConfirmDetailElement {
     data class PerpetualDetails(
         val model: PerpetualConfirmDetailsUIModel,
     ) : ConfirmDetailElement
+
+    data class PerpetualModifyAutoclose(
+        val takeProfitText: String?,
+        val stopLossText: String?,
+    ) : ConfirmDetailElement
 }

android/features/confirm/viewmodels/src/main/kotlin/com/gemwallet/android/features/confirm/models/PerpetualModifyAutocloseFactory.kt

@@ -0,0 +1,39 @@
+package com.gemwallet.android.features.confirm.models
+
+import com.gemwallet.android.model.CurrencyFormatter
+import com.wallet.core.primitives.Currency
+import com.wallet.core.primitives.PerpetualModifyConfirmData
+import com.wallet.core.primitives.PerpetualModifyPositionType
+
+object PerpetualModifyAutocloseFactory {
+
+    private const val ClearedPlaceholder: String = "-"
+
+    fun create(data: PerpetualModifyConfirmData): ConfirmDetailElement.PerpetualModifyAutoclose? {
+        val tpsl = data.modifyTypes
+            .filterIsInstance<PerpetualModifyPositionType.Tpsl>()
+            .firstOrNull()?.content
+        val cancelOrderIds = data.modifyTypes
+            .filterIsInstance<PerpetualModifyPositionType.Cancel>()
+            .flatMap { it.content }
+            .map { it.orderId }
+            .toSet()
+        val takeProfitCanceled = data.takeProfitOrderId != null &&
+            data.takeProfitOrderId in cancelOrderIds
+        val stopLossCanceled = data.stopLossOrderId != null &&
+            data.stopLossOrderId in cancelOrderIds
+        val formatter = CurrencyFormatter(currency = Currency.USD)
+        val takeProfitText: String? = when {
+            tpsl?.takeProfit != null -> tpsl.takeProfit?.toDoubleOrNull()?.let(formatter::string)
+            takeProfitCanceled -> ClearedPlaceholder
+            else -> null
+        }
+        val stopLossText: String? = when {
+            tpsl?.stopLoss != null -> tpsl.stopLoss?.toDoubleOrNull()?.let(formatter::string)
+            stopLossCanceled -> ClearedPlaceholder
+            else -> null
+        }
+        if (takeProfitText == null && stopLossText == null) return null
+        return ConfirmDetailElement.PerpetualModifyAutoclose(takeProfitText, stopLossText)
+    }
+}

android/features/confirm/viewmodels/src/main/kotlin/com/gemwallet/android/features/confirm/viewmodels/ConfirmViewModel.kt

@@ -27,11 +27,13 @@ import com.gemwallet.android.ui.models.swap.SwapProviderUIModelFactory
 import com.gemwallet.android.ui.models.actions.FinishConfirmAction
 import com.gemwallet.android.domains.confirm.AmountUIModel
 import com.gemwallet.android.features.confirm.models.ConfirmDetailElement
+import com.gemwallet.android.features.confirm.models.PerpetualModifyAutocloseFactory
 import com.gemwallet.android.domains.confirm.ConfirmError
 import com.gemwallet.android.domains.confirm.ConfirmState
 import com.gemwallet.android.domains.confirm.FeeUIModel
 import com.wallet.core.primitives.AssetId
 import com.wallet.core.primitives.Currency
+import com.wallet.core.primitives.PerpetualType
 import com.wallet.core.primitives.FeePriority
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Dispatchers
@@ -323,9 +325,10 @@ class ConfirmViewModel @Inject constructor(
 
     private fun buildPerpetualDetailElement(
         params: ConfirmParams.PerpetualParams?,
-    ): ConfirmDetailElement.PerpetualDetails? {
-        val model = PerpetualConfirmDetailsUIModelFactory.create(params?.perpetualType ?: return null) ?: return null
-        return ConfirmDetailElement.PerpetualDetails(model)
+    ): ConfirmDetailElement? = when (val type = params?.perpetualType) {
+        null -> null
+        is PerpetualType.Modify -> PerpetualModifyAutocloseFactory.create(type.content)
+        else -> PerpetualConfirmDetailsUIModelFactory.create(type)?.let(ConfirmDetailElement::PerpetualDetails)
     }
 
     private fun buildSwapDetailElement(