@novastera-oss/nitro-metamask 0.4.2 → 0.4.3

package/app.plugin.js

@@ -7,12 +7,12 @@ const withMetamaskAppDelegate = (config) => {
     // Check if AppDelegate is Swift
     if (modResults.language === 'swift') {
       // Check if the method already exists
-      if (modResults.contents.includes('MetaMaskSDK.shared.handleUrl')) {
+      if (modResults.contents.includes('MetaMaskSDK.sharedInstance?.handleUrl')) {
         return config;
       }
       
       // Add import if not present
-      if (!modResults.contents.includes('import MetaMaskSDK')) {
+      if (!modResults.contents.includes('import metamask_ios_sdk')) {
         // Find the last import statement and add after it
         const importRegex = /^import\s+.*$/gm;
         const imports = modResults.contents.match(importRegex);
@@ -21,14 +21,14 @@ const withMetamaskAppDelegate = (config) => {
           const lastImportIndex = modResults.contents.lastIndexOf(lastImport);
           modResults.contents = 
             modResults.contents.slice(0, lastImportIndex + lastImport.length) +
-            '\nimport MetaMaskSDK' +
+            '\nimport metamask_ios_sdk' +
             modResults.contents.slice(lastImportIndex + lastImport.length);
         } else {
           // No imports found, add at the top after the first line
           const firstLineIndex = modResults.contents.indexOf('\n');
           modResults.contents = 
             modResults.contents.slice(0, firstLineIndex + 1) +
-            'import MetaMaskSDK\n' +
+            'import metamask_ios_sdk\n' +
             modResults.contents.slice(firstLineIndex + 1);
         }
       }
@@ -47,7 +47,7 @@ const withMetamaskAppDelegate = (config) => {
     if let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
        components.host == "mmsdk" {
       // Handle MetaMask deep link return
-      MetaMaskSDK.shared.handleUrl(url)
+      MetaMaskSDK.sharedInstance?.handleUrl(url)
       return true
     }
     

package/ios/HybridNitroMetamask.swift

@@ -1,36 +1,133 @@
 import NitroModules
-import MetaMaskSDK
+import metamask_ios_sdk
 import Foundation
 
 final class HybridNitroMetamask: HybridNitroMetamaskSpec {
-  private let sdk = MetaMaskSDK.shared
+  // SDK instance - can be recreated when configure() is called
+  // Aligned with Android: SDK is recreated when configure() changes values
+  private var sdkInstance: MetaMaskSDK? = nil
+  private var lastUsedUrl: String? = nil
+  private var lastUsedScheme: String? = nil
   
-  // Configurable dapp URL - stored for consistency with Android
-  // iOS SDK handles deep linking automatically via Info.plist
+  // Get or create MetaMask SDK instance
+  // Aligned with Android: SDK is recreated when configure() changes values
+  private var sdk: MetaMaskSDK {
+    let currentUrl = dappUrl ?? "https://metamask.io"
+    let currentScheme = deepLinkScheme ?? getDefaultDappScheme()
+    
+    // Check if we need to recreate the SDK
+    if let existing = sdkInstance,
+       lastUsedUrl == currentUrl,
+       lastUsedScheme == currentScheme {
+      return existing
+    }
+    
+    // Check if there's a shared instance we should use (only if it matches our config)
+    if let existing = MetaMaskSDK.sharedInstance,
+       lastUsedUrl == currentUrl,
+       lastUsedScheme == currentScheme {
+      sdkInstance = existing
+      return existing
+    }
+    
+    // Create new SDK instance with current configuration
+    let appMetadata = AppMetadata(
+      name: "NitroMetamask",
+      url: currentUrl,
+      iconUrl: nil,
+      base64Icon: nil,
+      apiVersion: nil
+    )
+    
+    NSLog("NitroMetamask: Initializing SDK with url=\(currentUrl), scheme=\(currentScheme)")
+    
+    let newSdk = MetaMaskSDK.shared(
+      appMetadata,
+      transport: .deeplinking(dappScheme: currentScheme),
+      enableDebug: true,
+      sdkOptions: nil
+    )
+    
+    sdkInstance = newSdk
+    lastUsedUrl = currentUrl
+    lastUsedScheme = currentScheme
+    
+    return newSdk
+  }
+  
+  // Configurable dapp URL and deep link scheme
   private var dappUrl: String? = nil
+  private var deepLinkScheme: String? = nil
   
   func configure(dappUrl: String?, deepLinkScheme: String?) {
-    // iOS SDK handles deep linking automatically via Info.plist
-    // Store the URL for consistency with Android implementation
-    // deepLinkScheme is ignored on iOS as it's handled automatically
-    self.dappUrl = dappUrl
-    NSLog("NitroMetamask: configure: Dapp URL set to \(dappUrl ?? "default"). Deep link handled automatically via Info.plist")
+    let urlToUse = dappUrl ?? "https://metamask.io"
+    let schemeToUse = deepLinkScheme ?? getDefaultDappScheme()
+    
+    var changed = false
+    if self.dappUrl != urlToUse {
+      self.dappUrl = urlToUse
+      changed = true
+    }
+    if self.deepLinkScheme != schemeToUse {
+      self.deepLinkScheme = schemeToUse
+      changed = true
+    }
+    
+    if changed {
+      // Invalidate existing instance to force recreation with new values
+      // This aligns with Android behavior
+      sdkInstance = nil
+      lastUsedUrl = nil
+      lastUsedScheme = nil
+      NSLog("NitroMetamask: configure: Dapp URL=\(urlToUse), Scheme=\(schemeToUse). SDK will be recreated on next access.")
+    } else {
+      NSLog("NitroMetamask: configure: No changes, keeping existing SDK instance.")
+    }
+  }
+  
+  // Helper to get default deep link scheme from Info.plist
+  private func getDefaultDappScheme() -> String {
+    // Try to get the first URL scheme from Info.plist
+    if let urlTypes = Bundle.main.object(forInfoDictionaryKey: "CFBundleURLTypes") as? [[String: Any]],
+       let firstType = urlTypes.first,
+       let schemes = firstType["CFBundleURLSchemes"] as? [String],
+       let firstScheme = schemes.first {
+      return firstScheme
+    }
+    // Fallback to a default scheme
+    return "nitrometamask"
   }
 
   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()
+      NSLog("NitroMetamask: connect() called")
+      
+      // Check if MetaMask is installed before attempting to connect
+      if !self.sdk.isMetaMaskInstalled {
+        let errorMessage = "MetaMask is not installed. Please install MetaMask from the App Store to continue."
+        NSLog("NitroMetamask: MetaMask not installed - \(errorMessage)")
+        throw NSError(
+          domain: "MetamaskConnector",
+          code: -2,
+          userInfo: [NSLocalizedDescriptionKey: errorMessage]
+        )
+      }
+      
+      // Based on MetaMask iOS SDK docs: connect() returns Result<[String], RequestError>
       // Reference: https://github.com/MetaMask/metamask-ios-sdk
-      let connectResult = try await self.sdk.connect()
+      let connectResult = await self.sdk.connect()
+      
+      NSLog("NitroMetamask: connect() result: \(connectResult)")
       
       switch connectResult {
       case .success:
         // After successful connection, get account info from SDK
-        // Note: sdk.account is a String (address), not an object
+        // Note: sdk.account is a String (not optional), check if empty
         // Reference: https://raw.githubusercontent.com/MetaMask/metamask-ios-sdk/924d91bb3e98a5383c3082d6d5ba3ddac9e1c565/README.md
-        guard let address = self.sdk.account, !address.isEmpty else {
+        let address = self.sdk.account
+        guard !address.isEmpty else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
@@ -40,11 +137,9 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
         
         // 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 {
+        let chainIdHex = self.sdk.chainId
+        guard !chainIdHex.isEmpty,
+              let chainIdInt = Int(chainIdHex.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
@@ -58,6 +153,7 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
         )
         
       case .failure(let error):
+        NSLog("NitroMetamask: connect() failed: \(error)")
         throw error
       }
     }
@@ -70,7 +166,8 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
       // 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 {
+      let account = self.sdk.account
+      guard !account.isEmpty else {
         throw NSError(
           domain: "MetamaskConnector",
           code: -1,
@@ -88,20 +185,19 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
       )
       
       // Make the request using the SDK's async request method
-      let result = try await self.sdk.request(request)
+      // request() returns Result<String, RequestError>
+      NSLog("NitroMetamask: signMessage() calling request")
+      let result = await self.sdk.request(request)
+      
+      NSLog("NitroMetamask: signMessage() result: \(result)")
       
       // Extract signature from response
-      // The signature should be a hex-encoded string (0x-prefixed)
-      if let signature = result as? String {
+      switch result {
+      case .success(let signature):
         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):
+        NSLog("NitroMetamask: signMessage() failed: \(error)")
+        throw error
       }
     }
   }
@@ -133,12 +229,27 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
       // Use the SDK's connectAndSign convenience method - it will connect if needed and sign the message
       // This is the recommended approach per MetaMask iOS SDK documentation
       // Reference: https://github.com/MetaMask/metamask-ios-sdk
-      let connectSignResult = try await self.sdk.connectAndSign(message: message)
+      // Check if MetaMask is installed before attempting to connect and sign
+      if !self.sdk.isMetaMaskInstalled {
+        let errorMessage = "MetaMask is not installed. Please install MetaMask from the App Store to continue."
+        NSLog("NitroMetamask: MetaMask not installed - \(errorMessage)")
+        throw NSError(
+          domain: "MetamaskConnector",
+          code: -2,
+          userInfo: [NSLocalizedDescriptionKey: errorMessage]
+        )
+      }
+      
+      NSLog("NitroMetamask: connectSign() calling connectAndSign")
+      let connectSignResult = await self.sdk.connectAndSign(message: message)
+      
+      NSLog("NitroMetamask: connectSign() result: \(connectSignResult)")
       
       switch connectSignResult {
       case .success(let signature):
         // After connectSign completes, get the address and chainId from the SDK
-        guard let address = self.sdk.account, !address.isEmpty else {
+        let address = self.sdk.account
+        guard !address.isEmpty else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
@@ -146,7 +257,8 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
           )
         }
         
-        guard let chainIdHex = self.sdk.chainId, !chainIdHex.isEmpty else {
+        let chainIdHex = self.sdk.chainId
+        guard !chainIdHex.isEmpty else {
           throw NSError(
             domain: "MetamaskConnector",
             code: -1,
@@ -176,18 +288,20 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
 
   func getAddress() -> Promise<Variant_NullType_String> {
     return Promise.async {
-      if let account = self.sdk.account, !account.isEmpty {
+      let account = self.sdk.account
+      if !account.isEmpty {
         return Variant_NullType_String.second(account)
       } else {
-        return Variant_NullType_String.first(NullType())
+        return Variant_NullType_String.first(NullType.null)
       }
     }
   }
 
   func getChainId() -> Promise<Variant_NullType_Int64> {
     return Promise.async {
-      guard let chainIdHex = self.sdk.chainId, !chainIdHex.isEmpty else {
-        return Variant_NullType_Int64.first(NullType())
+      let chainIdHex = self.sdk.chainId
+      guard !chainIdHex.isEmpty else {
+        return Variant_NullType_Int64.first(NullType.null)
       }
       
       // Parse chainId from hex string (e.g., "0x1") to Int64 (bigint maps to Int64 in Swift)
@@ -195,7 +309,7 @@ final class HybridNitroMetamask: HybridNitroMetamaskSpec {
         return Variant_NullType_Int64.second(chainIdInt)
       } else {
         NSLog("NitroMetamask: Invalid chainId format: \(chainIdHex)")
-        return Variant_NullType_Int64.first(NullType())
+        return Variant_NullType_Int64.first(NullType.null)
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@novastera-oss/nitro-metamask",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Native mobile MetaMask wallet integration for React Native. Part of Novastera CRM/ERP platform ecosystem. Provides secure authentication and message signing for Web3 mobile applications.",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",