@novastera-oss/nitro-metamask 0.2.3 → 0.2.4

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

@@ -1,35 +1,34 @@
 package com.margelo.nitro.nitrometamask
 
-import com.margelo.nitro.Promise
+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 com.facebook.react.bridge.ReactApplicationContext
-import kotlinx.coroutines.suspendCoroutine
+import io.metamask.androidsdk.EthereumRequest
+import io.metamask.androidsdk.EthereumMethod
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
 
 class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
-    companion object {
-        @Volatile
-        private var reactContext: ReactApplicationContext? = null
-        
-        fun setReactContext(context: ReactApplicationContext) {
-            reactContext = context
-        }
-    }
-    
     // Initialize Ethereum SDK with Context, DappMetadata, and SDKOptions
     // Based on: https://github.com/MetaMask/metamask-android-sdk
-    // The SDK requires a Context for initialization
+    // Using NitroRuntime for proper Nitro context access (survives reloads, no static leaks)
     private val ethereum: Ethereum by lazy {
-        val context = reactContext?.applicationContext
-            ?: throw IllegalStateException("ReactApplicationContext not initialized. Make sure NitroMetamaskPackage is properly registered.")
+        val context = NitroRuntime.applicationContext
+            ?: throw IllegalStateException("Nitro application context not available")
         
         val dappMetadata = DappMetadata(
             name = "Nitro MetaMask Connector",
             url = "https://novastera.com"
         )
-        val sdkOptions = SDKOptions()
+        // 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)
     }
@@ -38,10 +37,13 @@ class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
         // 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 suspendCoroutine
-            val result = suspendCoroutine<Result> { continuation ->
+            // 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 ->
-                    continuation.resume(callbackResult)
+                    if (continuation.isActive) {
+                        continuation.resume(callbackResult)
+                    }
                 }
             }
             
@@ -50,12 +52,23 @@ class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
                     // After successful connection, get account info from SDK
                     val address = ethereum.selectedAddress
                         ?: throw IllegalStateException("MetaMask SDK returned no address after connection")
-                    val chainId = ethereum.chainId
+                    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.toString()
+                        chainId = chainId
                     )
                 }
                 is Result.Error -> {
@@ -72,10 +85,28 @@ class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
         // Use Promise.async with coroutines for best practice in Nitro modules
         // Reference: https://nitro.margelo.com/docs/types/promises
         return Promise.async {
-            // Use the convenience method connectSign() which connects and signs in one call
-            // Based on SDK docs: ethereum.connectSign(message) returns Result synchronously
-            // Reference: https://github.com/MetaMask/metamask-android-sdk
-            when (val result = ethereum.connectSign(message)) {
+            // 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)
+                    }
+                }
+            }
+            
+            when (result) {
                 is Result.Success.Item -> {
                     // Extract signature from result
                     result.value as? String

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

@@ -7,8 +7,7 @@ import com.facebook.react.BaseReactPackage
 
 class NitroMetamaskPackage : BaseReactPackage() {
     override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-        // Store the ReactApplicationContext for use in HybridMetamaskConnector
-        HybridMetamaskConnector.setReactContext(reactContext)
+        // No need to store ReactApplicationContext - HybridMetamaskConnector uses NitroRuntime
         return null
     }
 

package/ios/HybridMetamaskConnector.swift

@@ -1,8 +1,8 @@
-import Foundation
-import MetaMaskSDK
 import NitroModules
+import MetaMaskSDK
+import Foundation
 
-class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
+final class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
   private let sdk = MetaMaskSDK.shared
 
   func connect() -> Promise<ConnectResult> {
@@ -14,17 +14,37 @@ class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
       let connectResult = try await self.sdk.connect()
       
       switch connectResult {
-      case .success(let value):
+      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"])
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no address after connection"]
+          )
         }
-        guard let chainId = self.sdk.chainId, !chainId.isEmpty else {
-          throw NSError(domain: "MetamaskConnector", code: -1, userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no chainId 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: chainId)
+        
+        return ConnectResult(
+          address: address,
+          chainId: Double(chainIdInt)
+        )
+        
       case .failure(let error):
         throw error
       }
@@ -35,17 +55,41 @@ class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
     // 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 the convenience method connectAndSign() which connects and signs in one call
-      // This is equivalent to Android's connectSign() method
+      // 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
-      // Example: https://raw.githubusercontent.com/MetaMask/metamask-ios-sdk/924d91bb3e98a5383c3082d6d5ba3ddac9e1c565/Example/metamask-ios-sdk/SignView.swift
-      let connectSignResult = try await self.sdk.connectAndSign(message: message)
+      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)
       
-      switch connectSignResult {
-      case .success(let signature):
+      // Extract signature from response
+      // The signature should be a hex-encoded string (0x-prefixed)
+      if let signature = result as? String {
         return signature
-      case .failure(let error):
-        throw error
+      } 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.3",
+  "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