Updated on 2026-08-14

core/ui/src/main/java/com/tangem/core/ui/components/transactions/Transaction.kt

@@ -23,7 +23,8 @@ import com.tangem.core.ui.R
 import com.tangem.core.ui.components.CircleShimmer
 import com.tangem.core.ui.components.RectangleShimmer
 import com.tangem.core.ui.components.transactions.state.TransactionState
-import com.tangem.core.ui.components.transactions.state.TransactionState.Content.*
+import com.tangem.core.ui.components.transactions.state.TransactionState.Content.Status
+import com.tangem.core.ui.components.transactions.state.TransactionState.Content.Direction
 import com.tangem.core.ui.extensions.TextReference
 import com.tangem.core.ui.extensions.resolveReference
 import com.tangem.core.ui.res.TangemTheme
@@ -131,8 +132,12 @@ private fun Icon(state: TransactionState, modifier: Modifier = Modifier) {
                 Icon(
                     painter = painterResource(
                         id = when (state) {
-                            is TransactionState.Send -> R.drawable.ic_arrow_up_24
-                            is TransactionState.Receive -> R.drawable.ic_arrow_down_24
+                            is TransactionState.Transfer -> {
+                                when (state.direction) {
+                                    Direction.OUTGOING -> R.drawable.ic_arrow_up_24
+                                    Direction.INCOMING -> R.drawable.ic_arrow_down_24
+                                }
+                            }
                             is TransactionState.Approve -> R.drawable.ic_doc_24
                             is TransactionState.Swap -> R.drawable.ic_exchange_vertical_24
                             is TransactionState.Custom -> R.drawable.ic_exchange_vertical_24
@@ -175,8 +180,7 @@ private fun Title(state: TransactionState, modifier: Modifier = Modifier) {
                 Text(
                     text = when (state) {
                         is TransactionState.Approve -> stringResource(R.string.common_approval)
-                        is TransactionState.Receive -> stringResource(R.string.common_transfer)
-                        is TransactionState.Send -> stringResource(R.string.common_transfer)
+                        is TransactionState.Transfer -> stringResource(R.string.common_transfer)
                         is TransactionState.Swap -> stringResource(R.string.common_swap)
                         is TransactionState.Custom -> state.title.resolveReference()
                     },
@@ -212,11 +216,18 @@ private fun Subtitle(state: TransactionState, modifier: Modifier = Modifier) {
         is TransactionState.Content -> {
             Text(
                 text = when (state) {
-                    is TransactionState.Send -> stringResource(
-                        id = R.string.transaction_history_transaction_to_address,
-                        state.address.resolveReference(),
-                    )
-                    is TransactionState.Receive,
+                    is TransactionState.Transfer -> {
+                        when (state.direction) {
+                            Direction.OUTGOING -> stringResource(
+                                id = R.string.transaction_history_transaction_to_address,
+                                state.address.resolveReference(),
+                            )
+                            Direction.INCOMING -> stringResource(
+                                id = R.string.transaction_history_transaction_from_address,
+                                state.address.resolveReference(),
+                            )
+                        }
+                    }
                     is TransactionState.Approve,
                     -> stringResource(
                         id = R.string.transaction_history_transaction_from_address,
@@ -227,10 +238,9 @@ private fun Subtitle(state: TransactionState, modifier: Modifier = Modifier) {
                         state.address.resolveReference(),
                     )
                     is TransactionState.Custom -> stringResource(
-                        id = if (state.isIncoming) {
-                            R.string.transaction_history_transaction_from_address
-                        } else {
-                            R.string.transaction_history_transaction_to_address
+                        id = when (state.direction) {
+                            Direction.OUTGOING -> R.string.transaction_history_transaction_to_address
+                            Direction.INCOMING -> R.string.transaction_history_transaction_from_address
                         },
                         state.subtitle.resolveReference(),
                     )
@@ -262,7 +272,10 @@ private fun Amount(state: TransactionState, modifier: Modifier = Modifier) {
                 text = state.amount,
                 modifier = modifier,
                 textAlign = TextAlign.End,
-                color = TangemTheme.colors.text.primary1,
+                color = when (state.direction) {
+                    Direction.INCOMING -> TangemTheme.colors.text.accent
+                    Direction.OUTGOING -> TangemTheme.colors.text.primary1
+                },
                 style = TangemTheme.typography.body2,
             )
         }
@@ -336,19 +349,21 @@ private fun Preview_TransactionItem_DarkTheme(
 
 private class TransactionItemStateProvider : CollectionPreviewParameterProvider<TransactionState>(
     collection = listOf(
-        TransactionState.Send(
+        TransactionState.Transfer(
             txHash = UUID.randomUUID().toString(),
             address = TextReference.Str("33BddS...ga2B"),
             amount = "-0.500913 BTC",
             timestamp = "8:41",
             status = Status.Confirmed,
+            direction = Direction.OUTGOING,
         ),
-        TransactionState.Receive(
+        TransactionState.Transfer(
             txHash = UUID.randomUUID().toString(),
             address = TextReference.Str("33BddS...ga2B"),
             amount = "+0.500913 BTC",
             timestamp = "8:41",
             status = Status.Unconfirmed,
+            direction = Direction.INCOMING,
         ),
         TransactionState.Approve(
             txHash = UUID.randomUUID().toString(),
@@ -356,6 +371,7 @@ private class TransactionItemStateProvider : CollectionPreviewParameterProvider<
             amount = "+0.500913 BTC",
             timestamp = "8:41",
             status = Status.Failed,
+            direction = Direction.OUTGOING,
         ),
         TransactionState.Swap(
             txHash = UUID.randomUUID().toString(),
@@ -363,6 +379,7 @@ private class TransactionItemStateProvider : CollectionPreviewParameterProvider<
             amount = "+0.500913 BTC",
             timestamp = "8:41",
             status = Status.Unconfirmed,
+            direction = Direction.INCOMING,
         ),
         TransactionState.Custom(
             txHash = UUID.randomUUID().toString(),
@@ -370,9 +387,9 @@ private class TransactionItemStateProvider : CollectionPreviewParameterProvider<
             amount = "+0.500913 BTC",
             timestamp = "8:41",
             status = Status.Confirmed,
+            direction = Direction.INCOMING,
             title = TextReference.Str("Submit"),
             subtitle = TextReference.Str("33BddS...ga2B"),
-            isIncoming = true,
         ),
         TransactionState.Custom(
             txHash = UUID.randomUUID().toString(),
@@ -380,9 +397,9 @@ private class TransactionItemStateProvider : CollectionPreviewParameterProvider<
             amount = "+0.500913 BTC",
             timestamp = "8:41",
             status = Status.Confirmed,
+            direction = Direction.OUTGOING,
             title = TextReference.Str("Submit"),
             subtitle = TextReference.Str("33BddS...ga2B"),
-            isIncoming = false,
         ),
         TransactionState.Loading(txHash = UUID.randomUUID().toString()),
     ),

core/ui/src/main/java/com/tangem/core/ui/components/transactions/state/TransactionState.kt

@@ -19,6 +19,7 @@ sealed interface TransactionState {
      * @property amount    amount
      * @property timestamp timestamp
      * @property status    transaction status
+     * @property direction transaction direction
      */
     sealed class Content : TransactionState {
 
@@ -26,6 +27,7 @@ sealed interface TransactionState {
         abstract val amount: String
         abstract val timestamp: String
         abstract val status: Status
+        abstract val direction: Direction
 
         fun copySealed(
             txHash: String = this.txHash,
@@ -33,13 +35,13 @@ sealed interface TransactionState {
             amount: String = this.amount,
             timestamp: String = this.timestamp,
             status: Status = this.status,
+            direction: Direction = this.direction,
         ): Content {
             return when (this) {
-                is Approve -> copy(txHash, address, amount, timestamp, status)
-                is Receive -> copy(txHash, address, amount, timestamp, status)
-                is Send -> copy(txHash, address, amount, timestamp, status)
-                is Swap -> copy(txHash, address, amount, timestamp, status)
-                is Custom -> copy(txHash, address, amount, timestamp, status)
+                is Approve -> copy(txHash, address, amount, timestamp, status, direction)
+                is Transfer -> copy(txHash, address, amount, timestamp, status, direction)
+                is Swap -> copy(txHash, address, amount, timestamp, status, direction)
+                is Custom -> copy(txHash, address, amount, timestamp, status, direction)
             }
         }
 
@@ -48,6 +50,11 @@ sealed interface TransactionState {
             object Confirmed : Status()
             object Unconfirmed : Status()
         }
+
+        enum class Direction {
+            INCOMING,
+            OUTGOING,
+        }
     }
 
     /**
@@ -57,29 +64,15 @@ sealed interface TransactionState {
      * @property address   address
      * @property amount    amount
      * @property timestamp timestamp
+     * @property direction transaction direction
      */
-    data class Send(
-        override val txHash: String,
-        override val address: TextReference,
-        override val amount: String,
-        override val timestamp: String,
-        override val status: Status,
-    ) : Content()
-
-    /**
-     * Completed receiving transaction state
-     *
-     * @property txHash    transaction hash
-     * @property address   address
-     * @property amount    amount
-     * @property timestamp timestamp
-     */
-    data class Receive(
+    data class Transfer(
         override val txHash: String,
         override val address: TextReference,
         override val amount: String,
         override val timestamp: String,
         override val status: Status,
+        override val direction: Direction,
     ) : Content()
 
     /**
@@ -89,6 +82,7 @@ sealed interface TransactionState {
      * @property address   address
      * @property amount    amount
      * @property timestamp timestamp
+     * @property direction transaction direction
      */
     data class Approve(
         override val txHash: String,
@@ -96,6 +90,7 @@ sealed interface TransactionState {
         override val amount: String,
         override val timestamp: String,
         override val status: Status,
+        override val direction: Direction,
     ) : Content()
 
     /**
@@ -105,6 +100,7 @@ sealed interface TransactionState {
      * @property address   address
      * @property amount    amount
      * @property timestamp timestamp
+     * @property direction transaction direction
      */
     data class Swap(
         override val txHash: String,
@@ -112,6 +108,7 @@ sealed interface TransactionState {
         override val amount: String,
         override val timestamp: String,
         override val status: Status,
+        override val direction: Direction,
     ) : Content()
 
     data class Custom(
@@ -120,9 +117,9 @@ sealed interface TransactionState {
         override val amount: String,
         override val timestamp: String,
         override val status: Status,
+        override val direction: Direction,
         val title: TextReference,
         val subtitle: TextReference,
-        val isIncoming: Boolean,
     ) : Content()
 
     /**

features/tokendetails/impl/src/main/kotlin/com/tangem/feature/tokendetails/presentation/tokendetails/state/factory/txhistory/TokenDetailsTxHistoryToTransactionStateConverter.kt

@@ -10,7 +10,6 @@ import com.tangem.utils.toBriefAddressFormat
 import com.tangem.utils.toFormattedCurrencyString
 import org.joda.time.DateTime
 import org.joda.time.DateTimeZone
-import java.math.BigDecimal
 
 internal class TokenDetailsTxHistoryToTransactionStateConverter(
     private val symbol: String,
@@ -30,108 +29,98 @@ internal class TokenDetailsTxHistoryToTransactionStateConverter(
             TxHistoryItem.TransactionType.Deposit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Deposit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Submit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Submit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Supply -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Supply"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Unoswap -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Unoswap"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Withdraw -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Withdraw"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             is TxHistoryItem.TransactionType.Custom -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.timestampInMillis.toTimeFormat(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str(type.id),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
         }
     }
 
     private fun mapTransfer(item: TxHistoryItem): TransactionState {
-        return when (item.direction) {
-            is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Receive(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.timestampInMillis.toTimeFormat(),
-                status = item.status.tiUiStatus(),
-            )
-            is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Send(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.timestampInMillis.toTimeFormat(),
-                status = item.status.tiUiStatus(),
-            )
-        }
+        return TransactionState.Transfer(
+            txHash = item.txHash,
+            address = item.direction.extractAddress(),
+            amount = item.extractFormattedCryptoBalance(),
+            timestamp = item.timestampInMillis.toTimeFormat(),
+            status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
+        )
     }
 
     private fun mapApprove(item: TxHistoryItem): TransactionState {
         return TransactionState.Approve(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.timestampInMillis.toTimeFormat(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
     private fun mapSwap(item: TxHistoryItem): TransactionState {
         return TransactionState.Swap(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.timestampInMillis.toTimeFormat(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
 
-    private fun BigDecimal.toCryptoCurrencyFormat(): String {
-        return toFormattedCurrencyString(currency = symbol, decimals = decimals)
-    }
-
     private fun TxHistoryItem.TransactionDirection.extractAddress(): TextReference = when (val addr = address) {
         TxHistoryItem.Address.Multiple -> TextReference.Res(R.string.transaction_history_multiple_addresses)
         is TxHistoryItem.Address.Single -> TextReference.Str(addr.rawAddress.toBriefAddressFormat())
@@ -146,4 +135,17 @@ internal class TokenDetailsTxHistoryToTransactionStateConverter(
     private fun Long.toTimeFormat(): String {
         return DateTimeFormatters.formatTime(time = DateTime(this, DateTimeZone.getDefault()))
     }
+
+    private fun TxHistoryItem.TransactionDirection.toUiDirection() = when (this) {
+        is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Content.Direction.INCOMING
+        is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Content.Direction.OUTGOING
+    }
+
+    private fun TxHistoryItem.extractFormattedCryptoBalance(): String {
+        val prefix = when (direction) {
+            is TxHistoryItem.TransactionDirection.Incoming -> "+"
+            is TxHistoryItem.TransactionDirection.Outgoing -> "-"
+        }
+        return prefix + amount.toFormattedCurrencyString(currency = symbol, decimals = decimals)
+    }
 }

features/tokendetails/impl/src/main/kotlin/com/tangem/feature/tokendetails/presentation/tokendetails/state/factory/txhistory/TokenDetailsTxHistoryTransactionStateConverter.kt

@@ -7,7 +7,6 @@ import com.tangem.features.tokendetails.impl.R
 import com.tangem.utils.converter.Converter
 import com.tangem.utils.toBriefAddressFormat
 import com.tangem.utils.toFormattedCurrencyString
-import java.math.BigDecimal
 
 internal class TokenDetailsTxHistoryTransactionStateConverter(
     private val symbol: String,
@@ -27,101 +26,95 @@ internal class TokenDetailsTxHistoryTransactionStateConverter(
             TxHistoryItem.TransactionType.Deposit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Deposit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Submit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Submit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Supply -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Supply"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Unoswap -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Unoswap"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Withdraw -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Withdraw"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             is TxHistoryItem.TransactionType.Custom -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str(type.id),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
         }
     }
 
     private fun mapTransfer(item: TxHistoryItem): TransactionState {
-        return when (item.direction) {
-            is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Receive(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.getRawTimestamp(),
-                status = item.status.tiUiStatus(),
-            )
-            is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Send(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.getRawTimestamp(),
-                status = item.status.tiUiStatus(),
-            )
-        }
+        return TransactionState.Transfer(
+            txHash = item.txHash,
+            address = item.direction.extractAddress(),
+            amount = item.extractFormattedCryptoBalance(),
+            timestamp = item.getRawTimestamp(),
+            status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
+        )
     }
 
     private fun mapApprove(item: TxHistoryItem): TransactionState {
         return TransactionState.Approve(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.getRawTimestamp(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
     private fun mapSwap(item: TxHistoryItem): TransactionState {
         return TransactionState.Swap(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.getRawTimestamp(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
 
@@ -133,10 +126,6 @@ internal class TokenDetailsTxHistoryTransactionStateConverter(
      */
     private fun TxHistoryItem.getRawTimestamp() = this.timestampInMillis.toString()
 
-    private fun BigDecimal.toCryptoCurrencyFormat(): String {
-        return toFormattedCurrencyString(currency = symbol, decimals = decimals)
-    }
-
     private fun TxHistoryItem.TransactionDirection.extractAddress(): TextReference = when (val addr = address) {
         TxHistoryItem.Address.Multiple -> TextReference.Res(R.string.transaction_history_multiple_addresses)
         is TxHistoryItem.Address.Single -> TextReference.Str(addr.rawAddress.toBriefAddressFormat())
@@ -147,4 +136,17 @@ internal class TokenDetailsTxHistoryTransactionStateConverter(
         TxHistoryItem.TransactionStatus.Failed -> TransactionState.Content.Status.Failed
         TxHistoryItem.TransactionStatus.Unconfirmed -> TransactionState.Content.Status.Unconfirmed
     }
+
+    private fun TxHistoryItem.TransactionDirection.toUiDirection() = when (this) {
+        is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Content.Direction.INCOMING
+        is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Content.Direction.OUTGOING
+    }
+
+    private fun TxHistoryItem.extractFormattedCryptoBalance(): String {
+        val prefix = when (direction) {
+            is TxHistoryItem.TransactionDirection.Incoming -> "+"
+            is TxHistoryItem.TransactionDirection.Outgoing -> "-"
+        }
+        return prefix + amount.toFormattedCurrencyString(currency = symbol, decimals = decimals)
+    }
 }

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/common/WalletPreviewData.kt

@@ -429,22 +429,24 @@ internal object WalletPreviewData {
                         listOf(
                             TxHistoryState.TxHistoryItemState.GroupTitle("Today"),
                             TxHistoryState.TxHistoryItemState.Transaction(
-                                TransactionState.Send(
+                                TransactionState.Transfer(
                                     txHash = UUID.randomUUID().toString(),
                                     address = TextReference.Str("33BddS...ga2B"),
                                     amount = "-0.500913 BTC",
                                     timestamp = "8:41",
                                     status = TransactionState.Content.Status.Unconfirmed,
+                                    direction = TransactionState.Content.Direction.OUTGOING,
                                 ),
                             ),
                             TxHistoryState.TxHistoryItemState.GroupTitle("Yesterday"),
                             TxHistoryState.TxHistoryItemState.Transaction(
-                                TransactionState.Send(
+                                TransactionState.Transfer(
                                     txHash = UUID.randomUUID().toString(),
                                     address = TextReference.Str("33BddS...ga2B"),
                                     amount = "-0.500913 BTC",
                                     timestamp = "8:41",
                                     status = TransactionState.Content.Status.Confirmed,
+                                    direction = TransactionState.Content.Direction.OUTGOING,
                                 ),
                             ),
                         ),

features/wallet/impl/src/main/java/com/tangem/feature/wallet/presentation/wallet/state/factory/txhistory/WalletTxHistoryTransactionStateConverter.kt

@@ -7,7 +7,6 @@ import com.tangem.feature.wallet.impl.R
 import com.tangem.utils.converter.Converter
 import com.tangem.utils.toBriefAddressFormat
 import com.tangem.utils.toFormattedCurrencyString
-import java.math.BigDecimal
 
 class WalletTxHistoryTransactionStateConverter(
     private val symbol: String,
@@ -27,101 +26,95 @@ class WalletTxHistoryTransactionStateConverter(
             TxHistoryItem.TransactionType.Deposit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Deposit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Submit -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Submit"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Supply -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Supply"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Unoswap -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Unoswap"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             TxHistoryItem.TransactionType.Withdraw -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str("Withdraw"),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
             is TxHistoryItem.TransactionType.Custom -> TransactionState.Custom(
                 txHash = item.txHash,
                 address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
+                amount = item.extractFormattedCryptoBalance(),
                 timestamp = item.getRawTimestamp(),
                 status = item.status.tiUiStatus(),
+                direction = item.direction.toUiDirection(),
                 title = TextReference.Str(type.id),
                 subtitle = item.direction.extractAddress(),
-                isIncoming = item.direction is TxHistoryItem.TransactionDirection.Incoming,
             )
         }
     }
 
     private fun mapTransfer(item: TxHistoryItem): TransactionState {
-        return when (item.direction) {
-            is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Receive(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.getRawTimestamp(),
-                status = item.status.tiUiStatus(),
-            )
-            is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Send(
-                txHash = item.txHash,
-                address = item.direction.extractAddress(),
-                amount = item.amount.toCryptoCurrencyFormat(),
-                timestamp = item.getRawTimestamp(),
-                status = item.status.tiUiStatus(),
-            )
-        }
+        return TransactionState.Transfer(
+            txHash = item.txHash,
+            address = item.direction.extractAddress(),
+            amount = item.extractFormattedCryptoBalance(),
+            timestamp = item.getRawTimestamp(),
+            status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
+        )
     }
 
     private fun mapApprove(item: TxHistoryItem): TransactionState {
         return TransactionState.Approve(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.getRawTimestamp(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
     private fun mapSwap(item: TxHistoryItem): TransactionState {
         return TransactionState.Swap(
             txHash = item.txHash,
             address = item.direction.extractAddress(),
-            amount = item.amount.toCryptoCurrencyFormat(),
+            amount = item.extractFormattedCryptoBalance(),
             timestamp = item.getRawTimestamp(),
             status = item.status.tiUiStatus(),
+            direction = item.direction.toUiDirection(),
         )
     }
 
@@ -133,10 +126,6 @@ class WalletTxHistoryTransactionStateConverter(
      */
     private fun TxHistoryItem.getRawTimestamp() = this.timestampInMillis.toString()
 
-    private fun BigDecimal.toCryptoCurrencyFormat(): String {
-        return toFormattedCurrencyString(currency = symbol, decimals = decimals)
-    }
-
     private fun TxHistoryItem.TransactionDirection.extractAddress(): TextReference = when (val addr = address) {
         TxHistoryItem.Address.Multiple -> TextReference.Res(R.string.transaction_history_multiple_addresses)
         is TxHistoryItem.Address.Single -> TextReference.Str(addr.rawAddress.toBriefAddressFormat())
@@ -147,4 +136,17 @@ class WalletTxHistoryTransactionStateConverter(
         TxHistoryItem.TransactionStatus.Failed -> TransactionState.Content.Status.Failed
         TxHistoryItem.TransactionStatus.Unconfirmed -> TransactionState.Content.Status.Unconfirmed
     }
+
+    private fun TxHistoryItem.TransactionDirection.toUiDirection() = when (this) {
+        is TxHistoryItem.TransactionDirection.Incoming -> TransactionState.Content.Direction.INCOMING
+        is TxHistoryItem.TransactionDirection.Outgoing -> TransactionState.Content.Direction.OUTGOING
+    }
+
+    private fun TxHistoryItem.extractFormattedCryptoBalance(): String {
+        val prefix = when (direction) {
+            is TxHistoryItem.TransactionDirection.Incoming -> "+"
+            is TxHistoryItem.TransactionDirection.Outgoing -> "-"
+        }
+        return prefix + amount.toFormattedCurrencyString(currency = symbol, decimals = decimals)
+    }
 }