@novastera-oss/nitro-metamask 0.2.7 → 0.3.3

package/android/fix-prefab.gradle

@@ -48,4 +48,4 @@ afterEvaluate {
       }
     }
   }
-}
+}

package/android/gradle.properties

@@ -1,5 +1,5 @@
 NitroMetamask_kotlinVersion=2.1.20
 NitroMetamask_minSdkVersion=23
-NitroMetamask_targetSdkVersion=36
-NitroMetamask_compileSdkVersion=36
+NitroMetamask_targetSdkVersion=35
+NitroMetamask_compileSdkVersion=34
 NitroMetamask_ndkVersion=27.1.12297006

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

@@ -0,0 +1,409 @@
+package com.margelo.nitro.nitrometamask
+
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.util.Log
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.nitrometamask.HybridNitroMetamaskSpec
+import com.margelo.nitro.nitrometamask.ConnectResult
+import com.margelo.nitro.nitrometamask.MetamaskContextHolder
+import io.metamask.androidsdk.Ethereum
+import io.metamask.androidsdk.Result
+import io.metamask.androidsdk.DappMetadata
+import io.metamask.androidsdk.SDKOptions
+import io.metamask.androidsdk.EthereumRequest
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+class HybridNitroMetamask : HybridNitroMetamaskSpec() {
+    // Configurable dapp URL - defaults to novastera.com if not set
+    // This is only used for SDK validation - the deep link return is handled via AndroidManifest.xml
+    @Volatile
+    private var dappUrl: String? = null
+    
+    // Ethereum SDK instance - lazy initialization
+    @Volatile
+    private var ethereumInstance: Ethereum? = null
+    
+    // Track the URL used when creating the current SDK instance
+    @Volatile
+    private var lastUsedUrl: 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
+    // Reference: https://raw.githubusercontent.com/MetaMask/metamask-android-sdk/a448378fbedc3afbf70759ba71294f7819af2f37/metamask-android-sdk/src/main/java/io/metamask/androidsdk/DappMetadata.kt
+    private val ethereum: Ethereum
+        get() {
+            val currentUrl = dappUrl ?: "https://novastera.com"
+            val existing = ethereumInstance
+            val lastUrl = lastUsedUrl
+            
+            // If not initialized or URL changed, recreate SDK
+            if (existing == null || lastUrl != currentUrl) {
+                synchronized(this) {
+                    // Double-check after acquiring lock
+                    val existingAfterLock = ethereumInstance
+                    val lastUrlAfterLock = lastUsedUrl
+                    if (existingAfterLock == null || lastUrlAfterLock != currentUrl) {
+                        val context = MetamaskContextHolder.get()
+                        
+                        // DappMetadata.url must be a valid HTTP/HTTPS URL for SDK validation
+                        // This is separate from the deep link scheme which is auto-detected from AndroidManifest.xml
+                        // The deep link return to your app is handled automatically via the manifest
+                        val dappMetadata = DappMetadata(
+                            name = "Nitro MetaMask Connector",
+                            url = currentUrl
+                        )
+                        val sdkOptions = SDKOptions(
+                            infuraAPIKey = null,
+                            readonlyRPCMap = null
+                        )
+                        
+                        ethereumInstance = Ethereum(context, dappMetadata, sdkOptions)
+                        lastUsedUrl = currentUrl
+                        Log.d("NitroMetamask", "Ethereum SDK initialized with DappMetadata.url=$currentUrl. Deep link auto-detected from AndroidManifest.xml")
+                    }
+                }
+            }
+            return ethereumInstance!!
+        }
+    
+    
+    override fun configure(dappUrl: String?) {
+        synchronized(this) {
+            val urlToUse = dappUrl ?: "https://novastera.com"
+            if (this.dappUrl != urlToUse) {
+                this.dappUrl = urlToUse
+                // 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")
+            }
+        }
+    }
+
+    override fun connect(): Promise<ConnectResult> {
+        // Use Promise.async with coroutines for best practice in Nitro modules
+        // Reference: https://nitro.margelo.com/docs/types/promises
+        return Promise.async {
+            // Convert callback-based connect() to suspend function using suspendCancellableCoroutine
+            // This handles cancellation properly when JS GC disposes the promise
+            val result = suspendCancellableCoroutine<Result> { continuation ->
+                ethereum.connect { callbackResult ->
+                    if (continuation.isActive) {
+                        continuation.resume(callbackResult)
+                    }
+                }
+            }
+            
+            when (result) {
+                is Result.Success.Item -> {
+                    // After successful connection, get account info from SDK
+                    val address = ethereum.selectedAddress
+                        ?: throw IllegalStateException("MetaMask SDK returned no address after connection")
+                    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)
+                    val chainId = try {
+                        val chainIdInt = if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
+                            chainIdString.substring(2).toLong(16).toInt()
+                        } else {
+                            chainIdString.toLong().toInt()
+                        }
+                        chainIdInt.toDouble()
+                    } catch (e: NumberFormatException) {
+                        throw IllegalStateException("Invalid chainId format: $chainIdString")
+                    }
+                    
+                    ConnectResult(
+                        address = address,
+                        chainId = chainId
+                    )
+                }
+                is Result.Success.ItemMap -> {
+                    // Handle ItemMap case (shouldn't happen for connect, but make exhaustive)
+                    throw IllegalStateException("Unexpected ItemMap result from MetaMask connect")
+                }
+                is Result.Success.Items -> {
+                    // Handle Items case (shouldn't happen for connect, but make exhaustive)
+                    throw IllegalStateException("Unexpected Items result from MetaMask connect")
+                }
+                is Result.Error -> {
+                    // Result.Error contains the error directly
+                    val errorMessage = result.error?.message ?: result.error?.toString() ?: "MetaMask connection failed"
+                    throw Exception(errorMessage)
+                }
+            }
+        }
+    }
+
+    override fun signMessage(message: String): Promise<String> {
+        // Use Promise.async with coroutines for best practice in Nitro modules
+        // Reference: https://nitro.margelo.com/docs/types/promises
+        return Promise.async {
+            // Verify connection state before attempting to sign
+            // MetaMask SDK requires an active connection to sign messages
+            val address = ethereum.selectedAddress
+            if (address.isNullOrEmpty()) {
+                throw IllegalStateException("No connected account. Please call connect() first to establish a connection with MetaMask.")
+            }
+            
+            // Create EthereumRequest for personal_sign
+            // Based on MetaMask Android SDK docs: params are [account, message]
+            // Reference: https://github.com/MetaMask/metamask-android-sdk
+            // EthereumRequest constructor expects method as String
+            val request = EthereumRequest(
+                method = "personal_sign",
+                params = listOf(address, message)
+            )
+            
+            // Convert callback-based sendRequest() to suspend function
+            // The SDK will automatically handle deep link return to the app
+            val result = suspendCancellableCoroutine<Result> { continuation ->
+                ethereum.sendRequest(request) { callbackResult ->
+                    if (continuation.isActive) {
+                        continuation.resume(callbackResult)
+                    }
+                }
+            }
+            
+            when (result) {
+                is Result.Success.Item -> {
+                    // Extract signature from response
+                    // The signature should be a hex-encoded string (0x-prefixed)
+                    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)
+                            }
+                            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}")
+                        }
+                    }
+                    
+                    signature
+                }
+                is Result.Success.ItemMap -> {
+                    // Handle ItemMap case (shouldn't happen for signMessage, but make exhaustive)
+                    throw IllegalStateException("Unexpected ItemMap result from MetaMask signMessage")
+                }
+                is Result.Success.Items -> {
+                    // Handle Items case (shouldn't happen for signMessage, but make exhaustive)
+                    throw IllegalStateException("Unexpected Items result from MetaMask signMessage")
+                }
+                is Result.Error -> {
+                    // Result.Error contains the error directly
+                    val errorMessage = result.error?.message ?: result.error?.toString() ?: "MetaMask signing failed"
+                    throw Exception(errorMessage)
+                }
+            }
+        }
+    }
+
+    override fun connectSign(nonce: String, exp: Long): Promise<String> {
+        // 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
+        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
+                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)
+                )
+                
+                // 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 ->
+                        Log.d("NitroMetamask", "connectSign: Received callback result: ${callbackResult.javaClass.simpleName}")
+                        if (continuation.isActive) {
+                            continuation.resume(callbackResult)
+                        } else {
+                            Log.w("NitroMetamask", "connectSign: Continuation not active, ignoring callback")
+                        }
+                    }
+                }
+                
+                Log.d("NitroMetamask", "connectSign: Processing signResult")
+                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 (already connected)")
+                            } 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)
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -2,35 +2,14 @@ package com.margelo.nitro.nitrometamask
 
 import android.content.Context
 
-/**
- * Context holder for MetaMask SDK initialization.
- * 
- * Nitro does not provide Android Context access, so we must manage it ourselves.
- * This pattern is used by all Nitro modules that need Context (VisionCamera, MMKV, etc.)
- * 
- * The context is initialized from NitroMetamaskPackage when React Native loads the module.
- */
 object MetamaskContextHolder {
-    @Volatile
-    private var appContext: Context? = null
+    private var context: Context? = null
 
-    /**
-     * Initialize the context holder with the React Native application context.
-     * This should be called once from NitroMetamaskPackage.getModule()
-     */
-    fun initialize(context: Context) {
-        appContext = context.applicationContext
+    fun initialize(ctx: Context) {
+        context = ctx.applicationContext
     }
 
-    /**
-     * Get the application context.
-     * Throws if not initialized - this ensures we fail fast if the package wasn't loaded correctly.
-     */
     fun get(): Context {
-        return appContext
-            ?: throw IllegalStateException(
-                "MetamaskContextHolder not initialized. " +
-                "Make sure NitroMetamaskPackage is properly registered in your React Native app."
-            )
+        return context ?: throw IllegalStateException("Context not initialized")
     }
 }

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

@@ -1,20 +1,49 @@
 package com.margelo.nitro.nitrometamask
 
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
-import com.facebook.react.BaseReactPackage
+import com.margelo.nitro.nitrometamask.NitroMetamaskOnLoad
 
 class NitroMetamaskPackage : BaseReactPackage() {
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-        // Initialize MetamaskContextHolder with React Native application context
-        // This is the ONLY way to get Context in Nitro modules - Nitro doesn't provide Context APIs
-        // The context is stored in our own holder and accessed by HybridMetamaskConnector
-        MetamaskContextHolder.initialize(reactContext)
+    @Volatile
+    private var contextInitialized = false
+
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext
+    ): NativeModule? {
+        // Initialize context on first call (thread-safe)
+        if (!contextInitialized) {
+            synchronized(this) {
+                if (!contextInitialized) {
+                    MetamaskContextHolder.initialize(reactContext)
+                    contextInitialized = true
+                }
+            }
+        }
         return null
     }
 
-    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        // Register a dummy module name to ensure getModule() is called
+        // This guarantees context initialization
+        return ReactModuleInfoProvider {
+            mapOf(
+                "NitroMetamaskPackage" to ReactModuleInfo(
+                    "NitroMetamaskPackage",
+                    "NitroMetamaskPackage",
+                    false, // canOverrideExistingModule
+                    true, // needsEagerInit
+                    true, // hasConstants
+                    false, // isCxxModule
+                    true // isTurboModule
+                )
+            )
+        }
+    }
 
     companion object {
         init {

package/ios/Bridge.h

@@ -1,8 +1,8 @@
 //
 //  Bridge.h
-//  NitroMetamask
+//  nitro-metamask
 //
-//  Created by Marc Rousavy on 22.07.24.
+//  Created by DarkSorrow on 05/01/2026
 //
 
 #pragma once