@novastera-oss/nitro-metamask 0.2.7 → 0.3.3

package/nitrogen/generated/ios/NitroMetamask-Swift-Cxx-Bridge.cpp

@@ -8,7 +8,7 @@
 #include "NitroMetamask-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
-#include "HybridMetamaskConnectorSpecSwift.hpp"
+#include "HybridNitroMetamaskSpecSwift.hpp"
 #include "NitroMetamask-Swift-Cxx-Umbrella.hpp"
 #include <NitroModules/NitroDefines.hpp>
 
@@ -38,19 +38,19 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
     };
   }
   
-  // pragma MARK: std::shared_ptr<HybridMetamaskConnectorSpec>
-  std::shared_ptr<HybridMetamaskConnectorSpec> create_std__shared_ptr_HybridMetamaskConnectorSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
-    NitroMetamask::HybridMetamaskConnectorSpec_cxx swiftPart = NitroMetamask::HybridMetamaskConnectorSpec_cxx::fromUnsafe(swiftUnsafePointer);
-    return std::make_shared<margelo::nitro::nitrometamask::HybridMetamaskConnectorSpecSwift>(swiftPart);
+  // pragma MARK: std::shared_ptr<HybridNitroMetamaskSpec>
+  std::shared_ptr<HybridNitroMetamaskSpec> create_std__shared_ptr_HybridNitroMetamaskSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    NitroMetamask::HybridNitroMetamaskSpec_cxx swiftPart = NitroMetamask::HybridNitroMetamaskSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::nitrometamask::HybridNitroMetamaskSpecSwift>(swiftPart);
   }
-  void* NON_NULL get_std__shared_ptr_HybridMetamaskConnectorSpec_(std__shared_ptr_HybridMetamaskConnectorSpec_ cppType) {
-    std::shared_ptr<margelo::nitro::nitrometamask::HybridMetamaskConnectorSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::nitrometamask::HybridMetamaskConnectorSpecSwift>(cppType);
+  void* NON_NULL get_std__shared_ptr_HybridNitroMetamaskSpec_(std__shared_ptr_HybridNitroMetamaskSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::nitrometamask::HybridNitroMetamaskSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::nitrometamask::HybridNitroMetamaskSpecSwift>(cppType);
     #ifdef NITRO_DEBUG
     if (swiftWrapper == nullptr) [[unlikely]] {
-      throw std::runtime_error("Class \"HybridMetamaskConnectorSpec\" is not implemented in Swift!");
+      throw std::runtime_error("Class \"HybridNitroMetamaskSpec\" is not implemented in Swift!");
     }
     #endif
-    NitroMetamask::HybridMetamaskConnectorSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    NitroMetamask::HybridNitroMetamaskSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
     return swiftPart.toUnsafe();
   }
 

package/nitrogen/generated/ios/NitroMetamask-Swift-Cxx-Bridge.hpp

@@ -10,22 +10,23 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
-// Forward declaration of `HybridMetamaskConnectorSpec` to properly resolve imports.
-namespace margelo::nitro::nitrometamask { class HybridMetamaskConnectorSpec; }
+// Forward declaration of `HybridNitroMetamaskSpec` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { class HybridNitroMetamaskSpec; }
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridMetamaskConnectorSpec_cxx` to properly resolve imports.
-namespace NitroMetamask { class HybridMetamaskConnectorSpec_cxx; }
+// Forward declaration of `HybridNitroMetamaskSpec_cxx` to properly resolve imports.
+namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 
 // Include C++ defined types
 #include "ConnectResult.hpp"
-#include "HybridMetamaskConnectorSpec.hpp"
+#include "HybridNitroMetamaskSpec.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string>
 
 /**
@@ -34,6 +35,21 @@ namespace NitroMetamask { class HybridMetamaskConnectorSpec_cxx; }
  */
 namespace margelo::nitro::nitrometamask::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::shared_ptr<Promise<ConnectResult>>
   /**
    * Specialized version of `std::shared_ptr<Promise<ConnectResult>>`.
@@ -124,17 +140,26 @@ namespace margelo::nitro::nitrometamask::bridge::swift {
     return Func_void_std__string_Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::shared_ptr<HybridMetamaskConnectorSpec>
+  // pragma MARK: std::shared_ptr<HybridNitroMetamaskSpec>
   /**
-   * Specialized version of `std::shared_ptr<HybridMetamaskConnectorSpec>`.
+   * Specialized version of `std::shared_ptr<HybridNitroMetamaskSpec>`.
    */
-  using std__shared_ptr_HybridMetamaskConnectorSpec_ = std::shared_ptr<HybridMetamaskConnectorSpec>;
-  std::shared_ptr<HybridMetamaskConnectorSpec> create_std__shared_ptr_HybridMetamaskConnectorSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridMetamaskConnectorSpec_(std__shared_ptr_HybridMetamaskConnectorSpec_ cppType);
+  using std__shared_ptr_HybridNitroMetamaskSpec_ = std::shared_ptr<HybridNitroMetamaskSpec>;
+  std::shared_ptr<HybridNitroMetamaskSpec> create_std__shared_ptr_HybridNitroMetamaskSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridNitroMetamaskSpec_(std__shared_ptr_HybridNitroMetamaskSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridNitroMetamaskSpec>
+  using std__weak_ptr_HybridNitroMetamaskSpec_ = std::weak_ptr<HybridNitroMetamaskSpec>;
+  inline std__weak_ptr_HybridNitroMetamaskSpec_ weakify_std__shared_ptr_HybridNitroMetamaskSpec_(const std::shared_ptr<HybridNitroMetamaskSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::weak_ptr<HybridMetamaskConnectorSpec>
-  using std__weak_ptr_HybridMetamaskConnectorSpec_ = std::weak_ptr<HybridMetamaskConnectorSpec>;
-  inline std__weak_ptr_HybridMetamaskConnectorSpec_ weakify_std__shared_ptr_HybridMetamaskConnectorSpec_(const std::shared_ptr<HybridMetamaskConnectorSpec>& strong) noexcept { return strong; }
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
   
   // pragma MARK: Result<std::shared_ptr<Promise<ConnectResult>>>
   using Result_std__shared_ptr_Promise_ConnectResult___ = Result<std::shared_ptr<Promise<ConnectResult>>>;

package/nitrogen/generated/ios/NitroMetamask-Swift-Cxx-Umbrella.hpp

@@ -10,16 +10,17 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
-// Forward declaration of `HybridMetamaskConnectorSpec` to properly resolve imports.
-namespace margelo::nitro::nitrometamask { class HybridMetamaskConnectorSpec; }
+// Forward declaration of `HybridNitroMetamaskSpec` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { class HybridNitroMetamaskSpec; }
 
 // Include C++ defined types
 #include "ConnectResult.hpp"
-#include "HybridMetamaskConnectorSpec.hpp"
+#include "HybridNitroMetamaskSpec.hpp"
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <memory>
+#include <optional>
 #include <string>
 
 // C++ helpers for Swift
@@ -32,8 +33,8 @@ namespace margelo::nitro::nitrometamask { class HybridMetamaskConnectorSpec; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
-// Forward declaration of `HybridMetamaskConnectorSpec_cxx` to properly resolve imports.
-namespace NitroMetamask { class HybridMetamaskConnectorSpec_cxx; }
+// Forward declaration of `HybridNitroMetamaskSpec_cxx` to properly resolve imports.
+namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 
 // Include Swift defined types
 #if __has_include("NitroMetamask-Swift.h")

package/nitrogen/generated/ios/NitroMetamaskAutolinking.mm

@@ -10,7 +10,7 @@
 #import "NitroMetamask-Swift-Cxx-Umbrella.hpp"
 #import <type_traits>
 
-#include "HybridMetamaskConnectorSpecSwift.hpp"
+#include "HybridNitroMetamaskSpecSwift.hpp"
 
 @interface NitroMetamaskAutolinking : NSObject
 @end
@@ -22,9 +22,9 @@
   using namespace margelo::nitro::nitrometamask;
 
   HybridObjectRegistry::registerHybridObjectConstructor(
-    "MetamaskConnector",
+    "NitroMetamask",
     []() -> std::shared_ptr<HybridObject> {
-      std::shared_ptr<HybridMetamaskConnectorSpec> hybridObject = NitroMetamask::NitroMetamaskAutolinking::createMetamaskConnector();
+      std::shared_ptr<HybridNitroMetamaskSpec> hybridObject = NitroMetamask::NitroMetamaskAutolinking::createNitroMetamask();
       return hybridObject;
     }
   );

package/nitrogen/generated/ios/NitroMetamaskAutolinking.swift

@@ -9,15 +9,15 @@ public final class NitroMetamaskAutolinking {
   public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
 
   /**
-   * Creates an instance of a Swift class that implements `HybridMetamaskConnectorSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridMetamaskConnectorSpec_cxx`)
+   * Creates an instance of a Swift class that implements `HybridNitroMetamaskSpec`,
+   * and wraps it in a Swift class that can directly interop with C++ (`HybridNitroMetamaskSpec_cxx`)
    *
    * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridMetamaskConnector`).
+   * in the `"autolinking"` property of `nitro.json` (in this case, `HybridNitroMetamask`).
    */
-  public static func createMetamaskConnector() -> bridge.std__shared_ptr_HybridMetamaskConnectorSpec_ {
-    let hybridObject = HybridMetamaskConnector()
-    return { () -> bridge.std__shared_ptr_HybridMetamaskConnectorSpec_ in
+  public static func createNitroMetamask() -> bridge.std__shared_ptr_HybridNitroMetamaskSpec_ {
+    let hybridObject = HybridNitroMetamask()
+    return { () -> bridge.std__shared_ptr_HybridNitroMetamaskSpec_ in
       let __cxxWrapped = hybridObject.getCxxWrapper()
       return __cxxWrapped.getCxxPart()
     }()

package/nitrogen/generated/ios/c++/{HybridMetamaskConnectorSpecSwift.cpp → HybridNitroMetamaskSpecSwift.cpp}

@@ -1,11 +1,11 @@
 ///
-/// HybridMetamaskConnectorSpecSwift.cpp
+/// HybridNitroMetamaskSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2026 Marc Rousavy @ Margelo
 ///
 
-#include "HybridMetamaskConnectorSpecSwift.hpp"
+#include "HybridNitroMetamaskSpecSwift.hpp"
 
 namespace margelo::nitro::nitrometamask {
 } // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/ios/c++/{HybridMetamaskConnectorSpecSwift.hpp → HybridNitroMetamaskSpecSwift.hpp}

@@ -1,5 +1,5 @@
 ///
-/// HybridMetamaskConnectorSpecSwift.hpp
+/// HybridNitroMetamaskSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2026 Marc Rousavy @ Margelo
@@ -7,42 +7,43 @@
 
 #pragma once
 
-#include "HybridMetamaskConnectorSpec.hpp"
+#include "HybridNitroMetamaskSpec.hpp"
 
-// Forward declaration of `HybridMetamaskConnectorSpec_cxx` to properly resolve imports.
-namespace NitroMetamask { class HybridMetamaskConnectorSpec_cxx; }
+// Forward declaration of `HybridNitroMetamaskSpec_cxx` to properly resolve imports.
+namespace NitroMetamask { class HybridNitroMetamaskSpec_cxx; }
 
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 
+#include <string>
+#include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
-#include <string>
 
 #include "NitroMetamask-Swift-Cxx-Umbrella.hpp"
 
 namespace margelo::nitro::nitrometamask {
 
   /**
-   * The C++ part of HybridMetamaskConnectorSpec_cxx.swift.
+   * The C++ part of HybridNitroMetamaskSpec_cxx.swift.
    *
-   * HybridMetamaskConnectorSpecSwift (C++) accesses HybridMetamaskConnectorSpec_cxx (Swift), and might
+   * HybridNitroMetamaskSpecSwift (C++) accesses HybridNitroMetamaskSpec_cxx (Swift), and might
    * contain some additional bridging code for C++ <> Swift interop.
    *
    * Since this obviously introduces an overhead, I hope at some point in
-   * the future, HybridMetamaskConnectorSpec_cxx can directly inherit from the C++ class HybridMetamaskConnectorSpec
+   * the future, HybridNitroMetamaskSpec_cxx can directly inherit from the C++ class HybridNitroMetamaskSpec
    * to simplify the whole structure and memory management.
    */
-  class HybridMetamaskConnectorSpecSwift: public virtual HybridMetamaskConnectorSpec {
+  class HybridNitroMetamaskSpecSwift: public virtual HybridNitroMetamaskSpec {
   public:
     // Constructor from a Swift instance
-    explicit HybridMetamaskConnectorSpecSwift(const NitroMetamask::HybridMetamaskConnectorSpec_cxx& swiftPart):
-      HybridObject(HybridMetamaskConnectorSpec::TAG),
+    explicit HybridNitroMetamaskSpecSwift(const NitroMetamask::HybridNitroMetamaskSpec_cxx& swiftPart):
+      HybridObject(HybridNitroMetamaskSpec::TAG),
       _swiftPart(swiftPart) { }
 
   public:
     // Get the Swift part
-    inline NitroMetamask::HybridMetamaskConnectorSpec_cxx& getSwiftPart() noexcept {
+    inline NitroMetamask::HybridNitroMetamaskSpec_cxx& getSwiftPart() noexcept {
       return _swiftPart;
     }
 
@@ -63,6 +64,12 @@ namespace margelo::nitro::nitrometamask {
 
   public:
     // Methods
+    inline void configure(const std::optional<std::string>& dappUrl) override {
+      auto __result = _swiftPart.configure(dappUrl);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline std::shared_ptr<Promise<ConnectResult>> connect() override {
       auto __result = _swiftPart.connect();
       if (__result.hasError()) [[unlikely]] {
@@ -79,9 +86,17 @@ 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 {
+      auto __result = _swiftPart.connectSign(nonce, std::forward<decltype(exp)>(exp));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
-    NitroMetamask::HybridMetamaskConnectorSpec_cxx _swiftPart;
+    NitroMetamask::HybridNitroMetamaskSpec_cxx _swiftPart;
   };
 
 } // namespace margelo::nitro::nitrometamask

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

@@ -0,0 +1,59 @@
+///
+/// HybridNitroMetamaskSpec.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
+
+/// See ``HybridNitroMetamaskSpec``
+public protocol HybridNitroMetamaskSpec_protocol: HybridObject {
+  // Properties
+  
+
+  // Methods
+  func configure(dappUrl: String?) throws -> Void
+  func connect() throws -> Promise<ConnectResult>
+  func signMessage(message: String) throws -> Promise<String>
+  func connectSign(nonce: String, exp: Int64) throws -> Promise<String>
+}
+
+public extension HybridNitroMetamaskSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject NitroMetamask]"
+  }
+}
+
+/// See ``HybridNitroMetamaskSpec``
+open class HybridNitroMetamaskSpec_base {
+  private weak var cxxWrapper: HybridNitroMetamaskSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridNitroMetamaskSpec_cxx {
+  #if DEBUG
+    guard self is HybridNitroMetamaskSpec else {
+      fatalError("`self` is not a `HybridNitroMetamaskSpec`! Did you accidentally inherit from `HybridNitroMetamaskSpec_base` instead of `HybridNitroMetamaskSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridNitroMetamaskSpec_cxx(self as! HybridNitroMetamaskSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the NitroMetamask HybridObject.
+ * Implement this protocol to create Swift-based instances of NitroMetamask.
+ * ```swift
+ * class HybridNitroMetamask : HybridNitroMetamaskSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridNitroMetamaskSpec = HybridNitroMetamaskSpec_protocol & HybridNitroMetamaskSpec_base

package/nitrogen/generated/ios/swift/{HybridMetamaskConnectorSpec_cxx.swift → HybridNitroMetamaskSpec_cxx.swift}

@@ -1,5 +1,5 @@
 ///
-/// HybridMetamaskConnectorSpec_cxx.swift
+/// HybridNitroMetamaskSpec_cxx.swift
 /// 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 @@ import Foundation
 import NitroModules
 
 /**
- * A class implementation that bridges HybridMetamaskConnectorSpec over to C++.
+ * A class implementation that bridges HybridNitroMetamaskSpec over to C++.
  * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
  *
  * Also, some Swift types need to be bridged with special handling:
@@ -17,7 +17,7 @@ import NitroModules
  * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
  * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
  */
-open class HybridMetamaskConnectorSpec_cxx {
+open class HybridNitroMetamaskSpec_cxx {
   /**
    * The Swift <> C++ bridge's namespace (`margelo::nitro::nitrometamask::bridge::swift`)
    * from `NitroMetamask-Swift-Cxx-Bridge.hpp`.
@@ -26,30 +26,30 @@ open class HybridMetamaskConnectorSpec_cxx {
   public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
 
   /**
-   * Holds an instance of the `HybridMetamaskConnectorSpec` Swift protocol.
+   * Holds an instance of the `HybridNitroMetamaskSpec` Swift protocol.
    */
-  private var __implementation: any HybridMetamaskConnectorSpec
+  private var __implementation: any HybridNitroMetamaskSpec
 
   /**
    * Holds a weak pointer to the C++ class that wraps the Swift class.
    */
-  private var __cxxPart: bridge.std__weak_ptr_HybridMetamaskConnectorSpec_
+  private var __cxxPart: bridge.std__weak_ptr_HybridNitroMetamaskSpec_
 
   /**
-   * Create a new `HybridMetamaskConnectorSpec_cxx` that wraps the given `HybridMetamaskConnectorSpec`.
+   * Create a new `HybridNitroMetamaskSpec_cxx` that wraps the given `HybridNitroMetamaskSpec`.
    * All properties and methods bridge to C++ types.
    */
-  public init(_ implementation: any HybridMetamaskConnectorSpec) {
+  public init(_ implementation: any HybridNitroMetamaskSpec) {
     self.__implementation = implementation
     self.__cxxPart = .init()
     /* no base class */
   }
 
   /**
-   * Get the actual `HybridMetamaskConnectorSpec` instance this class wraps.
+   * Get the actual `HybridNitroMetamaskSpec` instance this class wraps.
    */
   @inline(__always)
-  public func getHybridMetamaskConnectorSpec() -> any HybridMetamaskConnectorSpec {
+  public func getHybridNitroMetamaskSpec() -> any HybridNitroMetamaskSpec {
     return __implementation
   }
 
@@ -62,25 +62,25 @@ open class HybridMetamaskConnectorSpec_cxx {
   }
 
   /**
-   * Casts an unsafe pointer to a `HybridMetamaskConnectorSpec_cxx`.
-   * The pointer has to be a retained opaque `Unmanaged<HybridMetamaskConnectorSpec_cxx>`.
+   * Casts an unsafe pointer to a `HybridNitroMetamaskSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridNitroMetamaskSpec_cxx>`.
    * This removes one strong reference from the object!
    */
-  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridMetamaskConnectorSpec_cxx {
-    return Unmanaged<HybridMetamaskConnectorSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridNitroMetamaskSpec_cxx {
+    return Unmanaged<HybridNitroMetamaskSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
   }
 
   /**
    * Gets (or creates) the C++ part of this Hybrid Object.
-   * The C++ part is a `std::shared_ptr<HybridMetamaskConnectorSpec>`.
+   * The C++ part is a `std::shared_ptr<HybridNitroMetamaskSpec>`.
    */
-  public func getCxxPart() -> bridge.std__shared_ptr_HybridMetamaskConnectorSpec_ {
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridNitroMetamaskSpec_ {
     let cachedCxxPart = self.__cxxPart.lock()
     if Bool(fromCxx: cachedCxxPart) {
       return cachedCxxPart
     } else {
-      let newCxxPart = bridge.create_std__shared_ptr_HybridMetamaskConnectorSpec_(self.toUnsafe())
-      __cxxPart = bridge.weakify_std__shared_ptr_HybridMetamaskConnectorSpec_(newCxxPart)
+      let newCxxPart = bridge.create_std__shared_ptr_HybridNitroMetamaskSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridNitroMetamaskSpec_(newCxxPart)
       return newCxxPart
     }
   }
@@ -117,6 +117,24 @@ open class HybridMetamaskConnectorSpec_cxx {
   
 
   // Methods
+  @inline(__always)
+  public final func configure(dappUrl: 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
+        }
+      }())
+      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 +172,23 @@ open class HybridMetamaskConnectorSpec_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_std__string___ {
+    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)
+        __result
+          .then({ __result in __promiseHolder.resolve(std.string(__result)) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__string___(__exceptionPtr)
+    }
+  }
 }

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

@@ -0,0 +1,24 @@
+///
+/// HybridNitroMetamaskSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridNitroMetamaskSpec.hpp"
+
+namespace margelo::nitro::nitrometamask {
+
+  void HybridNitroMetamaskSpec::loadHybridMethods() {
+    // load base methods/properties
+    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);
+    });
+  }
+
+} // namespace margelo::nitro::nitrometamask

package/nitrogen/generated/shared/c++/{HybridMetamaskConnectorSpec.hpp → HybridNitroMetamaskSpec.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
@@ -16,34 +16,35 @@
 // Forward declaration of `ConnectResult` to properly resolve imports.
 namespace margelo::nitro::nitrometamask { struct ConnectResult; }
 
+#include <string>
+#include <optional>
 #include "ConnectResult.hpp"
 #include <NitroModules/Promise.hpp>
-#include <string>
 
 namespace margelo::nitro::nitrometamask {
 
   using namespace margelo::nitro;
 
   /**
-   * An abstract base class for `MetamaskConnector`
-   * Inherit this class to create instances of `HybridMetamaskConnectorSpec` in C++.
+   * An abstract base class for `NitroMetamask`
+   * Inherit this class to create instances of `HybridNitroMetamaskSpec` in C++.
    * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
    * @example
    * ```cpp
-   * class HybridMetamaskConnector: public HybridMetamaskConnectorSpec {
+   * class HybridNitroMetamask: public HybridNitroMetamaskSpec {
    * public:
-   *   HybridMetamaskConnector(...): HybridObject(TAG) { ... }
+   *   HybridNitroMetamask(...): HybridObject(TAG) { ... }
    *   // ...
    * };
    * ```
    */
-  class HybridMetamaskConnectorSpec: public virtual HybridObject {
+  class HybridNitroMetamaskSpec: public virtual HybridObject {
     public:
       // Constructor
-      explicit HybridMetamaskConnectorSpec(): HybridObject(TAG) { }
+      explicit HybridNitroMetamaskSpec(): HybridObject(TAG) { }
 
       // Destructor
-      ~HybridMetamaskConnectorSpec() override = default;
+      ~HybridNitroMetamaskSpec() override = default;
 
     public:
       // Properties
@@ -51,8 +52,10 @@ namespace margelo::nitro::nitrometamask {
 
     public:
       // Methods
+      virtual void configure(const std::optional<std::string>& dappUrl) = 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;
 
     protected:
       // Hybrid Setup
@@ -60,7 +63,7 @@ namespace margelo::nitro::nitrometamask {
 
     protected:
       // Tag for logging
-      static constexpr auto TAG = "MetamaskConnector";
+      static constexpr auto TAG = "NitroMetamask";
   };
 
 } // namespace margelo::nitro::nitrometamask