@novastera-oss/nitro-metamask 0.2.7 → 0.3.3

package/ios/HybridNitroMetamask.swift

@@ -0,0 +1,241 @@
+import NitroModules
+import MetaMaskSDK
+import Foundation
+
+final class HybridNitroMetamask: HybridNitroMetamaskSpec {
+  private let sdk = MetaMaskSDK.shared
+  
+  // Configurable dapp URL - stored for consistency with Android
+  // iOS SDK handles deep linking automatically via Info.plist
+  private var dappUrl: String? = nil
+  
+  func configure(dappUrl: String?) {
+    // iOS SDK handles deep linking automatically via Info.plist
+    // Store the URL for consistency with Android implementation
+    self.dappUrl = dappUrl
+    NSLog("NitroMetamask: configure: Dapp URL set to \(dappUrl ?? "default"). Deep link handled automatically via Info.plist")
+  }
+
+  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
+      }
+    }
+  }
+
+  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"]
+        )
+      }
+    }
+  }
+
+  func connectSign(nonce: String, exp: Int64) -> Promise<String> {
+    // Use Promise.async with Swift async/await for best practice in Nitro modules
+    // Reference: https://nitro.margelo.com/docs/types/promises
+    // Based on MetaMask iOS SDK: connect and sign in one call
+    // Reference: https://github.com/MetaMask/metamask-ios-sdk
+    return Promise.async {
+      // First, ensure we're connected
+      var address = self.sdk.account
+      var chainIdHex = self.sdk.chainId
+      
+      // If not connected, connect first
+      if address == nil || address?.isEmpty == true || chainIdHex == nil || chainIdHex?.isEmpty == true {
+        let connectResult = try await self.sdk.connect()
+        
+        switch connectResult {
+        case .success:
+          address = self.sdk.account
+          chainIdHex = self.sdk.chainId
+          
+          guard let account = address, !account.isEmpty else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "MetaMask SDK returned no address after connection"]
+            )
+          }
+          
+          guard let chainId = chainIdHex, !chainId.isEmpty,
+                let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Invalid chainId format"]
+            )
+          }
+          
+          // Construct JSON message
+          let messageDict: [String: Any] = [
+            "address": account,
+            "chainID": chainIdInt,
+            "nonce": nonce,
+            "exp": exp
+          ]
+          
+          guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
+                let message = String(data: jsonData, encoding: .utf8) else {
+            throw NSError(
+              domain: "MetamaskConnector",
+              code: -1,
+              userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+            )
+          }
+          
+          // Create EthereumRequest for personal_sign
+          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
+          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"]
+            )
+          }
+          
+        case .failure(let error):
+          throw error
+        }
+      } else {
+        // Already connected, construct message and sign
+        guard let account = address, !account.isEmpty,
+              let chainId = chainIdHex, !chainId.isEmpty,
+              let chainIdInt = Int(chainId.replacingOccurrences(of: "0x", with: ""), radix: 16) else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Invalid connection state"]
+          )
+        }
+        
+        // Construct JSON message
+        let messageDict: [String: Any] = [
+          "address": account,
+          "chainID": chainIdInt,
+          "nonce": nonce,
+          "exp": Int64(exp)
+        ]
+        
+        guard let jsonData = try? JSONSerialization.data(withJSONObject: messageDict),
+              let message = String(data: jsonData, encoding: .utf8) else {
+          throw NSError(
+            domain: "MetamaskConnector",
+            code: -1,
+            userInfo: [NSLocalizedDescriptionKey: "Failed to create JSON message"]
+          )
+        }
+        
+        // Create EthereumRequest for personal_sign
+        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
+        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/commonjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NitroMetamask = void 0;
+var _reactNativeNitroModules = require("react-native-nitro-modules");
+/**
+ * NitroMetamask - MetaMask connector for React Native
+ * 
+ * @example
+ * ```ts
+ * import { NitroMetamask } from '@novastera-oss/nitro-metamask'
+ * 
+ * const result = await NitroMetamask.connect()
+ * const signature = await NitroMetamask.signMessage('Hello')
+ * ```
+ */
+const NitroMetamask = exports.NitroMetamask = _reactNativeNitroModules.NitroModules.createHybridObject('NitroMetamask');
+//# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_reactNativeNitroModules","require","NitroMetamask","exports","NitroModules","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,aAAa,GAAAC,OAAA,CAAAD,aAAA,GAAGE,qCAAY,CAACC,kBAAkB,CAAoB,eAAe,CAAC","ignoreList":[]}

package/lib/commonjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/lib/commonjs/specs/nitro-metamask.nitro.js

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=nitro-metamask.nitro.js.map

package/lib/commonjs/specs/nitro-metamask.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/nitro-metamask.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+/**
+ * NitroMetamask - MetaMask connector for React Native
+ * 
+ * @example
+ * ```ts
+ * import { NitroMetamask } from '@novastera-oss/nitro-metamask'
+ * 
+ * const result = await NitroMetamask.connect()
+ * const signature = await NitroMetamask.signMessage('Hello')
+ * ```
+ */
+export const NitroMetamask = NitroModules.createHybridObject('NitroMetamask');
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","NitroMetamask","createHybridObject"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMC,aAAa,GAAGD,YAAY,CAACE,kBAAkB,CAAoB,eAAe,CAAC","ignoreList":[]}

package/lib/module/specs/nitro-metamask.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=nitro-metamask.nitro.js.map

package/lib/module/specs/nitro-metamask.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../../src","sources":["specs/nitro-metamask.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,15 @@
+import type { NitroMetamask as NitroMetamaskSpec, ConnectResult } from './specs/nitro-metamask.nitro';
+/**
+ * NitroMetamask - MetaMask connector for React Native
+ *
+ * @example
+ * ```ts
+ * import { NitroMetamask } from '@novastera-oss/nitro-metamask'
+ *
+ * const result = await NitroMetamask.connect()
+ * const signature = await NitroMetamask.signMessage('Hello')
+ * ```
+ */
+export declare const NitroMetamask: NitroMetamaskSpec;
+export type { ConnectResult, NitroMetamaskSpec };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAA;AAErG;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,mBAAsE,CAAA;AAEhG,YAAY,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAA"}

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts

@@ -0,0 +1,23 @@
+import { type HybridObject } from 'react-native-nitro-modules';
+export interface ConnectResult {
+    address: string;
+    chainId: number;
+}
+export interface NitroMetamask extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Configure the dapp URL for MetaMask SDK validation.
+     * This URL is only used for SDK validation - the deep link return is handled automatically via AndroidManifest.xml.
+     *
+     * @param dappUrl - A valid HTTP/HTTPS URL (e.g., "https://yourdomain.com").
+     *                  If not provided, defaults to "https://novastera.com".
+     *                  This is separate from the deep link scheme which is auto-detected from your manifest.
+     */
+    configure(dappUrl?: string): void;
+    connect(): Promise<ConnectResult>;
+    signMessage(message: string): Promise<string>;
+    connectSign(nonce: string, exp: bigint): Promise<string>;
+}
+//# sourceMappingURL=nitro-metamask.nitro.d.ts.map

package/lib/typescript/src/specs/nitro-metamask.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nitro-metamask.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/nitro-metamask.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAE9D,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,aAAc,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACtF;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,OAAO,IAAI,OAAO,CAAC,aAAa,CAAC,CAAA;IACjC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAC7C,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CACzD"}

package/nitro.json

@@ -13,12 +13,12 @@
     "androidCxxLibName": "NitroMetamask"
   },
   "autolinking": {
-    "MetamaskConnector": {
-      "swift": "HybridMetamaskConnector",
-      "kotlin": "HybridMetamaskConnector"
+    "NitroMetamask": {
+      "swift": "HybridNitroMetamask",
+      "kotlin": "HybridNitroMetamask"
     }
   },
   "ignorePaths": [
     "**/node_modules"
   ]
-}
+}

package/nitrogen/generated/android/NitroMetamask+autolinking.cmake

@@ -33,9 +33,9 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/NitroMetamaskOnLoad.cpp
   # Shared Nitrogen C++ sources
-  ../nitrogen/generated/shared/c++/HybridMetamaskConnectorSpec.cpp
+  ../nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.cpp
   # Android-specific Nitrogen C++ sources
-  ../nitrogen/generated/android/c++/JHybridMetamaskConnectorSpec.cpp
+  ../nitrogen/generated/android/c++/JHybridNitroMetamaskSpec.cpp
 )
 
 # From node_modules/react-native/ReactAndroid/cmake-utils/folly-flags.cmake

package/nitrogen/generated/android/NitroMetamaskOnLoad.cpp

@@ -15,7 +15,7 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
-#include "JHybridMetamaskConnectorSpec.hpp"
+#include "JHybridNitroMetamaskSpec.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
 namespace margelo::nitro::nitrometamask {
@@ -27,13 +27,13 @@ int initialize(JavaVM* vm) {
 
   return facebook::jni::initialize(vm, [] {
     // Register native JNI methods
-    margelo::nitro::nitrometamask::JHybridMetamaskConnectorSpec::registerNatives();
+    margelo::nitro::nitrometamask::JHybridNitroMetamaskSpec::registerNatives();
 
     // Register Nitro Hybrid Objects
     HybridObjectRegistry::registerHybridObjectConstructor(
-      "MetamaskConnector",
+      "NitroMetamask",
       []() -> std::shared_ptr<HybridObject> {
-        static DefaultConstructableObject<JHybridMetamaskConnectorSpec::javaobject> object("com/margelo/nitro/nitrometamask/HybridMetamaskConnector");
+        static DefaultConstructableObject<JHybridNitroMetamaskSpec::javaobject> object("com/margelo/nitro/nitrometamask/HybridNitroMetamask");
         auto instance = object.create();
         return instance->cthis()->shared();
       }

package/nitrogen/generated/android/c++/{JHybridMetamaskConnectorSpec.cpp → JHybridNitroMetamaskSpec.cpp}

@@ -1,11 +1,11 @@
 ///
-/// JHybridMetamaskConnectorSpec.cpp
+/// JHybridNitroMetamaskSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
-#include "JHybridMetamaskConnectorSpec.hpp"
+#include "JHybridNitroMetamaskSpec.hpp"
 
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
@@ -15,30 +15,31 @@ namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 #include <NitroModules/JPromise.hpp>
 #include "JConnectResult.hpp"
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::nitrometamask {
 
-  jni::local_ref<JHybridMetamaskConnectorSpec::jhybriddata> JHybridMetamaskConnectorSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+  jni::local_ref<JHybridNitroMetamaskSpec::jhybriddata> JHybridNitroMetamaskSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
     return makeCxxInstance(jThis);
   }
 
-  void JHybridMetamaskConnectorSpec::registerNatives() {
+  void JHybridNitroMetamaskSpec::registerNatives() {
     registerHybrid({
-      makeNativeMethod("initHybrid", JHybridMetamaskConnectorSpec::initHybrid),
+      makeNativeMethod("initHybrid", JHybridNitroMetamaskSpec::initHybrid),
     });
   }
 
-  size_t JHybridMetamaskConnectorSpec::getExternalMemorySize() noexcept {
+  size_t JHybridNitroMetamaskSpec::getExternalMemorySize() noexcept {
     static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
     return method(_javaPart);
   }
 
-  void JHybridMetamaskConnectorSpec::dispose() noexcept {
+  void JHybridNitroMetamaskSpec::dispose() noexcept {
     static const auto method = javaClassStatic()->getMethod<void()>("dispose");
     method(_javaPart);
   }
 
-  std::string JHybridMetamaskConnectorSpec::toString() {
+  std::string JHybridNitroMetamaskSpec::toString() {
     static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
     auto javaString = method(_javaPart);
     return javaString->toStdString();
@@ -48,7 +49,11 @@ namespace margelo::nitro::nitrometamask {
   
 
   // Methods
-  std::shared_ptr<Promise<ConnectResult>> JHybridMetamaskConnectorSpec::connect() {
+  void JHybridNitroMetamaskSpec::configure(const std::optional<std::string>& dappUrl) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* dappUrl */)>("configure");
+    method(_javaPart, dappUrl.has_value() ? jni::make_jstring(dappUrl.value()) : nullptr);
+  }
+  std::shared_ptr<Promise<ConnectResult>> JHybridNitroMetamaskSpec::connect() {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>()>("connect");
     auto __result = method(_javaPart);
     return [&]() {
@@ -64,7 +69,7 @@ namespace margelo::nitro::nitrometamask {
       return __promise;
     }();
   }
-  std::shared_ptr<Promise<std::string>> JHybridMetamaskConnectorSpec::signMessage(const std::string& message) {
+  std::shared_ptr<Promise<std::string>> JHybridNitroMetamaskSpec::signMessage(const std::string& message) {
     static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* message */)>("signMessage");
     auto __result = method(_javaPart, jni::make_jstring(message));
     return [&]() {
@@ -80,5 +85,21 @@ namespace margelo::nitro::nitrometamask {
       return __promise;
     }();
   }
+  std::shared_ptr<Promise<std::string>> JHybridNitroMetamaskSpec::connectSign(const std::string& nonce, int64_t exp) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<jni::JString> /* nonce */, int64_t /* exp */)>("connectSign");
+    auto __result = method(_javaPart, jni::make_jstring(nonce), exp);
+    return [&]() {
+      auto __promise = Promise<std::string>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<jni::JString>(__boxedResult);
+        __promise->resolve(__result->toStdString());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
 
 } // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/android/c++/{JHybridMetamaskConnectorSpec.hpp → JHybridNitroMetamaskSpec.hpp}

@@ -1,5 +1,5 @@
 ///
-/// HybridMetamaskConnectorSpec.hpp
+/// HybridNitroMetamaskSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2026 Marc Rousavy @ Margelo
@@ -9,7 +9,7 @@
 
 #include <NitroModules/JHybridObject.hpp>
 #include <fbjni/fbjni.h>
-#include "HybridMetamaskConnectorSpec.hpp"
+#include "HybridNitroMetamaskSpec.hpp"
 
 
 
@@ -18,22 +18,22 @@ namespace margelo::nitro::nitrometamask {
 
   using namespace facebook;
 
-  class JHybridMetamaskConnectorSpec: public jni::HybridClass<JHybridMetamaskConnectorSpec, JHybridObject>,
-                                      public virtual HybridMetamaskConnectorSpec {
+  class JHybridNitroMetamaskSpec: public jni::HybridClass<JHybridNitroMetamaskSpec, JHybridObject>,
+                                  public virtual HybridNitroMetamaskSpec {
   public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/HybridMetamaskConnectorSpec;";
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrometamask/HybridNitroMetamaskSpec;";
     static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
     static void registerNatives();
 
   protected:
     // C++ constructor (called from Java via `initHybrid()`)
-    explicit JHybridMetamaskConnectorSpec(jni::alias_ref<jhybridobject> jThis) :
-      HybridObject(HybridMetamaskConnectorSpec::TAG),
+    explicit JHybridNitroMetamaskSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroMetamaskSpec::TAG),
       HybridBase(jThis),
       _javaPart(jni::make_global(jThis)) {}
 
   public:
-    ~JHybridMetamaskConnectorSpec() override {
+    ~JHybridNitroMetamaskSpec() override {
       // Hermes GC can destroy JS objects on a non-JNI Thread.
       jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
     }
@@ -44,7 +44,7 @@ namespace margelo::nitro::nitrometamask {
     std::string toString() override;
 
   public:
-    inline const jni::global_ref<JHybridMetamaskConnectorSpec::javaobject>& getJavaPart() const noexcept {
+    inline const jni::global_ref<JHybridNitroMetamaskSpec::javaobject>& getJavaPart() const noexcept {
       return _javaPart;
     }
 
@@ -54,13 +54,15 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
+    void configure(const std::optional<std::string>& dappUrl) override;
     std::shared_ptr<Promise<ConnectResult>> connect() override;
     std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) override;
+    std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) override;
 
   private:
     friend HybridBase;
     using HybridBase::HybridBase;
-    jni::global_ref<JHybridMetamaskConnectorSpec::javaobject> _javaPart;
+    jni::global_ref<JHybridNitroMetamaskSpec::javaobject> _javaPart;
   };
 
 } // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrometamask/{HybridMetamaskConnectorSpec.kt → HybridNitroMetamaskSpec.kt}

@@ -1,5 +1,5 @@
 ///
-/// HybridMetamaskConnectorSpec.kt
+/// HybridNitroMetamaskSpec.kt
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2026 Marc Rousavy @ Margelo
@@ -14,8 +14,8 @@ import com.margelo.nitro.core.Promise
 import com.margelo.nitro.core.HybridObject
 
 /**
- * A Kotlin class representing the MetamaskConnector HybridObject.
- * Implement this abstract class to create Kotlin-based instances of MetamaskConnector.
+ * A Kotlin class representing the NitroMetamask HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NitroMetamask.
  */
 @DoNotStrip
 @Keep
@@ -24,7 +24,7 @@ import com.margelo.nitro.core.HybridObject
   "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
   "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
 )
-abstract class HybridMetamaskConnectorSpec: HybridObject() {
+abstract class HybridNitroMetamaskSpec: HybridObject() {
   @DoNotStrip
   private var mHybridData: HybridData = initHybrid()
 
@@ -39,13 +39,17 @@ abstract class HybridMetamaskConnectorSpec: HybridObject() {
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {
-    return "[HybridObject MetamaskConnector]"
+    return "[HybridObject NitroMetamask]"
   }
 
   // Properties
   
 
   // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun configure(dappUrl: String?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun connect(): Promise<ConnectResult>
@@ -53,10 +57,14 @@ abstract class HybridMetamaskConnectorSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun signMessage(message: String): Promise<String>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun connectSign(nonce: String, exp: Long): Promise<String>
 
   private external fun initHybrid(): HybridData
 
   companion object {
-    protected const val TAG = "HybridMetamaskConnectorSpec"
+    protected const val TAG = "HybridNitroMetamaskSpec"
   }
 }