@hxa-rn/react-native-quick-crypto 1.1.0-beta.1

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/HybridFunction.hpp

@@ -0,0 +1,269 @@
+//
+//  HybridFunction.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+namespace margelo::nitro {
+template <typename T, typename Enable>
+struct JSIConverter;
+} // namespace margelo::nitro
+
+#include "CountTrailingOptionals.hpp"
+#include "InstanceMethod.hpp"
+#include "JSIConverter.hpp"
+#include "NitroDefines.hpp"
+#include "NitroTypeInfo.hpp"
+#include <exception>
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents the kind of a function - it can be either a normal function ("METHOD"),
+ * or a property ("GETTER" + "SETTER")
+ */
+enum class FunctionKind { METHOD, GETTER, SETTER };
+
+/**
+ * A helper for an `InstanceMethod` that doesn't have a typed return value or arguments, but instead uses raw JSI values.
+ */
+template <typename T>
+using RawInstanceMethod = InstanceMethod<
+    /* instance type */ T,
+    /* return value */ jsi::Value,
+    /* jsi::HostFunction arguments */ jsi::Runtime&, const jsi::Value&, const jsi::Value*, size_t>;
+
+/**
+ * Represents a Hybrid Function.
+ */
+class HybridFunction final {
+private:
+  jsi::HostFunctionType _function;
+  size_t _paramCount;
+  std::string _name;
+
+public:
+  // getters
+  inline const std::string& getName() const {
+    return _name;
+  }
+  inline size_t getParamCount() const {
+    return _paramCount;
+  }
+  inline const jsi::HostFunctionType& getHostFunction() const {
+    return _function;
+  }
+
+public:
+  // functions
+  inline jsi::Function toJSFunction(jsi::Runtime& runtime) const {
+    return jsi::Function::createFromHostFunction(runtime, jsi::PropNameID::forUtf8(runtime, _name), static_cast<unsigned int>(_paramCount),
+                                                 _function);
+  }
+
+private:
+  HybridFunction(jsi::HostFunctionType&& function, size_t paramCount, const std::string& name)
+      : _function(std::move(function)), _paramCount(paramCount), _name(name) {}
+
+public:
+  /**
+   * Create a new `HybridFunction` that can be called from JS.
+   * This performs proper JSI -> C++ conversion using `JSIConverter<T>`,
+   * and assumes that the object this is called on has a proper `this` configured.
+   * The object's `this` needs to be a `NativeState`.
+   */
+  template <typename THybrid, typename ReturnType, typename... Args>
+  static inline HybridFunction createHybridFunction(/* The name of the method */ const std::string& name,
+                                                    /* The method on THybrid */ InstanceMethod<THybrid, ReturnType, Args...> method,
+                                                    /* The type of the method */ FunctionKind kind) {
+    jsi::HostFunctionType hostFunction = [name, method, kind](/* JS Runtime */ jsi::Runtime& runtime,
+                                                              /* HybridObject */ const jsi::Value& thisValue,
+                                                              /* JS arguments */ const jsi::Value* NON_NULL args,
+                                                              /* argument size */ size_t count) -> jsi::Value {
+      // 1. Get actual `HybridObject` instance from `thisValue` (it's stored as `NativeState`)
+      std::shared_ptr<THybrid> hybridInstance = getHybridObjectNativeState<THybrid>(runtime, thisValue, kind, name);
+
+      // 2. Make sure the given arguments match, either with a static size, or with potentially optional arguments size.
+      constexpr size_t optionalArgsCount = trailing_optionals_count_v<Args...>;
+      constexpr size_t maxArgsCount = sizeof...(Args);
+      constexpr size_t minArgsCount = maxArgsCount - optionalArgsCount;
+      bool isWithinArgsRange = (count >= minArgsCount && count <= maxArgsCount);
+      if (!isWithinArgsRange) [[unlikely]] {
+        // invalid amount of arguments passed!
+        std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
+        if constexpr (minArgsCount == maxArgsCount) {
+          // min and max args length is the same, so we don't have any optional parameters. fixed count
+          throw jsi::JSError(runtime, "`" + funcName + "` expected " + std::to_string(maxArgsCount) + " arguments, but received " +
+                                          std::to_string(count) + "!");
+        } else {
+          // min and max args length are different, so we have optional parameters - variable length arguments.
+          throw jsi::JSError(runtime, "`" + funcName + "` expected between " + std::to_string(minArgsCount) + " and " +
+                                          std::to_string(maxArgsCount) + " arguments, but received " + std::to_string(count) + "!");
+        }
+      }
+
+      try {
+        // 3. Actually call the method with JSI values as arguments and return a JSI value again.
+        //    Internally, this method converts the JSI values to C++ values using `JSIConverter<T>`.
+        return callMethod(hybridInstance.get(), method, runtime, args, count, std::index_sequence_for<Args...>{});
+      } catch (const std::exception& exception) {
+        // Some exception was thrown - add method name information and re-throw as `JSError`.
+        std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
+        std::string message = exception.what();
+        throw jsi::JSError(runtime, funcName + ": " + message);
+      } catch (...) {
+        // Some unknown exception was thrown - add method name information and re-throw as `JSError`.
+        std::string funcName = getHybridFuncFullName<THybrid>(kind, name, hybridInstance.get());
+        std::string errorName = TypeInfo::getCurrentExceptionName();
+        throw jsi::JSError(runtime, "`" + funcName + "` threw an unknown " + errorName + " error.");
+      }
+    };
+
+    return HybridFunction(std::move(hostFunction), sizeof...(Args), name);
+  }
+
+  /**
+   * Create a new `HybridFunction` that can be called from JS.
+   * Unlike `createHybridFunction(...)`, this method does **not** perform any argument parsing or size checking.
+   * It is a raw-, untyped JSI method, and the user is expected to manually handle arguments and return values.
+   */
+  template <typename Derived>
+  static inline HybridFunction createRawHybridFunction(/* The name of the raw method */ const std::string& name,
+                                                       /* The number of expected arguments */ size_t expectedArgumentsCount,
+                                                       /* The raw JSI method on the instance */ RawInstanceMethod<Derived> method) {
+    jsi::HostFunctionType hostFunction = [name, method](/* JS Runtime */ jsi::Runtime& runtime,
+                                                        /* HybridObject */ const jsi::Value& thisValue,
+                                                        /* JS arguments */ const jsi::Value* args,
+                                                        /* argument size */ size_t count) -> jsi::Value {
+      // 1. Get actual `HybridObject` instance from `thisValue` (it's stored as `NativeState`)
+      std::shared_ptr<Derived> hybridInstance = getHybridObjectNativeState<Derived>(runtime, thisValue, FunctionKind::METHOD, name);
+
+      // 2. Call the raw JSI method using raw JSI Values. Exceptions are also expected to be handled by the user.
+      Derived* pointer = hybridInstance.get();
+      return (pointer->*method)(runtime, thisValue, args, count);
+    };
+
+    return HybridFunction(std::move(hostFunction), expectedArgumentsCount, name);
+  }
+
+private:
+  /**
+   * Calls the given method on the given instance with the given `jsi::Value` arguments by converting them to the desired target types.
+   * The given method's return value will be converted to a `jsi::Value` again.
+   */
+  template <typename Derived, typename ReturnType, typename... Args, size_t... Is>
+  static inline jsi::Value callMethod(/* The instance to call the method on */ Derived* NON_NULL obj,
+                                      /* The method to call */ InstanceMethod<Derived, ReturnType, Args...> method,
+                                      /* JS Runtime */ jsi::Runtime& runtime,
+                                      /* JS Arguments */ const jsi::Value* NON_NULL args,
+                                      /* JS Arguments count */ size_t argsSize, std::index_sequence<Is...>) {
+    static const jsi::Value defaultValue;
+
+    if constexpr (std::is_void_v<ReturnType>) {
+      // It's a void method.
+      (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
+      return jsi::Value::undefined();
+    } else {
+      // It's returning some C++ type, we need to convert that to a JSI value now.
+      ReturnType result = (obj->*method)(JSIConverter<std::decay_t<Args>>::fromJSI(runtime, Is < argsSize ? args[Is] : defaultValue)...);
+      return JSIConverter<ReturnType>::toJSI(runtime, std::forward<ReturnType>(result));
+    }
+  }
+
+private:
+  /**
+   * Get the `NativeState` of the given `value`.
+   */
+  template <typename THybrid>
+  static inline std::shared_ptr<THybrid> getHybridObjectNativeState(jsi::Runtime& runtime, const jsi::Value& value,
+                                                                    [[maybe_unused]] FunctionKind funcKind,
+                                                                    [[maybe_unused]] const std::string& funcName) {
+    // 1. Convert jsi::Value to jsi::Object
+#ifdef NITRO_DEBUG
+    if (!value.isObject()) [[unlikely]] {
+      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
+                                      " - `this` is not bound! Suggestions:\n"
+                                      "- Did you accidentally destructure the `HybridObject`? (`const { " +
+                                      funcName +
+                                      " } = ...`)\n"
+                                      "- Did you call `dispose()` on the `HybridObject` before?"
+                                      "- Did you accidentally call `" +
+                                      funcName + "` on the prototype directly?");
+    }
+#endif
+    jsi::Object object = value.getObject(runtime);
+
+    // 2. Check if it even has any kind of `NativeState`
+#ifdef NITRO_DEBUG
+    if (!object.hasNativeState(runtime)) [[unlikely]] {
+      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
+                                      " - `this` does not have a NativeState! Suggestions:\n"
+                                      "- Did you accidentally destructure the `HybridObject`? (`const { " +
+                                      funcName +
+                                      " } = ...`)\n"
+                                      "- Did you call `dispose()` on the `HybridObject` before?"
+                                      "- Did you accidentally call `" +
+                                      funcName + "` on the prototype directly?");
+    }
+#endif
+
+    // 3. Get `NativeState` from the jsi::Object and check if it is non-null
+    std::shared_ptr<jsi::NativeState> nativeState = object.getNativeState(runtime);
+#ifdef NITRO_DEBUG
+    if (nativeState == nullptr) [[unlikely]] {
+      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
+                                      " - `this`'s `NativeState` is `null`, "
+                                      "did you accidentally call `dispose()` on this object?");
+    }
+#endif
+
+    // 4. Try casting it to our desired target type.
+    std::shared_ptr<THybrid> hybridInstance = std::dynamic_pointer_cast<THybrid>(nativeState);
+#ifdef NITRO_DEBUG
+    if (hybridInstance == nullptr) [[unlikely]] {
+      throw jsi::JSError(runtime, "Cannot " + getHybridFuncDebugInfo<THybrid>(funcKind, funcName) +
+                                      " - `this` has a NativeState, but it's the wrong type!");
+    }
+#endif
+    return hybridInstance;
+  }
+
+private:
+  template <typename THybrid>
+  static inline std::string getHybridFuncFullName(FunctionKind kind, const std::string& registrationName,
+                                                  THybrid* NULLABLE hybridInstance = nullptr) {
+    std::string typeName = hybridInstance != nullptr ? hybridInstance->getName() : TypeInfo::getFriendlyTypename<THybrid>(true);
+    switch (kind) {
+      case FunctionKind::METHOD:
+        return typeName + "." + registrationName + "(...)";
+      case FunctionKind::GETTER:
+      case FunctionKind::SETTER:
+        return typeName + "." + registrationName;
+    }
+  }
+  template <typename THybrid>
+  static inline std::string getHybridFuncDebugInfo(FunctionKind kind, const std::string& registrationName,
+                                                   THybrid* NULLABLE hybridInstance = nullptr) {
+    auto funcName = getHybridFuncFullName<THybrid>(kind, registrationName, hybridInstance);
+    switch (kind) {
+      case FunctionKind::METHOD:
+        return "call hybrid function `" + funcName + "`";
+      case FunctionKind::GETTER:
+        return "get hybrid property `" + funcName + "`";
+      case FunctionKind::SETTER:
+        return "set hybrid property `" + funcName + "`";
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/HybridNitroModulesProxy.hpp

@@ -0,0 +1,52 @@
+//
+//  HybridNitroModulesProxy.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#pragma once
+
+#include "BoxedHybridObject.hpp"
+#include "HybridObject.hpp"
+#include <memory>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * Represents the entry point for all other HybridObjects.
+ * The flow is as following:
+ * 1. (optional) Install a Dispatcher in `jsi::Runtime` to use async/callbacks.
+ * 2. Create an instance of `HybridNitroModulesProxy`
+ * 3. Pass the object from `.toObject()` it to JS (either install in global, or return somehow)
+ * 4. From JS, you can access methods on this HybridObject to create all other HybridObjects.
+ */
+class HybridNitroModulesProxy final : public HybridObject {
+public:
+  explicit HybridNitroModulesProxy() : HybridObject(TAG) {}
+
+public:
+  void loadHybridMethods() override;
+
+public:
+  // Hybrid Object Registry
+  std::shared_ptr<HybridObject> createHybridObject(const std::string& name);
+  bool hasHybridObject(const std::string& name);
+  std::vector<std::string> getAllHybridObjectNames();
+
+  // Helpers
+  std::shared_ptr<BoxedHybridObject> box(const std::shared_ptr<HybridObject>& hybridObject);
+  std::shared_ptr<HybridObject> updateMemorySize(const std::shared_ptr<HybridObject>& hybridObject);
+  jsi::Value hasNativeState(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t size);
+  jsi::Value isHybridObject(jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* args, size_t size);
+
+  // Build Info
+  std::string getBuildType();
+  std::string getVersion();
+
+private:
+  static constexpr auto TAG = "NitroModulesProxy";
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/HybridObject.hpp

@@ -0,0 +1,152 @@
+//
+// Created by Marc Rousavy on 21.02.24.
+//
+
+#pragma once
+
+#include "HybridObjectPrototype.hpp"
+
+#include "NitroDefines.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a C++ object that is exposed to JS.
+ * `HybridObject`s can have native getters and setters, and normal methods.
+ *
+ * To implement a `HybridObject`, simply inherit from this class and override `loadHybridMethods`
+ * to register the given getters, setters or methods.
+ *
+ * The new class can then be passed to JS using the `JSIConverter<HybridObject>`.
+ */
+class HybridObject : public virtual jsi::NativeState, public HybridObjectPrototype, public std::enable_shared_from_this<HybridObject> {
+public:
+  /**
+   * Create a new instance of a `HybridObject`.
+   * The given `name` will be used for logging and stringifying.
+   */
+  explicit HybridObject(const char* NON_NULL name);
+  /**
+   * Called when no more references to the given `HybridObject` exist in both C++ and JS.
+   * JS might keep references for longer, as it is a garbage collected language.
+   */
+  ~HybridObject() override = default;
+  /**
+   * HybridObjects cannot be copied.
+   */
+  HybridObject(const HybridObject& copy) = delete;
+  /**
+   * HybridObjects cannot be moved.
+   */
+  HybridObject(HybridObject&& move) = delete;
+  /**
+   * HybridObjects cannot be default-constructed!
+   * Use this instead;
+   * ```cpp
+   * MyHybridObject(): HybridObject(TAG) {}
+   * ```
+   */
+  HybridObject() {
+    throw std::runtime_error("Cannot default-construct HybridObject! "
+                             "Did you forget to add the `HybridObject(TAG)` base-constructor call to your Hybrid Object's constructor?");
+  }
+
+public:
+  /**
+   * Return the `jsi::Object` that holds this `HybridObject`. (boxed in a `jsi::Value`)
+   * This properly assigns (or creates) the base prototype for this type,
+   * and assigns it's NativeState.
+   * Additionally, this sets the external memory pressure for proper GC memory management.
+   */
+  jsi::Value toObject(jsi::Runtime& runtime);
+
+public:
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject as it's concrete type.
+   * The HybridObject must be managed inside a `shared_ptr` already, otherwise this will fail.
+   */
+  template <typename Derived>
+  std::shared_ptr<Derived> shared_cast() {
+    return std::dynamic_pointer_cast<Derived>(shared());
+  }
+  /**
+   * Get the `std::shared_ptr` instance of this HybridObject.
+   */
+  virtual std::shared_ptr<HybridObject> shared();
+
+public:
+  /**
+   * Get the HybridObject's name
+   */
+  std::string getName();
+  /**
+   * Compare this HybridObject for reference equality to the other HybridObject.
+   *
+   * While two `jsi::Object`s of the same `HybridObject` might not be equal when compared with `==`,
+   * they might still be the same `HybridObject` - in this case `equals(other)` will return true.
+   */
+  bool equals(const std::shared_ptr<HybridObject>& other);
+  /**
+   * Get a string representation of this `HybridObject` - useful for logging or debugging.
+   */
+  virtual std::string toString();
+  /**
+   * Eagerly- (and manually-) dispose all native resources this `HybridObject` holds.
+   * This method can only be manually called from JS using `dispose()`.
+   *
+   * If this method is never manually called, a `HybridObject` is expected to disposes it's
+   * resources as usual via the object's destructor (`~HybridObject()`, `deinit` or `finalize()`).
+   *
+   * By default, this method does nothing. It can be overridden to perform actual disposing/cleanup
+   * if required.
+   */
+  virtual void dispose() {}
+
+private:
+  /**
+   * The actual `dispose()` function from JS.
+   * This needs to be a raw JSI function as we remove the NativeState here.
+   */
+  jsi::Value disposeRaw(jsi::Runtime& runtime, const jsi::Value& thisArg, const jsi::Value* NON_NULL args, size_t count);
+
+protected:
+  /**
+   * Get the size of any external (heap) allocations this `HybridObject` has made, in bytes.
+   * This will be used to notify the JS GC about memory pressure.
+   */
+  virtual inline size_t getExternalMemorySize() noexcept {
+    return 0;
+  }
+
+protected:
+  /**
+   * Loads all native methods of this `HybridObject` to be exposed to JavaScript.
+   * The base implementation registers a `toString()` method and `name` property.
+   *
+   * Example:
+   *
+   * ```cpp
+   * int User::getAge() {
+   *   return 23;
+   * }
+   *
+   * void User::loadHybridMethods() {
+   *   HybridObject::loadHybridMethods();
+   *   registerHybridMethod("getAge", &User::getAge);
+   * }
+   * ```
+   */
+  virtual void loadHybridMethods() override;
+
+private:
+  static constexpr auto TAG = "HybridObject";
+  const char* NON_NULL _name = TAG;
+  std::unordered_map<jsi::Runtime*, BorrowingReference<jsi::WeakObject>> _objectCache;
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/HybridObjectPrototype.hpp

@@ -0,0 +1,93 @@
+//
+//  HybridObjectPrototype.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 07.08.24.
+//
+
+#pragma once
+
+#include "BorrowingReference.hpp"
+#include "HybridFunction.hpp"
+#include "NitroDefines.hpp"
+#include "Prototype.hpp"
+#include "PrototypeChain.hpp"
+#include <functional>
+#include <jsi/jsi.h>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <type_traits>
+
+namespace margelo::nitro {
+
+using namespace facebook;
+
+/**
+ * Represents a Hybrid Object's prototype.
+ * The prototype should be cached per Runtime, and can be assigned to multiple jsi::Objects.
+ * When assigned to a jsi::Object, all methods of this prototype can be called on that jsi::Object,
+ * as long as it has a valid NativeState (`this`).
+ */
+class HybridObjectPrototype {
+private:
+  PrototypeChain _prototypeChain;
+  bool _didLoadMethods = false;
+  static constexpr auto TAG = "HybridObjectPrototype";
+
+public:
+  HybridObjectPrototype() {}
+
+public:
+  /**
+   * Get a fully initialized jsi::Object that represents this prototype to JS.
+   * The result of this value will be cached per Runtime, so it's safe to call this often.
+   */
+  jsi::Value getPrototype(jsi::Runtime& runtime);
+
+private:
+  static jsi::Value createPrototype(jsi::Runtime& runtime, const std::shared_ptr<Prototype>& prototype);
+  using PrototypeCache = std::unordered_map<NativeInstanceId, BorrowingReference<jsi::Object>>;
+  static std::unordered_map<jsi::Runtime * NON_NULL, PrototypeCache> _prototypeCache;
+
+protected:
+  /**
+   * Loads all Hybrid Methods that will be initialized in this Prototype.
+   * This will only be called once for the first time the Prototype will be created,
+   * so don't conditionally register methods.
+   */
+  virtual void loadHybridMethods() = 0;
+
+private:
+  /**
+   * Ensures that all Hybrid Methods, Getters and Setters are initialized by calling loadHybridMethods().
+   */
+  inline void ensureInitialized() {
+    if (!_didLoadMethods) [[unlikely]] {
+      // lazy-load all exposed methods
+      loadHybridMethods();
+      _didLoadMethods = true;
+    }
+  }
+
+protected:
+  using RegisterFn = void (*NON_NULL)(Prototype&);
+  /**
+   * Registers the given methods inside the Hybrid Object's prototype.
+   *
+   * For subsequent HybridObjects of the same type, `registerFunc` will not be called again, as the
+   * prototype will already be known and cached.
+   * **Do not conditionally register hybrid methods, getters or setter!**
+   */
+  template <typename Derived>
+  inline void registerHybrids(Derived* NON_NULL /* this */, RegisterFn registerFunc) {
+    const std::shared_ptr<Prototype>& prototype = _prototypeChain.extendPrototype<Derived>();
+
+    if (!prototype->hasHybrids()) {
+      // The `Prototype` does not have any methods or properties registered yet - so do it now
+      registerFunc(*prototype);
+    }
+  }
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/HybridObjectRegistry.hpp

@@ -0,0 +1,53 @@
+//
+//  HybridObjectRegistry.hpp
+//  react-native-nitro
+//
+//  Created by Marc Rousavy on 22.07.24.
+//
+
+#pragma once
+
+#include "HybridObject.hpp"
+#include <functional>
+#include <string>
+
+namespace margelo::nitro {
+
+/**
+ * A registry that holds initializers for HybridObjects.
+ * This will be used to initialize them from JS using `NitroModules.createHybridObject<T>(name)`.
+ */
+class HybridObjectRegistry {
+public:
+  HybridObjectRegistry() = delete;
+
+public:
+  using HybridObjectConstructorFn = std::function<std::shared_ptr<HybridObject>()>;
+
+public:
+  /**
+   * Registers the given HybridObject in the `HybridObjectRegistry`.
+   * It will be uniquely identified via it's `hybridObjectName`, and can be initialized from
+   * JS using `NitroModules.createHybridObject<T>(name)` - which will call the `constructorFn` here.
+   */
+  static void registerHybridObjectConstructor(const std::string& hybridObjectName, HybridObjectConstructorFn&& constructorFn);
+
+  /**
+   * Unregisters a Hybrid Object with the given `hybridObjectName`.
+   * It is recommended to not use this method, as this makes HybridObject constructors unpredictable from JS.
+   */
+  static void unregisterHybridObjectConstructor(const std::string& hybridObjectName);
+
+  static std::shared_ptr<HybridObject> createHybridObject(const std::string& hybridObjectName);
+  static bool hasHybridObject(const std::string& hybridObjectName);
+  static std::vector<std::string> getAllHybridObjectNames();
+
+private:
+  static std::unordered_map<std::string, HybridObjectConstructorFn>& getRegistry();
+  static std::string getAllRegisteredHybridObjectNamesToString();
+
+private:
+  static constexpr auto TAG = "HybridObjectRegistry";
+};
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/InstallNitro.hpp

@@ -0,0 +1,41 @@
+//
+//  InstallNitro.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 05.10.24
+//
+
+#pragma once
+
+#include "Dispatcher.hpp"
+#include <jsi/jsi.h>
+#include <memory>
+
+namespace margelo::nitro {
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * Also registers the given `dispatcher` which allows using callbacks,
+ * and async code (Promises).
+ * The `dispatcher` needs to implement `runAsync`/`runSync` to run
+ * methods on whatever Thread can safely access `runtime`.
+ * In a non-thread-safe Runtime, it needs to be a single Thread (e.g.
+ * React's `CallInvoker`), but in a thread-safe Runtime it might just be
+ * an implementation that runs the method directly.
+ */
+void install(jsi::Runtime& runtime, std::shared_ptr<Dispatcher> dispatcher);
+
+/**
+ * Installs Nitro into the given JS `runtime`.
+ * This will create `global.NitroModulesProxy`, Nitro's entry-point,
+ * which can be used to create all registered HybridObjects from JS.
+ *
+ * No `Dispatcher` will be installed, meaning Nitro can only use synchronous
+ * methods.
+ */
+void install(jsi::Runtime& runtime);
+
+} // namespace margelo::nitro

package/harmony/quick_crypto/src/main/cpp/nitro/NitroModules/InstanceMethod.hpp

@@ -0,0 +1,23 @@
+//
+//  InstanceMethod.hpp
+//  NitroModules
+//
+//  Created by Marc Rousavy on 25.09.25.
+//
+
+#pragma once
+
+#include "NitroDefines.hpp"
+
+namespace margelo::nitro {
+
+/**
+ * Represents a Function pointer to an instance method of the given class.
+ * For example:
+ * `InstanceMethod<std::string, size_t>` could point to `size_t std::string::length()`
+ * `InstanceMethod<std::vector<int>, void, int>` could point to `void std::vector<int>::push_back(int)`
+ */
+template <typename T, typename ReturnType, typename... Args>
+using InstanceMethod = ReturnType (T::*NON_NULL)(Args...);
+
+} // namespace margelo::nitro