diff --git a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/domain/responses/ResponseJsonConverter.kt b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/domain/responses/ResponseJsonConverter.kt
index d54bc08a5d..794f4aa727 100644
--- a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/domain/responses/ResponseJsonConverter.kt
+++ b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/domain/responses/ResponseJsonConverter.kt
@@ -3,6 +3,7 @@ package com.tangem.tangemtest.ucase.domain.responses
 import com.google.gson.*
 import com.tangem.commands.*
 import com.tangem.common.extensions.toHexString
+import com.tangem.tangemtest.extensions.print
 import java.lang.reflect.Type
 import java.text.DateFormat
 import java.util.*
@@ -11,14 +12,17 @@ import java.util.*
 [REDACTED_AUTHOR]
  */
 class ResponseJsonConverter {
+
     val gson: Gson by lazy { init() }
 
+    private val fieldConverter = ResponseFieldConverter()
+
     private fun init(): Gson {
         val builder = GsonBuilder().apply {
-            registerTypeAdapter(ByteArray::class.java, ByteTypeAdapter())
-            registerTypeAdapter(SigningMethod::class.java, SigningMethodTypeAdapter())
-            registerTypeAdapter(SettingsMask::class.java, SettingsMaskTypeAdapter())
-            registerTypeAdapter(ProductMask::class.java, ProductMaskTypeAdapter())
+            registerTypeAdapter(ByteArray::class.java, ByteTypeAdapter(fieldConverter))
+            registerTypeAdapter(SigningMethod::class.java, SigningMethodTypeAdapter(fieldConverter))
+            registerTypeAdapter(SettingsMask::class.java, SettingsMaskTypeAdapter(fieldConverter))
+            registerTypeAdapter(ProductMask::class.java, ProductMaskTypeAdapter(fieldConverter))
             registerTypeAdapter(Date::class.java, DateTypeAdapter())
         }
         builder.setPrettyPrinting()
@@ -28,31 +32,41 @@ class ResponseJsonConverter {
     fun convertResponse(response: CommandResponse?): String = gson.toJson(response)
 }
 
-class ByteTypeAdapter : JsonSerializer<ByteArray> {
+class ByteTypeAdapter(
+        private val fieldConverter: ResponseFieldConverter
+) : JsonSerializer<ByteArray> {
     override fun serialize(src: ByteArray, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        return JsonPrimitive(src.toHexString())
+        return JsonPrimitive(fieldConverter.byteArray(src))
     }
 }
 
-class SettingsMaskTypeAdapter : JsonSerializer<SettingsMask> {
+class SettingsMaskTypeAdapter(
+        private val fieldConverter: ResponseFieldConverter
+) : JsonSerializer<SettingsMask> {
     override fun serialize(src: SettingsMask, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        val arrayElement = JsonArray()
-        Settings.values()
-                .filter { src.contains(it) }
-                .forEach { arrayElement.add(it.name) }
-        return arrayElement
+        return JsonArray().apply {
+            fieldConverter.settingsMaskList(src).forEach { add(it) }
+        }
     }
 }
 
-class ProductMaskTypeAdapter : JsonSerializer<ProductMask> {
+class ProductMaskTypeAdapter(
+        private val fieldConverter: ResponseFieldConverter
+) : JsonSerializer<ProductMask> {
     override fun serialize(src: ProductMask, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        return JsonPrimitive(src.rawValue.toString())
+        return JsonArray().apply {
+            fieldConverter.productMaskList(src).forEach { add(it) }
+        }
     }
 }
 
-class SigningMethodTypeAdapter : JsonSerializer<SigningMethod> {
+class SigningMethodTypeAdapter(
+        private val fieldConverter: ResponseFieldConverter
+) : JsonSerializer<SigningMethod> {
     override fun serialize(src: SigningMethod, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        return JsonPrimitive(src.rawValue.toString())
+        return JsonArray().apply {
+            fieldConverter.signingMethodList(src).forEach { add(it) }
+        }
     }
 }
 
@@ -61,4 +75,56 @@ class DateTypeAdapter : JsonSerializer<Date> {
         val formatter = DateFormat.getDateInstance(DateFormat.DEFAULT, Locale("en_US"))
         return JsonPrimitive(formatter.format(src).toString())
     }
+}
+
+class ResponseFieldConverter {
+
+    fun productMask(productMask: ProductMask?): String {
+        return productMaskList(productMask).print(wrap = false)
+    }
+
+    fun productMaskList(productMask: ProductMask?): List<String> {
+        val mask = productMask ?: return emptyList()
+
+        val signingMap = mutableMapOf(
+                ProductMask.note to "Note",
+                ProductMask.tag to "Tag",
+                ProductMask.idCard to "IdCard",
+                ProductMask.idIssuer to "IdIssuer"
+        )
+        return signingMap.filter { mask.contains(it.key) }.map { it.value }
+    }
+
+    fun signingMethod(signingMethod: SigningMethod?): String {
+        return signingMethodList(signingMethod).print(wrap = false)
+    }
+
+    fun signingMethodList(signingMethod: SigningMethod?): List<String> {
+        val methods = signingMethod ?: return emptyList()
+
+        val signingMap = mutableMapOf(
+                SigningMethod.signHash to "Hash",
+                SigningMethod.signRaw to "Raw",
+                SigningMethod.signHashValidatedByIssuer to "HashValidatedByIssuer",
+                SigningMethod.signRawValidatedByIssuer to "RawValidatedByIssuer",
+                SigningMethod.signHashValidatedByIssuerAndWriteIssuerData to "HashValidatedByIssuerAndWriteIssuerData",
+                SigningMethod.signRawValidatedByIssuerAndWriteIssuerData to "RawValidatedByIssuerAndWriteIssuerData",
+                SigningMethod.signPos to "Pos"
+        )
+        return signingMap.filter { methods.contains(it.key) }.map { it.value }
+    }
+
+    fun settingsMask(settingsMask: SettingsMask?): String {
+        return settingsMaskList(settingsMask).print(wrap = false)
+    }
+
+    fun settingsMaskList(settingsMask: SettingsMask?): List<String> {
+        val masks = settingsMask ?: return emptyList()
+
+        return Settings.values().filter { masks.contains(it) }.map { it.name }
+    }
+
+    fun byteArray(byteArray: ByteArray?): String {
+        return byteArray?.toHexString() ?: ""
+    }
 }
\ No newline at end of file
diff --git a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/responses/converter/CardConverter.kt b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/responses/converter/CardConverter.kt
index 7ccf0d0a13..cb8d978fbe 100644
--- a/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/responses/converter/CardConverter.kt
+++ b/tangem-demo/src/main/java/com/tangem/tangemtest/ucase/variants/responses/converter/CardConverter.kt
@@ -4,13 +4,13 @@ import com.tangem.commands.Card
 import com.tangem.commands.CardData
 import com.tangem.commands.Settings
 import com.tangem.commands.SettingsMask
-import com.tangem.common.extensions.toHexString
 import com.tangem.tangemtest.R
 import com.tangem.tangemtest._arch.structure.Id
 import com.tangem.tangemtest._arch.structure.StringId
 import com.tangem.tangemtest._arch.structure.abstraction.*
 import com.tangem.tangemtest._arch.structure.impl.BoolItem
 import com.tangem.tangemtest._arch.structure.impl.TextItem
+import com.tangem.tangemtest.ucase.domain.responses.ResponseFieldConverter
 import com.tangem.tangemtest.ucase.variants.personalize.BlockId
 import com.tangem.tangemtest.ucase.variants.responses.CardDataId
 import com.tangem.tangemtest.ucase.variants.responses.CardId
@@ -20,11 +20,11 @@ import ru.dev.gbixahue.eu4d.lib.kotlin.stringOf
 [REDACTED_AUTHOR]
  */
 class CardConverter : ModelToItems<Card> {
+
+    private val fieldConverter = ResponseFieldConverter()
+
     override fun convert(from: Card): List<Item> {
         val itemList = mutableListOf<Item>()
-//        val holder = GsonInitializer()
-//        itemList.add(TextItem(Additional.JSON_INCOMING, holder.gson.toJson(from)))
-
         itemList.add(simpleFields(from))
         itemList.add(cardData(from.cardData))
         itemList.add(settingsMask(from.settingsMask))
@@ -52,13 +52,13 @@ class CardConverter : ModelToItems<Card> {
         group.addItem(TextItem(CardId.manufacturerName, from.manufacturerName))
         group.addItem(TextItem(CardId.status, stringOf(from.status)))
         group.addItem(TextItem(CardId.firmwareVersion, from.firmwareVersion))
-        group.addItem(TextItem(CardId.cardPublicKey, from.cardPublicKey?.toHexString()))
-        group.addItem(TextItem(CardId.issuerPublicKey, from.issuerPublicKey?.toHexString()))
+        group.addItem(TextItem(CardId.cardPublicKey, fieldConverter.byteArray(from.cardPublicKey)))
+        group.addItem(TextItem(CardId.issuerPublicKey, fieldConverter.byteArray(from.issuerPublicKey)))
         group.addItem(TextItem(CardId.curve, stringOf(from.curve)))
         group.addItem(TextItem(CardId.maxSignatures, stringOf(from.maxSignatures)))
-        group.addItem(TextItem(CardId.signingMethod, stringOf(from.signingMethod?.rawValue)))
+        group.addItem(TextItem(CardId.signingMethod, fieldConverter.signingMethod(from.signingMethod)))
         group.addItem(TextItem(CardId.pauseBeforePin2, stringOf(from.pauseBeforePin2)))
-        group.addItem(TextItem(CardId.walletPublicKey, stringOf(from.walletPublicKey)))
+        group.addItem(TextItem(CardId.walletPublicKey, fieldConverter.byteArray(from.walletPublicKey)))
         group.addItem(TextItem(CardId.walletRemainingSignatures, stringOf(from.walletRemainingSignatures)))
         group.addItem(TextItem(CardId.walletSignedHashes, stringOf(from.walletSignedHashes)))
         group.addItem(TextItem(CardId.health, stringOf(from.health)))
@@ -80,8 +80,8 @@ class CardConverter : ModelToItems<Card> {
         group.addItem(TextItem(CardDataId.manufactureDateTime, stringOf(data.manufactureDateTime)))
         group.addItem(TextItem(CardDataId.issuerName, data.issuerName))
         group.addItem(TextItem(CardDataId.blockchainName, data.blockchainName))
-        group.addItem(TextItem(CardDataId.manufacturerSignature, data.manufacturerSignature?.toHexString()))
-        group.addItem(TextItem(CardDataId.productMask, stringOf(data.productMask?.rawValue)))
+        group.addItem(TextItem(CardDataId.manufacturerSignature, fieldConverter.byteArray(data.manufacturerSignature)))
+        group.addItem(TextItem(CardDataId.productMask, fieldConverter.productMask(data.productMask)))
         group.addItem(TextItem(CardDataId.tokenSymbol, data.tokenSymbol))
         group.addItem(TextItem(CardDataId.tokenContractAddress, data.tokenContractAddress))
         group.addItem(TextItem(CardDataId.tokenDecimal, data.tokenSymbol))
@@ -90,10 +90,9 @@ class CardConverter : ModelToItems<Card> {
     }
 
     private fun settingsMask(from: SettingsMask?): Item {
-        val group = createGroup(CardId.settingsMask, R.color.group_signing_method)
+        val group = createGroup(CardId.settingsMask, R.color.group_settings_mask)
         val data = from ?: return group
 
-//        group.addItem(TextItem(StringResId(R.string.response_card_settings_mask)))
         Settings.values().forEach { group.addItem(BoolItem(StringId(it.name), data.contains(it))) }
         return group
     }
diff --git a/tangem-demo/src/main/res/values/colors.xml b/tangem-demo/src/main/res/values/colors.xml
index 1c183064f5..180f557ffd 100644
--- a/tangem-demo/src/main/res/values/colors.xml
+++ b/tangem-demo/src/main/res/values/colors.xml
@@ -14,7 +14,7 @@
     <color name="field_description">@color/field_info</color>
 
     <color name="group_card_data">#D7E4F3</color>
-    <color name="group_signing_method">#D7F3E6</color>
+    <color name="group_settings_mask">#D7F3E6</color>
 
 
     <color name="switchTrack">#C6C6C6</color>