@novastera-oss/nitro-metamask 0.2.2 → 0.2.4

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

@@ -1,64 +1,123 @@
 package com.margelo.nitro.nitrometamask
 
+import com.margelo.nitro.core.Promise
+import com.margelo.nitro.core.NitroRuntime
 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 io.metamask.androidsdk.EthereumMethod
-import io.metamask.androidsdk.Result
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
 
 class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
-    private val ethereum by lazy { 
-        Ethereum.getInstance()
+    // Initialize Ethereum SDK with Context, DappMetadata, and SDKOptions
+    // Based on: https://github.com/MetaMask/metamask-android-sdk
+    // Using NitroRuntime for proper Nitro context access (survives reloads, no static leaks)
+    private val ethereum: Ethereum by lazy {
+        val context = NitroRuntime.applicationContext
+            ?: throw IllegalStateException("Nitro application context not available")
+        
+        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 suspend fun connect(): ConnectResult {
-        val result = ethereum.connect()
-        return when (result) {
-            is Result.Success.Item -> {
-                // result.value contains the connection result
-                // Based on SDK docs, this should contain address and chainId
-                val connectionResult = result.value
-                // Extract address and chainId from the result
-                // The SDK returns account info in result.value
-                val address = ethereum.selectedAddress
-                    ?: throw IllegalStateException("MetaMask SDK returned no address")
-                val chainId = ethereum.chainId
-                    ?: throw IllegalStateException("MetaMask SDK returned no chainId")
-                
-                ConnectResult(
-                    address = address,
-                    chainId = chainId.toString()
-                )
+    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)
+                    }
+                }
             }
-            is Result.Error -> {
-                throw Exception(result.error.message ?: "Failed to connect to MetaMask")
-            }
-            else -> {
-                throw IllegalStateException("Unexpected result type from MetaMask connect")
+            
+            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
+                    val chainId = try {
+                        if (chainIdString.startsWith("0x") || chainIdString.startsWith("0X")) {
+                            chainIdString.substring(2).toLong(16).toInt()
+                        } else {
+                            chainIdString.toLong().toInt()
+                        }
+                    } catch (e: NumberFormatException) {
+                        throw IllegalStateException("Invalid chainId format: $chainIdString")
+                    }
+                    
+                    ConnectResult(
+                        address = address,
+                        chainId = chainId
+                    )
+                }
+                is Result.Error -> {
+                    throw Exception(result.error.message ?: "Failed to connect to MetaMask")
+                }
+                else -> {
+                    throw IllegalStateException("Unexpected result type from MetaMask connect")
+                }
             }
         }
     }
 
-    override suspend fun signMessage(message: String): String {
-        val address = ethereum.selectedAddress
-            ?: throw IllegalStateException("No connected account. Call connect() first.")
-        
-        // Based on SDK documentation, personal_sign params are: [address, message]
-        // The SDK handles message encoding internally
-        val request = EthereumRequest(
-            method = EthereumMethod.PERSONAL_SIGN.value,
-            params = listOf(address, message)
-        )
-        
-        val result = ethereum.sendRequest(request)
-        return when (result) {
-            is Result.Success.Item -> {
-                result.value as? String ?: throw IllegalStateException("Invalid signature response")
-            }
-            is Result.Error -> {
-                throw Exception(result.error.message ?: "Failed to sign message")
+    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 {
+            // Use direct signMessage() method (requires connection first via connect())
+            // This is more explicit and predictable than connectSign() which forces connection
+            // Based on SDK docs: ethereum.signMessage() requires address and message
+            val address = ethereum.selectedAddress
+                ?: throw IllegalStateException("No connected account. Call connect() first.")
+            
+            // Create EthereumRequest for personal_sign
+            val request = EthereumRequest(
+                method = EthereumMethod.PERSONAL_SIGN.value,
+                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)
+                    }
+                }
             }
-            else -> {
-                throw IllegalStateException("Unexpected result type from MetaMask signMessage")
+            
+            when (result) {
+                is Result.Success.Item -> {
+                    // Extract signature from result
+                    result.value as? String
+                        ?: throw IllegalStateException("Invalid signature response format")
+                }
+                is Result.Error -> {
+                    throw Exception(result.error.message ?: "Failed to sign message")
+                }
+                else -> {
+                    throw IllegalStateException("Unexpected result type from MetaMask signMessage")
+                }
             }
         }
     }

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

@@ -6,7 +6,10 @@ import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.BaseReactPackage
 
 class NitroMetamaskPackage : BaseReactPackage() {
-    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        // No need to store ReactApplicationContext - HybridMetamaskConnector uses NitroRuntime
+        return null
+    }
 
     override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
 

package/ios/HybridMetamaskConnector.swift

@@ -1,53 +1,96 @@
-import Foundation
+import NitroModules
 import MetaMaskSDK
+import Foundation
 
-class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
+final class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
   private let sdk = MetaMaskSDK.shared
 
-  func connect() async throws -> ConnectResult {
-    // Based on MetaMask iOS SDK docs: let connectResult = await metamaskSDK.connect()
-    let connectResult = await sdk.connect()
-    
-    switch connectResult {
-    case .success(let value):
-      // After successful connection, get account info from SDK
-      guard let account = sdk.account else {
-        throw NSError(domain: "MetamaskConnector", code: -1, userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no account"])
+  func connect() -> Promise<ConnectResult> {
+    // Use Promise.async with Swift async/await for best practice in Nitro modules
+    // Reference: https://nitro.margelo.com/docs/types/promises
+    return Promise.async {
+      // Based on MetaMask iOS SDK docs: let connectResult = await metamaskSDK.connect()
+      // Reference: https://github.com/MetaMask/metamask-ios-sdk
+      let connectResult = try await self.sdk.connect()
+      
+      switch connectResult {
+      case .success:
+        // After successful connection, get account info from SDK
+        // Note: sdk.account is a String (address), not an object
+        // Reference: https://raw.githubusercontent.com/MetaMask/metamask-ios-sdk/924d91bb3e98a5383c3082d6d5ba3ddac9e1c565/README.md
+        guard let address = self.sdk.account, !address.isEmpty else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no address after connection"]
+          )
+        }
+        
+        // Parse chainId from hex string (e.g., "0x1") to number
+        // Nitro requires chainId to be a number, not a string, for type safety
+        guard
+          let chainIdHex = self.sdk.chainId,
+          !chainIdHex.isEmpty,
+          let chainIdInt = Int(chainIdHex.replacingOccurrences(of: "0x", with: ""), radix: 16)
+        else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Invalid chainId format"]
+          )
+        }
+        
+        return ConnectResult(
+          address: address,
+          chainId: Double(chainIdInt)
+        )
+        
+      case .failure(let error):
+        throw error
       }
-      return ConnectResult(address: account.address, chainId: "\(account.chainId)")
-    case .failure(let error):
-      throw error
     }
   }
 
-  func signMessage(message: String) async throws -> String {
-    // Get the connected account address
-    guard let account = sdk.account else {
-      throw NSError(domain: "MetamaskConnector", code: -1, userInfo: [NSLocalizedDescriptionKey: "No connected account. Call connect() first."])
-    }
-    
-    // Based on MetaMask iOS SDK docs, personal_sign params are: [account, message]
-    // The SDK handles message encoding internally
-    // Reference: https://github.com/MetaMask/metamask-ios-sdk
-    let params: [String] = [account.address, message]
-    
-    // Create EthereumRequest for personal_sign JSON-RPC method
-    let request = EthereumRequest(
-      method: .personalSign,
-      params: params
-    )
-    
-    // Make the request using the SDK's async request method
-    let result = try await sdk.request(request)
-    
-    // Extract signature from response
-    // The signature should be a hex-encoded string (0x-prefixed)
-    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"])
+  func signMessage(message: String) -> Promise<String> {
+    // Use Promise.async with Swift async/await for best practice in Nitro modules
+    // Reference: https://nitro.margelo.com/docs/types/promises
+    return Promise.async {
+      // Use explicit sign() method (requires connection first via connect())
+      // This is more explicit and predictable than connectAndSign() which forces connection
+      // Nitro encourages explicit object state, not convenience shortcuts
+      guard let account = self.sdk.account, !account.isEmpty else {
+        throw NSError(
+          domain: "MetamaskConnector",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "No connected account. Call connect() first."]
+        )
+      }
+      
+      // Create EthereumRequest for personal_sign
+      // Based on MetaMask iOS SDK docs: params are [account, message]
+      // Reference: https://raw.githubusercontent.com/MetaMask/metamask-ios-sdk/924d91bb3e98a5383c3082d6d5ba3ddac9e1c565/README.md
+      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
+      // The signature should be a hex-encoded string (0x-prefixed)
+      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/MetamaskConnector.nitro.d.ts

@@ -1,7 +1,7 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 export interface ConnectResult {
     address: string;
-    chainId: string;
+    chainId: number;
 }
 export interface MetamaskConnector extends HybridObject<{
     ios: 'swift';

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

@@ -33,11 +33,11 @@ namespace margelo::nitro::nitrometamask {
       static const auto clazz = javaClassStatic();
       static const auto fieldAddress = clazz->getField<jni::JString>("address");
       jni::local_ref<jni::JString> address = this->getFieldValue(fieldAddress);
-      static const auto fieldChainId = clazz->getField<jni::JString>("chainId");
-      jni::local_ref<jni::JString> chainId = this->getFieldValue(fieldChainId);
+      static const auto fieldChainId = clazz->getField<double>("chainId");
+      double chainId = this->getFieldValue(fieldChainId);
       return ConnectResult(
         address->toStdString(),
-        chainId->toStdString()
+        chainId
       );
     }
 
@@ -47,13 +47,13 @@ namespace margelo::nitro::nitrometamask {
      */
     [[maybe_unused]]
     static jni::local_ref<JConnectResult::javaobject> fromCpp(const ConnectResult& value) {
-      using JSignature = JConnectResult(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>);
+      using JSignature = JConnectResult(jni::alias_ref<jni::JString>, double);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
         jni::make_jstring(value.address),
-        jni::make_jstring(value.chainId)
+        value.chainId
       );
     }
   };

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

@@ -22,7 +22,7 @@ data class ConnectResult(
   val address: String,
   @DoNotStrip
   @Keep
-  val chainId: String
+  val chainId: Double
 ) {
   /* primary constructor */
 
@@ -34,7 +34,7 @@ data class ConnectResult(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(address: String, chainId: String): ConnectResult {
+    private fun fromCpp(address: String, chainId: Double): ConnectResult {
       return ConnectResult(address, chainId)
     }
   }

package/nitrogen/generated/ios/swift/ConnectResult.swift

@@ -19,8 +19,8 @@ public extension ConnectResult {
   /**
    * Create a new instance of `ConnectResult`.
    */
-  init(address: String, chainId: String) {
-    self.init(std.string(address), std.string(chainId))
+  init(address: String, chainId: Double) {
+    self.init(std.string(address), chainId)
   }
 
   @inline(__always)
@@ -29,7 +29,7 @@ public extension ConnectResult {
   }
   
   @inline(__always)
-  var chainId: String {
-    return String(self.__chainId)
+  var chainId: Double {
+    return self.__chainId
   }
 }

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

@@ -40,11 +40,11 @@ namespace margelo::nitro::nitrometamask {
   struct ConnectResult final {
   public:
     std::string address     SWIFT_PRIVATE;
-    std::string chainId     SWIFT_PRIVATE;
+    double chainId     SWIFT_PRIVATE;
 
   public:
     ConnectResult() = default;
-    explicit ConnectResult(std::string address, std::string chainId): address(address), chainId(chainId) {}
+    explicit ConnectResult(std::string address, double chainId): address(address), chainId(chainId) {}
 
   public:
     friend bool operator==(const ConnectResult& lhs, const ConnectResult& rhs) = default;
@@ -61,13 +61,13 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::nitrometamask::ConnectResult(
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address"))),
-        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrometamask::ConnectResult& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "address"), JSIConverter<std::string>::toJSI(runtime, arg.address));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "chainId"), JSIConverter<std::string>::toJSI(runtime, arg.chainId));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "chainId"), JSIConverter<double>::toJSI(runtime, arg.chainId));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -79,7 +79,7 @@ namespace margelo::nitro {
         return false;
       }
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address")))) return false;
-      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novastera-oss/nitro-metamask",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "nitro-metamask",
   "main": "lib/index",
   "module": "lib/index",

package/src/MetamaskConnector.nitro.ts

@@ -2,7 +2,7 @@ import type { HybridObject } from 'react-native-nitro-modules'
 
 export interface ConnectResult {
   address: string
-  chainId: string
+  chainId: number
 }
 
 export interface MetamaskConnector