@novastera-oss/nitro-metamask 0.6.3 → 0.7.2

package/android/src/main/java/io/metamask/androidsdk/KeyStorage.kt

@@ -0,0 +1,122 @@
+package io.metamask.androidsdk
+
+import android.content.Context
+import android.security.keystore.KeyGenParameterSpec
+import android.security.keystore.KeyProperties
+import android.util.Base64
+import android.util.Base64.decode
+import android.util.Base64.encodeToString
+import kotlinx.coroutines.*
+import java.security.KeyStore
+import javax.crypto.KeyGenerator
+import javax.crypto.SecretKey
+
+class KeyStorage(private val context: Context, private val logger: Logger = DefaultLogger): SecureStorage {
+
+    private val keyStoreAlias = context.packageName
+    private val androidKeyStore = "AndroidKeyStore"
+
+    private lateinit var keyStore: KeyStore
+    private lateinit var secretKey: SecretKey
+    private val coroutineScope = CoroutineScope(Dispatchers.IO)
+
+    init {
+        loadSecretKey()
+    }
+
+    private val secretKeyEntry: KeyStore.SecretKeyEntry? get() {
+            return try {
+                keyStore.getEntry(keyStoreAlias, null) as? KeyStore.SecretKeyEntry
+            } catch(e: Exception) {
+                logger.error("KeyStorage: ${e.message}")
+                null
+            }
+    }
+
+    private fun encodedValue(value: String): String {
+        val bytes = (value + keyStoreAlias).toByteArray()
+        val base64 = encodeToString(bytes, Base64.DEFAULT)
+        return base64.replace('/', '_').replace('=', '-').lowercase()
+    }
+
+    override fun loadSecretKey() {
+        keyStore = KeyStore.getInstance(androidKeyStore)
+        keyStore.load(null)
+        secretKey = secretKeyEntry?.secretKey ?: generateSecretKey()
+    }
+
+    private fun generateSecretKey(): SecretKey {
+        val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, androidKeyStore)
+        val keyGenParameterSpec = KeyGenParameterSpec.Builder(
+            keyStoreAlias,
+            KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
+        )
+            .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
+            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
+            .build()
+
+        keyGenerator.init(keyGenParameterSpec)
+        return keyGenerator.generateKey()
+    }
+
+    override fun clear(file: String) {
+        val encodedFileName = encodedValue(file)
+
+        coroutineScope.launch {
+            context.getSharedPreferences(
+                encodedFileName,
+                Context.MODE_PRIVATE)
+                .edit()
+                .clear()
+                .apply()
+        }
+    }
+
+    override fun clearValue(key: String, file: String) {
+        val encodedKey = encodedValue(key)
+        val encodedFileName = encodedValue(file)
+
+        coroutineScope.launch {
+            context.getSharedPreferences(
+                encodedFileName,
+                Context.MODE_PRIVATE)
+                .edit()
+                .putString(encodedKey, null)
+                .apply()
+        }
+    }
+
+    override fun putValue(value: String, key: String, file: String) {
+        val encodedKey = encodedValue(key)
+        val encodedFileName = encodedValue(file)
+
+        val bytes = value.toByteArray()
+        val base64 = encodeToString(bytes, Base64.DEFAULT)
+
+        coroutineScope.launch {
+            context.getSharedPreferences(
+                encodedFileName,
+                Context.MODE_PRIVATE)
+                .edit()
+                .putString(encodedKey, base64)
+                .apply()
+        }
+    }
+
+    override suspend fun getValue(key: String, file: String): String? {
+        val encodedKey = encodedValue(key)
+        val encodedFileName = encodedValue(file)
+
+        val base64 = context.getSharedPreferences(
+            encodedFileName,
+            Context.MODE_PRIVATE)
+            .getString(encodedKey, null)
+
+        if (base64 != null) {
+            val bytes = decode(base64, Base64.DEFAULT)
+            return bytes.toString(Charsets.UTF_8)
+        }
+
+        return null
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/Logger.kt

@@ -0,0 +1,18 @@
+package io.metamask.androidsdk
+
+import android.util.Log
+
+interface Logger {
+    fun log(message: String)
+    fun error(message: String)
+}
+
+object DefaultLogger : Logger {
+    override fun log(message: String) {
+        Log.d(TAG, message)
+    }
+
+    override fun error(message: String) {
+        Log.e(TAG, message)
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/Message.kt

@@ -0,0 +1,3 @@
+package io.metamask.androidsdk
+
+data class Message(val id: String, val message: String)

package/android/src/main/java/io/metamask/androidsdk/MessageType.kt

@@ -0,0 +1,11 @@
+package io.metamask.androidsdk
+
+enum class MessageType(val value: String) {
+    ID("id"),
+    TYPE("type"),
+    DATA("data"),
+    ERROR("error"),
+    READY("ready"),
+    KEYS_EXCHANGED("keys_exchanged"),
+    TERMINATE("terminate"),
+}

package/android/src/main/java/io/metamask/androidsdk/OriginatorInfo.kt

@@ -0,0 +1,12 @@
+package io.metamask.androidsdk
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class OriginatorInfo(
+    val title: String?,
+    val url: String?,
+    val icon: String?,
+    val dappId: String?,
+    val platform: String,
+    val apiVersion: String
+)

package/android/src/main/java/io/metamask/androidsdk/RequestError.kt

@@ -0,0 +1,8 @@
+package io.metamask.androidsdk
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RequestError(
+    val code: Int,
+    val message: String)

package/android/src/main/java/io/metamask/androidsdk/RequestInfo.kt

@@ -0,0 +1,9 @@
+package io.metamask.androidsdk
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class RequestInfo(
+    val type: String,
+    val originatorInfo: OriginatorInfo
+)

package/android/src/main/java/io/metamask/androidsdk/Result.kt

@@ -0,0 +1,11 @@
+package io.metamask.androidsdk
+
+sealed class Result {
+    sealed class Success: Result() {
+        data class Item(val value: String): Success()
+        data class Items(val value: List<String>): Success()
+        data class ItemMap(val value: Map<String, Any?>): Success()
+    }
+
+    data class Error(val error: RequestError): Result()
+}

package/android/src/main/java/io/metamask/androidsdk/RpcRequest.kt

@@ -0,0 +1,7 @@
+package io.metamask.androidsdk
+
+sealed class RpcRequest {
+    abstract val id: String
+    abstract val method: String
+    abstract val params: Any?
+}

package/android/src/main/java/io/metamask/androidsdk/SDKInfo.kt

@@ -0,0 +1,6 @@
+package io.metamask.androidsdk
+
+object SDKInfo {
+    const val VERSION = "0.6.6"
+    const val PLATFORM = "android"
+}

package/android/src/main/java/io/metamask/androidsdk/SDKOptions.kt

@@ -0,0 +1,6 @@
+package io.metamask.androidsdk
+
+data class SDKOptions(
+    val infuraAPIKey: String?,
+    var readonlyRPCMap: Map<String, String>?
+)

package/android/src/main/java/io/metamask/androidsdk/SecureStorage.kt

@@ -0,0 +1,9 @@
+package io.metamask.androidsdk
+
+interface SecureStorage {
+    fun loadSecretKey()
+    fun clear(file: String)
+    fun clearValue(key: String, file: String)
+    fun putValue(value: String, key: String, file: String)
+    suspend fun getValue(key: String, file: String): String?
+}

package/android/src/main/java/io/metamask/androidsdk/SessionConfig.kt

@@ -0,0 +1,10 @@
+package io.metamask.androidsdk
+
+data class SessionConfig(
+    val sessionId: String,
+    val expiryDate: Long
+) {
+    fun isValid(): Boolean {
+        return System.currentTimeMillis() < expiryDate
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/SessionManager.kt

@@ -0,0 +1,92 @@
+package io.metamask.androidsdk
+
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import kotlinx.coroutines.*
+import java.lang.reflect.Type
+
+class SessionManager(
+    private val store: SecureStorage,
+    var sessionDuration: Long = 30 * 24 * 3600, // 30 days default
+    private val logger: Logger = DefaultLogger
+) {
+    var sessionId: String = ""
+
+    var onInitialized: () -> Unit = {}
+    private val coroutineScope = CoroutineScope(Dispatchers.IO)
+
+    companion object {
+        const val SESSION_CONFIG_KEY = "SESSION_CONFIG_KEY"
+        const val SESSION_CONFIG_FILE = "SESSION_CONFIG_FILE"
+        const val SESSION_ACCOUNT_KEY = "SESSION_ACCOUNT_KEY"
+        const val SESSION_CHAIN_ID_KEY = "SESSION_CHAIN_ID_KEY"
+        const val DEFAULT_SESSION_DURATION: Long = 30 * 24 * 3600 // 30 days default
+    }    
+
+    init {
+        coroutineScope.launch {
+            val id = getSessionConfig().sessionId
+            sessionId = id
+            onInitialized()
+        }
+    }
+
+    fun updateSessionDuration(duration: Long) {
+        logger.log("SessionManager:: Session duration extended by: ${duration/3600.0/24.0} days")
+        coroutineScope.launch {
+            sessionDuration = duration
+            val sessionId = getSessionConfig().sessionId
+            val expiryDate = System.currentTimeMillis() + sessionDuration * 1000
+            val sessionConfig = SessionConfig(sessionId, expiryDate)
+            saveSessionConfig(sessionConfig)
+        }
+    }
+
+    suspend fun getSessionConfig(reset: Boolean = false): SessionConfig {
+        if (reset) {
+            store.clearValue(SESSION_CONFIG_KEY, SESSION_CONFIG_FILE)
+            return makeNewSessionConfig()
+        }
+
+        val sessionConfigJson = store.getValue(SESSION_CONFIG_KEY, SESSION_CONFIG_FILE)
+            ?: return makeNewSessionConfig()
+
+        val type: Type = object : TypeToken<SessionConfig>() {}.type
+
+        return try {
+            val sessionConfig: SessionConfig = Gson().fromJson(sessionConfigJson, type)
+
+            if (sessionConfig.isValid()) {
+                SessionConfig(sessionConfig.sessionId, System.currentTimeMillis() + sessionDuration * 1000)
+            } else {
+                makeNewSessionConfig()
+            }
+        } catch(e: Exception) {
+            logger.error("SessionManager: ${e.message}")
+            makeNewSessionConfig()
+        }
+    }
+
+    fun saveSessionConfig(sessionConfig: SessionConfig) {
+        val sessionConfigJson = Gson().toJson(sessionConfig)
+        store.putValue(sessionConfigJson, SESSION_CONFIG_KEY, SESSION_CONFIG_FILE)
+    }
+
+    fun clearSession(onComplete: () -> Unit) {
+        coroutineScope.launch {
+            store.clearValue(SESSION_CONFIG_KEY, SESSION_CONFIG_FILE)
+            makeNewSessionConfig()
+            sessionId = getSessionConfig().sessionId
+            onComplete()
+        }
+    }
+
+    fun makeNewSessionConfig(): SessionConfig {
+        store.clear(SESSION_CONFIG_FILE)
+        val sessionId = TimeStampGenerator.timestamp()
+        val expiryDate = System.currentTimeMillis() + sessionDuration * 1000
+        val sessionConfig = SessionConfig(sessionId, expiryDate)
+        saveSessionConfig(sessionConfig)
+        return sessionConfig
+    }
+}

package/android/src/main/java/io/metamask/androidsdk/SubmittedRequest.kt

@@ -0,0 +1,8 @@
+package io.metamask.androidsdk
+
+data class
+
+SubmittedRequest(
+    val request: RpcRequest,
+    val callback: (Result) -> Unit
+)

package/android/src/main/java/io/metamask/androidsdk/TimeStampGenerator.kt

@@ -0,0 +1,7 @@
+package io.metamask.androidsdk
+
+object TimeStampGenerator {
+    fun timestamp(): String {
+        return System.currentTimeMillis().toString()
+    }
+}

package/android/src/test/java/com/margelo/nitro/nitrometamask/CancellationStateMachineTest.kt

@@ -0,0 +1,128 @@
+package com.margelo.nitro.nitrometamask
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Unit tests for the cancellation state machine in HybridNitroMetamask.
+ *
+ * Since `checkAndCancelPendingOperation` and `pendingOperationCancellation` are private,
+ * we test the observable behavior through a minimal test double that replicates the
+ * exact state machine logic from the production class.
+ *
+ * Validates: Requirements 11.5, 11.6
+ */
+class CancellationStateMachineTest {
+
+    /**
+     * Minimal replica of the cancellation state machine extracted from HybridNitroMetamask.
+     * This mirrors the production logic exactly so the tests validate the real algorithm.
+     */
+    private class CancellationStateMachine {
+        @Volatile
+        var pendingOperationCancellation: (() -> Unit)? = null
+
+        fun checkAndCancelPendingOperation() {
+            val cancel = pendingOperationCancellation
+            if (cancel != null) {
+                synchronized(this) {
+                    if (pendingOperationCancellation != null) {
+                        pendingOperationCancellation = null
+                        cancel()
+                    }
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `setting then clearing handler leaves state null`() {
+        val sm = CancellationStateMachine()
+
+        sm.pendingOperationCancellation = { /* no-op */ }
+        assertNotNull("Handler should be set", sm.pendingOperationCancellation)
+
+        sm.pendingOperationCancellation = null
+        assertNull("Handler should be null after explicit clear", sm.pendingOperationCancellation)
+    }
+
+    @Test
+    fun `checkAndCancelPendingOperation with no pending operation is a no-op`() {
+        val sm = CancellationStateMachine()
+        val callCount = AtomicInteger(0)
+
+        // No handler set — should not throw or invoke anything
+        sm.checkAndCancelPendingOperation()
+
+        assertEquals("No handler should have been called", 0, callCount.get())
+        assertNull("Handler should remain null", sm.pendingOperationCancellation)
+    }
+
+    @Test
+    fun `checkAndCancelPendingOperation invokes handler and clears state`() {
+        val sm = CancellationStateMachine()
+        val callCount = AtomicInteger(0)
+
+        sm.pendingOperationCancellation = { callCount.incrementAndGet() }
+        sm.checkAndCancelPendingOperation()
+
+        assertEquals("Handler should have been called exactly once", 1, callCount.get())
+        assertNull("Handler should be null after cancellation fires", sm.pendingOperationCancellation)
+    }
+
+    @Test
+    fun `checkAndCancelPendingOperation is idempotent — second call is a no-op`() {
+        val sm = CancellationStateMachine()
+        val callCount = AtomicInteger(0)
+
+        sm.pendingOperationCancellation = { callCount.incrementAndGet() }
+
+        sm.checkAndCancelPendingOperation()
+        sm.checkAndCancelPendingOperation() // second call — handler already cleared
+
+        assertEquals("Handler should have been called exactly once", 1, callCount.get())
+        assertNull("Handler should remain null after second call", sm.pendingOperationCancellation)
+    }
+
+    @Test
+    fun `SDK callback clearing handler prevents cancellation from firing`() {
+        // Simulates the race-free path: SDK callback arrives first, clears the handler,
+        // then the foreground event fires but finds nothing to cancel.
+        val sm = CancellationStateMachine()
+        val cancelCallCount = AtomicInteger(0)
+
+        sm.pendingOperationCancellation = { cancelCallCount.incrementAndGet() }
+
+        // SDK callback arrives — clears handler (success path)
+        sm.pendingOperationCancellation = null
+
+        // Foreground event fires — should be a no-op
+        sm.checkAndCancelPendingOperation()
+
+        assertEquals("Cancellation should not have fired after SDK cleared the handler", 0, cancelCallCount.get())
+    }
+
+    @Test
+    fun `state is clean after cancellation so subsequent operations work correctly`() {
+        val sm = CancellationStateMachine()
+        val firstCallCount = AtomicInteger(0)
+        val secondCallCount = AtomicInteger(0)
+
+        // First operation
+        sm.pendingOperationCancellation = { firstCallCount.incrementAndGet() }
+        sm.checkAndCancelPendingOperation()
+
+        assertEquals("First handler called once", 1, firstCallCount.get())
+        assertNull("State clean after first cancellation", sm.pendingOperationCancellation)
+
+        // Second operation — state should be clean, new handler works correctly
+        sm.pendingOperationCancellation = { secondCallCount.incrementAndGet() }
+        sm.checkAndCancelPendingOperation()
+
+        assertEquals("Second handler called once", 1, secondCallCount.get())
+        assertNull("State clean after second cancellation", sm.pendingOperationCancellation)
+    }
+}

package/android/src/test/java/com/margelo/nitro/nitrometamask/ChainIdParsingTest.kt

@@ -0,0 +1,65 @@
+package com.margelo.nitro.nitrometamask
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Unit tests for chainId hex string parsing logic.
+ *
+ * Mirrors the parsing logic in HybridNitroMetamask.kt so the tests validate
+ * the real algorithm without requiring Android SDK dependencies.
+ *
+ * Validates: Requirements 2.6, 5.5
+ *
+ * Property 1: ChainId hex parsing round-trip
+ * For any valid hex string of the form "0x{N}", parsing it to a Long should
+ * produce the correct integer value.
+ */
+class ChainIdParsingTest {
+
+    /**
+     * Mirrors the chainId parsing logic from HybridNitroMetamask.kt.
+     */
+    fun parseChainId(chainIdString: String): Long {
+        return if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
+            chainIdString.substring(2).toLong(16)
+        } else {
+            chainIdString.toLong()
+        }
+    }
+
+    @Test
+    fun `parse Ethereum mainnet chainId 0x1 returns 1`() {
+        assertEquals(1L, parseChainId("0x1"))
+    }
+
+    @Test
+    fun `parse Polygon chainId 0x89 returns 137`() {
+        assertEquals(137L, parseChainId("0x89"))
+    }
+
+    @Test
+    fun `parse chainId 0xa returns 10`() {
+        assertEquals(10L, parseChainId("0xa"))
+    }
+
+    @Test
+    fun `parse decimal fallback string 1 returns 1`() {
+        assertEquals(1L, parseChainId("1"))
+    }
+
+    @Test
+    fun `parse uppercase 0X prefix is handled correctly`() {
+        assertEquals(1L, parseChainId("0X1"))
+    }
+
+    @Test
+    fun `parse larger hex chainId 0x38 returns 56 (BSC)`() {
+        assertEquals(56L, parseChainId("0x38"))
+    }
+
+    @Test
+    fun `parse hex chainId with multiple digits 0x2105 returns 8453 (Base)`() {
+        assertEquals(8453L, parseChainId("0x2105"))
+    }
+}