@novastera-oss/nitro-metamask 0.1.3

package/nitrogen/generated/ios/swift/Func_void_ConnectResult.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_ConnectResult.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: ConnectResult) -> 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_ConnectResult {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ value: ConnectResult) -> Void
+
+  public init(_ closure: @escaping (_ value: ConnectResult) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: ConnectResult) -> 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_ConnectResult`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_ConnectResult>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_ConnectResult {
+    return Unmanaged<Func_void_ConnectResult>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__exception_ptr.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_std__exception_ptr.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 `(_ error: Error) -> 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__exception_ptr {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ error: Error) -> Void
+
+  public init(_ closure: @escaping (_ error: Error) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(error: std.exception_ptr) -> Void {
+    self.closure(RuntimeError.from(cppError: error))
+  }
+
+  /**
+   * 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__exception_ptr`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__exception_ptr>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__exception_ptr {
+    return Unmanaged<Func_void_std__exception_ptr>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/Func_void_std__string.swift

@@ -0,0 +1,47 @@
+///
+/// Func_void_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: 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__string {
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  private let closure: (_ value: String) -> Void
+
+  public init(_ closure: @escaping (_ value: String) -> Void) {
+    self.closure = closure
+  }
+
+  @inline(__always)
+  public func call(value: std.string) -> Void {
+    self.closure(String(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_std__string`.
+   * The pointer has to be a retained opaque `Unmanaged<Func_void_std__string>`.
+   * This removes one strong reference from the object!
+   */
+  @inline(__always)
+  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_std__string {
+    return Unmanaged<Func_void_std__string>.fromOpaque(pointer).takeRetainedValue()
+  }
+}

package/nitrogen/generated/ios/swift/HybridMetamaskConnectorSpec.swift

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

package/nitrogen/generated/ios/swift/HybridMetamaskConnectorSpec_cxx.swift

@@ -0,0 +1,157 @@
+///
+/// HybridMetamaskConnectorSpec_cxx.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
+
+/**
+ * A class implementation that bridges HybridMetamaskConnectorSpec 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:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - 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 {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::nitrometamask::bridge::swift`)
+   * from `NitroMetamask-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.nitrometamask.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridMetamaskConnectorSpec` Swift protocol.
+   */
+  private var __implementation: any HybridMetamaskConnectorSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridMetamaskConnectorSpec_
+
+  /**
+   * Create a new `HybridMetamaskConnectorSpec_cxx` that wraps the given `HybridMetamaskConnectorSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridMetamaskConnectorSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridMetamaskConnectorSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridMetamaskConnectorSpec() -> any HybridMetamaskConnectorSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridMetamaskConnectorSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridMetamaskConnectorSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridMetamaskConnectorSpec_cxx {
+    return Unmanaged<HybridMetamaskConnectorSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridMetamaskConnectorSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridMetamaskConnectorSpec_ {
+    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)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func connect() -> bridge.Result_std__shared_ptr_Promise_ConnectResult___ {
+    do {
+      let __result = try self.__implementation.connect()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_ConnectResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_ConnectResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_ConnectResult__(__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_ConnectResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_ConnectResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func signMessage(message: std.string) -> bridge.Result_std__shared_ptr_Promise_std__string___ {
+    do {
+      let __result = try self.__implementation.signMessage(message: String(message))
+      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++/ConnectResult.hpp

@@ -0,0 +1,87 @@
+///
+/// ConnectResult.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 (ConnectResult).
+   */
+  struct ConnectResult final {
+  public:
+    std::string address     SWIFT_PRIVATE;
+    std::string chainId     SWIFT_PRIVATE;
+
+  public:
+    ConnectResult() = default;
+    explicit ConnectResult(std::string address, std::string chainId): address(address), chainId(chainId) {}
+
+  public:
+    friend bool operator==(const ConnectResult& lhs, const ConnectResult& rhs) = default;
+  };
+
+} // namespace margelo::nitro::nitrometamask
+
+namespace margelo::nitro {
+
+  // C++ ConnectResult <> JS ConnectResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::nitrometamask::ConnectResult> final {
+    static inline margelo::nitro::nitrometamask::ConnectResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::nitrometamask::ConnectResult(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "address"))),
+        JSIConverter<std::string>::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<std::string>::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, "address")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "chainId")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,22 @@
+///
+/// HybridMetamaskConnectorSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "HybridMetamaskConnectorSpec.hpp"
+
+namespace margelo::nitro::nitrometamask {
+
+  void HybridMetamaskConnectorSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("connect", &HybridMetamaskConnectorSpec::connect);
+      prototype.registerHybridMethod("signMessage", &HybridMetamaskConnectorSpec::signMessage);
+    });
+  }
+
+} // namespace margelo::nitro::nitrometamask

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

@@ -0,0 +1,66 @@
+///
+/// HybridMetamaskConnectorSpec.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/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `ConnectResult` to properly resolve imports.
+namespace margelo::nitro::nitrometamask { struct ConnectResult; }
+
+#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++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMetamaskConnector: public HybridMetamaskConnectorSpec {
+   * public:
+   *   HybridMetamaskConnector(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMetamaskConnectorSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMetamaskConnectorSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMetamaskConnectorSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<ConnectResult>> connect() = 0;
+      virtual std::shared_ptr<Promise<std::string>> signMessage(const std::string& message) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MetamaskConnector";
+  };
+
+} // namespace margelo::nitro::nitrometamask

package/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@novastera-oss/nitro-metamask",
+  "version": "0.1.3",
+  "description": "nitro-metamask",
+  "main": "lib/index",
+  "module": "lib/index",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index",
+  "source": "src/index",
+  "files": [
+    "src",
+    "react-native.config.js",
+    "lib",
+    "nitrogen",
+    "android/build.gradle",
+    "android/gradle.properties",
+    "android/fix-prefab.gradle",
+    "android/CMakeLists.txt",
+    "android/src",
+    "ios/**/*.h",
+    "ios/**/*.m",
+    "ios/**/*.mm",
+    "ios/**/*.cpp",
+    "ios/**/*.swift",
+    "app.plugin.js",
+    "nitro.json",
+    "*.podspec",
+    "README.md"
+  ],
+  "scripts": {
+    "postinstall": "tsc || exit 0;",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf android/build node_modules/**/android/build lib",
+    "lint": "eslint \"**/*.{js,ts,tsx}\" --fix",
+    "lint-ci": "eslint \"**/*.{js,ts,tsx}\" -f @jamesacarr/github-actions",
+    "typescript": "tsc",
+    "specs": "tsc --noEmit false && nitrogen --logLevel=\"debug\""
+  },
+  "keywords": [
+    "react-native",
+    "nitro"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrousavy/nitro.git"
+  },
+  "author": "Marc Rousavy <me@mrousavy.com> (https://github.com/mrousavy)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mrousavy/nitro/issues"
+  },
+  "homepage": "https://github.com/mrousavy/nitro#readme",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@react-native/eslint-config": "0.82.0",
+    "@types/react": "^19.1.03",
+    "eslint": "^9.39.0",
+    "eslint-config-prettier": "^10.1.0",
+    "eslint-plugin-prettier": "^5.2.1",
+    "nitrogen": "^0.32.0",
+    "prettier": "^3.3.3",
+    "react": "19.1.1",
+    "react-native": "0.82.0",
+    "react-native-nitro-modules": "^0.32.0",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "react": "*",
+    "react-native": "*",
+    "react-native-nitro-modules": "^0.32.0"
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "@react-native",
+      "prettier"
+    ],
+    "plugins": [
+      "prettier"
+    ],
+    "rules": {
+      "prettier/prettier": [
+        "warn",
+        {
+          "quoteProps": "consistent",
+          "singleQuote": true,
+          "tabWidth": 2,
+          "trailingComma": "es5",
+          "useTabs": false
+        }
+      ]
+    }
+  },
+  "eslintIgnore": [
+    "node_modules/",
+    "lib/"
+  ],
+  "prettier": {
+    "quoteProps": "consistent",
+    "singleQuote": true,
+    "tabWidth": 2,
+    "trailingComma": "es5",
+    "useTabs": false,
+    "semi": false
+  }
+}

package/react-native.config.js

@@ -0,0 +1,16 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+
+module.exports = {
+  dependency: {
+    platforms: {
+      /**
+       * @type {import('@react-native-community/cli-types').IOSDependencyParams}
+       */
+      ios: {},
+      /**
+       * @type {import('@react-native-community/cli-types').AndroidDependencyParams}
+       */
+      android: {},
+    },
+  },
+}

package/src/MetamaskConnector.nitro.ts

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules'
+
+export interface ConnectResult {
+  address: string
+  chainId: string
+}
+
+export interface MetamaskConnector
+  extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
+  connect(): Promise<ConnectResult>
+  signMessage(message: string): Promise<string>
+}
+

package/src/index.ts

@@ -0,0 +1,8 @@
+import { NitroModules } from 'react-native-nitro-modules'
+
+import type { ConnectResult, MetamaskConnector } from './MetamaskConnector.nitro'
+
+export const metamaskConnector =
+  NitroModules.createHybridObject<MetamaskConnector>('MetamaskConnector')
+
+export type { ConnectResult, MetamaskConnector }

package/src/specs/Example.nitro.ts

@@ -0,0 +1 @@
+// TODO: Export specs that extend HybridObject<...> here