@novastera-oss/nitro-metamask 0.2.2 → 0.2.3

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

@@ -1,64 +1,92 @@
 package com.margelo.nitro.nitrometamask
 
+import com.margelo.nitro.Promise
 import io.metamask.androidsdk.Ethereum
-import io.metamask.androidsdk.EthereumRequest
-import io.metamask.androidsdk.EthereumMethod
 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
 
 class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
-    private val ethereum by lazy { 
-        Ethereum.getInstance()
-    }
-
-    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()
-                )
-            }
-            is Result.Error -> {
-                throw Exception(result.error.message ?: "Failed to connect to MetaMask")
-            }
-            else -> {
-                throw IllegalStateException("Unexpected result type from MetaMask connect")
-            }
+    companion object {
+        @Volatile
+        private var reactContext: ReactApplicationContext? = null
+        
+        fun setReactContext(context: ReactApplicationContext) {
+            reactContext = context
         }
     }
-
-    override suspend fun signMessage(message: String): String {
-        val address = ethereum.selectedAddress
-            ?: throw IllegalStateException("No connected account. Call connect() first.")
+    
+    // Initialize Ethereum SDK with Context, DappMetadata, and SDKOptions
+    // Based on: https://github.com/MetaMask/metamask-android-sdk
+    // The SDK requires a Context for initialization
+    private val ethereum: Ethereum by lazy {
+        val context = reactContext?.applicationContext
+            ?: throw IllegalStateException("ReactApplicationContext not initialized. Make sure NitroMetamaskPackage is properly registered.")
         
-        // 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 dappMetadata = DappMetadata(
+            name = "Nitro MetaMask Connector",
+            url = "https://novastera.com"
         )
+        val sdkOptions = SDKOptions()
         
-        val result = ethereum.sendRequest(request)
-        return when (result) {
-            is Result.Success.Item -> {
-                result.value as? String ?: throw IllegalStateException("Invalid signature response")
+        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 suspendCoroutine
+            val result = suspendCoroutine<Result> { continuation ->
+                ethereum.connect { callbackResult ->
+                    continuation.resume(callbackResult)
+                }
             }
-            is Result.Error -> {
-                throw Exception(result.error.message ?: "Failed to sign message")
+            
+            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 chainId = ethereum.chainId
+                        ?: throw IllegalStateException("MetaMask SDK returned no chainId after connection")
+                    
+                    ConnectResult(
+                        address = address,
+                        chainId = chainId.toString()
+                    )
+                }
+                is Result.Error -> {
+                    throw Exception(result.error.message ?: "Failed to connect to MetaMask")
+                }
+                else -> {
+                    throw IllegalStateException("Unexpected result type from MetaMask connect")
+                }
             }
-            else -> {
-                throw IllegalStateException("Unexpected result type from MetaMask signMessage")
+        }
+    }
+
+    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 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)) {
+                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,11 @@ 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? {
+        // Store the ReactApplicationContext for use in HybridMetamaskConnector
+        HybridMetamaskConnector.setReactContext(reactContext)
+        return null
+    }
 
     override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider { HashMap() }
 

package/ios/HybridMetamaskConnector.swift

@@ -1,53 +1,52 @@
 import Foundation
 import MetaMaskSDK
+import NitroModules
 
 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(let value):
+        // 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"])
+        }
+        guard let chainId = self.sdk.chainId, !chainId.isEmpty else {
+          throw NSError(domain: "MetamaskConnector", code: -1, userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no chainId after connection"])
+        }
+        return ConnectResult(address: address, chainId: chainId)
+      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 the convenience method connectAndSign() which connects and signs in one call
+      // This is equivalent to Android's connectSign() method
+      // 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)
+      
+      switch connectSignResult {
+      case .success(let signature):
+        return signature
+      case .failure(let error):
+        throw error
+      }
     }
   }
 }

package/package.json

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