@novastera-oss/nitro-metamask 0.3.2 → 0.3.3

package/README.md

@@ -20,6 +20,86 @@ Novastera authentication with native mobile libraries
 npm install @novastera-oss/nitro-metamask react-native-nitro-modules
 ```
 
+### Android Configuration
+
+**Required:** Add a deep link intent filter to enable MetaMask to return to your app after connecting or signing.
+
+**File:** `android/app/src/main/AndroidManifest.xml`
+
+Add this inside your `MainActivity` `<activity>` tag:
+
+```xml
+<activity
+  android:name=".MainActivity"
+  android:launchMode="singleTask"
+  ...>
+  <!-- Existing intent filters -->
+  
+  <!-- Deep link intent filter for MetaMask callback -->
+  <intent-filter>
+    <action android:name="android.intent.action.VIEW" />
+    <category android:name="android.intent.category.DEFAULT" />
+    <category android:name="android.intent.category.BROWSABLE" />
+    <data android:scheme="nitrometamask" android:host="mmsdk" />
+  </intent-filter>
+</activity>
+```
+
+**Important:** 
+- Ensure `android:launchMode="singleTask"` is set on your MainActivity (recommended for deep linking)
+- This allows MetaMask to return to your app after the user approves the connection or signature
+
+### iOS Configuration
+
+For iOS, the MetaMask SDK handles deep linking automatically. No additional configuration is required in `Info.plist`.
+
+## Usage
+
+```typescript
+import { NitroMetamask } from '@novastera-oss/nitro-metamask';
+
+// Optional: Configure dapp URL (only needed if you have a website)
+// If not called, defaults to "https://novastera.com"
+// This URL is ONLY used for SDK validation - the deep link return is handled automatically
+NitroMetamask.configure('https://yourdomain.com'); // Optional
+
+// Connect to MetaMask
+const connectResult = await NitroMetamask.connect();
+console.log('Connected:', connectResult.address, 'Chain:', connectResult.chainId);
+
+// Sign a message (requires connection first)
+const signature = await NitroMetamask.signMessage('Hello from my app!');
+
+// Connect and sign in one call (convenience method)
+// This constructs a JSON message with address, chainID, nonce, and exp
+const nonce = 'random-nonce-123';
+const exp = BigInt(Date.now() + 42000); // 42 seconds from now (use BigInt for timestamp)
+const signature = await NitroMetamask.connectSign(nonce, exp);
+```
+
+### How Deep Linking Works
+
+**Important:** The MetaMask SDK requires a valid HTTP/HTTPS URL for `DappMetadata.url` validation, but this is **separate** from the deep link that returns to your app.
+
+**Two separate things:**
+1. **DappMetadata.url** (optional, configurable):
+   - Used only for SDK validation - the SDK checks it's a valid HTTP/HTTPS URL
+   - Defaults to `"https://novastera.com"` if not configured
+   - You can call `NitroMetamask.configure('https://yourdomain.com')` if you have a website
+   - If you don't have a website, the default works fine - it's just for validation
+   - [Reference](https://raw.githubusercontent.com/MetaMask/metamask-android-sdk/a448378fbedc3afbf70759ba71294f7819af2f37/metamask-android-sdk/src/main/java/io/metamask/androidsdk/DappMetadata.kt)
+
+2. **Deep Link Return** (automatic):
+   - Automatically detected from your `AndroidManifest.xml` intent filter
+   - The SDK reads `<data android:scheme="..." android:host="mmsdk" />` and uses it to return to your app
+   - This is what actually makes MetaMask return to your app after operations
+   - No configuration needed - it's handled automatically
+
+**Summary:** 
+- The `configure()` URL is just for SDK validation (you can use the default if you don't have a website)
+- The deep link return is handled automatically via your `AndroidManifest.xml`
+- Your app will return correctly as long as the manifest is configured properly
+
 ## Credits
 
 Bootstrapped with [create-nitro-module](https://github.com/patrickkabwe/create-nitro-module).

package/android/build.gradle

@@ -36,7 +36,7 @@ def getExtOrIntegerDefault(name) {
 }
 
 android {
-  namespace "com.nitrometamask"
+  namespace "com.margelo.nitro.nitrometamask"
 
   ndkVersion getExtOrDefault("ndkVersion")
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
@@ -152,6 +152,6 @@ if (isNewArchitectureEnabled()) {
   react {
     jsRootDir = file("../src/")
     libraryName = "NitroMetamask"
-    codegenJavaPackageName = "com.nitrometamask"
+    codegenJavaPackageName = "com.margelo.nitro.nitrometamask"
   }
 }

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/{nitrometamask → margelo/nitro/nitrometamask}/MetamaskContextHolder.kt

@@ -1,4 +1,4 @@
-package com.nitrometamask
+package com.margelo.nitro.nitrometamask
 
 import android.content.Context
 

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

@@ -1,4 +1,4 @@
-package com.nitrometamask
+package com.margelo.nitro.nitrometamask
 
 import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule

package/ios/HybridNitroMetamask.swift

@@ -4,6 +4,17 @@ import Foundation
 
 final class HybridNitroMetamask: HybridNitroMetamaskSpec {
   private let sdk = MetaMaskSDK.shared
+  
+  // Configurable dapp URL - stored for consistency with Android
+  // iOS SDK handles deep linking automatically via Info.plist
+  private var dappUrl: String? = nil
+  
+  func configure(dappUrl: String?) {
+    // iOS SDK handles deep linking automatically via Info.plist
+    // Store the URL for consistency with Android implementation
+    self.dappUrl = dappUrl
+    NSLog("NitroMetamask: configure: Dapp URL set to \(dappUrl ?? "default"). Deep link handled automatically via Info.plist")
+  }
 
   func connect() -> Promise<ConnectResult> {
     // Use Promise.async with Swift async/await for best practice in Nitro modules
@@ -93,4 +104,138 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
       }
     }
   }
+
+  func connectSign(nonce: String, exp: Int64) -> Promise<String> {
+    // Use Promise.async with Swift async/await for best practice in Nitro modules
+    // Reference: https://nitro.margelo.com/docs/types/promises
+    // Based on MetaMask iOS SDK: connect and sign in one call
+    // Reference: https://github.com/MetaMask/metamask-ios-sdk
+    return Promise.async {
+      // First, ensure we're connected
+      var address = self.sdk.account
+      var chainIdHex = self.sdk.chainId
+      
+      // If not connected, connect first
+      if address == nil || address?.isEmpty == true || chainIdHex == nil || chainIdHex?.isEmpty == true {
+        let connectResult = try await self.sdk.connect()
+        
+        switch connectResult {
+        case .success:
+          address = self.sdk.account
+          chainIdHex = self.sdk.chainId
+          
+          guard let account = address, !account.isEmpty else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no address after connection"]
+            )
+          }
+          
+          guard let chainId = chainIdHex, !chainId.isEmpty,
+                let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Invalid chainId format"]
+            )
+          }
+          
+          // Construct JSON message
+          let messageDict: [String: Any] = [
+            "address": account,
+            "chainID": chainIdInt,
+            "nonce": nonce,
+            "exp": exp
+          ]
+          
+          guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
+                let message = String(data: jsonData, encoding: .utf8) else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+            )
+          }
+          
+          // Create EthereumRequest for personal_sign
+          let params: [String] = [account, message]
+          let request = EthereumRequest(
+            method: .personalSign,
+            params: params
+          )
+          
+          // Make the request using the SDK's async request method
+          let result = try await self.sdk.request(request)
+          
+          // Extract signature from response
+          if let signature = result as? String {
+            return signature
+          } else if let dict = result as? [String: Any], let sig = dict["signature"] as? String ?? dict["result"] as? String {
+            return sig
+          } else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Invalid signature response format"]
+            )
+          }
+          
+        case .failure(let error):
+          throw error
+        }
+      } else {
+        // Already connected, construct message and sign
+        guard let account = address, !account.isEmpty,
+              let chainId = chainIdHex, !chainId.isEmpty,
+              let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Invalid connection state"]
+          )
+        }
+        
+        // Construct JSON message
+        let messageDict: [String: Any] = [
+          "address": account,
+          "chainID": chainIdInt,
+          "nonce": nonce,
+          "exp": Int64(exp)
+        ]
+        
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
+              let message = String(data: jsonData, encoding: .utf8) else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+          )
+        }
+        
+        // Create EthereumRequest for personal_sign
+        let params: [String] = [account, message]
+        let request = EthereumRequest(
+          method: .personalSign,
+          params: params
+        )
+        
+        // Make the request using the SDK's async request method
+        let result = try await self.sdk.request(request)
+        
+        // Extract signature from response
+        if let signature = result as? String {
+          return signature
+        } else if let dict = result as? [String: Any], let sig = dict["signature"] as? String ?? dict["result"] as? String {
+          return sig
+        } else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Invalid signature response format"]
+          )
+        }
+      }
+    }
+  }
 }

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts

@@ -7,7 +7,17 @@ export interface NitroMetamask extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
+    /**
+     * Configure the dapp URL for MetaMask SDK validation.
+     * This URL is only used for SDK validation - the deep link return is handled automatically via AndroidManifest.xml.
+     *
+     * @param dappUrl - A valid HTTP/HTTPS URL (e.g., "https://yourdomain.com").
+     *                  If not provided, defaults to "https://novastera.com".
+     *                  This is separate from the deep link scheme which is auto-detected from your manifest.
+     */
+    configure(dappUrl?: string): void;
     connect(): Promise<ConnectResult>;
     signMessage(message: string): Promise<string>;
+    connectSign(nonce: string, exp: bigint): Promise<string>;
 }
 //# sourceMappingURL=nitro-metamask.nitro.d.ts.map

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nitro-metamask.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-metamask.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACtF,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CAC9C"}
+{"version":3,"file":"nitro-metamask.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-metamask.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACtF;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC7C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACzD"}

package/nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.cpp

@@ -15,6 +15,7 @@ namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 #include <NitroModules/JPromise.hpp>
 #include "JConnectResult.hpp"
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::nitrometamask {
 
@@ -48,6 +49,10 @@ namespace margelo::nitro::nitrometamask {
   
 
   // Methods
+  void JHybridNitroMetamaskSpec::configure(const std::optional<std::string>& dappUrl) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* dappUrl */)>("configure");
+    method(_javaPart, dappUrl.has_value() ? jni::make_jstring(dappUrl.value()) : nullptr);
+  }
   std::shared_ptr<Promise<ConnectResult>> JHybridNitroMetamaskSpec::connect() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("connect");
     auto __result = method(_javaPart);
@@ -80,5 +85,21 @@ namespace margelo::nitro::nitrometamask {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<std::string>> JHybridNitroMetamaskSpec::connectSign(const std::string& nonce, int64_t exp) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* nonce */, int64_t /* exp */)>("connectSign");
+    auto __result = method(_javaPart, jni::make_jstring(nonce), exp);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.hpp

@@ -54,8 +54,10 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
+    void configure(const std::optional<std::string>& dappUrl) override;
     std::shared_ptr<Promise<ConnectResult>> connect() override;
     std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) override;
+    std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) override;
 
   private:
     friend HybridBase;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/HybridNitroMetamaskSpec.kt

@@ -46,6 +46,10 @@ abstract class HybridNitroMetamaskSpec: HybridObject() {
   
 
   // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun configure(dappUrl: String?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun connect(): Promise<ConnectResult>
@@ -53,6 +57,10 @@ abstract class HybridNitroMetamaskSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun signMessage(message: String): Promise<String>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun connectSign(nonce: String, exp: Long): Promise<String>
 
   private external fun initHybrid(): HybridData
 

package/nitrogen/generated/ios/NitroMetamask-Swift-Cxx-Bridge.hpp

@@ -26,6 +26,7 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 
 /**
@@ -34,6 +35,21 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
  */
 namespace margelo::nitro::nitrometamask::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<ConnectResult>>
   /**
    * Specialized version of `std::shared_ptr<Promise<ConnectResult>>`.
@@ -136,6 +152,15 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
   using std__weak_ptr_HybridNitroMetamaskSpec_ = std::weak_ptr<HybridNitroMetamaskSpec>;
   inline std__weak_ptr_HybridNitroMetamaskSpec_ weakify_std__shared_ptr_HybridNitroMetamaskSpec_(const std::shared_ptr<HybridNitroMetamaskSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<ConnectResult>>>
   using Result_std__shared_ptr_Promise_ConnectResult___ = Result<std::shared_ptr<Promise<ConnectResult>>>;
   inline Result_std__shared_ptr_Promise_ConnectResult___ create_Result_std__shared_ptr_Promise_ConnectResult___(const std::shared_ptr<Promise<ConnectResult>>& value) noexcept {

package/nitrogen/generated/ios/NitroMetamask-Swift-Cxx-Umbrella.hpp

@@ -20,6 +20,7 @@ namespace margelo::nitro::nitrometamask { class HybridNitroMetamaskSpec; }
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
+#include <optional>
 #include <string>
 
 // C++ helpers for Swift

package/nitrogen/generated/ios/c++/HybridNitroMetamaskSpecSwift.hpp

@@ -15,9 +15,10 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 
+#include <string>
+#include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
-#include <string>
 
 #include "NitroMetamask-Swift-Cxx-Umbrella.hpp"
 
@@ -63,6 +64,12 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
+    inline void configure(const std::optional<std::string>& dappUrl) override {
+      auto __result = _swiftPart.configure(dappUrl);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::shared_ptr<Promise<ConnectResult>> connect() override {
       auto __result = _swiftPart.connect();
       if (__result.hasError()) [[unlikely]] {
@@ -79,6 +86,14 @@ namespace margelo::nitro::nitrometamask {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) override {
+      auto __result = _swiftPart.connectSign(nonce, std::forward<decltype(exp)>(exp));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroMetamask::HybridNitroMetamaskSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridNitroMetamaskSpec.swift

@@ -14,8 +14,10 @@ public protocol HybridNitroMetamaskSpec_protocol: HybridObject {
   
 
   // Methods
+  func configure(dappUrl: String?) throws -> Void
   func connect() throws -> Promise<ConnectResult>
   func signMessage(message: String) throws -> Promise<String>
+  func connectSign(nonce: String, exp: Int64) throws -> Promise<String>
 }
 
 public extension HybridNitroMetamaskSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNitroMetamaskSpec_cxx.swift

@@ -117,6 +117,24 @@ open class HybridNitroMetamaskSpec_cxx {
   
 
   // Methods
+  @inline(__always)
+  public final func configure(dappUrl: bridge.std__optional_std__string_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.configure(dappUrl: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(dappUrl) {
+          let __unwrapped = bridge.get_std__optional_std__string_(dappUrl)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func connect() -> bridge.Result_std__shared_ptr_Promise_ConnectResult___ {
     do {
@@ -154,4 +172,23 @@ open class HybridNitroMetamaskSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func connectSign(nonce: std.string, exp: Int64) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.connectSign(nonce: String(nonce), exp: exp)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.cpp

@@ -14,8 +14,10 @@ namespace margelo::nitro::nitrometamask {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("configure", &HybridNitroMetamaskSpec::configure);
       prototype.registerHybridMethod("connect", &HybridNitroMetamaskSpec::connect);
       prototype.registerHybridMethod("signMessage", &HybridNitroMetamaskSpec::signMessage);
+      prototype.registerHybridMethod("connectSign", &HybridNitroMetamaskSpec::connectSign);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.hpp

@@ -16,9 +16,10 @@
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 
+#include <string>
+#include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
-#include <string>
 
 namespace margelo::nitro::nitrometamask {
 
@@ -51,8 +52,10 @@ namespace margelo::nitro::nitrometamask {
 
     public:
       // Methods
+      virtual void configure(const std::optional<std::string>& dappUrl) = 0;
       virtual std::shared_ptr<Promise<ConnectResult>> connect() = 0;
       virtual std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) = 0;
+      virtual std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novastera-oss/nitro-metamask",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "Novastera metamask authentication with native mobile libraries",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -12,7 +12,7 @@
     "clean": "git clean -dfX",
     "release": "semantic-release",
     "build": "npm run typecheck && bob build",
-    "codegen": "nitrogen --logLevel=\"debug\" && npm run build && node post-script.js"
+    "codegen": "nitrogen --logLevel=\"debug\" && npm run build"
   },
   "keywords": [
     "react-native",

package/react-native.config.js

@@ -11,7 +11,7 @@ module.exports = {
        * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
        */
       android: {
-        packageImportPath: 'import com.nitrometamask.NitroMetamaskPackage;',
+        packageImportPath: 'import com.margelo.nitro.nitrometamask.NitroMetamaskPackage;',
         packageInstance: 'new NitroMetamaskPackage()',
       },
     },

package/src/specs/nitro-metamask.nitro.ts

@@ -6,6 +6,16 @@ export interface ConnectResult {
 }
 
 export interface NitroMetamask extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
+  /**
+   * Configure the dapp URL for MetaMask SDK validation.
+   * This URL is only used for SDK validation - the deep link return is handled automatically via AndroidManifest.xml.
+   * 
+   * @param dappUrl - A valid HTTP/HTTPS URL (e.g., "https://yourdomain.com"). 
+   *                  If not provided, defaults to "https://novastera.com".
+   *                  This is separate from the deep link scheme which is auto-detected from your manifest.
+   */
+  configure(dappUrl?: string): void
   connect(): Promise<ConnectResult>
   signMessage(message: string): Promise<string>
+  connectSign(nonce: string, exp: bigint): Promise<string>
 }

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

@@ -1,146 +0,0 @@
-package com.nitrometamask
-
-import com.margelo.nitro.core.Promise
-import com.margelo.nitro.nitrometamask.HybridNitroMetamaskSpec
-import com.margelo.nitro.nitrometamask.ConnectResult
-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() {
-    // Initialize Ethereum SDK with Context, DappMetadata, and SDKOptions
-    // Based on: https://github.com/MetaMask/metamask-android-sdk
-    // Using MetamaskContextHolder for Context access (Nitro doesn't provide Context APIs)
-    // This pattern matches how other Nitro modules handle Context (VisionCamera, MMKV, etc.)
-    private val ethereum: Ethereum by lazy {
-        val context = MetamaskContextHolder.get()
-        
-        val dappMetadata = DappMetadata(
-            name = "Nitro MetaMask Connector",
-            url = "https://novastera.com"
-        )
-        // SDKOptions constructor requires infuraAPIKey and readonlyRPCMap parameters
-        // They can be null for basic usage without Infura or custom RPC
-        val sdkOptions = SDKOptions(
-            infuraAPIKey = null,
-            readonlyRPCMap = null
-        )
-        
-        Ethereum(context, dappMetadata, sdkOptions)
-    }
-
-    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
-            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")
-                    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)
-                }
-            }
-        }
-    }
-}