@novastera-oss/nitro-metamask 0.3.3 → 0.4.2

package/android/src/main/java/com/margelo/nitro/nitrometamask/HybridNitroMetamask.kt

@@ -5,9 +5,12 @@ import android.content.pm.PackageManager
 import android.net.Uri
 import android.util.Log
 import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.NullType
 import com.margelo.nitro.nitrometamask.HybridNitroMetamaskSpec
 import com.margelo.nitro.nitrometamask.ConnectResult
 import com.margelo.nitro.nitrometamask.MetamaskContextHolder
+import com.margelo.nitro.nitrometamask.Variant_NullType_String
+import com.margelo.nitro.nitrometamask.Variant_NullType_Long
 import io.metamask.androidsdk.Ethereum
 import io.metamask.androidsdk.Result
 import io.metamask.androidsdk.DappMetadata
@@ -22,6 +25,10 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
     @Volatile
     private var dappUrl: String? = null
     
+    // Configurable deep link scheme - if not set, will attempt auto-detection
+    @Volatile
+    private var configuredDeepLinkScheme: String? = null
+    
     // Ethereum SDK instance - lazy initialization
     @Volatile
     private var ethereumInstance: Ethereum? = null
@@ -30,6 +37,10 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
     @Volatile
     private var lastUsedUrl: String? = null
     
+    // Cache the detected deep link scheme to avoid repeated detection
+    @Volatile
+    private var cachedDeepLinkScheme: String? = null
+    
     // Get or create Ethereum SDK instance
     // Important: DappMetadata.url must be a valid HTTP/HTTPS URL (not a deep link scheme)
     // The SDK automatically detects and uses the deep link from AndroidManifest.xml
@@ -71,16 +82,165 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         }
     
     
-    override fun configure(dappUrl: String?) {
+    override fun configure(dappUrl: String?, deepLinkScheme: String?) {
         synchronized(this) {
             val urlToUse = dappUrl ?: "https://novastera.com"
+            val schemeToUse = deepLinkScheme?.takeIf { it.isNotEmpty() }
+            
+            var changed = false
             if (this.dappUrl != urlToUse) {
                 this.dappUrl = urlToUse
+                changed = true
+            }
+            if (this.configuredDeepLinkScheme != schemeToUse) {
+                this.configuredDeepLinkScheme = schemeToUse
+                // Clear cached detection when manually configured
+                cachedDeepLinkScheme = null
+                changed = true
+            }
+            
+            if (changed) {
                 // Invalidate existing instance to force recreation with new URL
                 ethereumInstance = null
                 lastUsedUrl = null
-                Log.d("NitroMetamask", "configure: Dapp URL set to $urlToUse. Deep link return is handled automatically via AndroidManifest.xml")
+                if (schemeToUse != null) {
+                    Log.d("NitroMetamask", "configure: Dapp URL set to $urlToUse, deep link scheme set to $schemeToUse")
+                } else {
+                    Log.d("NitroMetamask", "configure: Dapp URL set to $urlToUse. Deep link scheme will be auto-detected from AndroidManifest.xml")
+                }
+            }
+        }
+    }
+    
+    /**
+     * Get the deep link scheme - uses configured value first, then attempts auto-detection.
+     * Directly reads intent filters from PackageManager to find the scheme with host="mmsdk"
+     * Returns the scheme if found, null otherwise
+     * 
+     * The scheme is cached after first detection to avoid repeated queries.
+     */
+    private fun getDeepLinkScheme(context: android.content.Context): String? {
+        // Use configured scheme if available
+        configuredDeepLinkScheme?.let { return it }
+        
+        // Return cached detected scheme if available
+        cachedDeepLinkScheme?.let { return it }
+        
+        return try {
+            val packageManager = context.packageManager
+            val packageName = context.packageName
+            
+            // Query for activities that can handle VIEW intents with BROWSABLE category
+            val viewIntent = Intent(Intent.ACTION_VIEW).apply {
+                addCategory(android.content.Intent.CATEGORY_DEFAULT)
+                addCategory(android.content.Intent.CATEGORY_BROWSABLE)
+            }
+            
+            val resolveList = packageManager.queryIntentActivities(viewIntent, PackageManager.MATCH_DEFAULT_ONLY)
+            
+            // Look for activities in our package
+            for (resolveInfo in resolveList) {
+                if (resolveInfo.activityInfo?.packageName == packageName) {
+                    val filter = resolveInfo.filter ?: continue
+                    
+                    // Check if this filter has the required actions and categories
+                    if (!filter.hasAction(Intent.ACTION_VIEW)) continue
+                    if (!filter.hasCategory(android.content.Intent.CATEGORY_DEFAULT)) continue
+                    if (!filter.hasCategory(android.content.Intent.CATEGORY_BROWSABLE)) continue
+                    
+                    // Get all data schemes from this filter
+                    val schemeCount = filter.countDataSchemes()
+                    for (schemeIdx in 0 until schemeCount) {
+                        val scheme = filter.getDataScheme(schemeIdx)
+                        if (scheme != null) {
+                            // Check if this scheme has mmsdk host in any authority
+                            val authorityCount = filter.countDataAuthorities()
+                            var hasMmsdkHost = false
+                            for (authIdx in 0 until authorityCount) {
+                                val authority = filter.getDataAuthority(authIdx)
+                                if (authority != null && authority.host == "mmsdk") {
+                                    hasMmsdkHost = true
+                                    break
+                                }
+                            }
+                            
+                            if (hasMmsdkHost) {
+                                // Verify this scheme with mmsdk host resolves to our package
+                                val testUri = Uri.parse("$scheme://mmsdk")
+                                val testIntent = Intent(Intent.ACTION_VIEW, testUri).apply {
+                                    addCategory(android.content.Intent.CATEGORY_DEFAULT)
+                                    addCategory(android.content.Intent.CATEGORY_BROWSABLE)
+                                }
+                                
+                                // Verify this intent resolves to our package
+                                val testResolveList = packageManager.queryIntentActivities(testIntent, PackageManager.MATCH_DEFAULT_ONLY)
+                                for (testResolveInfo in testResolveList) {
+                                    if (testResolveInfo.activityInfo?.packageName == packageName) {
+                                        // Cache the detected scheme
+                                        cachedDeepLinkScheme = scheme
+                                        Log.d("NitroMetamask", "Detected deep link scheme: $scheme from activity ${resolveInfo.activityInfo?.name}")
+                                        return scheme
+                                    }
+                                }
+                                Log.w("NitroMetamask", "Scheme $scheme with mmsdk host found but does not resolve to package $packageName")
+                            }
+                        }
+                    }
+                }
             }
+            
+            Log.w("NitroMetamask", "Could not detect deep link scheme from AndroidManifest.xml. Searched ${resolveList.size} activities in package $packageName")
+            null
+        } catch (e: Exception) {
+            Log.w("NitroMetamask", "Error detecting deep link scheme: ${e.message}", e)
+            null
+        }
+    }
+    
+    /**
+     * Bring app back to foreground after MetaMask operations.
+     * Uses the deep link scheme detected from AndroidManifest.xml to trigger the return.
+     * This works by launching the same deep link that MetaMask app would use.
+     * 
+     * Note: Deep links work from background, but getLaunchIntentForPackage() is blocked.
+     * So we only use deep link, never fallback to launch intent.
+     */
+    private fun bringAppToForeground() {
+        try {
+            val context = MetamaskContextHolder.get()
+            // Must run on main thread - use Handler to ensure we're on main thread
+            android.os.Handler(android.os.Looper.getMainLooper()).post {
+                try {
+                    val deepLinkScheme = getDeepLinkScheme(context)
+                    if (deepLinkScheme != null) {
+                        // Use the configured or detected deep link scheme to bring app to foreground
+                        // This is the same deep link that MetaMask app would trigger
+                        // Deep links work from background (unlike getLaunchIntentForPackage)
+                        val intent = Intent(Intent.ACTION_VIEW).apply {
+                            data = Uri.parse("$deepLinkScheme://mmsdk")
+                            addFlags(
+                                Intent.FLAG_ACTIVITY_NEW_TASK or 
+                                Intent.FLAG_ACTIVITY_CLEAR_TOP or 
+                                Intent.FLAG_ACTIVITY_SINGLE_TOP
+                            )
+                            setPackage(context.packageName)
+                        }
+                        context.startActivity(intent)
+                        Log.d("NitroMetamask", "Brought app to foreground using deep link: $deepLinkScheme://mmsdk")
+                    } else {
+                        // Cannot use getLaunchIntentForPackage() - Android blocks it from background
+                        // MetaMask should handle the return via deep link automatically
+                        Log.w("NitroMetamask", "Could not determine deep link scheme. Please configure it via configure(dappUrl, deepLinkScheme) or ensure AndroidManifest.xml has the correct intent filter.")
+                    }
+                } catch (e: Exception) {
+                    // Silently fail - better than crashing
+                    // This is a defensive mechanism, not critical
+                    Log.e("NitroMetamask", "Failed to bring app to foreground: ${e.message}", e)
+                }
+            }
+        } catch (e: Exception) {
+            // Silently fail - this is a defensive mechanism, not critical
+            Log.e("NitroMetamask", "Error scheduling bringAppToForeground: ${e.message}", e)
         }
     }
 
@@ -106,15 +266,14 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
                     val chainIdString = ethereum.chainId
                         ?: throw IllegalStateException("MetaMask SDK returned no chainId after connection")
                     
-                    // Parse chainId from hex string (e.g., "0x1") or decimal string to number
-                    // Nitro requires chainId to be Double (number in TS maps to Double in Kotlin)
+                    // Parse chainId from hex string (e.g., "0x1") or decimal string to Long
+                    // chainId is an integer, so we use Long (bigint in TS maps to Long in Kotlin)
                     val chainId = try {
-                        val chainIdInt = if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
-                            chainIdString.substring(2).toLong(16).toInt()
+                        if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
+                            chainIdString.substring(2).toLong(16)
                         } else {
-                            chainIdString.toLong().toInt()
+                            chainIdString.toLong()
                         }
-                        chainIdInt.toDouble()
                     } catch (e: NumberFormatException) {
                         throw IllegalStateException("Invalid chainId format: $chainIdString")
                     }
@@ -178,22 +337,9 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
                     val signature = result.value as? String
                         ?: throw Exception("Invalid signature response format")
                     
-                    // Bring app to foreground after receiving the result
+                    // Bring app back to foreground immediately after receiving signature
                     // This must be done on the main thread
-                    val context = MetamaskContextHolder.get()
-                    android.os.Handler(android.os.Looper.getMainLooper()).post {
-                        try {
-                            val intent = Intent(Intent.ACTION_VIEW).apply {
-                                data = Uri.parse("nitrometamask://mmsdk")
-                                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                                setPackage(context.packageName)
-                            }
-                            context.startActivity(intent)
-                            Log.d("NitroMetamask", "Brought app to foreground after signing")
-                        } catch (e: Exception) {
-                            Log.w("NitroMetamask", "Failed to bring app to foreground: ${e.message}")
-                        }
-                    }
+                    bringAppToForeground()
                     
                     signature
                 }
@@ -214,148 +360,29 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
         }
     }
 
-    override fun connectSign(nonce: String, exp: Long): Promise<String> {
+    override fun connectSign(nonce: String, exp: Long): Promise<ConnectSignResult> {
         // Use Promise.async with coroutines for best practice in Nitro modules
         // Reference: https://nitro.margelo.com/docs/types/promises
         // Based on MetaMask Android SDK: ethereum.connectSign(message)
         // Reference: https://github.com/MetaMask/metamask-android-sdk
-        // This convenience method connects (if needed) and signs a JSON message
+        // The SDK's connectSign method handles connection and signing in one call
         return Promise.async {
-            // First, ensure we're connected to get address and chainId
-            val address = ethereum.selectedAddress
-            val chainIdString = ethereum.chainId
-            
-            // If not connected, connect first
-            if (address.isNullOrEmpty() || chainIdString.isNullOrEmpty()) {
-                val connectResult = suspendCancellableCoroutine<Result> { continuation ->
-                    ethereum.connect { callbackResult ->
-                        if (continuation.isActive) {
-                            continuation.resume(callbackResult)
-                        }
-                    }
-                }
-                
-                when (connectResult) {
-                    is Result.Success.Item -> {
-                        // Connection successful, get address and chainId
-                        val connectedAddress = ethereum.selectedAddress
-                            ?: throw IllegalStateException("MetaMask SDK returned no address after connection")
-                        val connectedChainId = ethereum.chainId
-                            ?: throw IllegalStateException("MetaMask SDK returned no chainId after connection")
-                        
-                        // Parse chainId to number
-                        val chainId = try {
-                            val chainIdInt = if (connectedChainId.startsWith("0x") || connectedChainId.startsWith("0X")) {
-                                connectedChainId.substring(2).toLong(16).toInt()
-                            } else {
-                                connectedChainId.toLong().toInt()
-                            }
-                            chainIdInt
-                        } catch (e: NumberFormatException) {
-                            throw IllegalStateException("Invalid chainId format: $connectedChainId")
-                        }
-                        
-                        // Construct JSON message
-                        val message = org.json.JSONObject().apply {
-                            put("address", connectedAddress)
-                            put("chainID", chainId)
-                            put("nonce", nonce)
-                            put("exp", exp)
-                        }.toString()
-                        
-                        // Sign the message using sendRequest with personal_sign (same as signMessage)
-                        // This ensures proper deep link handling for returning to the app
-                        val request = EthereumRequest(
-                            method = "personal_sign",
-                            params = listOf(connectedAddress, message)
-                        )
-                        
-                        val signResult = suspendCancellableCoroutine<Result> { signContinuation ->
-                            ethereum.sendRequest(request) { callbackResult ->
-                                if (signContinuation.isActive) {
-                                    signContinuation.resume(callbackResult)
-                                }
-                            }
-                        }
-                        
-                        when (signResult) {
-                            is Result.Success.Item -> {
-                                val signature = signResult.value as? String
-                                    ?: throw Exception("Invalid signature response format")
-                                
-                                // Bring app to foreground after receiving the result
-                                // This must be done on the main thread
-                                val context = MetamaskContextHolder.get()
-                                android.os.Handler(android.os.Looper.getMainLooper()).post {
-                                    try {
-                                        val intent = Intent(Intent.ACTION_VIEW).apply {
-                                            data = Uri.parse("nitrometamask://mmsdk")
-                                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                                            setPackage(context.packageName)
-                                        }
-                                        context.startActivity(intent)
-                                        Log.d("NitroMetamask", "Brought app to foreground after connectSign")
-                                    } catch (e: Exception) {
-                                        Log.w("NitroMetamask", "Failed to bring app to foreground: ${e.message}")
-                                    }
-                                }
-                                
-                                signature
-                            }
-                            is Result.Success.ItemMap -> {
-                                // Handle ItemMap case (shouldn't happen for personal_sign, but make exhaustive)
-                                throw IllegalStateException("Unexpected ItemMap result from MetaMask connectSign")
-                            }
-                            is Result.Success.Items -> {
-                                // Handle Items case (shouldn't happen for personal_sign, but make exhaustive)
-                                throw IllegalStateException("Unexpected Items result from MetaMask connectSign")
-                            }
-                            is Result.Error -> {
-                                val errorMessage = signResult.error?.message ?: signResult.error?.toString() ?: "MetaMask signing failed"
-                                throw Exception(errorMessage)
-                            }
-                        }
-                    }
-                    is Result.Error -> {
-                        val errorMessage = connectResult.error?.message ?: connectResult.error?.toString() ?: "MetaMask connection failed"
-                        throw Exception(errorMessage)
-                    }
-                    else -> {
-                        throw IllegalStateException("Unexpected result type from MetaMask connect")
-                    }
-                }
-            } else {
-                // Already connected, construct message and sign
-                val chainId = try {
-                    val chainIdInt = if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
-                        chainIdString.substring(2).toLong(16).toInt()
-                    } else {
-                        chainIdString.toLong().toInt()
-                    }
-                    chainIdInt
-                } catch (e: NumberFormatException) {
-                    throw IllegalStateException("Invalid chainId format: $chainIdString")
-                }
-                
-                // Construct JSON message
+            try {
+                // Construct JSON message with only nonce and exp
+                // We don't include address or chainID - just encrypt nonce and exp
                 val message = org.json.JSONObject().apply {
-                    put("address", address)
-                    put("chainID", chainId)
                     put("nonce", nonce)
                     put("exp", exp)
                 }.toString()
                 
-                // Sign the message using sendRequest with personal_sign (same as signMessage)
-                // This ensures proper deep link handling for returning to the app
-                val request = EthereumRequest(
-                    method = "personal_sign",
-                    params = listOf(address, message)
-                )
+                Log.d("NitroMetamask", "connectSign: Constructed message with nonce and exp: $message")
                 
-                // The SDK will automatically handle deep link return to the app
-                val signResult = suspendCancellableCoroutine<Result> { continuation ->
-                    Log.d("NitroMetamask", "connectSign: Sending personal_sign request")
-                    ethereum.sendRequest(request) { callbackResult ->
+                // Use the SDK's connectSign method - it will connect if needed and sign the message
+                // This is the recommended approach per MetaMask Android SDK documentation
+                // The SDK will handle bringing the app back to foreground via deep linking
+                val result = suspendCancellableCoroutine<Result> { continuation ->
+                    Log.d("NitroMetamask", "connectSign: Calling ethereum.connectSign with message")
+                    ethereum.connectSign(message) { callbackResult ->
                         Log.d("NitroMetamask", "connectSign: Received callback result: ${callbackResult.javaClass.simpleName}")
                         if (continuation.isActive) {
                             continuation.resume(callbackResult)
@@ -365,44 +392,191 @@ class HybridNitroMetamask : HybridNitroMetamaskSpec() {
                     }
                 }
                 
-                Log.d("NitroMetamask", "connectSign: Processing signResult")
-                when (signResult) {
+                Log.d("NitroMetamask", "connectSign: Processing result")
+                when (result) {
                     is Result.Success.Item -> {
-                        val signature = signResult.value as? String
+                        val signature = result.value as? String
                             ?: throw Exception("Invalid signature response format")
                         
-                        // Bring app to foreground after receiving the result
-                        // This must be done on the main thread
-                        val context = MetamaskContextHolder.get()
-                        android.os.Handler(android.os.Looper.getMainLooper()).post {
-                            try {
-                                val intent = Intent(Intent.ACTION_VIEW).apply {
-                                    data = Uri.parse("nitrometamask://mmsdk")
-                                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                                    setPackage(context.packageName)
+                        // After connectSign, the SDK state might not be immediately updated
+                        // Try to explicitly fetch the account and chainId to ensure they're available
+                        // This will trigger the SDK to update its state if needed
+                        try {
+                            val addressResult = suspendCancellableCoroutine<Result> { continuation ->
+                                ethereum.getEthAccounts { callbackResult ->
+                                    if (continuation.isActive) {
+                                        continuation.resume(callbackResult)
+                                    }
+                                }
+                            }
+                            val chainIdResult = suspendCancellableCoroutine<Result> { continuation ->
+                                ethereum.getChainId { callbackResult ->
+                                    if (continuation.isActive) {
+                                        continuation.resume(callbackResult)
+                                    }
+                                }
+                            }
+                            
+                            // getEthAccounts returns an array of addresses, we need to extract the first one
+                            // The SDK may return Result.Success.Item (JSON string) or Result.Success.Items (List)
+                            Log.d("NitroMetamask", "connectSign: addressResult type: ${addressResult.javaClass.simpleName}")
+                            val address = when (addressResult) {
+                                is Result.Success.Item -> {
+                                    val value = addressResult.value
+                                    Log.d("NitroMetamask", "connectSign: addressResult.Item value type: ${value.javaClass.simpleName}, value: $value")
+                                    // Check if it's a JSON array string that needs parsing
+                                    if (value.startsWith("[") && value.endsWith("]")) {
+                                        try {
+                                            val jsonArray = org.json.JSONArray(value)
+                                            val firstAddr = if (jsonArray.length() > 0) jsonArray.getString(0) else null
+                                            if (firstAddr != null && firstAddr.isNotEmpty()) {
+                                                ethereum.updateAccount(firstAddr)
+                                                Log.d("NitroMetamask", "connectSign: Extracted address from JSON array: $firstAddr")
+                                            }
+                                            firstAddr
+                                        } catch (e: Exception) {
+                                            Log.w("NitroMetamask", "connectSign: Failed to parse address array: ${e.message}")
+                                            // If it's not a JSON array, treat it as a single address
+                                            if (value.isNotEmpty()) {
+                                                ethereum.updateAccount(value)
+                                            }
+                                            value
+                                        }
+                                    } else {
+                                        // Single address string
+                                        if (value.isNotEmpty()) {
+                                            ethereum.updateAccount(value)
+                                        }
+                                        value
+                                    }
+                                }
+                                is Result.Success.Items -> {
+                                    // Array of addresses - get the first one
+                                    Log.d("NitroMetamask", "connectSign: addressResult.Items value size: ${addressResult.value.size}")
+                                    val firstAddr = addressResult.value.firstOrNull()
+                                    if (firstAddr != null && firstAddr.isNotEmpty()) {
+                                        ethereum.updateAccount(firstAddr)
+                                        Log.d("NitroMetamask", "connectSign: Extracted address from Items: $firstAddr")
+                                    }
+                                    firstAddr
+                                }
+                                else -> {
+                                    Log.w("NitroMetamask", "connectSign: Unexpected addressResult type: ${addressResult.javaClass.simpleName}")
+                                    null
+                                }
+                            }
+                            val chainIdStr = when (chainIdResult) {
+                                is Result.Success.Item -> {
+                                    val chainIdValue = chainIdResult.value as? String
+                                    // Update the SDK state with the chainId
+                                    if (chainIdValue != null && chainIdValue.isNotEmpty()) {
+                                        ethereum.updateChainId(chainIdValue)
+                                    }
+                                    chainIdValue
                                 }
-                                context.startActivity(intent)
-                                Log.d("NitroMetamask", "Brought app to foreground after connectSign (already connected)")
-                            } catch (e: Exception) {
-                                Log.w("NitroMetamask", "Failed to bring app to foreground: ${e.message}")
+                                else -> null
                             }
+                            
+                            // Parse chainId from hex string (e.g., "0x1") to Long
+                            val chainId = chainIdStr?.let { chainId ->
+                                try {
+                                    if (chainId.startsWith("0x") || chainId.startsWith("0X")) {
+                                        chainId.substring(2).toLong(16)
+                                    } else {
+                                        chainId.toLong()
+                                    }
+                                } catch (e: NumberFormatException) {
+                                    Log.w("NitroMetamask", "Invalid chainId format: $chainId", e)
+                                    null
+                                }
+                            }
+                            
+                            // Bring app back to foreground immediately after receiving signature
+                            // This must be done on the main thread
+                            bringAppToForeground()
+                            
+                            // Validate that we have all required values
+                            if (address == null || address.isEmpty()) {
+                                throw IllegalStateException("Failed to retrieve address after connectSign. The signature was received but the address could not be determined.")
+                            }
+                            if (chainId == null) {
+                                throw IllegalStateException("Failed to retrieve chainId after connectSign. The signature was received but the chainId could not be determined.")
+                            }
+                            
+                            Log.d("NitroMetamask", "connectSign: Returning ConnectSignResult with signature, address=$address, chainId=$chainId")
+                            
+                            // Return ConnectSignResult with signature, address, and chainId
+                            ConnectSignResult(
+                                signature = signature,
+                                address = address,
+                                chainId = chainId
+                            )
+                        } catch (e: Exception) {
+                            Log.e("NitroMetamask", "connectSign: Error fetching address/chainId: ${e.message}", e)
+                            throw e
                         }
-                        
-                        signature
                     }
                     is Result.Success.ItemMap -> {
-                        // Handle ItemMap case (shouldn't happen for personal_sign, but make exhaustive)
                         throw IllegalStateException("Unexpected ItemMap result from MetaMask connectSign")
                     }
                     is Result.Success.Items -> {
-                        // Handle Items case (shouldn't happen for personal_sign, but make exhaustive)
                         throw IllegalStateException("Unexpected Items result from MetaMask connectSign")
                     }
                     is Result.Error -> {
-                        val errorMessage = signResult.error?.message ?: signResult.error?.toString() ?: "MetaMask signing failed"
+                        val errorMessage = result.error?.message ?: result.error?.toString() ?: "MetaMask connectSign failed"
+                        Log.e("NitroMetamask", "connectSign: Error from MetaMask SDK: $errorMessage")
                         throw Exception(errorMessage)
                     }
                 }
+            } catch (e: Exception) {
+                Log.e("NitroMetamask", "connectSign: Unexpected error", e)
+                throw e
+            }
+        }
+    }
+
+    override fun getAddress(): Promise<Variant_NullType_String> {
+        return Promise.async {
+            // Read from ethereumState.value directly to get the most up-to-date value
+            // The SDK uses LiveData, so the cached properties might not be updated immediately
+            val state = ethereum.ethereumState.value
+            val address = state?.selectedAddress?.takeIf { it.isNotEmpty() } ?: ethereum.selectedAddress
+            Log.d("NitroMetamask", "getAddress: ethereumState.value?.selectedAddress = ${state?.selectedAddress}, ethereum.selectedAddress = ${ethereum.selectedAddress}, final = $address")
+            if (address == null || address.isEmpty()) {
+                Log.w("NitroMetamask", "getAddress: Address is null or empty")
+                // Use NullType.NULL singleton as per Nitro documentation: https://nitro.margelo.com/docs/types/nulls
+                Variant_NullType_String.First(NullType.NULL)
+            } else {
+                Log.d("NitroMetamask", "getAddress: Returning address: $address")
+                Variant_NullType_String.create(address)
+            }
+        }
+    }
+
+    override fun getChainId(): Promise<Variant_NullType_Long> {
+        return Promise.async {
+            // Read from ethereumState.value directly to get the most up-to-date value
+            // The SDK uses LiveData, so the cached properties might not be updated immediately
+            val state = ethereum.ethereumState.value
+            val chainIdString = state?.chainId?.takeIf { it.isNotEmpty() } ?: ethereum.chainId
+            Log.d("NitroMetamask", "getChainId: ethereumState.value?.chainId = ${state?.chainId}, ethereum.chainId = ${ethereum.chainId}, final = $chainIdString")
+            if (chainIdString == null || chainIdString.isEmpty()) {
+                Log.w("NitroMetamask", "getChainId: ChainId is null or empty")
+                // Use NullType.NULL singleton as per Nitro documentation: https://nitro.margelo.com/docs/types/nulls
+                Variant_NullType_Long.First(NullType.NULL)
+            } else {
+                try {
+                    val chainIdLong = if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
+                        chainIdString.substring(2).toLong(16)
+                    } else {
+                        chainIdString.toLong()
+                    }
+                    Log.d("NitroMetamask", "getChainId: Returning chainId: $chainIdLong")
+                    Variant_NullType_Long.create(chainIdLong)
+                } catch (e: NumberFormatException) {
+                    Log.w("NitroMetamask", "Invalid chainId format: $chainIdString", e)
+                    Variant_NullType_Long.First(NullType.NULL)
+                }
             }
         }
     }