@novastera-oss/nitro-metamask 0.3.2 → 0.4.1

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,8 +14,12 @@ public protocol HybridNitroMetamaskSpec_protocol: HybridObject {
   
 
   // Methods
+  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<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

@@ -117,6 +117,31 @@ open class HybridNitroMetamaskSpec_cxx {
   
 
   // Methods
+  @inline(__always)
+  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) {
+          let __unwrapped = bridge.get_std__optional_std__string_(dappUrl)
+          return String(__unwrapped)
+        } 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) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func connect() -> bridge.Result_std__shared_ptr_Promise_ConnectResult___ {
     do {
@@ -154,4 +179,75 @@ open class HybridNitroMetamaskSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  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_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(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      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_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

@@ -14,8 +14,12 @@ namespace margelo::nitro::nitrometamask {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("configure", &HybridNitroMetamaskSpec::configure);
       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,10 +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 <string>
+#include "ConnectSignResult.hpp"
+#include <NitroModules/Null.hpp>
+#include <variant>
 
 namespace margelo::nitro::nitrometamask {
 
@@ -51,8 +57,12 @@ namespace margelo::nitro::nitrometamask {
 
     public:
       // Methods
+      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<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,6 +1,6 @@
 {
   "name": "@novastera-oss/nitro-metamask",
-  "version": "0.3.2",
+  "version": "0.4.1",
   "description": "Novastera metamask authentication with native mobile libraries",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",
@@ -12,7 +12,7 @@
     "clean": "git clean -dfX",
     "release": "semantic-release",
     "build": "npm run typecheck && bob build",
-    "codegen": "nitrogen --logLevel=\"debug\" && npm run build && node post-script.js"
+    "codegen": "nitrogen --logLevel=\"debug\" && npm run build"
   },
   "keywords": [
     "react-native",
@@ -71,7 +71,8 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "*"
+    "react-native-nitro-modules": "*",
+    "@expo/config-plugins": "*"
   },
   "eslintConfig": {
     "root": true,

package/react-native.config.js

@@ -11,7 +11,7 @@ module.exports = {
        * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
        */
       android: {
-        packageImportPath: 'import com.nitrometamask.NitroMetamaskPackage;',
+        packageImportPath: 'import com.margelo.nitro.nitrometamask.NitroMetamaskPackage;',
         packageInstance: 'new NitroMetamaskPackage()',
       },
     },

package/src/specs/nitro-metamask.nitro.ts

@@ -2,10 +2,46 @@ import { type HybridObject } from 'react-native-nitro-modules'
 
 export interface ConnectResult {
   address: string
-  chainId: number
+  chainId: bigint
+}
+
+export interface ConnectSignResult {
+  signature: string
+  address: string
+  chainId: bigint
 }
 
 export interface NitroMetamask extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
+  /**
+   * Configure the dapp URL and deep link scheme for MetaMask SDK.
+   * 
+   * @param dappUrl - A valid HTTP/HTTPS URL (e.g., "https://yourdomain.com"). 
+   *                  If not provided, defaults to "https://novastera.com".
+   *                  This is used for SDK validation.
+   * @param deepLinkScheme - The deep link scheme from your AndroidManifest.xml (e.g., "nitrometamask").
+   *                         If not provided, the library will attempt to auto-detect it.
+   *                         This is used to return to your app after MetaMask operations.
+   */
+  configure(dappUrl?: string, deepLinkScheme?: string): void
   connect(): Promise<ConnectResult>
   signMessage(message: string): Promise<string>
+  /**
+   * Connect to MetaMask (if not already connected) and sign a message containing nonce and expiration.
+   * Returns the signature along with the address and chainId that were used to sign.
+   * 
+   * @param nonce - A unique nonce for this signing request
+   * @param exp - Expiration timestamp (as bigint)
+   * @returns Promise resolving to ConnectSignResult containing signature, address, and chainId
+   */
+  connectSign(nonce: string, exp: bigint): Promise<ConnectSignResult>
+  /**
+   * Get the currently connected wallet address.
+   * Returns null if not connected.
+   */
+  getAddress(): Promise<string | null>
+  /**
+   * Get the current chain ID.
+   * Returns null if not connected.
+   */
+  getChainId(): Promise<bigint | null>
 }