🚀 [Release v4.11.0]

.gitignore

@@ -46,4 +46,5 @@ service-data.json
 canary-file.json
 
 # Claude
-.claude/
+.claude/
+CLAUDE.local.md

app/build.gradle.kts

@@ -31,8 +31,8 @@ android {
         applicationId = "ltd.grunt.brainwallet"
         minSdk = 29
         targetSdk = 35
-        versionCode = 202506345
-        versionName = "v4.10.6"
+        versionCode = 202506346
+        versionName = "v4.11.0"
         multiDexEnabled = true
         base.archivesName.set("${defaultConfig.versionName}(${defaultConfig.versionCode})")
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

app/src/main/java/com/brainwallet/gameinterface/GdxGameView.kt

@@ -35,7 +35,7 @@ import org.koin.compose.viewmodel.koinViewModel
 import timber.log.Timber
 
 @Serializable
-private data class GameExitData(
+internal data class GameExitData(
     @SerialName("social_network") val socialNetwork: String = "none",
     val timestamp: Long = 0L,
     @SerialName("total_score") val totalScore: Int = 0,
@@ -102,7 +102,7 @@ private fun removeFragment(fm: FragmentManager, tag: String) {
     }
 }
 
-private fun handleGameExit(
+internal fun handleGameExit(
     jsonString: String,
     bytes: ByteArray?,
     gameHubViewModel: GameHubViewModel,

app/src/test/java/com/brainwallet/tools/crypto/Base58Test.kt

@@ -0,0 +1,79 @@
+package com.brainwallet.tools.crypto
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThrows
+import org.junit.Test
+
+class Base58Test {
+
+    @Test
+    fun `given empty byte array, when encode, then returns empty string`() {
+        assertEquals("", Base58.encode(ByteArray(0)))
+    }
+
+    @Test
+    fun `given empty string, when decode, then returns empty byte array`() {
+        assertArrayEquals(ByteArray(0), Base58.decode(""))
+    }
+
+    @Test
+    fun `given known byte sequence, when encode, then matches known base58 vector`() {
+        // "Hello World" in bytes is a well known Base58 test vector.
+        val input = "Hello World".toByteArray(Charsets.UTF_8)
+        assertEquals("JxF12TrwUP45BMd", Base58.encode(input))
+    }
+
+    @Test
+    fun `given known base58 string, when decode, then matches known byte vector`() {
+        val decoded = Base58.decode("JxF12TrwUP45BMd")
+        assertArrayEquals("Hello World".toByteArray(Charsets.UTF_8), decoded)
+    }
+
+    @Test
+    fun `given bytes with leading zeroes, when encode then decode, then round trips exactly`() {
+        val input = byteArrayOf(0, 0, 0, 1, 2, 3, 4, 5)
+        val encoded = Base58.encode(input)
+
+        // Leading zero bytes are represented as leading '1' characters.
+        assertEquals('1', encoded[0])
+        assertEquals('1', encoded[1])
+        assertEquals('1', encoded[2])
+
+        assertArrayEquals(input, Base58.decode(encoded))
+    }
+
+    @Test
+    fun `given all zero bytes, when encode then decode, then round trips exactly`() {
+        val input = ByteArray(5)
+        val encoded = Base58.encode(input)
+
+        assertEquals("11111", encoded)
+        assertArrayEquals(input, Base58.decode(encoded))
+    }
+
+    @Test
+    fun `given arbitrary byte array, when encode then decode, then round trips exactly`() {
+        val input = byteArrayOf(
+            0x00,
+            0x01.toByte(),
+            0xFF.toByte(),
+            0x7F,
+            0x80.toByte(),
+            0x10,
+            0x2A
+        )
+        val encoded = Base58.encode(input)
+        val decoded = Base58.decode(encoded)
+
+        assertArrayEquals(input, decoded)
+    }
+
+    @Test
+    fun `given string with invalid base58 character, when decode, then throws RuntimeException`() {
+        // '0', 'O', 'I', 'l' are excluded from the Base58 alphabet.
+        assertThrows(RuntimeException::class.java) {
+            Base58.decode("0OIl")
+        }
+    }
+}

app/src/test/java/com/brainwallet/tools/util/BRCompressorTest.kt

@@ -0,0 +1,58 @@
+package com.brainwallet.tools.util
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BRCompressorTest {
+
+    @Test
+    fun `given data, when gZipCompress then gZipExtract, then round trips exactly`() {
+        val data = "The quick brown fox jumps over the lazy dog".repeat(20).toByteArray(Charsets.UTF_8)
+
+        val compressed = BRCompressor.gZipCompress(data)
+        val extracted = BRCompressor.gZipExtract(compressed)
+
+        assertArrayEquals(data, extracted)
+    }
+
+    @Test
+    fun `given null data, when gZipCompress, then returns null`() {
+        assertNull(BRCompressor.gZipCompress(null))
+    }
+
+    @Test
+    fun `given null or empty compressed data, when gZipExtract, then returns null`() {
+        assertNull(BRCompressor.gZipExtract(null))
+        assertNull(BRCompressor.gZipExtract(ByteArray(0)))
+    }
+
+    @Test
+    fun `given data, when bz2Compress then bz2Extract, then round trips exactly`() {
+        val data = "The quick brown fox jumps over the lazy dog".repeat(20).toByteArray(Charsets.UTF_8)
+
+        val compressed = BRCompressor.bz2Compress(data)
+        val extracted = BRCompressor.bz2Extract(compressed)
+
+        assertArrayEquals(data, extracted)
+    }
+
+    @Test
+    fun `given null or empty compressed data, when bz2Extract, then returns null`() {
+        assertNull(BRCompressor.bz2Extract(null))
+        assertNull(BRCompressor.bz2Extract(ByteArray(0)))
+    }
+
+    @Test
+    fun `given gzip compressed bytes, when isGZIPStream, then returns true`() {
+        val compressed = BRCompressor.gZipCompress("payload".toByteArray(Charsets.UTF_8))
+        assertTrue(BRCompressor.isGZIPStream(compressed!!))
+    }
+
+    @Test
+    fun `given non gzip bytes, when isGZIPStream, then returns false`() {
+        assertFalse(BRCompressor.isGZIPStream(byteArrayOf(0x01, 0x02)))
+    }
+}

app/src/test/java/com/brainwallet/tools/util/BRDateUtilTest.kt

@@ -0,0 +1,59 @@
+package com.brainwallet.tools.util
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.util.Locale
+
+class BRDateUtilTest {
+
+    private fun minutesAgo(minutes: Long): Date = Date(System.currentTimeMillis() - minutes * 60 * 1000)
+
+    private fun hoursAgo(hours: Long): Date = Date(System.currentTimeMillis() - hours * 60 * 60 * 1000)
+
+    private fun daysAgo(days: Long): Date = Date(System.currentTimeMillis() - days * 24 * 60 * 60 * 1000)
+
+    @Test
+    fun `given date under a minute ago, then formats as zero minutes`() {
+        assertEquals("0 m", BRDateUtil.getCustomSpan(Date()))
+    }
+
+    @Test
+    fun `given date several minutes ago, then formats in minutes`() {
+        assertEquals("15 m", BRDateUtil.getCustomSpan(minutesAgo(15)))
+    }
+
+    @Test
+    fun `given date just under an hour ago, then still formats in minutes`() {
+        assertEquals("59 m", BRDateUtil.getCustomSpan(minutesAgo(59)))
+    }
+
+    @Test
+    fun `given date exactly one hour ago, then formats in hours`() {
+        assertEquals("1 h", BRDateUtil.getCustomSpan(hoursAgo(1)))
+    }
+
+    @Test
+    fun `given date just under a day ago, then still formats in hours`() {
+        assertEquals("23 h", BRDateUtil.getCustomSpan(hoursAgo(23)))
+    }
+
+    @Test
+    fun `given date exactly one day ago, then formats in days`() {
+        assertEquals("1 d", BRDateUtil.getCustomSpan(daysAgo(1)))
+    }
+
+    @Test
+    fun `given date just under a week ago, then still formats in days`() {
+        assertEquals("6 d", BRDateUtil.getCustomSpan(daysAgo(6)))
+    }
+
+    @Test
+    fun `given date a week or more ago, then formats as month and day`() {
+        val date = daysAgo(7)
+        val expected = SimpleDateFormat("MMM dd", Locale.getDefault()).format(date)
+
+        assertEquals(expected, BRDateUtil.getCustomSpan(date))
+    }
+}

app/src/test/java/com/brainwallet/tools/util/BytesUtilTest.kt

@@ -0,0 +1,59 @@
+package com.brainwallet.tools.util
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import java.io.ByteArrayInputStream
+import java.io.IOException
+import java.io.InputStream
+
+class BytesUtilTest {
+
+    @Test
+    fun `given empty stream, when readBytesFromStream, then returns empty byte array`() {
+        val result = BytesUtil.readBytesFromStream(ByteArrayInputStream(ByteArray(0)))
+        assertArrayEquals(ByteArray(0), result)
+    }
+
+    @Test
+    fun `given small stream, when readBytesFromStream, then returns all bytes`() {
+        val data = "hello world".toByteArray(Charsets.UTF_8)
+        val result = BytesUtil.readBytesFromStream(ByteArrayInputStream(data))
+        assertArrayEquals(data, result)
+    }
+
+    @Test
+    fun `given stream larger than internal buffer, when readBytesFromStream, then returns all bytes`() {
+        // Internal buffer is 1024 bytes, so exercise multiple read iterations.
+        val data = ByteArray(1024 * 3 + 17) { (it % 256).toByte() }
+        val result = BytesUtil.readBytesFromStream(ByteArrayInputStream(data))
+        assertArrayEquals(data, result)
+    }
+
+    @Test
+    fun `given stream that throws IOException, when readBytesFromStream, then returns bytes read so far without throwing`() {
+        val failingStream =
+            object : InputStream() {
+                private var callCount = 0
+
+                override fun read(): Int = throw UnsupportedOperationException("not used")
+
+                override fun read(
+                    b: ByteArray,
+                    off: Int,
+                    len: Int,
+                ): Int {
+                    callCount++
+                    if (callCount == 1) {
+                        b[off] = 42
+                        return 1
+                    }
+                    throw IOException("boom")
+                }
+            }
+
+        val result = BytesUtil.readBytesFromStream(failingStream)
+        assertEquals(1, result.size)
+        assertEquals(42.toByte(), result[0])
+    }
+}

app/src/test/java/com/brainwallet/tools/util/TypesConverterTest.kt

@@ -0,0 +1,68 @@
+package com.brainwallet.tools.util
+
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class TypesConverterTest {
+
+    @Test
+    fun `given positive int, when intToBytes then bytesToInt, then round trips exactly`() {
+        val value = 123456789
+        assertEquals(value, TypesConverter.bytesToInt(TypesConverter.intToBytes(value)))
+    }
+
+    @Test
+    fun `given negative int, when intToBytes then bytesToInt, then round trips exactly`() {
+        val value = -42
+        assertEquals(value, TypesConverter.bytesToInt(TypesConverter.intToBytes(value)))
+    }
+
+    @Test
+    fun `given zero int, when intToBytes, then returns four zero bytes`() {
+        assertArrayEquals(byteArrayOf(0, 0, 0, 0), TypesConverter.intToBytes(0))
+    }
+
+    @Test
+    fun `given positive long, when long2byteArray then byteArray2long, then round trips exactly`() {
+        val value = 9876543210123L
+        assertEquals(value, TypesConverter.byteArray2long(TypesConverter.long2byteArray(value)))
+    }
+
+    @Test
+    fun `given negative long, when long2byteArray then byteArray2long, then round trips exactly`() {
+        val value = -1L
+        assertEquals(value, TypesConverter.byteArray2long(TypesConverter.long2byteArray(value)))
+    }
+
+    @Test
+    fun `given char array, when toBytes then toChars, then values match as unsigned bytes`() {
+        val chars = charArrayOf('a', 'B', 'z', '1')
+        val bytes = TypesConverter.toBytes(chars)
+        val roundTripped = TypesConverter.toChars(bytes)
+
+        assertArrayEquals(chars, roundTripped)
+    }
+
+    @Test
+    fun `given mixed case char array, when lowerCaseCharArray, then all chars are lower case`() {
+        val chars = charArrayOf('A', 'b', 'C', '1', 'D')
+        assertArrayEquals(charArrayOf('a', 'b', 'c', '1', 'd'), TypesConverter.lowerCaseCharArray(chars))
+    }
+
+    @Test
+    fun `given char array, when charsToBytes, then matches UTF-8 encoded bytes`() {
+        val chars = "hello".toCharArray()
+        assertArrayEquals("hello".toByteArray(Charsets.UTF_8), TypesConverter.charsToBytes(chars))
+    }
+
+    @Test
+    fun `given seed bytes, when getNullTerminatedPhrase, then appends zero byte and zeroes original`() {
+        val rawSeed = byteArrayOf(1, 2, 3, 4)
+        val result = TypesConverter.getNullTerminatedPhrase(rawSeed)
+
+        assertArrayEquals(byteArrayOf(1, 2, 3, 4, 0), result)
+        // The original array must be wiped for security once copied.
+        assertArrayEquals(byteArrayOf(0, 0, 0, 0), rawSeed)
+    }
+}

app/src/test/kotlin/com/brainwallet/gameinterface/GameKoinModuleTest.kt

@@ -0,0 +1,30 @@
+package com.brainwallet.gameinterface
+
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.koin.dsl.koinApplication
+
+class GameKoinModuleTest {
+
+    @Test
+    fun `gameModule provides a GameSlot instance`() {
+        val koin = koinApplication { modules(gameModule) }.koin
+
+        val gameSlot = koin.get<GameSlot>()
+
+        assertNotNull(gameSlot)
+        assertTrue(gameSlot is GdxGameSlot)
+    }
+
+    @Test
+    fun `gameModule provides GameSlot as a singleton`() {
+        val koin = koinApplication { modules(gameModule) }.koin
+
+        val first = koin.get<GameSlot>()
+        val second = koin.get<GameSlot>()
+
+        assertSame(first, second)
+    }
+}