fix: address review findings across new modules

- getCipherInfo: use canonical OpenSSL name via cipher.getName(), remove number from signature
- Certificate: use safer empty ArrayBuffer pattern (non-null data pointer)
- Argon2: include OpenSSL error string in failure messages
- Prime: clean up callback signatures with proper union types
- Tests: strengthen verifySpkac assertion to assert.isTrue

Author: boorad

example/src/tests/certificate/certificate_tests.ts

@@ -21,9 +21,7 @@ const invalidSpkac = 'not-a-valid-spkac';
 
 test(SUITE, 'verifySpkac returns true for valid SPKAC', () => {
   const result = Certificate.verifySpkac(validSpkac);
-  assert.isBoolean(result);
-  // Note: result may be false if OpenSSL version doesn't support the specific key format
-  // The important thing is that it doesn't throw
+  assert.isTrue(result);
 });
 
 test(SUITE, 'verifySpkac returns false for invalid SPKAC', () => {

packages/react-native-quick-crypto/cpp/argon2/HybridArgon2.cpp

@@ -1,6 +1,7 @@
 #include <NitroModules/ArrayBuffer.hpp>
 #include <memory>
 #include <ncrypto.h>
+#include <openssl/err.h>
 #include <openssl/opensslv.h>
 #include <string>
 
@@ -50,7 +51,9 @@ static std::shared_ptr<ArrayBuffer> hashImpl(const std::string& algorithm, const
                       static_cast<uint32_t>(passes), static_cast<uint32_t>(version), secretBuf, adBuf, type);
 
   if (!result) {
-    throw std::runtime_error("Argon2 operation failed");
+    unsigned long err = ERR_peek_last_error();
+    const char* reason = err ? ERR_reason_error_string(err) : nullptr;
+    throw std::runtime_error(reason ? std::string("Argon2 operation failed: ") + reason : "Argon2 operation failed");
   }
 
   return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(result.get()), result.size());

packages/react-native-quick-crypto/cpp/certificate/HybridCertificate.cpp

@@ -13,12 +13,14 @@ std::shared_ptr<ArrayBuffer> HybridCertificate::exportPublicKey(const std::share
   auto bio = ncrypto::ExportPublicKey(reinterpret_cast<const char*>(spkac->data()), spkac->size());
 
   if (!bio) {
-    return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
   }
 
   BUF_MEM* mem = bio;
   if (!mem || mem->length == 0) {
-    return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
   }
 
   return ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(mem->data), mem->length);
@@ -28,7 +30,8 @@ std::shared_ptr<ArrayBuffer> HybridCertificate::exportChallenge(const std::share
   auto buf = ncrypto::ExportChallenge(reinterpret_cast<const char*>(spkac->data()), spkac->size());
 
   if (buf.data == nullptr) {
-    return std::make_shared<NativeArrayBuffer>(nullptr, 0, nullptr);
+    auto empty = new uint8_t[0];
+    return std::make_shared<NativeArrayBuffer>(empty, 0, [empty]() { delete[] empty; });
   }
 
   auto result = ToNativeArrayBuffer(reinterpret_cast<const uint8_t*>(buf.data), buf.len);

packages/react-native-quick-crypto/cpp/cipher/HybridCipher.cpp

@@ -376,7 +376,7 @@ std::optional<CipherInfo> HybridCipher::getCipherInfo(const std::string& name, s
     }
   }
 
-  std::string name_str(name);
+  std::string name_str(cipher.getName());
   std::transform(name_str.begin(), name_str.end(), name_str.begin(), ::tolower);
 
   std::string mode_str(cipher.getModeLabel());

packages/react-native-quick-crypto/src/cipher.ts

@@ -57,18 +57,11 @@ export function getCiphers(): string[] {
 }
 
 export function getCipherInfo(
-  nameOrNid: string | number,
+  name: string,
   options?: { keyLength?: number; ivLength?: number },
 ): CipherInfoResult | undefined {
-  if (typeof nameOrNid === 'string') {
-    if (nameOrNid.length === 0) return undefined;
-    return CipherUtils.getCipherInfo(
-      nameOrNid,
-      options?.keyLength,
-      options?.ivLength,
-    );
-  }
-  throw new TypeError('nameOrNid must be a string');
+  if (typeof name !== 'string' || name.length === 0) return undefined;
+  return CipherUtils.getCipherInfo(name, options?.keyLength, options?.ivLength);
 }
 
 interface CipherArgs {

packages/react-native-quick-crypto/src/prime.ts

@@ -66,16 +66,18 @@ export function generatePrimeSync(
   return result;
 }
 
+type GeneratePrimeCallback = (
+  err: Error | null,
+  prime: Buffer | bigint,
+) => void;
+
 export function generatePrime(
   size: number,
-  options?: GeneratePrimeOptions,
-  callback?: (err: Error | null, prime: Buffer | bigint) => void,
+  options: GeneratePrimeOptions | GeneratePrimeCallback,
+  callback?: GeneratePrimeCallback,
 ): void {
   if (typeof options === 'function') {
-    callback = options as unknown as (
-      err: Error | null,
-      prime: Buffer | bigint,
-    ) => void;
+    callback = options;
     options = {};
   }
   const safe = options?.safe ?? false;
@@ -108,16 +110,18 @@ export function checkPrimeSync(
   return getNative().checkPrimeSync(buf, checks);
 }
 
+type CheckPrimeCallback = (err: Error | null, result: boolean) => void;
+
 export function checkPrime(
   candidate: BinaryLike | bigint,
-  options?: CheckPrimeOptions | ((err: Error | null, result: boolean) => void),
-  callback?: (err: Error | null, result: boolean) => void,
+  options: CheckPrimeOptions | CheckPrimeCallback,
+  callback?: CheckPrimeCallback,
 ): void {
   if (typeof options === 'function') {
     callback = options;
     options = {};
   }
-  const checks = (options as CheckPrimeOptions)?.checks ?? 0;
+  const checks = options.checks ?? 0;
   const buf =
     typeof candidate === 'bigint'
       ? bigIntToBuffer(candidate)