react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.22

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

@@ -39,28 +39,26 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWKkty <> JS JWKkty (union)
   template <>
-  struct JSIConverter<JWKkty> final {
-    static inline JWKkty fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWKkty> final {
+    static inline margelo::nitro::crypto::JWKkty fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("AES"): return JWKkty::AES;
-        case hashString("RSA"): return JWKkty::RSA;
-        case hashString("EC"): return JWKkty::EC;
-        case hashString("oct"): return JWKkty::OCT;
+        case hashString("AES"): return margelo::nitro::crypto::JWKkty::AES;
+        case hashString("RSA"): return margelo::nitro::crypto::JWKkty::RSA;
+        case hashString("EC"): return margelo::nitro::crypto::JWKkty::EC;
+        case hashString("oct"): return margelo::nitro::crypto::JWKkty::OCT;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKkty - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, JWKkty arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::JWKkty arg) {
       switch (arg) {
-        case JWKkty::AES: return JSIConverter<std::string>::toJSI(runtime, "AES");
-        case JWKkty::RSA: return JSIConverter<std::string>::toJSI(runtime, "RSA");
-        case JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
-        case JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
+        case margelo::nitro::crypto::JWKkty::AES: return JSIConverter<std::string>::toJSI(runtime, "AES");
+        case margelo::nitro::crypto::JWKkty::RSA: return JSIConverter<std::string>::toJSI(runtime, "RSA");
+        case margelo::nitro::crypto::JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
+        case margelo::nitro::crypto::JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKkty to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");

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

@@ -37,24 +37,22 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWKuse <> JS JWKuse (union)
   template <>
-  struct JSIConverter<JWKuse> final {
-    static inline JWKuse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWKuse> final {
+    static inline margelo::nitro::crypto::JWKuse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("sig"): return JWKuse::SIG;
-        case hashString("enc"): return JWKuse::ENC;
+        case hashString("sig"): return margelo::nitro::crypto::JWKuse::SIG;
+        case hashString("enc"): return margelo::nitro::crypto::JWKuse::ENC;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKuse - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, JWKuse arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::JWKuse arg) {
       switch (arg) {
-        case JWKuse::SIG: return JSIConverter<std::string>::toJSI(runtime, "sig");
-        case JWKuse::ENC: return JSIConverter<std::string>::toJSI(runtime, "enc");
+        case margelo::nitro::crypto::JWKuse::SIG: return JSIConverter<std::string>::toJSI(runtime, "sig");
+        case margelo::nitro::crypto::JWKuse::ENC: return JSIConverter<std::string>::toJSI(runtime, "enc");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKuse to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,25 +24,23 @@ namespace margelo::nitro::crypto {
    * An enum which can be represented as a JavaScript enum (KFormatType).
    */
   enum class KFormatType {
-    KKEYFORMATDER      SWIFT_NAME(kkeyformatder) = 0,
-    KKEYFORMATPEM      SWIFT_NAME(kkeyformatpem) = 1,
-    KKEYFORMATJWK      SWIFT_NAME(kkeyformatjwk) = 2,
+    DER      SWIFT_NAME(der) = 0,
+    PEM      SWIFT_NAME(pem) = 1,
+    JWK      SWIFT_NAME(jwk) = 2,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KFormatType <> JS KFormatType (enum)
   template <>
-  struct JSIConverter<KFormatType> final {
-    static inline KFormatType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KFormatType> final {
+    static inline margelo::nitro::crypto::KFormatType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<KFormatType>(enumValue);
+      return static_cast<margelo::nitro::crypto::KFormatType>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KFormatType arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KFormatType arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -51,10 +48,11 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.

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

@@ -47,14 +47,12 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyDetail <> JS KeyDetail (object)
   template <>
-  struct JSIConverter<KeyDetail> final {
-    static inline KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyDetail> final {
+    static inline margelo::nitro::crypto::KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return KeyDetail(
+      return margelo::nitro::crypto::KeyDetail(
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "length")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "publicExponent")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "modulusLength")),
@@ -64,7 +62,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "namedCurve"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const KeyDetail& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::KeyDetail& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "length", JSIConverter<std::optional<double>>::toJSI(runtime, arg.length));
       obj.setProperty(runtime, "publicExponent", JSIConverter<std::optional<double>>::toJSI(runtime, arg.publicExponent));

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,26 +24,24 @@ namespace margelo::nitro::crypto {
    * An enum which can be represented as a JavaScript enum (KeyEncoding).
    */
   enum class KeyEncoding {
-    KKEYENCODINGPKCS1      SWIFT_NAME(kkeyencodingpkcs1) = 0,
-    KKEYENCODINGPKCS8      SWIFT_NAME(kkeyencodingpkcs8) = 1,
-    KKEYENCODINGSPKI      SWIFT_NAME(kkeyencodingspki) = 2,
-    KKEYENCODINGSEC1      SWIFT_NAME(kkeyencodingsec1) = 3,
+    PKCS1      SWIFT_NAME(pkcs1) = 0,
+    PKCS8      SWIFT_NAME(pkcs8) = 1,
+    SPKI      SWIFT_NAME(spki) = 2,
+    SEC1      SWIFT_NAME(sec1) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyEncoding <> JS KeyEncoding (enum)
   template <>
-  struct JSIConverter<KeyEncoding> final {
-    static inline KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyEncoding> final {
+    static inline margelo::nitro::crypto::KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<KeyEncoding>(enumValue);
+      return static_cast<margelo::nitro::crypto::KeyEncoding>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyEncoding arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KeyEncoding arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -52,10 +49,11 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.

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

@@ -0,0 +1,67 @@
+///
+/// KeyObject.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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
+
+
+
+
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * A struct which can be represented as a JavaScript object (KeyObject).
+   */
+  struct KeyObject {
+  public:
+    bool extractable     SWIFT_PRIVATE;
+
+  public:
+    KeyObject() = default;
+    explicit KeyObject(bool extractable): extractable(extractable) {}
+  };
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ KeyObject <> JS KeyObject (object)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::KeyObject> final {
+    static inline margelo::nitro::crypto::KeyObject fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::crypto::KeyObject(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, "extractable"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::KeyObject& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "extractable", JSIConverter<bool>::toJSI(runtime, arg.extractable));
+      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 (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "extractable"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -34,16 +33,14 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyType <> JS KeyType (enum)
   template <>
-  struct JSIConverter<KeyType> final {
-    static inline KeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyType> final {
+    static inline margelo::nitro::crypto::KeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<KeyType>(enumValue);
+      return static_cast<margelo::nitro::crypto::KeyType>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyType arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KeyType arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -51,10 +48,11 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.

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

@@ -35,44 +35,54 @@ namespace margelo::nitro::crypto {
     VERIFY      SWIFT_NAME(verify) = 3,
     DERIVEKEY      SWIFT_NAME(derivekey) = 4,
     DERIVEBITS      SWIFT_NAME(derivebits) = 5,
-    WRAPKEY      SWIFT_NAME(wrapkey) = 6,
-    UNWRAPKEY      SWIFT_NAME(unwrapkey) = 7,
+    ENCAPSULATEBITS      SWIFT_NAME(encapsulatebits) = 6,
+    DECAPSULATEBITS      SWIFT_NAME(decapsulatebits) = 7,
+    ENCAPSULATEKEY      SWIFT_NAME(encapsulatekey) = 8,
+    DECAPSULATEKEY      SWIFT_NAME(decapsulatekey) = 9,
+    WRAPKEY      SWIFT_NAME(wrapkey) = 10,
+    UNWRAPKEY      SWIFT_NAME(unwrapkey) = 11,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyUsage <> JS KeyUsage (union)
   template <>
-  struct JSIConverter<KeyUsage> final {
-    static inline KeyUsage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyUsage> final {
+    static inline margelo::nitro::crypto::KeyUsage fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("encrypt"): return KeyUsage::ENCRYPT;
-        case hashString("decrypt"): return KeyUsage::DECRYPT;
-        case hashString("sign"): return KeyUsage::SIGN;
-        case hashString("verify"): return KeyUsage::VERIFY;
-        case hashString("deriveKey"): return KeyUsage::DERIVEKEY;
-        case hashString("deriveBits"): return KeyUsage::DERIVEBITS;
-        case hashString("wrapKey"): return KeyUsage::WRAPKEY;
-        case hashString("unwrapKey"): return KeyUsage::UNWRAPKEY;
+        case hashString("encrypt"): return margelo::nitro::crypto::KeyUsage::ENCRYPT;
+        case hashString("decrypt"): return margelo::nitro::crypto::KeyUsage::DECRYPT;
+        case hashString("sign"): return margelo::nitro::crypto::KeyUsage::SIGN;
+        case hashString("verify"): return margelo::nitro::crypto::KeyUsage::VERIFY;
+        case hashString("deriveKey"): return margelo::nitro::crypto::KeyUsage::DERIVEKEY;
+        case hashString("deriveBits"): return margelo::nitro::crypto::KeyUsage::DERIVEBITS;
+        case hashString("encapsulateBits"): return margelo::nitro::crypto::KeyUsage::ENCAPSULATEBITS;
+        case hashString("decapsulateBits"): return margelo::nitro::crypto::KeyUsage::DECAPSULATEBITS;
+        case hashString("encapsulateKey"): return margelo::nitro::crypto::KeyUsage::ENCAPSULATEKEY;
+        case hashString("decapsulateKey"): return margelo::nitro::crypto::KeyUsage::DECAPSULATEKEY;
+        case hashString("wrapKey"): return margelo::nitro::crypto::KeyUsage::WRAPKEY;
+        case hashString("unwrapKey"): return margelo::nitro::crypto::KeyUsage::UNWRAPKEY;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum KeyUsage - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyUsage arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KeyUsage arg) {
       switch (arg) {
-        case KeyUsage::ENCRYPT: return JSIConverter<std::string>::toJSI(runtime, "encrypt");
-        case KeyUsage::DECRYPT: return JSIConverter<std::string>::toJSI(runtime, "decrypt");
-        case KeyUsage::SIGN: return JSIConverter<std::string>::toJSI(runtime, "sign");
-        case KeyUsage::VERIFY: return JSIConverter<std::string>::toJSI(runtime, "verify");
-        case KeyUsage::DERIVEKEY: return JSIConverter<std::string>::toJSI(runtime, "deriveKey");
-        case KeyUsage::DERIVEBITS: return JSIConverter<std::string>::toJSI(runtime, "deriveBits");
-        case KeyUsage::WRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "wrapKey");
-        case KeyUsage::UNWRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "unwrapKey");
+        case margelo::nitro::crypto::KeyUsage::ENCRYPT: return JSIConverter<std::string>::toJSI(runtime, "encrypt");
+        case margelo::nitro::crypto::KeyUsage::DECRYPT: return JSIConverter<std::string>::toJSI(runtime, "decrypt");
+        case margelo::nitro::crypto::KeyUsage::SIGN: return JSIConverter<std::string>::toJSI(runtime, "sign");
+        case margelo::nitro::crypto::KeyUsage::VERIFY: return JSIConverter<std::string>::toJSI(runtime, "verify");
+        case margelo::nitro::crypto::KeyUsage::DERIVEKEY: return JSIConverter<std::string>::toJSI(runtime, "deriveKey");
+        case margelo::nitro::crypto::KeyUsage::DERIVEBITS: return JSIConverter<std::string>::toJSI(runtime, "deriveBits");
+        case margelo::nitro::crypto::KeyUsage::ENCAPSULATEBITS: return JSIConverter<std::string>::toJSI(runtime, "encapsulateBits");
+        case margelo::nitro::crypto::KeyUsage::DECAPSULATEBITS: return JSIConverter<std::string>::toJSI(runtime, "decapsulateBits");
+        case margelo::nitro::crypto::KeyUsage::ENCAPSULATEKEY: return JSIConverter<std::string>::toJSI(runtime, "encapsulateKey");
+        case margelo::nitro::crypto::KeyUsage::DECAPSULATEKEY: return JSIConverter<std::string>::toJSI(runtime, "decapsulateKey");
+        case margelo::nitro::crypto::KeyUsage::WRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "wrapKey");
+        case margelo::nitro::crypto::KeyUsage::UNWRAPKEY: return JSIConverter<std::string>::toJSI(runtime, "unwrapKey");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert KeyUsage to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -90,6 +100,10 @@ namespace margelo::nitro {
         case hashString("verify"):
         case hashString("deriveKey"):
         case hashString("deriveBits"):
+        case hashString("encapsulateBits"):
+        case hashString("decapsulateBits"):
+        case hashString("encapsulateKey"):
+        case hashString("decapsulateKey"):
         case hashString("wrapKey"):
         case hashString("unwrapKey"):
           return true;

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

@@ -38,26 +38,24 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ NamedCurve <> JS NamedCurve (union)
   template <>
-  struct JSIConverter<NamedCurve> final {
-    static inline NamedCurve fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::NamedCurve> final {
+    static inline margelo::nitro::crypto::NamedCurve fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("P-256"): return NamedCurve::P_256;
-        case hashString("P-384"): return NamedCurve::P_384;
-        case hashString("P-521"): return NamedCurve::P_521;
+        case hashString("P-256"): return margelo::nitro::crypto::NamedCurve::P_256;
+        case hashString("P-384"): return margelo::nitro::crypto::NamedCurve::P_384;
+        case hashString("P-521"): return margelo::nitro::crypto::NamedCurve::P_521;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum NamedCurve - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, NamedCurve arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::NamedCurve arg) {
       switch (arg) {
-        case NamedCurve::P_256: return JSIConverter<std::string>::toJSI(runtime, "P-256");
-        case NamedCurve::P_384: return JSIConverter<std::string>::toJSI(runtime, "P-384");
-        case NamedCurve::P_521: return JSIConverter<std::string>::toJSI(runtime, "P-521");
+        case margelo::nitro::crypto::NamedCurve::P_256: return JSIConverter<std::string>::toJSI(runtime, "P-256");
+        case margelo::nitro::crypto::NamedCurve::P_384: return JSIConverter<std::string>::toJSI(runtime, "P-384");
+        case margelo::nitro::crypto::NamedCurve::P_521: return JSIConverter<std::string>::toJSI(runtime, "P-521");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert NamedCurve to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-quick-crypto",
-  "version": "1.0.0-beta.20",
+  "version": "1.0.0-beta.22",
   "description": "A fast implementation of Node's `crypto` module written in C/C++ JSI",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -9,6 +9,7 @@
   "source": "src/index",
   "scripts": {
     "clean": "del-cli android/build lib",
+    "clean:deep": "bun run clean && del-cli node_modules",
     "tsc": "tsc --noEmit",
     "typescript": "tsc --noEmit",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
@@ -73,28 +74,29 @@
   "dependencies": {
     "@craftzdog/react-native-buffer": "6.1.0",
     "events": "3.3.0",
-    "react-native-quick-base64": "2.2.0",
+    "expo-build-properties": "0.14.6",
+    "react-native-quick-base64": "2.2.2",
     "readable-stream": "4.5.2",
+    "safe-buffer": "^5.2.1",
     "util": "0.12.5"
   },
   "devDependencies": {
     "@types/jest": "29.5.11",
-    "@types/node": "22.0.0",
+    "@types/node": "24.3.0",
     "@types/react": "18.3.3",
     "@types/readable-stream": "4.0.18",
     "del-cli": "6.0.0",
-    "expo": "^47.0.0",
-    "expo-build-properties": "0.14.6",
+    "expo": "^52.0.0",
     "jest": "29.7.0",
-    "nitro-codegen": "0.25.2",
-    "react-native-builder-bob": "0.39.1",
-    "react-native-nitro-modules": "0.25.2"
+    "nitro-codegen": "0.29.1",
+    "react-native-builder-bob": "0.40.15",
+    "react-native-nitro-modules": "0.29.1"
   },
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "*",
-    "expo": ">=47.0.0"
+    "react-native-nitro-modules": ">=0.29.1",
+    "expo": ">=48.0.0"
   },
   "peerDependenciesMeta": {
     "expo": {
@@ -103,7 +105,8 @@
   },
   "release-it": {
     "npm": {
-      "publish": true
+      "publish": true,
+      "skipChecks": true
     },
     "git": false,
     "github": {

package/src/blake3.ts

@@ -0,0 +1,123 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import { Buffer } from '@craftzdog/react-native-buffer';
+import type { Blake3 as NativeBlake3 } from './specs/blake3.nitro';
+import type { BinaryLike, Encoding } from './utils';
+import { binaryLikeToArrayBuffer, ab2str } from './utils';
+
+const BLAKE3_KEY_LEN = 32;
+const BLAKE3_OUT_LEN = 32;
+
+export interface Blake3Options {
+  dkLen?: number;
+  key?: Uint8Array;
+  context?: string;
+}
+
+export class Blake3 {
+  private native: NativeBlake3;
+  private mode: 'hash' | 'keyed' | 'deriveKey';
+  private keyData?: Uint8Array;
+  private contextData?: string;
+
+  constructor(opts?: Blake3Options) {
+    this.native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+
+    if (opts?.key && opts?.context) {
+      throw new Error(
+        'BLAKE3: cannot use both key and context options together',
+      );
+    }
+
+    if (opts?.key) {
+      if (opts.key.length !== BLAKE3_KEY_LEN) {
+        throw new Error(`BLAKE3: key must be exactly ${BLAKE3_KEY_LEN} bytes`);
+      }
+      this.mode = 'keyed';
+      this.keyData = opts.key;
+      this.native.initKeyed(opts.key.buffer as ArrayBuffer);
+    } else if (opts?.context !== undefined) {
+      if (typeof opts.context !== 'string' || opts.context.length === 0) {
+        throw new Error('BLAKE3: context must be a non-empty string');
+      }
+      this.mode = 'deriveKey';
+      this.contextData = opts.context;
+      this.native.initDeriveKey(opts.context);
+    } else {
+      this.mode = 'hash';
+      this.native.initHash();
+    }
+  }
+
+  update(data: BinaryLike, inputEncoding?: Encoding): this {
+    const buffer = binaryLikeToArrayBuffer(data, inputEncoding ?? 'utf8');
+    this.native.update(buffer);
+    return this;
+  }
+
+  digest(): Buffer;
+  digest(encoding: Encoding): string;
+  digest(length: number): Buffer;
+  digest(encodingOrLength?: Encoding | number): Buffer | string {
+    let length: number | undefined;
+    let encoding: Encoding | undefined;
+
+    if (typeof encodingOrLength === 'number') {
+      length = encodingOrLength;
+    } else if (encodingOrLength) {
+      encoding = encodingOrLength;
+    }
+
+    const result = this.native.digest(length);
+
+    if (encoding && encoding !== 'buffer') {
+      return ab2str(result, encoding);
+    }
+
+    return Buffer.from(result);
+  }
+
+  digestLength(length: number): Buffer {
+    return Buffer.from(this.native.digest(length));
+  }
+
+  reset(): this {
+    this.native.reset();
+    return this;
+  }
+
+  copy(): Blake3 {
+    const copied = new Blake3();
+    // Replace the native with a copy
+    copied.native = this.native.copy() as NativeBlake3;
+    copied.mode = this.mode;
+    copied.keyData = this.keyData;
+    copied.contextData = this.contextData;
+    return copied;
+  }
+
+  static getVersion(): string {
+    const native = NitroModules.createHybridObject<NativeBlake3>('Blake3');
+    native.initHash();
+    return native.getVersion();
+  }
+}
+
+export function createBlake3(opts?: Blake3Options): Blake3 {
+  return new Blake3(opts);
+}
+
+export function blake3(data: BinaryLike, opts?: Blake3Options): Uint8Array {
+  const hasher = new Blake3(opts);
+  hasher.update(data);
+  const length = opts?.dkLen ?? BLAKE3_OUT_LEN;
+  const result = hasher.digestLength(length);
+  return new Uint8Array(result);
+}
+
+blake3.create = createBlake3;
+
+export const blake3Exports = {
+  Blake3,
+  createBlake3,
+  blake3,
+};