fix(crypto): add MintAsStringSerializer so Mint deserializes correctly

PublicKeyAsStringSerializer.deserialize() always returned PublicKey,
causing ClassCastException when deserializing classes with Mint fields
(e.g. LocalFiat). Introduce MintAsStringSerializer that returns Mint
and apply it to the Mint class.

Author: bmc08gt

apps/flipcash/shared/workers/src/test/kotlin/com/flipcash/app/workers/internal/GiftCardFundingWorkerTest.kt

@@ -23,15 +23,12 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 import kotlin.test.assertEquals
-import kotlin.test.assertTrue
 
 @OptIn(ExperimentalCoroutinesApi::class)
 @RunWith(RobolectricTestRunner::class)
@@ -148,33 +145,25 @@ class GiftCardFundingWorkerTest {
     // ---- buildInputData serialization roundtrip ----
 
     @Test
-    fun `buildInputData serializes amount to valid JSON`() {
+    fun `buildInputData serializes and deserializes amount roundtrip`() {
         val amount = testLocalFiat()
         val serialized = Json.encodeToString(LocalFiat.serializer(), amount)
-
-        // Verify the JSON is valid and contains expected fields
-        val jsonElement = Json.parseToJsonElement(serialized)
-        val jsonObject = jsonElement.jsonObject
-
-        // Verify structure: underlyingTokenAmount, nativeAmount, rate, mint
-        assertTrue(jsonObject.containsKey("underlyingTokenAmount"), "Missing underlyingTokenAmount")
-        assertTrue(jsonObject.containsKey("nativeAmount"), "Missing nativeAmount")
-        assertTrue(jsonObject.containsKey("rate"), "Missing rate")
-        assertTrue(jsonObject.containsKey("mint"), "Missing mint")
-
-        // Verify mint serializes as base58 string
-        val mintValue = jsonObject["mint"]?.jsonPrimitive?.content
-        assertEquals("5AMAA9JV9H97YYVxx8F6FsCMmTwXSuTTQneiup4RYAUQ", mintValue)
+        val deserialized = Json.decodeFromString(LocalFiat.serializer(), serialized)
+
+        assertEquals(amount.underlyingTokenAmount.quarks, deserialized.underlyingTokenAmount.quarks)
+        assertEquals(amount.underlyingTokenAmount.currencyCode, deserialized.underlyingTokenAmount.currencyCode)
+        assertEquals(amount.nativeAmount.quarks, deserialized.nativeAmount.quarks)
+        assertEquals(amount.nativeAmount.currencyCode, deserialized.nativeAmount.currencyCode)
+        assertEquals(amount.rate.fx, deserialized.rate.fx)
+        assertEquals(amount.rate.currency, deserialized.rate.currency)
+        assertEquals(amount.mint.bytes, deserialized.mint.bytes)
     }
 
     @Test
     fun `buildInputData serializes and deserializes token roundtrip`() {
-        // Mint uses PublicKeyAsStringSerializer which deserializes to PublicKey (parent class).
-        // We verify the base58 string roundtrips correctly — this is what the worker uses.
         val mint = Mint.usdf
         val serialized = Json.encodeToString(mint)
-        // Deserialize as PublicKey since the serializer returns PublicKey, then verify bytes match
-        val deserialized = Json.decodeFromString<com.getcode.solana.keys.PublicKey>(serialized)
+        val deserialized = Json.decodeFromString<Mint>(serialized)
 
         assertEquals(mint.bytes, deserialized.bytes)
     }

libs/encryption/keys/src/main/kotlin/com/getcode/solana/keys/Mint.kt

@@ -1,10 +1,10 @@
 package com.getcode.solana.keys
 
-import com.getcode.utils.serializer.PublicKeyAsStringSerializer
+import com.getcode.utils.serializer.MintAsStringSerializer
 import com.getcode.vendor.Base58
 import kotlinx.serialization.Serializable
 
-@Serializable(with = PublicKeyAsStringSerializer::class)
+@Serializable(with = MintAsStringSerializer::class)
 class Mint(bytes: List<Byte>): PublicKey(bytes) {
     constructor(base58: String) : this(Base58.decode(base58).toList())
 

libs/encryption/keys/src/main/kotlin/com/getcode/utils/serializer/MintSerializer.kt

@@ -0,0 +1,23 @@
+package com.getcode.utils.serializer
+
+import com.getcode.solana.keys.Mint
+import com.getcode.solana.keys.base58
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+object MintAsStringSerializer : KSerializer<Mint> {
+    override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("Mint", PrimitiveKind.STRING)
+
+    override fun serialize(encoder: Encoder, value: Mint) {
+        encoder.encodeString(value.base58())
+    }
+
+    override fun deserialize(decoder: Decoder): Mint {
+        val base58 = decoder.decodeString()
+        return Mint(base58)
+    }
+}

libs/encryption/keys/src/test/kotlin/com/getcode/utils/serializer/SerializerTest.kt

@@ -1,5 +1,6 @@
 package com.getcode.utils.serializer
 
+import com.getcode.solana.keys.Mint
 import com.getcode.solana.keys.PublicKey
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
@@ -73,6 +74,15 @@ class SerializerTest {
         assertEquals(original.key, decoded.key)
     }
 
+    @Test
+    fun mintSerializerRoundtrip() {
+        val mint = Mint.usdf
+        val json = Json.encodeToString(mint)
+        val decoded = Json.decodeFromString<Mint>(json)
+        assertEquals(mint.bytes, decoded.bytes)
+        assertTrue(decoded is Mint, "Deserialized value should be Mint, not just PublicKey")
+    }
+
     @Test
     fun publicKeySerializerProducesBase58String() {
         val bytes = ByteArray(32) { 1 }