@novastera-oss/nitro-metamask 0.3.3 → 0.4.2

package/nitrogen/generated/ios/c++/HybridNitroMetamaskSpecSwift.hpp

@@ -14,11 +14,16 @@ namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+// Forward declaration of `ConnectSignResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectSignResult; }
 
 #include <string>
 #include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
+#include "ConnectSignResult.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
 
 #include "NitroMetamask-Swift-Cxx-Umbrella.hpp"
 
@@ -64,8 +69,8 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
-    inline void configure(const std::optional<std::string>& dappUrl) override {
-      auto __result = _swiftPart.configure(dappUrl);
+    inline void configure(const std::optional<std::string>& dappUrl, const std::optional<std::string>& deepLinkScheme) override {
+      auto __result = _swiftPart.configure(dappUrl, deepLinkScheme);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -86,7 +91,7 @@ namespace margelo::nitro::nitrometamask {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) override {
+    inline std::shared_ptr<Promise<ConnectSignResult>> connectSign(const std::string& nonce, int64_t exp) override {
       auto __result = _swiftPart.connectSign(nonce, std::forward<decltype(exp)>(exp));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
@@ -94,6 +99,22 @@ namespace margelo::nitro::nitrometamask {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getAddress() override {
+      auto __result = _swiftPart.getAddress();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> getChainId() override {
+      auto __result = _swiftPart.getChainId();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     NitroMetamask::HybridNitroMetamaskSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/ConnectResult.swift

@@ -19,7 +19,7 @@ public extension ConnectResult {
   /**
    * Create a new instance of `ConnectResult`.
    */
-  init(address: String, chainId: Double) {
+  init(address: String, chainId: Int64) {
     self.init(std.string(address), chainId)
   }
 
@@ -29,7 +29,7 @@ public extension ConnectResult {
   }
   
   @inline(__always)
-  var chainId: Double {
+  var chainId: Int64 {
     return self.__chainId
   }
 }

package/nitrogen/generated/ios/swift/ConnectSignResult.swift

@@ -0,0 +1,40 @@
+///
+/// ConnectSignResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `ConnectSignResult`, backed by a C++ struct.
+ */
+public typealias ConnectSignResult = margelo.nitro.nitrometamask.ConnectSignResult
+
+public extension ConnectSignResult {
+  private typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  /**
+   * Create a new instance of `ConnectSignResult`.
+   */
+  init(signature: String, address: String, chainId: Int64) {
+    self.init(std.string(signature), std.string(address), chainId)
+  }
+
+  @inline(__always)
+  var signature: String {
+    return String(self.__signature)
+  }
+  
+  @inline(__always)
+  var address: String {
+    return String(self.__address)
+  }
+  
+  @inline(__always)
+  var chainId: Int64 {
+    return self.__chainId
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_ConnectSignResult.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_ConnectSignResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: ConnectSignResult) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_ConnectSignResult {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ value: ConnectSignResult) -> Void
+
+  public init(_ closure: @escaping (_ value: ConnectSignResult) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: ConnectSignResult) -> Void {
+    self.closure(value)
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_ConnectSignResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_ConnectSignResult>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_ConnectSignResult {
+    return Unmanaged<Func_void_ConnectSignResult>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__int64_t_.swift

@@ -0,0 +1,59 @@
+///
+/// Func_void_std__variant_nitro__NullType__int64_t_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Variant_NullType_Int64) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__variant_nitro__NullType__int64_t_ {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ value: Variant_NullType_Int64) -> Void
+
+  public init(_ closure: @escaping (_ value: Variant_NullType_Int64) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__variant_nitro__NullType__int64_t_) -> Void {
+    self.closure({ () -> Variant_NullType_Int64 in
+      let __variant = value
+      switch __variant.index() {
+        case 0:
+          let __actual = __variant.get_0()
+          return .first(NullType.null)
+        case 1:
+          let __actual = __variant.get_1()
+          return .second(__actual)
+        default:
+          fatalError("Variant can never have index \(__variant.index())!")
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__int64_t_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__int64_t_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__int64_t_ {
+    return Unmanaged<Func_void_std__variant_nitro__NullType__int64_t_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__variant_nitro__NullType__std__string_.swift

@@ -0,0 +1,59 @@
+///
+/// Func_void_std__variant_nitro__NullType__std__string_.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Wraps a Swift `(_ value: Variant_NullType_String) -> Void` as a class.
+ * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
+ */
+public final class Func_void_std__variant_nitro__NullType__std__string_ {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ value: Variant_NullType_String) -> Void
+
+  public init(_ closure: @escaping (_ value: Variant_NullType_String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: bridge.std__variant_nitro__NullType__std__string_) -> Void {
+    self.closure({ () -> Variant_NullType_String in
+      let __variant = value
+      switch __variant.index() {
+        case 0:
+          let __actual = __variant.get_0()
+          return .first(NullType.null)
+        case 1:
+          let __actual = __variant.get_1()
+          return .second(String(__actual))
+        default:
+          fatalError("Variant can never have index \(__variant.index())!")
+      }
+    }())
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  @inline(__always)
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `Func_void_std__variant_nitro__NullType__std__string_`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__variant_nitro__NullType__std__string_>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__variant_nitro__NullType__std__string_ {
+    return Unmanaged<Func_void_std__variant_nitro__NullType__std__string_>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridNitroMetamaskSpec.swift

@@ -14,10 +14,12 @@ public protocol HybridNitroMetamaskSpec_protocol: HybridObject {
   
 
   // Methods
-  func configure(dappUrl: String?) throws -> Void
+  func configure(dappUrl: String?, deepLinkScheme: String?) throws -> Void
   func connect() throws -> Promise<ConnectResult>
   func signMessage(message: String) throws -> Promise<String>
-  func connectSign(nonce: String, exp: Int64) throws -> Promise<String>
+  func connectSign(nonce: String, exp: Int64) throws -> Promise<ConnectSignResult>
+  func getAddress() throws -> Promise<Variant_NullType_String>
+  func getChainId() throws -> Promise<Variant_NullType_Int64>
 }
 
 public extension HybridNitroMetamaskSpec_protocol {

package/nitrogen/generated/ios/swift/HybridNitroMetamaskSpec_cxx.swift

@@ -118,7 +118,7 @@ open class HybridNitroMetamaskSpec_cxx {
 
   // Methods
   @inline(__always)
-  public final func configure(dappUrl: bridge.std__optional_std__string_) -> bridge.Result_void_ {
+  public final func configure(dappUrl: bridge.std__optional_std__string_, deepLinkScheme: bridge.std__optional_std__string_) -> bridge.Result_void_ {
     do {
       try self.__implementation.configure(dappUrl: { () -> String? in
         if bridge.has_value_std__optional_std__string_(dappUrl) {
@@ -127,6 +127,13 @@ open class HybridNitroMetamaskSpec_cxx {
         } else {
           return nil
         }
+      }(), deepLinkScheme: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(deepLinkScheme) {
+          let __unwrapped = bridge.get_std__optional_std__string_(deepLinkScheme)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
       }())
       return bridge.create_Result_void_()
     } catch (let __error) {
@@ -174,21 +181,73 @@ open class HybridNitroMetamaskSpec_cxx {
   }
   
   @inline(__always)
-  public final func connectSign(nonce: std.string, exp: Int64) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+  public final func connectSign(nonce: std.string, exp: Int64) -> bridge.Result_std__shared_ptr_Promise_ConnectSignResult___ {
     do {
       let __result = try self.__implementation.connectSign(nonce: String(nonce), exp: exp)
-      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__string__ in
-        let __promise = bridge.create_std__shared_ptr_Promise_std__string__()
-        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__string__(__promise)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_ConnectSignResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_ConnectSignResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_ConnectSignResult__(__promise)
         __result
-          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .then({ __result in __promiseHolder.resolve(__result) })
           .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
         return __promise
       }()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+      return bridge.create_Result_std__shared_ptr_Promise_ConnectSignResult___(__resultCpp)
     } catch (let __error) {
       let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+      return bridge.create_Result_std__shared_ptr_Promise_ConnectSignResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getAddress() -> bridge.Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____ {
+    do {
+      let __result = try self.__implementation.getAddress()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_nitro__NullType__std__string_ in
+              switch __result {
+                case .first(let __value):
+                  return bridge.create_std__variant_nitro__NullType__std__string_(margelo.nitro.NullType.null)
+                case .second(let __value):
+                  return bridge.create_std__variant_nitro__NullType__std__string_(std.string(__value))
+              }
+            }().variant) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__std__string____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getChainId() -> bridge.Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____ {
+    do {
+      let __result = try self.__implementation.getChainId()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__variant_nitro__NullType__int64_t_ in
+              switch __result {
+                case .first(let __value):
+                  return bridge.create_std__variant_nitro__NullType__int64_t_(margelo.nitro.NullType.null)
+                case .second(let __value):
+                  return bridge.create_std__variant_nitro__NullType__int64_t_(__value)
+              }
+            }().variant) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__variant_nitro__NullType__int64_t____(__exceptionPtr)
     }
   }
 }

package/nitrogen/generated/ios/swift/Variant_NullType_Int64.swift

@@ -0,0 +1,18 @@
+///
+/// Variant_NullType_Int64.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `null | bigint`
+ */
+@frozen
+public enum Variant_NullType_Int64 {
+  case first(NullType)
+  case second(Int64)
+}

package/nitrogen/generated/ios/swift/Variant_NullType_String.swift

@@ -0,0 +1,18 @@
+///
+/// Variant_NullType_String.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * An Swift enum with associated values representing a Variant/Union type.
+ * JS type: `null | string`
+ */
+@frozen
+public enum Variant_NullType_String {
+  case first(NullType)
+  case second(String)
+}

package/nitrogen/generated/shared/c++/ConnectResult.hpp

@@ -40,11 +40,11 @@ namespace margelo::nitro::nitrometamask {
   struct ConnectResult final {
   public:
     std::string address     SWIFT_PRIVATE;
-    double chainId     SWIFT_PRIVATE;
+    int64_t chainId     SWIFT_PRIVATE;
 
   public:
     ConnectResult() = default;
-    explicit ConnectResult(std::string address, double chainId): address(address), chainId(chainId) {}
+    explicit ConnectResult(std::string address, int64_t 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<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))
+        JSIConverter<int64_t>::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<double>::toJSI(runtime, arg.chainId));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "chainId"), JSIConverter<int64_t>::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<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
+      if (!JSIConverter<int64_t>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/ConnectSignResult.hpp

@@ -0,0 +1,91 @@
+///
+/// ConnectSignResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::nitrometamask {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ConnectSignResult).
+   */
+  struct ConnectSignResult final {
+  public:
+    std::string signature     SWIFT_PRIVATE;
+    std::string address     SWIFT_PRIVATE;
+    int64_t chainId     SWIFT_PRIVATE;
+
+  public:
+    ConnectSignResult() = default;
+    explicit ConnectSignResult(std::string signature, std::string address, int64_t chainId): signature(signature), address(address), chainId(chainId) {}
+
+  public:
+    friend bool operator==(const ConnectSignResult& lhs, const ConnectSignResult& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrometamask
+
+namespace margelo::nitro {
+
+  // C++ ConnectSignResult <> JS ConnectSignResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrometamask::ConnectSignResult> final {
+    static inline margelo::nitro::nitrometamask::ConnectSignResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrometamask::ConnectSignResult(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "signature"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address"))),
+        JSIConverter<int64_t>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitrometamask::ConnectSignResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "signature"), JSIConverter<std::string>::toJSI(runtime, arg.signature));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "address"), JSIConverter<std::string>::toJSI(runtime, arg.address));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "chainId"), JSIConverter<int64_t>::toJSI(runtime, arg.chainId));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "signature")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address")))) return false;
+      if (!JSIConverter<int64_t>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.cpp

@@ -18,6 +18,8 @@ namespace margelo::nitro::nitrometamask {
       prototype.registerHybridMethod("connect", &HybridNitroMetamaskSpec::connect);
       prototype.registerHybridMethod("signMessage", &HybridNitroMetamaskSpec::signMessage);
       prototype.registerHybridMethod("connectSign", &HybridNitroMetamaskSpec::connectSign);
+      prototype.registerHybridMethod("getAddress", &HybridNitroMetamaskSpec::getAddress);
+      prototype.registerHybridMethod("getChainId", &HybridNitroMetamaskSpec::getChainId);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridNitroMetamaskSpec.hpp

@@ -15,11 +15,16 @@
 
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+// Forward declaration of `ConnectSignResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectSignResult; }
 
 #include <string>
 #include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
+#include "ConnectSignResult.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
 
 namespace margelo::nitro::nitrometamask {
 
@@ -52,10 +57,12 @@ namespace margelo::nitro::nitrometamask {
 
     public:
       // Methods
-      virtual void configure(const std::optional<std::string>& dappUrl) = 0;
+      virtual void configure(const std::optional<std::string>& dappUrl, const std::optional<std::string>& deepLinkScheme) = 0;
       virtual std::shared_ptr<Promise<ConnectResult>> connect() = 0;
       virtual std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) = 0;
-      virtual std::shared_ptr<Promise<std::string>> connectSign(const std::string& nonce, int64_t exp) = 0;
+      virtual std::shared_ptr<Promise<ConnectSignResult>> connectSign(const std::string& nonce, int64_t exp) = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, std::string>>> getAddress() = 0;
+      virtual std::shared_ptr<Promise<std::variant<nitro::NullType, int64_t>>> getChainId() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novastera-oss/nitro-metamask",
-  "version": "0.3.3",
-  "description": "Novastera metamask authentication with native mobile libraries",
+  "version": "0.4.2",
+  "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",
   "types": "./lib/typescript/src/index.d.ts",
@@ -18,7 +18,20 @@
     "react-native",
     "@novastera-oss/nitro-metamask",
     "metamask",
-    "novastera"
+    "novastera",
+    "crm",
+    "erp",
+    "web3",
+    "blockchain",
+    "ethereum",
+    "wallet",
+    "mobile",
+    "ios",
+    "android",
+    "nitro-modules",
+    "authentication",
+    "crypto",
+    "defi"
   ],
   "files": [
     "src",
@@ -71,7 +84,8 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "*"
+    "react-native-nitro-modules": "*",
+    "@expo/config-plugins": "*"
   },
   "eslintConfig": {
     "root": true,