@novastera-oss/nitro-metamask 0.2.1 → 0.2.3

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

@@ -1,46 +1,92 @@
 package com.margelo.nitro.nitrometamask
 
-import io.metamask.androidsdk.ConnectOptions
-import io.metamask.androidsdk.EthereumClient
-import io.metamask.androidsdk.Request
-import io.metamask.androidsdk.RequestResult
+import com.margelo.nitro.Promise
+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
 
 class HybridMetamaskConnector : HybridMetamaskConnectorSpec() {
-    private val client by lazy { EthereumClient.getInstance() }
-
-    override suspend fun connect(): ConnectResult {
-        val response = client.connect(ConnectOptions())
-        val address = response.accounts.firstOrNull()
-            ?: throw IllegalStateException("MetaMask SDK returned no accounts")
-
-        return ConnectResult(
-            address = address,
-            chainId = response.chainId.toString()
-        )
-    }
-
-    override suspend fun signMessage(message: String): String {
-        val address = client.getSelectedAddress() 
-            ?: throw IllegalStateException("No connected account. Call connect() first.")
+    companion object {
+        @Volatile
+        private var reactContext: ReactApplicationContext? = null
         
-        // Convert message to hex-encoded format for personal_sign
-        // personal_sign expects: personal_sign(messageHex, address)
-        // where messageHex is "0x" + hex-encoded UTF-8 bytes
-        val messageBytes = message.toByteArray(Charsets.UTF_8)
-        val messageHex = "0x" + messageBytes.joinToString("") { "%02x".format(it) }
+        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
+    private val ethereum: Ethereum by lazy {
+        val context = reactContext?.applicationContext
+            ?: throw IllegalStateException("ReactApplicationContext not initialized. Make sure NitroMetamaskPackage is properly registered.")
         
-        val request = Request(
-            method = "personal_sign",
-            params = listOf(messageHex, address)
+        val dappMetadata = DappMetadata(
+            name = "Nitro MetaMask Connector",
+            url = "https://novastera.com"
         )
+        val sdkOptions = SDKOptions()
         
-        val result = client.sendRequest(request)
-        return when (result) {
-            is RequestResult.Success -> {
-                result.data 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)
+                }
+            }
+            
+            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")
+                }
             }
-            is RequestResult.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 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,57 +1,52 @@
 import Foundation
 import MetaMaskSDK
+import NitroModules
 
 class HybridMetamaskConnector: HybridMetamaskConnectorSpec {
   private let sdk = MetaMaskSDK.shared
 
-  func connect() async throws -> ConnectResult {
-    try await withCheckedThrowingContinuation { continuation in
-      sdk.connect { response in
-        switch response {
-        case .success(let account):
-          let result = ConnectResult(address: account.address, chainId: "\(account.chainId)")
-          continuation.resume(returning: result)
-        case .failure(let error):
-          continuation.resume(throwing: error)
+  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
       }
     }
   }
 
-  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."])
-    }
-    
-    // Convert message to hex-encoded format for personal_sign
-    // personal_sign expects: personal_sign(messageHex, address)
-    // where messageHex is "0x" + hex-encoded UTF-8 bytes
-    // Reference: https://github.com/MetaMask/metamask-ios-sdk#5-connect-with-request
-    guard let messageData = message.data(using: .utf8) else {
-      throw NSError(domain: "MetamaskConnector", code: -1, userInfo: [NSLocalizedDescriptionKey: "Failed to encode message"])
-    }
-    
-    let messageHex = "0x" + messageData.map { String(format: "%02x", $0) }.joined()
-    let params: [String] = [messageHex, account.address]
-    
-    // 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.1",
+  "version": "0.2.3",
   "description": "nitro-metamask",
   "main": "lib/index",
   "module": "lib/index",