diff --git a/.github/workflows/validate-cpp.yml b/.github/workflows/validate-cpp.yml
index cd9dad45..cb4da4f5 100644
--- a/.github/workflows/validate-cpp.yml
+++ b/.github/workflows/validate-cpp.yml
@@ -27,10 +27,12 @@ jobs:
           github_token: ${{ secrets.github_token }}
           reporter: github-pr-review
           flags: --linelength=230
-          targets: --recursive packages/react-native-quick-crypto/cpp packages/react-native-quick-crypto/android/src/main/cpp packages/react-native-quick-crypto/nitrogen/generated/shared/c++
+          targets: --recursive packages/react-native-quick-crypto/cpp packages/react-native-quick-crypto/android/src/main/cpp
           filter: "-legal/copyright\
             ,-readability/todo\
             ,-build/namespaces\
             ,-whitespace/comments\
             ,-build/include_order\
+            ,-whitespace/indent_namespace\
+            ,-whitespace/parens\
             "
diff --git a/bun.lockb b/bun.lockb
index 8ebdaea2..005a0446 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/docs/implementation-coverage.md b/docs/implementation-coverage.md
index 6fd759c6..4e89d93d 100644
--- a/docs/implementation-coverage.md
+++ b/docs/implementation-coverage.md
@@ -111,8 +111,8 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
   * ❌ `crypto.diffieHellman(options)`
   * ❌ `crypto.hash(algorithm, data[, outputEncoding])`
   * ❌ `crypto.generateKey(type, options, callback)`
-  * ❌ `crypto.generateKeyPair(type, options, callback)`
-  * ❌ `crypto.generateKeyPairSync(type, options)`
+  * 🚧 `crypto.generateKeyPair(type, options, callback)`
+  * 🚧 `crypto.generateKeyPairSync(type, options)`
   * ❌ `crypto.generateKeySync(type, options)`
   * ❌ `crypto.generatePrime(size[, options[, callback]])`
   * ❌ `crypto.generatePrimeSync(size[, options])`
@@ -141,10 +141,10 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
   * ❌ `crypto.secureHeapUsed()`
   * ❌ `crypto.setEngine(engine[, flags])`
   * ❌ `crypto.setFips(bool)`
-  * ❌ `crypto.sign(algorithm, data, key[, callback])`
+  * 🚧 `crypto.sign(algorithm, data, key[, callback])`
   * ❌ `crypto.subtle` (see below)
   * ❌ `crypto.timingSafeEqual(a, b)`
-  * ❌ `crypto.verify(algorithm, data, key, signature[, callback])`
+  * 🚧 `crypto.verify(algorithm, data, key, signature[, callback])`
   * ❌ `crypto.webcrypto` (see below)
 
 🚧 Details below still a work in progress 🚧
@@ -162,10 +162,10 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
 | `rsa-pss` | ❌ |
 | `dsa`     | ❌ |
 | `ec`      | ❌ |
-| `ed25519` | ❌ |
-| `ed448`   | ❌ |
-| `x25519`  | ❌ |
-| `x448`    | ❌ |
+| `ed25519` | ✅ |
+| `ed448`   | ✅ |
+| `x25519`  | ✅ |
+| `x448`    | ✅ |
 | `dh`      | ❌ |
 
 ## `crypto.generateKeyPairSync`
@@ -175,10 +175,10 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
 | `rsa-pss` | ❌ |
 | `dsa`     | ❌ |
 | `ec`      | ❌ |
-| `ed25519` | ❌ |
-| `ed448`   | ❌ |
-| `x25519`  | ❌ |
-| `x448`    | ❌ |
+| `ed25519` | ✅ |
+| `ed448`   | ✅ |
+| `x25519`  | ✅ |
+| `x448`    | ✅ |
 | `dh`      | ❌ |
 
 ## `crypto.generateKeySync`
@@ -187,6 +187,25 @@ This document attempts to describe the implementation status of Crypto APIs/Inte
 | `aes`      | ❌ |
 | `hmac`     | ❌ |
 
+## `crypto.sign`
+| Algorithm           | Status |
+| ---------           | :----: |
+| `RSASSA-PKCS1-v1_5` |  |
+| `RSA-PSS`           |  |
+| `ECDSA`             |  |
+| `Ed25519`           | ✅ |
+| `Ed448`             | ✅ |
+| `HMAC`              |  |
+
+## `crypto.verify`
+| Algorithm           | Status |
+| ---------           | :----: |
+| `RSASSA-PKCS1-v1_5` |  |
+| `RSA-PSS`           |  |
+| `ECDSA`             |  |
+| `Ed25519`           | ✅ |
+| `Ed448`             | ✅ |
+| `HMAC`              |  |
 
 # `WebCrypto`
 
diff --git a/example/index.ts b/example/index.ts
index 9167e9b7..fb144100 100644
--- a/example/index.ts
+++ b/example/index.ts
@@ -2,6 +2,9 @@
 import { install } from 'react-native-quick-crypto';
 install();
 
+// event-target-shim
+import 'event-target-polyfill';
+
 // readable-stream
 // @ts-expect-error - although process.version is readonly, we're setting it for readable-stream
 global.process.version = 'v22.0.0';
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index 79feb2aa..7534179d 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -7,19 +7,21 @@ PODS:
   - hermes-engine (0.76.1):
     - hermes-engine/Pre-built (= 0.76.1)
   - hermes-engine/Pre-built (0.76.1)
-  - NitroModules (0.14.0):
+  - NitroModules (0.18.1):
     - DoubleConversion
     - glog
     - hermes-engine
     - RCT-Folly (= 2024.01.01.00)
     - RCTRequired
     - RCTTypeSafety
+    - React-callinvoker
     - React-Core
     - React-debug
     - React-Fabric
     - React-featureflags
     - React-graphics
     - React-ImageManager
+    - React-jsi
     - React-NativeModulesApple
     - React-RCTFabric
     - React-rendererdebug
@@ -28,8 +30,8 @@ PODS:
     - ReactCommon/turbomodule/bridging
     - ReactCommon/turbomodule/core
     - Yoga
-  - OpenSSL-Universal (3.2.2000)
-  - QuickCrypto (1.0.0-beta.3):
+  - OpenSSL-Universal (3.3.2000)
+  - QuickCrypto (1.0.0-beta.5):
     - DoubleConversion
     - glog
     - hermes-engine
@@ -1936,9 +1938,9 @@ SPEC CHECKSUMS:
   fmt: 10c6e61f4be25dc963c36bd73fc7b1705fe975be
   glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a
   hermes-engine: 46f1ffbf0297f4298862068dd4c274d4ac17a1fd
-  NitroModules: 69a6524b390ed8ca220e15f00bcfbd2f7c24472e
-  OpenSSL-Universal: f8a9c4fdab7e21cb70bda471c269e86e9212439c
-  QuickCrypto: 452b6fe586fa5c0a93e7ccca0a619387763d5adf
+  NitroModules: 55f64932b4581a7d02103bc35b84c7bd3204106b
+  OpenSSL-Universal: b60a3702c9fea8b3145549d421fdb018e53ab7b4
+  QuickCrypto: 8d76ae3a0bf60509f671193eb4ed666a80da34cb
   RCT-Folly: 84578c8756030547307e4572ab1947de1685c599
   RCTDeprecation: fde92935b3caa6cb65cbff9fbb7d3a9867ffb259
   RCTRequired: 75c6cee42d21c1530a6f204ba32ff57335d19007
diff --git a/example/package.json b/example/package.json
index a1d1edcc..5e902394 100644
--- a/example/package.json
+++ b/example/package.json
@@ -21,6 +21,7 @@
   },
   "dependencies": {
     "@craftzdog/react-native-buffer": "6.0.5",
+    "@noble/curves": "^1.7.0",
     "@noble/hashes": "^1.5.0",
     "@react-navigation/bottom-tabs": "^6.6.1",
     "@react-navigation/native": "6.1.18",
@@ -28,17 +29,19 @@
     "buffer": "6.0.3",
     "chai": "<5.0.0",
     "crypto-browserify": "^3.12.0",
+    "event-target-polyfill": "^0.0.4",
     "events": "3.3.0",
     "react": "18.3.1",
     "react-native": "0.76.1",
     "react-native-bouncy-checkbox": "4.0.1",
-    "react-native-nitro-modules": "0.14.0",
+    "react-native-nitro-modules": "0.18.1",
     "react-native-quick-base64": "2.1.2",
-    "react-native-quick-crypto": "1.0.0-beta.5",
+    "react-native-quick-crypto": "workspace:*",
     "react-native-safe-area-context": "4.14.0",
     "react-native-screens": "3.35.0",
     "react-native-vector-icons": "^10.1.0",
     "readable-stream": "4.5.2",
+    "tinybench": "^3.0.6",
     "util": "0.12.5"
   },
   "devDependencies": {
@@ -86,7 +89,9 @@
       "@release-it/bumper": {
         "out": {
           "file": "package.json",
-          "path": ["dependencies.react-native-quick-crypto"]
+          "path": [
+            "dependencies.react-native-quick-crypto"
+          ]
         }
       }
     }
diff --git a/example/src/benchmarks/benchmarks.ts b/example/src/benchmarks/benchmarks.ts
index e79112ce..a0a2dbce 100644
--- a/example/src/benchmarks/benchmarks.ts
+++ b/example/src/benchmarks/benchmarks.ts
@@ -1,92 +1,57 @@
-import type {
-  BenchmarkFn,
-  BenchmarkResult,
-  Challenger,
-  ImportedBenchmark,
-  SuiteState,
-} from '../types/benchmarks';
-import { calculateTimes } from './utils';
+import type { Bench } from 'tinybench';
+import type { BenchFn, BenchmarkResult, SuiteState } from '../types/benchmarks';
 
 export class BenchmarkSuite {
   name: string;
   enabled: boolean;
-  benchmarks: Benchmark[];
+  benchmarks: BenchFn[];
   state: SuiteState;
   results: BenchmarkResult[] = [];
+  notes?: Record<string, string>;
 
-  constructor(name: string) {
+  constructor(
+    name: string,
+    benchmarks: BenchFn[],
+    notes?: Record<string, string>,
+  ) {
     this.name = name;
     this.enabled = false;
     this.state = 'idle';
-    this.benchmarks = [];
+    this.benchmarks = benchmarks;
     this.results = [];
-  }
-
-  addBenchmark(imported: ImportedBenchmark) {
-    this.benchmarks.push(new Benchmark(imported));
+    this.notes = notes;
   }
 
   addResult(result: BenchmarkResult) {
     this.results.push(result);
   }
 
-  run(multiplier: number = 1) {
+  async run() {
     this.results = [];
-    this.benchmarks.forEach(benchmark => {
-      benchmark.run(this, multiplier);
+    const promises = this.benchmarks.map(async benchFn => {
+      const b = await benchFn();
+      await b.run();
+      this.processResults(b);
+      this.state = 'done';
     });
+    await Promise.all(promises);
   }
-}
 
-export class Benchmark {
-  name: string; // function name
-  runCount: number;
-  us?: BenchmarkFn;
-  them: Challenger[];
-
-  constructor(benchmark: ImportedBenchmark) {
-    this.name = benchmark.name;
-    this.runCount = benchmark.runCount;
-    this.us = benchmark.us;
-    this.them = benchmark.them;
-  }
+  processResults = (b: Bench): void => {
+    const tasks = b.tasks;
+    const us = tasks.find(t => t.name === 'rnqc');
+    const themTasks = tasks.filter(t => t.name !== 'rnqc');
 
-  run(suite: BenchmarkSuite, multiplier: number = 1) {
-    const usTime = this.timeFn(this.us!, multiplier);
-    this.them.forEach(them => {
-      const themTime = this.timeFn(them.fn, multiplier);
-      const type = usTime < themTime ? 'faster' : 'slower';
-      const times = calculateTimes(usTime, themTime);
-      const result: BenchmarkResult = {
+    themTasks.map(them => {
+      const notes = this.notes?.[them.name] ?? '';
+      this.addResult({
         errorMsg: undefined,
         challenger: them.name,
-        notes: them.notes,
-        runCount: this.runCount * multiplier,
-        fnName: this.name,
-        time: themTime,
-        us: usTime,
-        type,
-        times,
-      };
-      suite.addResult(result);
+        notes,
+        benchName: b.name,
+        them: them.result,
+        us: us?.result,
+      });
     });
-  }
-
-  /**
-   * @returns time in ms
-   */
-  timeFn = (fn: BenchmarkFn, multiplier: number = 1): number => {
-    // warm up imports, etc.
-    fn();
-
-    const totalRunCount = this.runCount * multiplier;
-
-    // do the actual benchmark
-    const start = performance.now();
-    for (let i = 0; i < totalRunCount; i++) {
-      fn();
-    }
-    const end = performance.now();
-    return end - start;
   };
 }
diff --git a/example/src/benchmarks/ed/ed25519.ts b/example/src/benchmarks/ed/ed25519.ts
new file mode 100644
index 00000000..61ab6960
--- /dev/null
+++ b/example/src/benchmarks/ed/ed25519.ts
@@ -0,0 +1,80 @@
+import { Bench } from 'tinybench';
+import rnqc from 'react-native-quick-crypto';
+import { ed25519 as noble } from '@noble/curves/ed25519';
+import type { BenchFn } from '../../types/benchmarks';
+
+const TIME_MS = 1000;
+const message = 'hello world';
+const buffer = Buffer.from(message);
+const ab = buffer.buffer;
+const arr = new Uint8Array(buffer);
+
+const ed25519_sign_verify_async: BenchFn = async () => {
+  // rnqc setup
+  const ed = new rnqc.Ed('ed25519', {});
+  await ed.generateKeyPair();
+
+  // noble setup
+  const noblePrivateKey = noble.utils.randomPrivateKey();
+  const noblePublicKey = noble.getPublicKey(noblePrivateKey);
+
+  const bench = new Bench({
+    name: 'ed25519 sign/verify (async)',
+    time: TIME_MS,
+  });
+
+  bench.add('rnqc', async () => {
+    const signature = await ed.sign(ab);
+    const verified = await ed.verify(signature, ab);
+    if (!verified) {
+      throw new Error('Signature verification failed');
+    }
+  });
+
+  bench.add('@noble/curves/ed25519', () => {
+    const signature = noble.sign(arr, noblePrivateKey);
+    const verified = noble.verify(signature, arr, noblePublicKey);
+    if (!verified) {
+      throw new Error('Signature verification failed');
+    }
+  });
+
+  bench.warmupTime = 100;
+  return bench;
+};
+
+const ed25519_sign_verify_sync: BenchFn = () => {
+  // rnqc setup
+  const ed = new rnqc.Ed('ed25519', {});
+  ed.generateKeyPairSync();
+
+  // noble setup
+  const noblePrivateKey = noble.utils.randomPrivateKey();
+  const noblePublicKey = noble.getPublicKey(noblePrivateKey);
+
+  const bench = new Bench({
+    name: 'ed25519 sign/verify (sync)',
+    time: TIME_MS,
+  });
+
+  bench.add('rnqc', () => {
+    const signature = ed.signSync(ab);
+    const verified = ed.verifySync(signature, ab);
+    if (!verified) {
+      throw new Error('Signature verification failed');
+    }
+  });
+
+  bench.add('@noble/curves/ed25519', () => {
+    const signature = noble.sign(arr, noblePrivateKey);
+    const verified = noble.verify(signature, arr, noblePublicKey);
+    if (!verified) {
+      throw new Error('Signature verification failed');
+    }
+  });
+
+  bench.warmupTime = 100;
+  return bench;
+};
+
+export default [ed25519_sign_verify_async, ed25519_sign_verify_sync];
diff --git a/example/src/benchmarks/pbkdf2/pbkdf2.ts b/example/src/benchmarks/pbkdf2/pbkdf2.ts
index aab26a37..08f8af1a 100644
--- a/example/src/benchmarks/pbkdf2/pbkdf2.ts
+++ b/example/src/benchmarks/pbkdf2/pbkdf2.ts
@@ -3,44 +3,51 @@ import * as noble from '@noble/hashes/pbkdf2';
 import { sha256 } from '@noble/hashes/sha2';
 // @ts-expect-error - crypto-browserify is not typed
 import browserify from 'crypto-browserify';
+import type { BenchFn } from '../../types/benchmarks';
+import { Bench } from 'tinybench';
 
-import type { ImportedBenchmark } from '../../types/benchmarks';
-
-export const pbkdf2_256_1_32_async: ImportedBenchmark = {
-  name: 'pbkdf2_256_1_32_async',
-  runCount: 1000,
-  us: () => rnqc.pbkdf2('password', 'salt', 1, 32, 'sha256', () => {}),
-  them: [
-    {
-      name: '@noble/hashes/pbkdf2',
-      notes: '',
-      fn: () =>
-        noble.pbkdf2Async(sha256, 'password', 'salt', { c: 1, dkLen: 32 }),
-    },
-    {
-      name: 'browserify/pbkdf2',
-      notes: '',
-      fn: () =>
-        browserify.pbkdf2('password', 'salt', 1, 32, 'sha256', () => {}),
-    },
-  ],
+const TIME_MS = 1000;
+
+const pbkdf2_256_1_32_async: BenchFn = () => {
+  const bench = new Bench({
+    name: 'pbkdf2 sha256 1x 32b (async)',
+    time: TIME_MS,
+  });
+
+  bench
+    .add('rnqc', () => {
+      rnqc.pbkdf2('password', 'salt', 1, 32, 'sha256', () => {});
+    })
+    .add('@noble/hashes/pbkdf2', async () => {
+      await noble.pbkdf2Async(sha256, 'password', 'salt', { c: 1, dkLen: 32 });
+    })
+    .add('browserify/pbkdf2', () => {
+      browserify.pbkdf2('password', 'salt', 1, 32, 'sha256', () => {});
+    });
+
+  bench.warmupTime = 100;
+  return bench;
 };
 
-export const pbkdf2_256_1_32_sync: ImportedBenchmark = {
-  name: 'pbkdf2_256_1_32_sync',
-  runCount: 1000,
-  us: () =>
-    rnqc.pbkdf2Sync('password', 'salt', 1, 32, 'sha256' as HashAlgorithm),
-  them: [
-    {
-      name: '@noble/hashes/pbkdf2',
-      notes: '',
-      fn: () => noble.pbkdf2(sha256, 'password', 'salt', { c: 1, dkLen: 32 }),
-    },
-    {
-      name: 'browserify/pbkdf2',
-      notes: '',
-      fn: () => browserify.pbkdf2Sync('password', 'salt', 1, 32, 'sha256'),
-    },
-  ],
+const pbkdf2_256_1_32_sync: BenchFn = () => {
+  const bench = new Bench({
+    name: 'pbkdf2 sha256 1x 32b (sync)',
+    time: TIME_MS,
+  });
+
+  bench
+    .add('rnqc', () => {
+      rnqc.pbkdf2Sync('password', 'salt', 1, 32, 'sha256' as HashAlgorithm);
+    })
+    .add('@noble/hashes/pbkdf2', () => {
+      noble.pbkdf2(sha256, 'password', 'salt', { c: 1, dkLen: 32 });
+    })
+    .add('browserify/pbkdf2', () => {
+      browserify.pbkdf2Sync('password', 'salt', 1, 32, 'sha256');
+    });
+
+  bench.warmupTime = 100;
+  return bench;
 };
+
+export default [pbkdf2_256_1_32_async, pbkdf2_256_1_32_sync];
diff --git a/example/src/benchmarks/random/randomBytes.ts b/example/src/benchmarks/random/randomBytes.ts
index 9fb083ca..3b1ff3d8 100644
--- a/example/src/benchmarks/random/randomBytes.ts
+++ b/example/src/benchmarks/random/randomBytes.ts
@@ -1,30 +1,39 @@
 import rnqc from 'react-native-quick-crypto';
 // @ts-expect-error - crypto-browserify is not typed
 import browserify from 'crypto-browserify';
-import type { ImportedBenchmark } from '../../types/benchmarks';
-
-export const randomBytes10: ImportedBenchmark = {
-  name: 'randomBytes10',
-  runCount: 10000,
-  us: () => rnqc.randomBytes(10),
-  them: [
-    {
-      name: 'crypto-browserify',
-      notes: `crypto-browserify uses 'globalThis.crypto' under the hood, which on RN is this library, if polyfilled.  So this benchmark doesn't make a lot of sense.`,
-      fn: () => browserify.randomBytes(10),
-    },
-  ],
+import type { BenchFn } from '../../types/benchmarks';
+import { Bench } from 'tinybench';
+
+const TIME_MS = 1000;
+
+const randomBytes10: BenchFn = () => {
+  const bench = new Bench({
+    name: 'randomBytes10',
+    time: TIME_MS,
+  });
+
+  bench
+    .add('rnqc', () => {
+      rnqc.randomBytes(10);
+    })
+    .add('browserify/randombytes', () => browserify.randomBytes(10));
+
+  bench.warmupTime = 100;
+  return bench;
 };
 
-export const randomBytes1024: ImportedBenchmark = {
-  name: 'randomBytes1024',
-  runCount: 5000,
-  us: () => rnqc.randomBytes(1024),
-  them: [
-    {
-      name: 'crypto-browserify',
-      notes: `crypto-browserify uses 'globalThis.crypto' under the hood, which on RN is this library, if polyfilled.  So this benchmark doesn't make a lot of sense.`,
-      fn: () => browserify.randomBytes(1024),
-    },
-  ],
+const randomBytes1024: BenchFn = () => {
+  const bench = new Bench({
+    name: 'randomBytes1024',
+    time: TIME_MS,
+  });
+
+  bench
+    .add('rnqc', () => rnqc.randomBytes(1024))
+    .add('browserify/randombytes', () => browserify.randomBytes(1024));
+  bench.warmupTime = 100;
+
+  return bench;
 };
+
+export default [randomBytes10, randomBytes1024];
diff --git a/example/src/components/BenchmarkItem.tsx b/example/src/components/BenchmarkItem.tsx
index 2873924a..129aa627 100644
--- a/example/src/components/BenchmarkItem.tsx
+++ b/example/src/components/BenchmarkItem.tsx
@@ -5,11 +5,9 @@ import {
   StyleSheet,
   TouchableOpacity,
   ActivityIndicator,
-  InteractionManager,
 } from 'react-native';
 import BouncyCheckbox from 'react-native-bouncy-checkbox';
 import { useNavigation } from '@react-navigation/native';
-// import { calculateTimes, formatNumber } from '../benchmarks/utils';
 import { colors } from '../styles/colors';
 import type { BenchmarkSuite } from '../benchmarks/benchmarks';
 import { calculateTimes, formatNumber } from '../benchmarks/utils';
@@ -17,13 +15,13 @@ import { calculateTimes, formatNumber } from '../benchmarks/utils';
 type BenchmarkItemProps = {
   suite: BenchmarkSuite;
   toggle: () => void;
-  multiplier: number;
+  bumpRunCurrent: () => void;
 };
 
 export const BenchmarkItem: React.FC<BenchmarkItemProps> = ({
   suite,
   toggle,
-  multiplier,
+  bumpRunCurrent,
 }: BenchmarkItemProps) => {
   const [running, setRunning] = useState(false);
   const navigation = useNavigation();
@@ -35,38 +33,24 @@ export const BenchmarkItem: React.FC<BenchmarkItemProps> = ({
 
   useEffect(() => {
     const run = async () => {
-      await waitForGc();
-      suite.run(multiplier);
-      suite.state = 'done';
+      await suite.run();
       setRunning(false);
+      bumpRunCurrent();
     };
-    if (running) run();
+    if (running) {
+      run();
+    }
   }, [running]);
 
-  function delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  async function waitForGc(): Promise<void> {
-    await delay(500);
-    return new Promise(resolve => {
-      requestAnimationFrame(() => {
-        InteractionManager.runAfterInteractions(() => {
-          resolve();
-        });
-      });
-    });
-  }
-
   // results handling
-  const usTime = suite.results.reduce((acc, result) => {
-    return acc + result.us;
+  const usTput = suite.results.reduce((acc, result) => {
+    return acc + (result.us?.throughput.mean || 0);
   }, 0);
-  const themTime = suite.results.reduce((acc, result) => {
-    return acc + result.time;
+  const themTput = suite.results.reduce((acc, result) => {
+    return acc + (result.them?.throughput.mean || 0);
   }, 0);
-  const times = calculateTimes(usTime, themTime);
-  const timesStyle = usTime < themTime ? styles.faster : styles.slower;
+  const times = calculateTimes(usTput, themTput);
+  const timesStyle = usTput > themTput ? styles.faster : styles.slower;
 
   // render component
   return (
diff --git a/example/src/components/BenchmarkResultItem.tsx b/example/src/components/BenchmarkResultItem.tsx
index dc92bd4a..da5e003f 100644
--- a/example/src/components/BenchmarkResultItem.tsx
+++ b/example/src/components/BenchmarkResultItem.tsx
@@ -1,17 +1,18 @@
 import React from 'react';
 import { View, Text, StyleSheet } from 'react-native';
 import type { BenchmarkResult } from '../types/benchmarks';
-import { formatNumber } from '../benchmarks/utils';
+import { calculateTimes, formatNumber } from '../benchmarks/utils';
 import { colors } from '../styles/colors';
 
 type BenchmarkResultItemProps = {
   result: BenchmarkResult;
 };
 
+type Key = 'throughput' | 'latency';
+
 export const BenchmarkResultItemHeader: React.FC = () => {
   return (
     <View style={styles.itemContainer}>
-      <Text style={styles.text}>&nbsp;</Text>
       <Text style={[styles.text, styles.description]}>&nbsp;</Text>
       <Text style={styles.label}>times</Text>
       <Text style={styles.label}>rnqc</Text>
@@ -23,31 +24,49 @@ export const BenchmarkResultItemHeader: React.FC = () => {
 export const BenchmarkResultItem: React.FC<BenchmarkResultItemProps> = ({
   result,
 }: BenchmarkResultItemProps) => {
-  const emoji = result.type === 'faster' ? '🐇' : '🐢';
-  const timesType = result.type === 'faster' ? 'faster' : 'slower';
-  const timesStyle = timesType === 'faster' ? styles.faster : styles.slower;
+  const rows = ['throughput', 'latency'].map((key, i) => {
+    const us = result.us![key as Key].mean;
+    const them = result.them![key as Key].mean;
+    const comparison = key === 'throughput' ? us > them : us < them;
+    const places = key === 'throughput' ? 2 : 3;
+    const times = calculateTimes(us, them);
+    const emoji = comparison ? '🐇' : '🐢';
+    const timesType = comparison ? 'faster' : 'slower';
+    const timesStyle = timesType === 'faster' ? styles.faster : styles.slower;
+
+    return (
+      <View key={i}>
+        <View style={styles.itemContainer}>
+          <Text style={styles.text}>{emoji}</Text>
+          <Text style={[styles.text, styles.description]}>
+            {key} {key === 'throughput' ? '(ops/s)' : '(ms)'}
+          </Text>
+          <Text style={[styles.value, timesStyle]}>
+            {formatNumber(times, 2, 'x')}
+          </Text>
+          <Text style={styles.value}>{formatNumber(us, places, '')}</Text>
+          <Text style={styles.value}>{formatNumber(them, places, '')}</Text>
+        </View>
+      </View>
+    );
+  });
 
   return (
     <View>
-      <View style={styles.itemContainer}>
-        <Text style={styles.text}>{emoji}</Text>
-        <Text style={[styles.text, styles.description]}>{result.fnName}</Text>
-        <Text style={[styles.value, timesStyle]}>
-          {formatNumber(result.times, 2, 'x')}
-        </Text>
-        <Text style={styles.value}>{formatNumber(result.us, 2, 'ms')}</Text>
-        <Text style={styles.value}>{formatNumber(result.time, 2, 'ms')}</Text>
+      <View style={styles.subContainer}>
+        <Text style={[styles.sub, styles.benchName]}>{result.benchName}</Text>
       </View>
+      {rows}
       <View style={styles.subContainer}>
         <Text style={[styles.sub, styles.subLabel]}>challenger</Text>
         <Text style={[styles.sub, styles.subValue]}>{result.challenger}</Text>
-        <Text style={[styles.sub, styles.subLabel]}>runs</Text>
-        <Text style={[styles.sub, styles.subValue]}>{result.runCount}</Text>
-      </View>
-      <View style={styles.subContainer}>
-        <Text style={[styles.sub, styles.subLabel]}>notes</Text>
-        <Text style={[styles.sub, styles.notes]}>{result.notes}</Text>
       </View>
+      {result.notes !== '' && (
+        <View style={styles.subContainer}>
+          <Text style={[styles.sub, styles.subLabel]}>notes</Text>
+          <Text style={[styles.sub, styles.subValue]}>{result.notes}</Text>
+        </View>
+      )}
     </View>
   );
 };
@@ -60,6 +79,7 @@ const styles = StyleSheet.create({
   subContainer: {
     flexDirection: 'row',
     paddingHorizontal: 4,
+    paddingTop: 8,
   },
   text: {
     flexShrink: 1,
@@ -68,12 +88,14 @@ const styles = StyleSheet.create({
   },
   description: {
     flex: 3,
+    fontSize: 10,
+    alignSelf: 'flex-end',
   },
   value: {
     fontSize: 10,
     fontFamily: 'Courier New',
     minWidth: 60,
-    textAlign: 'center',
+    textAlign: 'right',
     alignSelf: 'flex-end',
   },
   label: {
@@ -101,8 +123,10 @@ const styles = StyleSheet.create({
   subValue: {
     flex: 2,
   },
-  notes: {
-    paddingTop: 2,
-    flex: 5,
+  benchName: {
+    fontSize: 10,
+    fontWeight: 'bold',
+    flex: 1,
+    textAlign: 'left',
   },
 });
diff --git a/example/src/hooks/useBenchmarks.ts b/example/src/hooks/useBenchmarks.ts
index 16d7930b..5342f79d 100644
--- a/example/src/hooks/useBenchmarks.ts
+++ b/example/src/hooks/useBenchmarks.ts
@@ -1,6 +1,8 @@
-/* eslint-disable @typescript-eslint/no-require-imports */
 import { useEffect, useState } from 'react';
 import { BenchmarkSuite } from '../benchmarks/benchmarks';
+import ed from '../benchmarks/ed/ed25519';
+import pbkdf2 from '../benchmarks/pbkdf2/pbkdf2';
+import random from '../benchmarks/random/randomBytes';
 
 export const useBenchmarks = (): [
   BenchmarkSuite[],
@@ -8,17 +10,47 @@ export const useBenchmarks = (): [
   () => void,
   () => void,
   () => void,
+  () => void,
 ] => {
   const [suites, setSuites] = useState<BenchmarkSuite[]>([]);
+  const [runCurrent, setRunCurrent] = useState<number>(-1);
 
   // initial load of benchmark suites
   useEffect(() => {
     const newSuites: BenchmarkSuite[] = [];
-    newSuites.push(random());
-    newSuites.push(pbkdf2());
+    newSuites.push(new BenchmarkSuite('ed', ed));
+    newSuites.push(new BenchmarkSuite('pbkdf2', pbkdf2));
+    newSuites.push(
+      new BenchmarkSuite('random', random, {
+        'browserify/randombytes':
+          'polyfilled with RNQC, so a somewhat senseless benchmark',
+      }),
+    );
     setSuites(newSuites);
   }, []);
 
+  // This jank is used to trick async functions into running synchronously
+  // so we run one benchmark at a time and have dedicated resources instead of
+  // conflicting with other benchmarks.
+  useEffect(() => {
+    if (runCurrent < 0) return; // not running benchmarks
+    // reset to -1 if we're past the end
+    if (runCurrent >= suites.length) {
+      setRunCurrent(-1);
+      return;
+    }
+    const s = suites[runCurrent];
+    if (s?.enabled) {
+      updateSuites(suite => {
+        if (suite.name === s.name) {
+          suite.state = 'running';
+        }
+      });
+    } else {
+      setRunCurrent(runCurrent + 1);
+    }
+  }, [runCurrent]);
+
   const updateSuites = (fn: (suite: BenchmarkSuite) => void) => {
     if (!suites.length) return;
     const copy = [...suites];
@@ -43,32 +75,13 @@ export const useBenchmarks = (): [
       suite.enabled = false;
     });
 
-  const runBenchmarks = () =>
-    updateSuites(suite => {
-      if (suite.enabled && suite.state !== 'running') {
-        suite.state = 'running';
-      }
-    });
-
-  return [suites, toggle, checkAll, clearAll, runBenchmarks];
-};
+  const runBenchmarks = () => {
+    setRunCurrent(0);
+  };
 
-const random = () => {
-  const suite = new BenchmarkSuite('random');
-  suite.addBenchmark(require('../benchmarks/random/randomBytes').randomBytes10);
-  suite.addBenchmark(
-    require('../benchmarks/random/randomBytes').randomBytes1024,
-  );
-  return suite;
-};
+  const bumpRunCurrent = () => {
+    setRunCurrent(runCurrent + 1);
+  };
 
-const pbkdf2 = () => {
-  const suite = new BenchmarkSuite('pbkdf2');
-  suite.addBenchmark(
-    require('../benchmarks/pbkdf2/pbkdf2').pbkdf2_256_1_32_async,
-  );
-  suite.addBenchmark(
-    require('../benchmarks/pbkdf2/pbkdf2').pbkdf2_256_1_32_sync,
-  );
-  return suite;
+  return [suites, toggle, checkAll, clearAll, runBenchmarks, bumpRunCurrent];
 };
diff --git a/example/src/hooks/useTestsList.ts b/example/src/hooks/useTestsList.ts
index b76ad333..bbe542fa 100644
--- a/example/src/hooks/useTestsList.ts
+++ b/example/src/hooks/useTestsList.ts
@@ -2,6 +2,7 @@ import { useState, useCallback } from 'react';
 import type { TestSuites } from '../types/tests';
 import { TestsContext } from '../tests/util';
 
+import '../tests/ed25519/ed25519_tests';
 import '../tests/pbkdf2/pbkdf2_tests';
 import '../tests/random/random_tests';
 // import '../tests/HmacTests/HmacTests';
diff --git a/example/src/hooks/useTestsRun.ts b/example/src/hooks/useTestsRun.ts
index 9e5d04c0..71e4c0a0 100644
--- a/example/src/hooks/useTestsRun.ts
+++ b/example/src/hooks/useTestsRun.ts
@@ -50,10 +50,10 @@ const run = (
   Object.entries(suites).map(([suiteName, suite]) => {
     stats.suites++;
 
-    Object.entries(suite.tests).map(([testName, test]) => {
+    Object.entries(suite.tests).map(async ([testName, test]) => {
       if (!suite.value) return;
       try {
-        test();
+        await test();
         stats.passes++;
         addTestResult({
           type: 'correct',
diff --git a/example/src/navigators/children/BenchmarkSuitesScreen.tsx b/example/src/navigators/children/BenchmarkSuitesScreen.tsx
index 7c8902ce..5ba525f8 100644
--- a/example/src/navigators/children/BenchmarkSuitesScreen.tsx
+++ b/example/src/navigators/children/BenchmarkSuitesScreen.tsx
@@ -1,41 +1,17 @@
-import React, { useState } from 'react';
-import {
-  View,
-  Text,
-  StyleSheet,
-  SafeAreaView,
-  TextInput,
-  FlatList,
-} from 'react-native';
+import React from 'react';
+import { View, Text, StyleSheet, SafeAreaView, FlatList } from 'react-native';
 import { BenchmarkItem } from '../../components/BenchmarkItem';
-import { colors } from '../../styles/colors';
 import { useBenchmarks } from '../../hooks/useBenchmarks';
 import { Button } from '../../components/Button';
 
 export const BenchmarkSuitesScreen = () => {
-  const [suites, toggle, checkAll, clearAll, runBenchmarks] = useBenchmarks();
-  const [multiplier, setMultiplier] = useState<number>(1);
+  const [suites, toggle, checkAll, clearAll, runBenchmarks, bumpRunCurrent] =
+    useBenchmarks();
 
   let totalCount = 0;
 
   return (
     <SafeAreaView style={styles.mainContainer}>
-      <View style={styles.options}>
-        <View style={styles.option}>
-          <Text style={styles.optionLabel}>run count multiplier</Text>
-          <TextInput
-            style={styles.textInput}
-            value={multiplier.toString()}
-            onChangeText={(s: string) => setMultiplier(parseInt(s, 10))}
-          />
-        </View>
-        <Text style={styles.optionCaption}>
-          Each benchmark has a distinct run count. If you want to really
-          exercise the device, you can increase this number to multiply the run
-          count of each benchmark. Recommended values are 1-5.
-        </Text>
-        <View style={styles.option}></View>
-      </View>
       <View style={styles.benchmarkList}>
         <FlatList
           data={suites}
@@ -47,7 +23,7 @@ export const BenchmarkSuitesScreen = () => {
                 key={index.toString()}
                 suite={item}
                 toggle={() => toggle(item.name)}
-                multiplier={multiplier}
+                bumpRunCurrent={bumpRunCurrent}
               />
             );
           }}
@@ -59,7 +35,7 @@ export const BenchmarkSuitesScreen = () => {
       <View style={styles.menu}>
         <Button title="Check All" onPress={checkAll} />
         <Button title="Clear All" onPress={clearAll} />
-        <Button title="Run" onPress={() => runBenchmarks()} color="green" />
+        <Button title="Run" onPress={runBenchmarks} color="green" />
       </View>
     </SafeAreaView>
   );
@@ -69,36 +45,6 @@ const styles = StyleSheet.create({
   mainContainer: {
     flex: 1,
   },
-  options: {
-    flex: 1,
-    padding: 5,
-    borderBottomWidth: 1,
-    borderColor: colors.gray,
-  },
-  option: {
-    flexDirection: 'row',
-  },
-  optionLabel: {
-    fontSize: 10,
-    fontWeight: 'bold',
-    paddingRight: 5,
-    alignSelf: 'center',
-  },
-  optionCaption: {
-    fontSize: 8,
-    color: colors.darkgray,
-    paddingRight: 5,
-    alignSelf: 'center',
-  },
-  textInput: {
-    backgroundColor: colors.white,
-    borderRadius: 3,
-    borderColor: colors.gray,
-    borderWidth: 1,
-    padding: 5,
-    width: 75,
-    textAlign: 'right',
-  },
   benchmarkList: {
     flex: 9,
   },
diff --git a/example/src/tests/ed25519/ed25519_tests.ts b/example/src/tests/ed25519/ed25519_tests.ts
new file mode 100644
index 00000000..70039991
--- /dev/null
+++ b/example/src/tests/ed25519/ed25519_tests.ts
@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-unused-expressions */
+import { Ed } from 'react-native-quick-crypto';
+// import type {
+//   // KeyObject,
+//   // CFRGKeyPairType,
+//   // GenerateKeyPairCallback,
+//   GenerateKeyPairOptions,
+//   // KeyPairKey,
+// } from 'react-native-quick-crypto';
+import { expect } from 'chai';
+import { test } from '../util';
+
+const SUITE = 'ed25519';
+
+/*
+const jwkOptions: GenerateKeyPairOptions = {
+  publicKeyEncoding: {
+    format: 'jwk',
+  },
+  privateKeyEncoding: {
+    format: 'jwk',
+  },
+};
+
+const types: CFRGKeyPairType[] = ['ed25519', 'ed448', 'x25519', 'x448'];
+types.map((type) => {
+  test(SUITE, `generateKeyPair - ${type}`, () => {
+    const callback: GenerateKeyPairCallback = (
+      err: Error | undefined,
+      publicKey: KeyPairKey,
+      privateKey: KeyPairKey,
+    ) => {
+      expect(err).to.be.undefined;
+      expect(publicKey).not.to.be.null;
+      expect(privateKey).not.to.be.null;
+      // console.log('publ', ab2str(publicKey as ArrayBuffer));
+      // console.log('priv', ab2str(privateKey as ArrayBuffer));
+    };
+
+    crypto.generateKeyPair(
+      type,
+      jwkOptions,
+      callback
+    );
+  });
+});
+*/
+
+test(SUITE, 'sign/verify', async () => {
+  const data = Buffer.from('hello world');
+  const ed = new Ed('ed25519', {});
+  await ed.generateKeyPair();
+  const signature = await ed.sign(data.buffer);
+  const verified = await ed.verify(signature, data.buffer);
+  expect(verified).to.be.true;
+});
diff --git a/example/src/tests/util.ts b/example/src/tests/util.ts
index b81f6bb9..46c94c17 100644
--- a/example/src/tests/util.ts
+++ b/example/src/tests/util.ts
@@ -1,11 +1,11 @@
-import type { Suites, TestSuite } from '../types/suite';
+import type { TestSuites } from '../types/tests';
 
-export const TestsContext: Suites<TestSuite> = {};
+export const TestsContext: TestSuites = {};
 
 export const test = (
   suiteName: string,
   testName: string,
-  fn: () => void,
+  fn: () => void | Promise<void>,
 ): void => {
   if (!TestsContext[suiteName]) {
     TestsContext[suiteName] = { value: false, tests: {} };
diff --git a/example/src/types/benchmarks.ts b/example/src/types/benchmarks.ts
index 22792d33..123b25d4 100644
--- a/example/src/types/benchmarks.ts
+++ b/example/src/types/benchmarks.ts
@@ -1,28 +1,20 @@
-export type ImportedBenchmark = {
-  name: string;
-  runCount: number;
-  us: BenchmarkFn;
-  them: Challenger[];
-};
+import type { Bench, TaskResult } from 'tinybench';
 
-export type SuiteState = 'idle' | 'running' | 'done';
+export type BenchFn = () => Bench | Promise<Bench>;
 
-export type BenchmarkFn = () => void;
+export type SuiteState = 'idle' | 'running' | 'done';
 
 export type Challenger = {
   name: string;
   notes: string;
-  fn: BenchmarkFn;
+  // fn: BenchmarkFn;
 };
 
 export type BenchmarkResult = {
   errorMsg?: string;
   challenger?: string;
   notes?: string;
-  runCount: number;
-  fnName: string;
-  time: number;
-  us: number;
-  type: 'faster' | 'slower';
-  times: number;
+  benchName: string | undefined;
+  them: Readonly<TaskResult> | undefined;
+  us: Readonly<TaskResult> | undefined;
 };
diff --git a/example/src/types/tests.ts b/example/src/types/tests.ts
index 637c11bf..4d795285 100644
--- a/example/src/types/tests.ts
+++ b/example/src/types/tests.ts
@@ -8,5 +8,5 @@ export interface TestSuite {
 }
 
 export interface Tests {
-  [key: string]: () => void;
+  [key: string]: () => void | Promise<void>;
 }
diff --git a/example/tsconfig.json b/example/tsconfig.json
index fb537197..57aefe62 100644
--- a/example/tsconfig.json
+++ b/example/tsconfig.json
@@ -13,7 +13,4 @@
   "compilerOptions": {
     "jsx": "react"
   },
-  "references": [
-    { "path": "../packages/react-native-quick-crypto" },
-  ],
 }
diff --git a/package.json b/package.json
index 0f5f3913..3695cba2 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,7 @@
     "clean": "bun --filter='*' clean",
     "specs": "bun --filter='react-native-quick-crypto' specs",
     "pods": "bun --filter='react-native-quick-crypto-example' pods",
-    "example": "bun --filter='react-native-quick-crypto-example' start",
+    "start": "bun --filter='react-native-quick-crypto-example' start",
     "bootstrap": "bun install && bun pods",
     "tsc": "bun --filter='*' typescript",
     "lint": "bun --filter='*' lint",
@@ -16,10 +16,6 @@
     "pre-release": "./scripts/prepare-release.sh",
     "release": "bun pre-release && release-it --github.release=false"
   },
-  "workspaces": [
-    "packages/react-native-quick-crypto",
-    "example"
-  ],
   "devDependencies": {
     "@release-it/bumper": "^6.0.1",
     "@release-it/conventional-changelog": "^8.0.1",
@@ -43,5 +39,9 @@
         "out": "package.json"
       }
     }
-  }
+  },
+  "workspaces": [
+    "packages/react-native-quick-crypto",
+    "example"
+  ]
 }
diff --git a/packages/react-native-quick-crypto/android/CMakeLists.txt b/packages/react-native-quick-crypto/android/CMakeLists.txt
index e381faa5..ac8da346 100644
--- a/packages/react-native-quick-crypto/android/CMakeLists.txt
+++ b/packages/react-native-quick-crypto/android/CMakeLists.txt
@@ -9,6 +9,7 @@ set(CMAKE_CXX_STANDARD 20)
 add_library(
   ${PACKAGE_NAME} SHARED
   src/main/cpp/cpp-adapter.cpp
+  ../cpp/ed25519/HybridEdKeyPair.cpp
   ../cpp/pbkdf2/HybridPbkdf2.cpp
   ../cpp/random/HybridRandom.cpp
   ../deps/fastpbkdf2/fastpbkdf2.c
@@ -20,6 +21,7 @@ include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/QuickCrypto+autolinkin
 # local includes
 include_directories(
   "src/main/cpp"
+  "../cpp/ed25519"
   "../cpp/pbkdf2"
   "../cpp/random"
   "../cpp/utils"
@@ -29,8 +31,6 @@ include_directories(
 # Third party libraries (Prefabs)
 find_library(LOG_LIB log)
 
-find_package(ReactAndroid REQUIRED CONFIG)
-find_package(fbjni REQUIRED CONFIG)
 find_package(openssl REQUIRED CONFIG)
 
 # Link all libraries together
@@ -38,9 +38,7 @@ target_link_libraries(
   ${PACKAGE_NAME}
   ${LOG_LIB}                             # <-- Logcat logger
   android                                # <-- Android core
-  fbjni::fbjni                           # <-- Facebook C++ JNI helpers
   openssl::crypto                        # <-- OpenSSL (Crypto)
-  ReactAndroid::jsi
   )
 
 if(ReactAndroid_VERSION_MINOR GREATER_EQUAL 76)
diff --git a/packages/react-native-quick-crypto/android/build.gradle b/packages/react-native-quick-crypto/android/build.gradle
index 977d02fb..6fe251d1 100644
--- a/packages/react-native-quick-crypto/android/build.gradle
+++ b/packages/react-native-quick-crypto/android/build.gradle
@@ -7,7 +7,7 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.2.2"
+    classpath "com.android.tools.build:gradle:8.7.3"
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"
   }
 }
@@ -49,9 +49,18 @@ android {
 
     externalNativeBuild {
       cmake {
-        cppFlags "-O2 -frtti -fexceptions -Wall -fstack-protector-all"
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
         arguments "-DANDROID_STL=c++_shared"
         abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
       }
     }
   }
@@ -67,6 +76,27 @@ android {
     prefab true
   }
 
+packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
   buildTypes {
     release {
       minifyEnabled false
@@ -108,8 +138,7 @@ dependencies {
   implementation project(":react-native-nitro-modules")
 
   // Add a dependency on OpenSSL
-  // TODO: update to v3 (see #351)
-  implementation "com.android.ndk.thirdparty:openssl:1.1.1q-beta-1"
+  implementation 'io.github.ronickg:openssl:3.3.2'
 }
 
 if (isNewArchitectureEnabled()) {
diff --git a/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.cpp b/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.cpp
new file mode 100644
index 00000000..2db3f6a2
--- /dev/null
+++ b/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.cpp
@@ -0,0 +1,233 @@
+#include "HybridEdKeyPair.hpp"
+
+#include <memory>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+std::shared_ptr<Promise<void>>
+HybridEdKeyPair::generateKeyPair(
+  double publicFormat,
+  double publicType,
+  double privateFormat,
+  double privateType,
+  const std::optional<std::string>& cipher,
+  const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  std::optional<std::shared_ptr<ArrayBuffer>> nativePassphrase = std::nullopt;
+  if (passphrase.has_value()) {
+    nativePassphrase = ToNativeArrayBuffer(passphrase.value());
+  }
+
+  return Promise<void>::async(
+    [this, publicFormat, publicType, privateFormat, privateType, cipher,
+     nativePassphrase]() {
+      this->generateKeyPairSync(
+        publicFormat,
+        publicType,
+        privateFormat,
+        privateType,
+        cipher,
+        nativePassphrase
+      );
+    }
+  );
+}
+
+void
+HybridEdKeyPair::generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+) {
+  EVP_PKEY_CTX* pctx;
+
+  // key context
+  pctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pctx == nullptr) {
+    throw std::runtime_error("Invalid curve name: " + this->curve);
+  }
+
+  // keygen init
+  if (EVP_PKEY_keygen_init(pctx) <= 0) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to initialize keygen");
+  }
+
+  // generate key
+  EVP_PKEY_keygen(pctx, &this->pkey);
+  if (this->pkey == nullptr) {
+    EVP_PKEY_CTX_free(pctx);
+    throw std::runtime_error("Failed to generate key");
+  }
+
+  // cleanup
+  EVP_PKEY_CTX_free(pctx);
+}
+
+
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+HybridEdKeyPair::sign(
+  const std::shared_ptr<ArrayBuffer>& message
+) {
+  // get owned NativeArrayBuffer before passing to sync function
+  auto nativeMessage = ToNativeArrayBuffer(message);
+
+  return Promise<std::shared_ptr<ArrayBuffer>>::async([this, nativeMessage]() {
+      return this->signSync(nativeMessage);
+    }
+  );
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::signSync(
+  const std::shared_ptr<ArrayBuffer>& message
+) {
+  this->checkKeyPair();
+
+  size_t sig_len = 0;
+  uint8_t* sig = NULL;
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating signing context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating signing context: " + this->curve);
+  }
+
+  if (EVP_DigestSignInit(md_ctx, &pkey_ctx, NULL, NULL, this->pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize signing: " + std::string(err));
+  }
+
+  // Calculate the required size for the signature by passing a NULL buffer.
+  if (EVP_DigestSign(md_ctx, NULL, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature size");
+  }
+  sig = new uint8_t[sig_len];
+
+  // Actually calculate the signature
+  if (EVP_DigestSign(md_ctx, sig, &sig_len, message.get()->data(), message.get()->size()) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to calculate signature");
+  }
+
+  // return value for JS
+  std::shared_ptr<ArrayBuffer> signature = std::make_shared<NativeArrayBuffer>(
+    sig,
+    sig_len,
+    [=]() { delete[] sig; }
+  );
+
+  // Clean up
+  EVP_MD_CTX_free(md_ctx);
+
+  return signature;
+}
+
+std::shared_ptr<Promise<bool>>
+HybridEdKeyPair::verify(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message
+) {
+  // get owned NativeArrayBuffers before passing to sync function
+  auto nativeSignature = ToNativeArrayBuffer(signature);
+  auto nativeMessage = ToNativeArrayBuffer(message);
+
+  return Promise<bool>::async([this, nativeSignature, nativeMessage]() {
+      return this->verifySync(nativeSignature, nativeMessage);
+    }
+  );
+}
+
+bool
+HybridEdKeyPair::verifySync(
+  const std::shared_ptr<ArrayBuffer>& signature,
+  const std::shared_ptr<ArrayBuffer>& message
+) {
+  this->checkKeyPair();
+
+  EVP_MD_CTX* md_ctx = nullptr;
+  EVP_PKEY_CTX* pkey_ctx = nullptr;
+
+  // key context
+  md_ctx = EVP_MD_CTX_new();
+  if (md_ctx == nullptr) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Error creating verify context");
+  }
+
+  pkey_ctx = EVP_PKEY_CTX_new_from_name(nullptr, this->curve.c_str(), nullptr);
+  if (pkey_ctx == nullptr) {
+    EVP_PKEY_CTX_free(pkey_ctx);
+    throw std::runtime_error("Error creating verify context: " + this->curve);
+  }
+
+  if (EVP_DigestVerifyInit(md_ctx, &pkey_ctx, NULL, NULL, this->pkey) <= 0) {
+    EVP_MD_CTX_free(md_ctx);
+    char* err = ERR_error_string(ERR_get_error(), NULL);
+    throw std::runtime_error("Failed to initialize verify: " + std::string(err));
+  }
+
+  // verify
+  auto res = EVP_DigestVerify(
+    md_ctx,
+    signature.get()->data(), signature.get()->size(),
+    message.get()->data(), message.get()->size()
+  );
+
+  //return value for JS
+  if (res < 0) {
+    EVP_MD_CTX_free(md_ctx);
+    throw std::runtime_error("Failed to verify");
+  }
+  return res == 1; // true if 1, false if 0
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPublicKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* publ = new uint8_t[len];
+  EVP_PKEY_get_raw_public_key(this->pkey, publ, &len);
+
+  return std::make_shared<NativeArrayBuffer>(publ, len, [=]() { delete[] publ; });
+}
+
+std::shared_ptr<ArrayBuffer>
+HybridEdKeyPair::getPrivateKey() {
+  this->checkKeyPair();
+  size_t len = 32;
+  uint8_t* priv = new uint8_t[len];
+  EVP_PKEY_get_raw_private_key(this->pkey, priv, &len);
+
+  return std::make_shared<NativeArrayBuffer>(priv, len, [=]() { delete[] priv; });
+}
+
+void
+HybridEdKeyPair::checkKeyPair() {
+  if (this->pkey == nullptr) {
+    throw std::runtime_error("Keypair not initialized");
+  }
+}
+
+void
+HybridEdKeyPair::setCurve(const std::string& curve) {
+  this->curve = curve;
+}
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.hpp b/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.hpp
new file mode 100644
index 00000000..b8cd8520
--- /dev/null
+++ b/packages/react-native-quick-crypto/cpp/ed25519/HybridEdKeyPair.hpp
@@ -0,0 +1,72 @@
+#include <openssl/evp.h>
+#include <openssl/err.h>
+#include <memory>
+#include <string>
+
+#include "HybridEdKeyPairSpec.hpp"
+#include "Utils.hpp"
+
+namespace margelo::nitro::crypto {
+
+using namespace facebook;
+
+class HybridEdKeyPair : public HybridEdKeyPairSpec {
+ public:
+  HybridEdKeyPair() : HybridObject(TAG) {}
+
+ public:
+  // Methods
+  std::shared_ptr<Promise<void>>
+  generateKeyPair(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  void
+  generateKeyPairSync(
+    double publicFormat,
+    double publicType,
+    double privateFormat,
+    double privateType,
+    const std::optional<std::string>& cipher,
+    const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase
+  ) override;
+
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  sign(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<ArrayBuffer>
+  signSync(const std::shared_ptr<ArrayBuffer>& message) override;
+
+  std::shared_ptr<Promise<bool>>
+  verify(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message
+  ) override;
+
+  bool
+  verifySync(
+    const std::shared_ptr<ArrayBuffer>& signature,
+    const std::shared_ptr<ArrayBuffer>& message
+  ) override;
+
+ protected:
+  std::shared_ptr<ArrayBuffer>
+  getPublicKey() override;
+
+  std::shared_ptr<ArrayBuffer> getPrivateKey();
+
+  void checkKeyPair();
+
+  void setCurve(const std::string& curve);
+
+ private:
+  std::string curve;
+  EVP_PKEY* pkey = nullptr;
+};
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.cpp b/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.cpp
index f06a9283..3389167d 100644
--- a/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.cpp
+++ b/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.cpp
@@ -3,7 +3,7 @@
 
 namespace margelo::nitro::crypto {
 
-std::future<std::shared_ptr<ArrayBuffer>>
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
 HybridPbkdf2::pbkdf2(
   const std::shared_ptr<ArrayBuffer>& password,
   const std::shared_ptr<ArrayBuffer>& salt,
@@ -15,10 +15,11 @@ HybridPbkdf2::pbkdf2(
   auto nativePassword = ToNativeArrayBuffer(password);
   auto nativeSalt = ToNativeArrayBuffer(salt);
 
-  return std::async(std::launch::async,
-                    [this, nativePassword, nativeSalt, iterations, keylen, digest]() {
-                      return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
-                    });
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+    [this, nativePassword, nativeSalt, iterations, keylen, digest]() {
+      return this->pbkdf2Sync(nativePassword, nativeSalt, iterations, keylen, digest);
+    }
+  );
 }
 
 std::shared_ptr<ArrayBuffer>
diff --git a/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.hpp b/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.hpp
index fadb5621..b435b3b2 100644
--- a/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.hpp
+++ b/packages/react-native-quick-crypto/cpp/pbkdf2/HybridPbkdf2.hpp
@@ -8,12 +8,12 @@ namespace margelo::nitro::crypto {
 using namespace facebook;
 
 class HybridPbkdf2 : public HybridPbkdf2Spec {
-public:
+ public:
   HybridPbkdf2() : HybridObject(TAG) {}
 
-public:
+ public:
   // Methods
-  virtual std::future<std::shared_ptr<ArrayBuffer>>
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
   pbkdf2(
     const std::shared_ptr<ArrayBuffer>& password,
     const std::shared_ptr<ArrayBuffer>& salt,
@@ -22,7 +22,7 @@ class HybridPbkdf2 : public HybridPbkdf2Spec {
     const std::string& digest
   ) override;
 
-  virtual std::shared_ptr<ArrayBuffer>
+  std::shared_ptr<ArrayBuffer>
   pbkdf2Sync(
     const std::shared_ptr<ArrayBuffer>& password,
     const std::shared_ptr<ArrayBuffer>& salt,
diff --git a/packages/react-native-quick-crypto/cpp/random/HybridRandom.cpp b/packages/react-native-quick-crypto/cpp/random/HybridRandom.cpp
index dbcbcb5a..d9da94f3 100644
--- a/packages/react-native-quick-crypto/cpp/random/HybridRandom.cpp
+++ b/packages/react-native-quick-crypto/cpp/random/HybridRandom.cpp
@@ -28,17 +28,18 @@ size_t checkOffset(double size, double offset) {
 
 namespace margelo::nitro::crypto {
 
-std::future<std::shared_ptr<ArrayBuffer>>
+std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
 HybridRandom::randomFill(const std::shared_ptr<ArrayBuffer>& buffer,
                          double dOffset,
                          double dSize) {
   // get owned NativeArrayBuffer before passing to sync function
   auto nativeBuffer = ToNativeArrayBuffer(buffer);
 
-  return std::async(std::launch::async,
-                    [this, nativeBuffer, dOffset, dSize]() {
-                      return this->randomFillSync(nativeBuffer, dOffset, dSize);
-                    });
+  return Promise<std::shared_ptr<ArrayBuffer>>::async(
+    [this, nativeBuffer, dOffset, dSize]() {
+      return this->randomFillSync(nativeBuffer, dOffset, dSize);
+    }
+  );
 };
 
 std::shared_ptr<ArrayBuffer>
diff --git a/packages/react-native-quick-crypto/cpp/random/HybridRandom.hpp b/packages/react-native-quick-crypto/cpp/random/HybridRandom.hpp
index 7d7a5718..44e68169 100644
--- a/packages/react-native-quick-crypto/cpp/random/HybridRandom.hpp
+++ b/packages/react-native-quick-crypto/cpp/random/HybridRandom.hpp
@@ -1,5 +1,6 @@
 #include <cmath>
 #include <future>
+#include <memory>
 #include <iostream>
 
 #include "HybridRandomSpec.hpp"
@@ -9,13 +10,16 @@ namespace margelo::nitro::crypto {
 using namespace facebook;
 
 class HybridRandom : public HybridRandomSpec {
-public:
+ public:
   HybridRandom() : HybridObject(TAG) {}
 
-public:
+ public:
   // Methods
-  std::future<std::shared_ptr<ArrayBuffer>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
-  std::shared_ptr<ArrayBuffer> randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+  std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
+
+  std::shared_ptr<ArrayBuffer>
+  randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double dOffset, double dSize) override;
 };
 
 inline void printData(std::string name, uint8_t* data, size_t size) {
diff --git a/packages/react-native-quick-crypto/nitro.json b/packages/react-native-quick-crypto/nitro.json
index cd22074c..dfd36c51 100644
--- a/packages/react-native-quick-crypto/nitro.json
+++ b/packages/react-native-quick-crypto/nitro.json
@@ -8,6 +8,7 @@
     "androidCxxLibName": "QuickCrypto"
   },
   "autolinking": {
+    "EdKeyPair": { "cpp": "HybridEdKeyPair" },
     "Pbkdf2": { "cpp": "HybridPbkdf2" },
     "Random": { "cpp": "HybridRandom" }
   },
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
index 05eb7021..4e92c362 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
+++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.cmake
@@ -27,6 +27,7 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/QuickCryptoOnLoad.cpp
   # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp
   ../nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.cpp
   ../nitrogen/generated/shared/c++/HybridPbkdf2Spec.cpp
   ../nitrogen/generated/shared/c++/HybridRandomSpec.cpp
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle
index 437a6f80..e27484b7 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle
+++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCrypto+autolinking.gradle
@@ -13,6 +13,8 @@
 /// apply from: '../nitrogen/generated/android/QuickCrypto+autolinking.gradle'
 /// ```
 
+logger.warn("[NitroModules] 🔥 QuickCrypto is boosted by nitro!")
+
 android {
   sourceSets {
     main {
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
index e57d293e..e5424517 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/android/QuickCryptoOnLoad.cpp
@@ -11,6 +11,7 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "HybridEdKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
 #include "HybridRandom.hpp"
 
@@ -26,6 +27,15 @@ int initialize(JavaVM* vm) {
     
 
     // Register Nitro Hybrid Objects
+    HybridObjectRegistry::registerHybridObjectConstructor(
+      "EdKeyPair",
+      []() -> std::shared_ptr<HybridObject> {
+        static_assert(std::is_default_constructible_v<HybridEdKeyPair>,
+                      "The HybridObject \"HybridEdKeyPair\" is not default-constructible! "
+                      "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+        return std::make_shared<HybridEdKeyPair>();
+      }
+    );
     HybridObjectRegistry::registerHybridObjectConstructor(
       "Pbkdf2",
       []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb
index 6a5aed32..a3d5d04c 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb
+++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto+autolinking.rb
@@ -20,7 +20,7 @@
 # ```
 
 def add_nitrogen_files(spec)
-  Pod::UI.puts "[NitroModules] Adding QuickCrypto specs..."
+  Pod::UI.puts "[NitroModules] 🔥 QuickCrypto is boosted by nitro!"
 
   spec.dependency "NitroModules"
 
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp
index ed64ea77..295e0db6 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp
@@ -20,7 +20,7 @@
 #include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/AnyMapHolder.hpp>
 #include <NitroModules/HybridContext.hpp>
-#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/RuntimeError.hpp>
 
 // Forward declarations of Swift defined types
 
@@ -30,6 +30,9 @@
 // This header is generated by Xcode/Swift on every app build.
 // If it cannot be found, make sure the Swift module's name (= podspec name) is actually "QuickCrypto".
 #include "QuickCrypto-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<QuickCrypto/QuickCrypto-Swift.h>)
+#include <QuickCrypto/QuickCrypto-Swift.h>
 #else
 #error QuickCrypto's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "QuickCrypto", and try building the app first.
 #endif
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
index 77896c89..c500cfff 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
+++ b/packages/react-native-quick-crypto/nitrogen/generated/ios/QuickCryptoAutolinking.mm
@@ -10,6 +10,7 @@
 
 #import <type_traits>
 
+#include "HybridEdKeyPair.hpp"
 #include "HybridPbkdf2.hpp"
 #include "HybridRandom.hpp"
 
@@ -22,6 +23,15 @@ + (void) load {
   using namespace margelo::nitro;
   using namespace margelo::nitro::crypto;
 
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EdKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEdKeyPair>,
+                    "The HybridObject \"HybridEdKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEdKeyPair>();
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "Pbkdf2",
     []() -> std::shared_ptr<HybridObject> {
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CFRGKeyPairType.hpp
similarity index 53%
rename from packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp
rename to packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CFRGKeyPairType.hpp
index 46480829..a511b105 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/AsymmetricKeyType.hpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/CFRGKeyPairType.hpp
@@ -1,5 +1,5 @@
 ///
-/// AsymmetricKeyType.hpp
+/// CFRGKeyPairType.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
 /// Copyright © 2024 Marc Rousavy @ Margelo
@@ -26,13 +26,13 @@
 namespace margelo::nitro::crypto {
 
   /**
-   * An enum which can be represented as a JavaScript union (AsymmetricKeyType).
+   * An enum which can be represented as a JavaScript union (CFRGKeyPairType).
    */
-  enum class AsymmetricKeyType {
-    RSA      SWIFT_NAME(rsa) = 0,
-    RSA_PSS      SWIFT_NAME(rsaPss) = 1,
-    DSA      SWIFT_NAME(dsa) = 2,
-    EC      SWIFT_NAME(ec) = 3,
+  enum class CFRGKeyPairType {
+    ED25519      SWIFT_NAME(ed25519) = 0,
+    ED448      SWIFT_NAME(ed448) = 1,
+    X25519      SWIFT_NAME(x25519) = 2,
+    X448      SWIFT_NAME(x448) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
@@ -41,28 +41,28 @@ namespace margelo::nitro {
 
   using namespace margelo::nitro::crypto;
 
-  // C++ AsymmetricKeyType <> JS AsymmetricKeyType (union)
+  // C++ CFRGKeyPairType <> JS CFRGKeyPairType (union)
   template <>
-  struct JSIConverter<AsymmetricKeyType> {
-    static inline AsymmetricKeyType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<CFRGKeyPairType> {
+    static inline CFRGKeyPairType 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("rsa"): return AsymmetricKeyType::RSA;
-        case hashString("rsa-pss"): return AsymmetricKeyType::RSA_PSS;
-        case hashString("dsa"): return AsymmetricKeyType::DSA;
-        case hashString("ec"): return AsymmetricKeyType::EC;
+        case hashString("ed25519"): return CFRGKeyPairType::ED25519;
+        case hashString("ed448"): return CFRGKeyPairType::ED448;
+        case hashString("x25519"): return CFRGKeyPairType::X25519;
+        case hashString("x448"): return CFRGKeyPairType::X448;
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AsymmetricKeyType - invalid value!");
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum CFRGKeyPairType - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, AsymmetricKeyType arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, CFRGKeyPairType arg) {
       switch (arg) {
-        case AsymmetricKeyType::RSA: return JSIConverter<std::string>::toJSI(runtime, "rsa");
-        case AsymmetricKeyType::RSA_PSS: return JSIConverter<std::string>::toJSI(runtime, "rsa-pss");
-        case AsymmetricKeyType::DSA: return JSIConverter<std::string>::toJSI(runtime, "dsa");
-        case AsymmetricKeyType::EC: return JSIConverter<std::string>::toJSI(runtime, "ec");
+        case CFRGKeyPairType::ED25519: return JSIConverter<std::string>::toJSI(runtime, "ed25519");
+        case CFRGKeyPairType::ED448: return JSIConverter<std::string>::toJSI(runtime, "ed448");
+        case CFRGKeyPairType::X25519: return JSIConverter<std::string>::toJSI(runtime, "x25519");
+        case CFRGKeyPairType::X448: return JSIConverter<std::string>::toJSI(runtime, "x448");
         default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert AsymmetricKeyType to JS - invalid value: "
+          throw std::invalid_argument("Cannot convert CFRGKeyPairType to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
       }
     }
@@ -72,10 +72,10 @@ namespace margelo::nitro {
       }
       std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
       switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("rsa"):
-        case hashString("rsa-pss"):
-        case hashString("dsa"):
-        case hashString("ec"):
+        case hashString("ed25519"):
+        case hashString("ed448"):
+        case hashString("x25519"):
+        case hashString("x448"):
           return true;
         default:
           return false;
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp
new file mode 100644
index 00000000..35ee9ab5
--- /dev/null
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.cpp
@@ -0,0 +1,28 @@
+///
+/// HybridEdKeyPairSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 Marc Rousavy @ Margelo
+///
+
+#include "HybridEdKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridEdKeyPairSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("generateKeyPair", &HybridEdKeyPairSpec::generateKeyPair);
+      prototype.registerHybridMethod("generateKeyPairSync", &HybridEdKeyPairSpec::generateKeyPairSync);
+      prototype.registerHybridMethod("getPublicKey", &HybridEdKeyPairSpec::getPublicKey);
+      prototype.registerHybridMethod("sign", &HybridEdKeyPairSpec::sign);
+      prototype.registerHybridMethod("signSync", &HybridEdKeyPairSpec::signSync);
+      prototype.registerHybridMethod("verify", &HybridEdKeyPairSpec::verify);
+      prototype.registerHybridMethod("verifySync", &HybridEdKeyPairSpec::verifySync);
+      prototype.registerHybridMethod("setCurve", &HybridEdKeyPairSpec::setCurve);
+    });
+  }
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp
new file mode 100644
index 00000000..25c2425b
--- /dev/null
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridEdKeyPairSpec.hpp
@@ -0,0 +1,73 @@
+///
+/// HybridEdKeyPairSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2024 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 `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <NitroModules/Promise.hpp>
+#include <optional>
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EdKeyPair`
+   * Inherit this class to create instances of `HybridEdKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEdKeyPair: public HybridEdKeyPairSpec {
+   * public:
+   *   HybridEdKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEdKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEdKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      virtual ~HybridEdKeyPairSpec() { }
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
+      virtual void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual void setCurve(const std::string& curve) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EdKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp
index 21ca53f4..302edbc5 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridKeyObjectHandleSpec.hpp
@@ -21,8 +21,8 @@ namespace margelo::nitro::crypto { enum class KFormatType; }
 namespace margelo::nitro::crypto { enum class KeyEncoding; }
 // Forward declaration of `JWK` to properly resolve imports.
 namespace margelo::nitro::crypto { struct JWK; }
-// Forward declaration of `AsymmetricKeyType` to properly resolve imports.
-namespace margelo::nitro::crypto { enum class AsymmetricKeyType; }
+// Forward declaration of `CFRGKeyPairType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class CFRGKeyPairType; }
 // Forward declaration of `KeyType` to properly resolve imports.
 namespace margelo::nitro::crypto { enum class KeyType; }
 // Forward declaration of `NamedCurve` to properly resolve imports.
@@ -36,7 +36,7 @@ namespace margelo::nitro::crypto { struct KeyDetail; }
 #include "KeyEncoding.hpp"
 #include <string>
 #include "JWK.hpp"
-#include "AsymmetricKeyType.hpp"
+#include "CFRGKeyPairType.hpp"
 #include "KeyType.hpp"
 #include <variant>
 #include "NamedCurve.hpp"
@@ -75,7 +75,7 @@ namespace margelo::nitro::crypto {
       // Methods
       virtual std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual JWK exportJwk(const JWK& key, bool handleRsaPss) = 0;
-      virtual AsymmetricKeyType getAsymmetricKeyType() = 0;
+      virtual CFRGKeyPairType getAsymmetricKeyType() = 0;
       virtual bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual bool initECRaw(const std::string& curveName, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
       virtual std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp
index 96c1113b..b768fe32 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridPbkdf2Spec.hpp
@@ -16,7 +16,7 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
-#include <future>
+#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <string>
 
@@ -51,7 +51,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
-      virtual std::future<std::shared_ptr<ArrayBuffer>> pbkdf2(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen, const std::string& digest) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> pbkdf2(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen, const std::string& digest) = 0;
       virtual std::shared_ptr<ArrayBuffer> pbkdf2Sync(const std::shared_ptr<ArrayBuffer>& password, const std::shared_ptr<ArrayBuffer>& salt, double iterations, double keylen, const std::string& digest) = 0;
 
     protected:
diff --git a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp
index a23618ec..2814784a 100644
--- a/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp
+++ b/packages/react-native-quick-crypto/nitrogen/generated/shared/c++/HybridRandomSpec.hpp
@@ -16,7 +16,7 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
-#include <future>
+#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 
 namespace margelo::nitro::crypto {
@@ -50,7 +50,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
-      virtual std::future<std::shared_ptr<ArrayBuffer>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double size) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> randomFill(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double size) = 0;
       virtual std::shared_ptr<ArrayBuffer> randomFillSync(const std::shared_ptr<ArrayBuffer>& buffer, double offset, double size) = 0;
 
     protected:
diff --git a/packages/react-native-quick-crypto/package.json b/packages/react-native-quick-crypto/package.json
index 5614ca41..4af68df7 100644
--- a/packages/react-native-quick-crypto/package.json
+++ b/packages/react-native-quick-crypto/package.json
@@ -69,7 +69,7 @@
   "dependencies": {
     "@craftzdog/react-native-buffer": "6.0.5",
     "events": "3.3.0",
-    "react-native-nitro-modules": "0.14.0",
+    "react-native-nitro-modules": "0.18.1",
     "react-native-quick-base64": "2.1.2",
     "readable-stream": "4.5.2",
     "string_decoder": "1.3.0",
@@ -87,7 +87,7 @@
     "eslint": "9.9.0",
     "eslint-plugin-react-native": "^4.1.0",
     "jest": "29.7.0",
-    "nitro-codegen": "0.14.0",
+    "nitro-codegen": "0.18.1",
     "prettier": "3.3.3",
     "react-native-builder-bob": "0.30.0",
     "release-it": "17.6.0",
diff --git a/packages/react-native-quick-crypto/src/ed.ts b/packages/react-native-quick-crypto/src/ed.ts
new file mode 100644
index 00000000..57e97106
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/ed.ts
@@ -0,0 +1,58 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type { EdKeyPair } from './specs/edKeyPair.nitro';
+import type { CFRGKeyPairType, KeyPairGenConfig } from './utils';
+
+export class Ed {
+  type: CFRGKeyPairType;
+  config: KeyPairGenConfig;
+  native: EdKeyPair;
+
+  constructor(type: CFRGKeyPairType, config: KeyPairGenConfig) {
+    this.type = type;
+    this.config = config;
+    this.native = NitroModules.createHybridObject<EdKeyPair>('EdKeyPair');
+    this.native.setCurve(type);
+  }
+
+  async generateKeyPair(): Promise<void> {
+    this.native.generateKeyPair(
+      this.config.publicFormat || (-1 as number),
+      this.config.publicType || (-1 as number),
+      this.config.privateFormat || (-1 as number),
+      this.config.privateType || (-1 as number),
+      this.config.cipher as string,
+      this.config.passphrase as ArrayBuffer,
+    );
+  }
+
+  generateKeyPairSync(): void {
+    this.native.generateKeyPairSync(
+      this.config.publicFormat || (-1 as number),
+      this.config.publicType || (-1 as number),
+      this.config.privateFormat || (-1 as number),
+      this.config.privateType || (-1 as number),
+      this.config.cipher as string,
+      this.config.passphrase as ArrayBuffer,
+    );
+  }
+
+  getPublicKey(): ArrayBuffer {
+    return this.native.getPublicKey();
+  }
+
+  async sign(message: ArrayBuffer): Promise<ArrayBuffer> {
+    return this.native.sign(message);
+  }
+
+  signSync(message: ArrayBuffer): ArrayBuffer {
+    return this.native.signSync(message);
+  }
+
+  async verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean> {
+    return this.native.verify(signature, message);
+  }
+
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean {
+    return this.native.verifySync(signature, message);
+  }
+}
diff --git a/packages/react-native-quick-crypto/src/index.ts b/packages/react-native-quick-crypto/src/index.ts
index f40e20b4..88d87814 100644
--- a/packages/react-native-quick-crypto/src/index.ts
+++ b/packages/react-native-quick-crypto/src/index.ts
@@ -2,6 +2,8 @@
 import { Buffer } from '@craftzdog/react-native-buffer';
 
 // API imports
+import * as keys from './keys';
+import * as ed from './ed';
 import * as pbkdf2 from './pbkdf2';
 import * as random from './random';
 
@@ -21,20 +23,17 @@ const QuickCrypto = {
   // createCipheriv,
   // createDecipher,
   // createDecipheriv,
-  // createPublicKey,
-  // createPrivateKey,
-  // createSecretKey,
   // publicEncrypt,
   // publicDecrypt,
   // privateDecrypt,
   // generateKey,
-  // generateKeyPair,
-  // generateKeyPairSync,
   // generateKeySync,
   // createSign,
   // createVerify,
   // subtle,
   // constants,
+  ...keys,
+  ...ed,
   ...pbkdf2,
   ...random,
   // getCiphers,
@@ -60,6 +59,7 @@ global.process.nextTick = setImmediate;
 
 // exports
 export default QuickCrypto;
+export * from './ed';
 export * from './utils';
 
 // Additional exports for CommonJS compatibility
diff --git a/packages/react-native-quick-crypto/src/keys/classes.ts b/packages/react-native-quick-crypto/src/keys/classes.ts
new file mode 100644
index 00000000..a5b78340
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/keys/classes.ts
@@ -0,0 +1,211 @@
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
+import type {
+  AsymmetricKeyType,
+  EncodingOptions,
+  KeyUsage,
+  SubtleAlgorithm,
+} from '../utils';
+import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+
+export class CryptoKey {
+  keyObject: KeyObject;
+  keyAlgorithm: SubtleAlgorithm;
+  keyUsages: KeyUsage[];
+  keyExtractable: boolean;
+
+  constructor(
+    keyObject: KeyObject,
+    keyAlgorithm: SubtleAlgorithm,
+    keyUsages: KeyUsage[],
+    keyExtractable: boolean,
+  ) {
+    this.keyObject = keyObject;
+    this.keyAlgorithm = keyAlgorithm;
+    this.keyUsages = keyUsages;
+    this.keyExtractable = keyExtractable;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  inspect(_depth: number, _options: unknown): unknown {
+    throw new Error('CryptoKey.inspect is not implemented');
+    // if (depth < 0) return this;
+
+    // const opts = {
+    //   ...options,
+    //   depth: options.depth == null ? null : options.depth - 1,
+    // };
+
+    // return `CryptoKey ${inspect(
+    //   {
+    //     type: this.type,
+    //     extractable: this.extractable,
+    //     algorithm: this.algorithm,
+    //     usages: this.usages,
+    //   },
+    //   opts
+    // )}`;
+  }
+
+  get type() {
+    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
+    return this.keyObject.type;
+  }
+
+  get extractable() {
+    return this.keyExtractable;
+  }
+
+  get algorithm() {
+    return this.keyAlgorithm;
+  }
+
+  get usages() {
+    return this.keyUsages;
+  }
+}
+
+export class KeyObject {
+  handle: KeyObjectHandle;
+  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  export(_options?: EncodingOptions): ArrayBuffer {
+    return new ArrayBuffer(0);
+  }
+
+  constructor(type: string, handle: KeyObjectHandle) {
+    if (type !== 'secret' && type !== 'public' && type !== 'private')
+      throw new Error(`invalid KeyObject type: ${type}`);
+    this.handle = handle;
+    this.type = type;
+  }
+
+  // get type(): string {
+  //   return this.type;
+  // }
+
+  // static from(key) {
+  //   if (!isCryptoKey(key))
+  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
+  //   return key[kKeyObject];
+  // }
+
+  // equals(otherKeyObject) {
+  //   if (!isKeyObject(otherKeyObject)) {
+  //     throw new ERR_INVALID_ARG_TYPE(
+  //       'otherKeyObject',
+  //       'KeyObject',
+  //       otherKeyObject
+  //     );
+  //   }
+
+  //   return (
+  //     otherKeyObject.type === this.type &&
+  //     this[kHandle].equals(otherKeyObject[kHandle])
+  //   );
+  // }
+}
+
+export class SecretKeyObject extends KeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('secret', handle);
+  }
+
+  // get symmetricKeySize() {
+  //   return this[kHandle].getSymmetricKeySize();
+  // }
+
+  export(options?: EncodingOptions) {
+    if (options !== undefined) {
+      if (options.format === 'jwk') {
+        throw new Error('SecretKey export for jwk is not implemented');
+        // return this.handle.exportJwk({}, false);
+      }
+    }
+    return this.handle.exportKey();
+  }
+}
+
+// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
+// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
+
+// function normalizeKeyDetails(details = {}) {
+//   if (details.publicExponent !== undefined) {
+//     return {
+//       ...details,
+//       publicExponent: bigIntArrayToUnsignedBigInt(
+//         new Uint8Array(details.publicExponent)
+//       ),
+//     };
+//   }
+//   return details;
+// }
+
+export class AsymmetricKeyObject extends KeyObject {
+  constructor(type: string, handle: KeyObjectHandle) {
+    super(type, handle);
+  }
+
+  private _asymmetricKeyType?: AsymmetricKeyType;
+
+  get asymmetricKeyType(): AsymmetricKeyType {
+    if (!this._asymmetricKeyType) {
+      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
+    }
+    return this._asymmetricKeyType;
+  }
+
+  // get asymmetricKeyDetails() {
+  //   switch (this._asymmetricKeyType) {
+  //     case 'rsa':
+  //     case 'rsa-pss':
+  //     case 'dsa':
+  //     case 'ec':
+  //       return (
+  //         this[kAsymmetricKeyDetails] ||
+  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
+  //           this[kHandle].keyDetail({})
+  //         ))
+  //       );
+  //     default:
+  //       return {};
+  //   }
+  // }
+}
+
+export class PublicKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('public', handle);
+  }
+
+  export(options: EncodingOptions) {
+    if (options?.format === 'jwk') {
+      throw new Error('PublicKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const { format, type } = parsePublicKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    return this.handle.exportKey(format, type);
+  }
+}
+
+export class PrivateKeyObject extends AsymmetricKeyObject {
+  constructor(handle: KeyObjectHandle) {
+    super('private', handle);
+  }
+
+  export(options: EncodingOptions) {
+    if (options?.format === 'jwk') {
+      if (options.passphrase !== undefined) {
+        throw new Error('jwk does not support encryption');
+      }
+      throw new Error('PrivateKey export for jwk is not implemented');
+      // return this.handle.exportJwk({}, false);
+    }
+    const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(
+      options,
+      this.asymmetricKeyType,
+    );
+    return this.handle.exportKey(format, type, cipher, passphrase);
+  }
+}
diff --git a/packages/react-native-quick-crypto/src/keys/generateKeyPair.ts b/packages/react-native-quick-crypto/src/keys/generateKeyPair.ts
new file mode 100644
index 00000000..b05cf058
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/keys/generateKeyPair.ts
@@ -0,0 +1,146 @@
+// import { ed25519 } from '../ed25519';
+// import {
+//   kEmptyObject,
+//   validateFunction,
+//   type CryptoKeyPair,
+//   type GenerateKeyPairCallback,
+//   type GenerateKeyPairOptions,
+//   type GenerateKeyPairPromiseReturn,
+//   type GenerateKeyPairReturn,
+//   type KeyPairGenConfig,
+//   type KeyPairType,
+// } from '../utils';
+// import { parsePrivateKeyEncoding, parsePublicKeyEncoding } from './utils';
+
+// export const generateKeyPair = (
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+//   callback: GenerateKeyPairCallback,
+// ): void => {
+//   validateFunction(callback);
+//   internalGenerateKeyPair(true, type, options, callback);
+// };
+
+// // Promisify generateKeyPair
+// // (attempted to use util.promisify, to no avail)
+// export const generateKeyPairPromise = (
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+// ): Promise<GenerateKeyPairPromiseReturn> => {
+//   return new Promise((resolve, reject) => {
+//     generateKeyPair(type, options, (err, publicKey, privateKey) => {
+//       if (err) {
+//         reject([err, undefined]);
+//       } else {
+//         resolve([undefined, { publicKey, privateKey }]);
+//       }
+//     });
+//   });
+// };
+
+// // generateKeyPairSync
+// export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
+// export function generateKeyPairSync(
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions,
+// ): CryptoKeyPair;
+// export function generateKeyPairSync(
+//   type: KeyPairType,
+//   options?: GenerateKeyPairOptions,
+// ): CryptoKeyPair {
+//   const [err, publicKey, privateKey] = internalGenerateKeyPair(
+//     false,
+//     type,
+//     options,
+//     undefined,
+//   )!;
+
+//   if (err) {
+//     throw err;
+//   }
+
+//   return {
+//     publicKey,
+//     privateKey,
+//   };
+// }
+
+// function parseKeyPairEncoding(
+//   keyType: string,
+//   options: GenerateKeyPairOptions = kEmptyObject,
+// ): KeyPairGenConfig {
+//   const { publicKeyEncoding, privateKeyEncoding } = options;
+
+//   let publicFormat, publicType;
+//   if (publicKeyEncoding == null) {
+//     publicFormat = publicType = -1;
+//   } else if (typeof publicKeyEncoding === 'object') {
+//     ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
+//       publicKeyEncoding,
+//       keyType,
+//       'publicKeyEncoding',
+//     ));
+//   } else {
+//     throw new Error(
+//       'Invalid argument options.publicKeyEncoding',
+//       publicKeyEncoding,
+//     );
+//   }
+
+//   let privateFormat, privateType, cipher, passphrase;
+//   if (privateKeyEncoding == null) {
+//     privateFormat = privateType = -1;
+//   } else if (typeof privateKeyEncoding === 'object') {
+//     ({
+//       format: privateFormat,
+//       type: privateType,
+//       cipher,
+//       passphrase,
+//     } = parsePrivateKeyEncoding(
+//       privateKeyEncoding,
+//       keyType,
+//       'privateKeyEncoding',
+//     ));
+//   } else {
+//     throw new Error(
+//       'Invalid argument options.privateKeyEncoding',
+//       publicKeyEncoding as ErrorOptions,
+//     );
+//   }
+
+//   return {
+//     publicFormat,
+//     publicType,
+//     privateFormat,
+//     privateType,
+//     cipher,
+//     passphrase,
+//   };
+// }
+
+// function internalGenerateKeyPair(
+//   isAsync: boolean,
+//   type: KeyPairType,
+//   options: GenerateKeyPairOptions | undefined,
+//   callback: GenerateKeyPairCallback | undefined,
+// ): GenerateKeyPairReturn | void {
+//   const encoding = parseKeyPairEncoding(type, options);
+
+//   switch (type) {
+//     case 'ed25519':
+//     case 'ed448':
+//     case 'x25519':
+//     case 'x448': {
+//       return ed25519.utils.generateKeyPair(isAsync, type, encoding, callback);
+//     }
+//     default:
+//     // Fall through
+//   }
+
+//   const err = new Error(`
+//     Invalid Argument options: '${type}' scheme not supported for
+//     generateKeyPair(). Currently not all encryption methods are supported in
+//     this library.  Check docs/implementation_coverage.md for status.
+//   `);
+//   return [err, undefined, undefined];
+// }
diff --git a/packages/react-native-quick-crypto/src/keys/index.ts b/packages/react-native-quick-crypto/src/keys/index.ts
index 5f101a40..eab7a7cc 100644
--- a/packages/react-native-quick-crypto/src/keys/index.ts
+++ b/packages/react-native-quick-crypto/src/keys/index.ts
@@ -1,99 +1,42 @@
-import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
-import type { EncodingOptions, KeyUsage, SubtleAlgorithm } from '../utils';
-
-export class CryptoKey {
-  keyObject: KeyObject;
-  keyAlgorithm: SubtleAlgorithm;
-  keyUsages: KeyUsage[];
-  keyExtractable: boolean;
-
-  constructor(
-    keyObject: KeyObject,
-    keyAlgorithm: SubtleAlgorithm,
-    keyUsages: KeyUsage[],
-    keyExtractable: boolean,
-  ) {
-    this.keyObject = keyObject;
-    this.keyAlgorithm = keyAlgorithm;
-    this.keyUsages = keyUsages;
-    this.keyExtractable = keyExtractable;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  inspect(_depth: number, _options: unknown): unknown {
-    throw new Error('CryptoKey.inspect is not implemented');
-    // if (depth < 0) return this;
-
-    // const opts = {
-    //   ...options,
-    //   depth: options.depth == null ? null : options.depth - 1,
-    // };
-
-    // return `CryptoKey ${inspect(
-    //   {
-    //     type: this.type,
-    //     extractable: this.extractable,
-    //     algorithm: this.algorithm,
-    //     usages: this.usages,
-    //   },
-    //   opts
-    // )}`;
-  }
-
-  get type() {
-    // if (!(this instanceof CryptoKey)) throw new Error('Invalid CryptoKey');
-    return this.keyObject.type;
-  }
-
-  get extractable() {
-    return this.keyExtractable;
-  }
-
-  get algorithm() {
-    return this.keyAlgorithm;
-  }
-
-  get usages() {
-    return this.keyUsages;
-  }
-}
-
-class KeyObject {
-  handle: KeyObjectHandle;
-  type: 'public' | 'secret' | 'private' | 'unknown' = 'unknown';
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  export(_options?: EncodingOptions): ArrayBuffer {
-    return new ArrayBuffer(0);
-  }
-
-  constructor(type: string, handle: KeyObjectHandle) {
-    if (type !== 'secret' && type !== 'public' && type !== 'private')
-      throw new Error(`invalid KeyObject type: ${type}`);
-    this.handle = handle;
-    this.type = type;
-  }
-
-  // get type(): string {
-  //   return this.type;
-  // }
-
-  // static from(key) {
-  //   if (!isCryptoKey(key))
-  //     throw new ERR_INVALID_ARG_TYPE('key', 'CryptoKey', key);
-  //   return key[kKeyObject];
-  // }
-
-  // equals(otherKeyObject) {
-  //   if (!isKeyObject(otherKeyObject)) {
-  //     throw new ERR_INVALID_ARG_TYPE(
-  //       'otherKeyObject',
-  //       'KeyObject',
-  //       otherKeyObject
-  //     );
-  //   }
-
-  //   return (
-  //     otherKeyObject.type === this.type &&
-  //     this[kHandle].equals(otherKeyObject[kHandle])
-  //   );
-  // }
-}
+import {
+  CryptoKey,
+  KeyObject,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+} from './classes';
+// import { generateKeyPair } from './generateKeyPair';
+// import { sign, verify } from './signVerify';
+import {
+  isCryptoKey,
+  parseKeyEncoding,
+  parsePrivateKeyEncoding,
+  parsePublicKeyEncoding,
+} from './utils';
+
+export {
+  // Node Public API
+  // createSecretKey,
+  // createPublicKey,
+  // createPrivateKey,
+  CryptoKey,
+  // generateKeyPair,
+  KeyObject,
+  // InternalCryptoKey,
+  // sign,
+  // verify,
+
+  // Node Internal API
+  parsePublicKeyEncoding,
+  parsePrivateKeyEncoding,
+  parseKeyEncoding,
+  // preparePrivateKey,
+  // preparePublicOrPrivateKey,
+  // prepareSecretKey,
+  SecretKeyObject,
+  PublicKeyObject,
+  PrivateKeyObject,
+  // isKeyObject,
+  isCryptoKey,
+  // importGenericSecretKey,
+};
diff --git a/packages/react-native-quick-crypto/src/keys/signVerify.ts b/packages/react-native-quick-crypto/src/keys/signVerify.ts
new file mode 100644
index 00000000..28dd0914
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/keys/signVerify.ts
@@ -0,0 +1,39 @@
+// import { KeyObject, PublicKeyObject, PrivateKeyObject } from '.';
+// import { ed25519 } from '../ed25519';
+// import type {
+//   BinaryLike,
+//   BinaryLikeNode,
+//   SignCallback,
+//   VerifyCallback,
+// } from '../utils';
+
+// export function sign(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   callback: SignCallback,
+// ): ArrayBuffer {
+//   console.log('sign  ', algorithm, data, key, callback);
+//   return new ArrayBuffer(32);
+// }
+
+// export function verify(
+//   algorithm: string | null | undefined,
+//   data: BinaryLike,
+//   key: BinaryLikeNode | KeyObject,
+//   signature: ArrayBuffer,
+//   callback: VerifyCallback,
+// ): boolean {
+//   if (!algorithm) {
+//     if (key instanceof PublicKeyObject) {
+//       switch (key.asymmetricKeyType) {
+//         case 'ed25519':
+//         case 'ed448':
+//         case 'x25519':
+//         case 'x448': {
+//           return ed25519.verify(signature, data, key);
+//         }
+//     }
+//   }
+//   throw new Error('Verify not implemented', algorithm, data, key, signature, callback);
+// }
diff --git a/packages/react-native-quick-crypto/src/keys/utils.ts b/packages/react-native-quick-crypto/src/keys/utils.ts
new file mode 100644
index 00000000..a5a97fb9
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/keys/utils.ts
@@ -0,0 +1,184 @@
+import {
+  binaryLikeToArrayBuffer,
+  isStringOrBuffer,
+  KeyEncoding,
+  KFormatType,
+} from '../utils';
+import type { EncodingOptions } from '../utils';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const isCryptoKey = (obj: any): boolean => {
+  return obj !== null && obj?.keyObject !== undefined;
+};
+
+/**
+ * Parses the public key encoding based on an object. keyType must be undefined
+ * when this is used to parse an input encoding and must be a valid key type if
+ * used to parse an output encoding.
+ */
+export function parsePublicKeyEncoding(
+  enc: EncodingOptions,
+  keyType: string | undefined,
+  objName?: string,
+) {
+  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
+}
+
+/**
+ * Parses the private key encoding based on an object. keyType must be undefined
+ * when this is used to parse an input encoding and must be a valid key type if
+ * used to parse an output encoding.
+ */
+export function parsePrivateKeyEncoding(
+  enc: EncodingOptions,
+  keyType: string | undefined,
+  objName?: string,
+) {
+  return parseKeyEncoding(enc, keyType, false, objName);
+}
+
+export function parseKeyEncoding(
+  enc: EncodingOptions,
+  keyType?: string,
+  isPublic?: boolean,
+  objName?: string,
+) {
+  // validateObject(enc, 'options');
+
+  const isInput = keyType === undefined;
+
+  const { format, type } = parseKeyFormatAndType(
+    enc,
+    keyType,
+    isPublic,
+    objName,
+  );
+
+  let cipher, passphrase, encoding;
+  if (isPublic !== true) {
+    ({ cipher, passphrase, encoding } = enc);
+
+    if (!isInput) {
+      if (cipher != null) {
+        if (typeof cipher !== 'string')
+          throw new Error(
+            `Invalid argument ${option('cipher', objName)}: ${cipher}`,
+          );
+        if (
+          format === KFormatType.kKeyFormatDER &&
+          (type === KeyEncoding.kKeyEncodingPKCS1 ||
+            type === KeyEncoding.kKeyEncodingSEC1)
+        ) {
+          throw new Error(
+            `Incompatible key options ${encodingNames[type]} does not support encryption`,
+          );
+        }
+      } else if (passphrase !== undefined) {
+        throw new Error(
+          `invalid argument ${option('cipher', objName)}: ${cipher}`,
+        );
+      }
+    }
+
+    if (
+      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||
+      (!isInput && cipher != null && !isStringOrBuffer(passphrase))
+    ) {
+      throw new Error(
+        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`,
+      );
+    }
+  }
+
+  if (passphrase !== undefined)
+    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);
+
+  return { format, type, cipher, passphrase };
+}
+
+const encodingNames = {
+  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
+  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
+  [KeyEncoding.kKeyEncodingSPKI]: 'spki',
+  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',
+};
+
+function option(name: string, objName?: string) {
+  return objName === undefined
+    ? `options.${name}`
+    : `options.${objName}.${name}`;
+}
+
+function parseKeyFormat(
+  formatStr?: string,
+  defaultFormat?: KFormatType,
+  optionName?: string,
+) {
+  if (formatStr === undefined && defaultFormat !== undefined)
+    return defaultFormat;
+  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;
+  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;
+  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
+  throw new Error(`Invalid key format str: ${optionName}`);
+}
+
+function parseKeyType(
+  typeStr: string | undefined,
+  required: boolean,
+  keyType: string | undefined,
+  isPublic: boolean | undefined,
+  optionName: string,
+): KeyEncoding | undefined {
+  if (typeStr === undefined && !required) {
+    return undefined;
+  } else if (typeStr === 'pkcs1') {
+    if (keyType !== undefined && keyType !== 'rsa') {
+      throw new Error(
+        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`,
+      );
+    }
+    return KeyEncoding.kKeyEncodingPKCS1;
+  } else if (typeStr === 'spki' && isPublic !== false) {
+    return KeyEncoding.kKeyEncodingSPKI;
+  } else if (typeStr === 'pkcs8' && isPublic !== true) {
+    return KeyEncoding.kKeyEncodingPKCS8;
+  } else if (typeStr === 'sec1' && isPublic !== true) {
+    if (keyType !== undefined && keyType !== 'ec') {
+      throw new Error(
+        `Incompatible key options ${typeStr} can only be used for EC keys`,
+      );
+    }
+    return KeyEncoding.kKeyEncodingSEC1;
+  }
+
+  throw new Error(`Invalid option ${optionName} - ${typeStr}`);
+}
+
+function parseKeyFormatAndType(
+  enc: EncodingOptions,
+  keyType?: string,
+  isPublic?: boolean,
+  objName?: string,
+) {
+  const { format: formatStr, type: typeStr } = enc;
+
+  const isInput = keyType === undefined;
+  const format = parseKeyFormat(
+    formatStr,
+    isInput ? KFormatType.kKeyFormatPEM : undefined,
+    option('format', objName),
+  );
+
+  const isRequired =
+    (!isInput || format === KFormatType.kKeyFormatDER) &&
+    format !== KFormatType.kKeyFormatJWK;
+
+  const type = parseKeyType(
+    typeStr,
+    isRequired,
+    keyType,
+    isPublic,
+    option('type', objName),
+  );
+  return { format, type };
+}
diff --git a/packages/react-native-quick-crypto/src/specs/edKeyPair.nitro.ts b/packages/react-native-quick-crypto/src/specs/edKeyPair.nitro.ts
new file mode 100644
index 00000000..dc6aba6f
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/specs/edKeyPair.nitro.ts
@@ -0,0 +1,32 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+
+export interface EdKeyPair
+  extends HybridObject<{ ios: 'c++'; android: 'c++' }> {
+  generateKeyPair(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+    cipher?: string,
+    passphrase?: ArrayBuffer,
+  ): Promise<void>;
+
+  generateKeyPairSync(
+    publicFormat: number,
+    publicType: number,
+    privateFormat: number,
+    privateType: number,
+    cipher?: string,
+    passphrase?: ArrayBuffer,
+  ): void;
+
+  getPublicKey(): ArrayBuffer;
+
+  sign(message: ArrayBuffer): Promise<ArrayBuffer>;
+  signSync(message: ArrayBuffer): ArrayBuffer;
+
+  verify(signature: ArrayBuffer, message: ArrayBuffer): Promise<boolean>;
+  verifySync(signature: ArrayBuffer, message: ArrayBuffer): boolean;
+
+  setCurve(curve: string): void;
+}
diff --git a/packages/react-native-quick-crypto/src/utils/conversion.ts b/packages/react-native-quick-crypto/src/utils/conversion.ts
index 03dad89f..5e9e63ab 100644
--- a/packages/react-native-quick-crypto/src/utils/conversion.ts
+++ b/packages/react-native-quick-crypto/src/utils/conversion.ts
@@ -96,3 +96,5 @@ export function binaryLikeToArrayBuffer(
 export function ab2str(buf: ArrayBuffer, encoding: string = 'hex') {
   return Buffer.from(buf).toString(encoding);
 }
+
+export const kEmptyObject = Object.freeze(Object.create(null));
diff --git a/packages/react-native-quick-crypto/src/utils/index.ts b/packages/react-native-quick-crypto/src/utils/index.ts
index d16cca11..aad2b671 100644
--- a/packages/react-native-quick-crypto/src/utils/index.ts
+++ b/packages/react-native-quick-crypto/src/utils/index.ts
@@ -2,3 +2,4 @@ export * from './conversion';
 export * from './errors';
 export * from './hashnames';
 export * from './types';
+export * from './validation';
diff --git a/packages/react-native-quick-crypto/src/utils/types.ts b/packages/react-native-quick-crypto/src/utils/types.ts
index db6c44f3..8deca073 100644
--- a/packages/react-native-quick-crypto/src/utils/types.ts
+++ b/packages/react-native-quick-crypto/src/utils/types.ts
@@ -1,6 +1,7 @@
-import { type Buffer } from '@craftzdog/react-native-buffer';
-import { type Buffer as SBuffer } from 'safe-buffer';
-import { type CipherKey } from 'crypto'; // @types/node
+import type { Buffer } from '@craftzdog/react-native-buffer';
+import type { Buffer as SBuffer } from 'safe-buffer';
+import type { CipherKey } from 'crypto'; // @types/node
+import type { KeyObjectHandle } from '../specs/keyObjectHandle.nitro';
 
 export type ArrayBufferView = TypedArray | DataView | ArrayBufferLike | Buffer;
 
@@ -38,6 +39,7 @@ export type RSAKeyPairAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP';
 export type ECKeyPairAlgorithm = 'ECDSA' | 'ECDH';
 
 export type CFRGKeyPairAlgorithm = 'Ed25519' | 'Ed448' | 'X25519' | 'X448';
+export type CFRGKeyPairType = 'ed25519' | 'ed448' | 'x25519' | 'x448';
 
 export type KeyPairAlgorithm =
   | RSAKeyPairAlgorithm
@@ -95,6 +97,8 @@ export type SubtleAlgorithm = {
   publicExponent?: number | Uint8Array;
 };
 
+export type KeyPairType = CFRGKeyPairType;
+
 export type KeyUsage =
   | 'encrypt'
   | 'decrypt'
@@ -127,7 +131,22 @@ export enum KeyEncoding {
   kKeyEncodingSEC1,
 }
 
-export type AsymmetricKeyType = 'rsa' | 'rsa-pss' | 'dsa' | 'ec';
+export type KeyPairGenConfig = {
+  publicFormat?: KFormatType;
+  publicType?: KeyEncoding;
+  privateFormat?: KFormatType;
+  privateType?: KeyEncoding;
+  cipher?: string;
+  passphrase?: ArrayBuffer;
+};
+
+export type AsymmetricKeyType =
+  // 'rsa' |
+  // 'rsa-pss' |
+  // 'dsa' |
+  // 'ec' |
+  // 'dh' |
+  CFRGKeyPairType;
 
 type JWKkty = 'AES' | 'RSA' | 'EC' | 'oct';
 type JWKuse = 'sig' | 'enc';
@@ -189,3 +208,64 @@ export interface KeyDetail {
   saltLength?: number;
   namedCurve?: string;
 }
+
+export type GenerateKeyPairOptions = {
+  modulusLength?: number; // Key size in bits (RSA, DSA).
+  publicExponent?: number; // Public exponent (RSA). Default: 0x10001.
+  hashAlgorithm?: string; // Name of the message digest (RSA-PSS).
+  mgf1HashAlgorithm?: string; // string Name of the message digest used by MGF1 (RSA-PSS).
+  saltLength?: number; // Minimal salt length in bytes (RSA-PSS).
+  divisorLength?: number; // Size of q in bits (DSA).
+  namedCurve?: string; // Name of the curve to use (EC).
+  prime?: Buffer; // The prime parameter (DH).
+  primeLength?: number; // Prime length in bits (DH).
+  generator?: number; // Custom generator (DH). Default: 2.
+  groupName?: string; // Diffie-Hellman group name (DH). See crypto.getDiffieHellman().
+  publicKeyEncoding?: EncodingOptions; // See keyObject.export().
+  privateKeyEncoding?: EncodingOptions; // See keyObject.export().
+  paramEncoding?: string;
+  hash?: string;
+  mgf1Hash?: string;
+};
+
+// Note: removed CryptoKey class from this type (from 0.x) because Nitro doesn't
+//       handle custom JS objects.  We might need to make it a JS object.
+export type KeyPairKey = ArrayBuffer | KeyObjectHandle | undefined;
+
+export type GenerateKeyPairReturn = [
+  error?: Error,
+  privateKey?: KeyPairKey,
+  publicKey?: KeyPairKey,
+];
+
+export type GenerateKeyPairCallback = (
+  error?: Error,
+  publicKey?: KeyPairKey,
+  privateKey?: KeyPairKey,
+) => GenerateKeyPairReturn | void;
+
+export type KeyPair = {
+  publicKey?: KeyPairKey;
+  privateKey?: KeyPairKey;
+};
+
+export type GenerateKeyPairPromiseReturn = [error?: Error, keypair?: KeyPair];
+
+export type CryptoKeyPair = {
+  publicKey: KeyPairKey;
+  privateKey: KeyPairKey;
+};
+
+export enum KeyVariant {
+  RSA_SSA_PKCS1_v1_5,
+  RSA_PSS,
+  RSA_OAEP,
+  DSA,
+  EC,
+  NID,
+  DH,
+}
+
+export type SignCallback = (err: Error | null, signature?: ArrayBuffer) => void;
+
+export type VerifyCallback = (err: Error | null, valid?: boolean) => void;
diff --git a/packages/react-native-quick-crypto/src/utils/validation.ts b/packages/react-native-quick-crypto/src/utils/validation.ts
new file mode 100644
index 00000000..ddcc7c54
--- /dev/null
+++ b/packages/react-native-quick-crypto/src/utils/validation.ts
@@ -0,0 +1,35 @@
+export function validateFunction(f: unknown): boolean {
+  return f !== null && typeof f === 'function';
+}
+
+export function isStringOrBuffer(val: unknown): val is string | ArrayBuffer {
+  return (
+    typeof val === 'string' ||
+    ArrayBuffer.isView(val) ||
+    val instanceof ArrayBuffer
+  );
+}
+
+export function validateObject<T>(
+  value: unknown,
+  name: string,
+  options?: {
+    allowArray: boolean;
+    allowFunction: boolean;
+    nullable: boolean;
+  } | null,
+): value is T {
+  const useDefaultOptions = options == null;
+  const allowArray = useDefaultOptions ? false : options.allowArray;
+  const allowFunction = useDefaultOptions ? false : options.allowFunction;
+  const nullable = useDefaultOptions ? false : options.nullable;
+  if (
+    (!nullable && value === null) ||
+    (!allowArray && Array.isArray(value)) ||
+    (typeof value !== 'object' &&
+      (!allowFunction || typeof value !== 'function'))
+  ) {
+    throw new Error(`${name} is not a valid object $${value}`);
+  }
+  return true;
+}
diff --git a/packages/react-native-quick-crypto/zzz/ts/Cipher.ts b/packages/react-native-quick-crypto/zzz/ts/Cipher.ts
deleted file mode 100644
index cbbb2f2c..00000000
--- a/packages/react-native-quick-crypto/zzz/ts/Cipher.ts
+++ /dev/null
@@ -1,832 +0,0 @@
-import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import Stream from 'readable-stream';
-import {
-  type BinaryLike,
-  binaryLikeToArrayBuffer,
-  type CipherEncoding,
-  type Encoding,
-  getDefaultEncoding,
-  kEmptyObject,
-  validateFunction,
-  validateObject,
-  validateString,
-  validateUint32,
-  validateInt32,
-  type BinaryLikeNode,
-} from './utils';
-import { type InternalCipher, KeyVariant } from './NativeQuickCrypto/Cipher';
-import type {
-  CipherCCMOptions,
-  CipherCCMTypes,
-  CipherGCMTypes,
-  CipherGCMOptions,
-  CipherOCBOptions,
-  CipherOCBTypes,
-  DecipherGCM,
-  DecipherOCB,
-  DecipherCCM,
-  CipherCCM,
-  CipherOCB,
-  CipherGCM,
-} from 'crypto'; // @types/node
-import { StringDecoder } from 'string_decoder';
-import { Buffer } from '@craftzdog/react-native-buffer';
-import { Buffer as SBuffer } from 'safe-buffer';
-import { constants } from './constants';
-import {
-  CryptoKey,
-  parsePrivateKeyEncoding,
-  parsePublicKeyEncoding,
-  preparePrivateKey,
-  preparePublicOrPrivateKey,
-  type CryptoKeyPair,
-  type KeyPairType,
-  type NamedCurve,
-} from './keys';
-import type { KeyObjectHandle } from './NativeQuickCrypto/webcrypto';
-
-export enum ECCurve {
-  OPENSSL_EC_EXPLICIT_CURVE,
-  OPENSSL_EC_NAMED_CURVE,
-}
-
-// make sure that nextTick is there
-global.process.nextTick = setImmediate;
-
-const createInternalCipher = NativeQuickCrypto.createCipher;
-const createInternalDecipher = NativeQuickCrypto.createDecipher;
-const _publicEncrypt = NativeQuickCrypto.publicEncrypt;
-const _publicDecrypt = NativeQuickCrypto.publicDecrypt;
-const _privateDecrypt = NativeQuickCrypto.privateDecrypt;
-
-function getUIntOption(options: Record<string, any>, key: string) {
-  let value;
-  if (options && (value = options[key]) != null) {
-    // >>> Turns any type into a positive integer (also sets the sign bit to 0)
-    // eslint-disable-next-line no-bitwise
-    if (value >>> 0 !== value) throw new Error(`options.${key}: ${value}`);
-    return value;
-  }
-  return -1;
-}
-
-function normalizeEncoding(enc: string) {
-  if (!enc) return 'utf8';
-  var retried;
-  while (true) {
-    switch (enc) {
-      case 'utf8':
-      case 'utf-8':
-        return 'utf8';
-      case 'ucs2':
-      case 'ucs-2':
-      case 'utf16le':
-      case 'utf-16le':
-        return 'utf16le';
-      case 'latin1':
-      case 'binary':
-        return 'latin1';
-      case 'base64':
-      case 'ascii':
-      case 'hex':
-        return enc;
-      default:
-        if (retried) return; // undefined
-        enc = ('' + enc).toLowerCase();
-        retried = true;
-    }
-  }
-}
-
-function validateEncoding(data: string, encoding: string) {
-  const normalizedEncoding = normalizeEncoding(encoding);
-  const length = data.length;
-
-  if (normalizedEncoding === 'hex' && length % 2 !== 0) {
-    throw new Error(`Encoding ${encoding} not valid for data length ${length}`);
-  }
-}
-
-function getDecoder(decoder?: StringDecoder, encoding?: BufferEncoding) {
-  return decoder ?? new StringDecoder(encoding);
-}
-
-class CipherCommon extends Stream.Transform {
-  private internal: InternalCipher;
-  private decoder: StringDecoder | undefined;
-
-  constructor(
-    cipherType: string,
-    cipherKey: BinaryLikeNode,
-    isCipher: boolean,
-    options: Record<string, any> = {},
-    iv?: BinaryLike | null
-  ) {
-    super(options);
-    const cipherKeyBuffer = binaryLikeToArrayBuffer(cipherKey);
-    // defaults to 16 bytes
-    const authTagLength =
-      getUIntOption(options, 'authTagLength') !== -1
-        ? getUIntOption(options, 'authTagLength')
-        : 16;
-    const args = {
-      cipher_type: cipherType,
-      cipher_key: cipherKeyBuffer,
-      iv,
-      ...options,
-      auth_tag_len: authTagLength,
-    };
-    this.internal = isCipher
-      ? createInternalCipher(args)
-      : createInternalDecipher(args);
-  }
-
-  update(
-    data: BinaryLike,
-    inputEncoding?: CipherEncoding,
-    outputEncoding?: CipherEncoding
-  ): ArrayBuffer | string {
-    const defaultEncoding = getDefaultEncoding();
-    inputEncoding = inputEncoding ?? defaultEncoding;
-    outputEncoding = outputEncoding ?? defaultEncoding;
-
-    if (typeof data === 'string') {
-      validateEncoding(data, inputEncoding);
-    } else if (!ArrayBuffer.isView(data)) {
-      throw new Error('Invalid data argument');
-    }
-
-    if (typeof data === 'string') {
-      // On node this is handled on the native side
-      // on our case we need to correctly send the arraybuffer to the jsi side
-      inputEncoding = inputEncoding === 'buffer' ? 'utf8' : inputEncoding;
-      data = binaryLikeToArrayBuffer(data, inputEncoding);
-    } else {
-      data = binaryLikeToArrayBuffer(data as any, inputEncoding);
-    }
-
-    const ret = this.internal.update(data);
-
-    if (outputEncoding && outputEncoding !== 'buffer') {
-      this.decoder = getDecoder(this.decoder, outputEncoding);
-
-      return this.decoder!.write(SBuffer.from(ret) as any);
-    }
-
-    return ret;
-  }
-
-  final(): ArrayBuffer;
-  final(outputEncoding: BufferEncoding | 'buffer'): string;
-  final(outputEncoding?: BufferEncoding | 'buffer'): ArrayBuffer | string {
-    const ret = this.internal.final();
-
-    if (outputEncoding && outputEncoding !== 'buffer') {
-      this.decoder = getDecoder(this.decoder, outputEncoding);
-
-      return this.decoder!.end(SBuffer.from(ret) as any);
-    }
-
-    return ret;
-  }
-
-  _transform(chunk: BinaryLike, encoding: Encoding, callback: () => void) {
-    this.push(this.update(chunk, encoding));
-    callback();
-  }
-
-  _flush(callback: () => void) {
-    this.push(this.final());
-    callback();
-  }
-
-  public setAutoPadding(autoPadding?: boolean): this {
-    this.internal.setAutoPadding(!!autoPadding);
-    return this;
-  }
-
-  public setAAD(
-    buffer: Buffer,
-    options?: {
-      plaintextLength: number;
-    }
-  ): this {
-    this.internal.setAAD({
-      data: buffer.buffer,
-      plaintextLength: options?.plaintextLength,
-    });
-    return this;
-  }
-
-  public getAuthTag(): ArrayBuffer {
-    return this.internal.getAuthTag();
-  }
-
-  public setAuthTag(tag: Buffer): this {
-    this.internal.setAuthTag(binaryLikeToArrayBuffer(tag));
-    return this;
-  }
-}
-
-class Cipher extends CipherCommon {
-  constructor(
-    cipherType: string,
-    cipherKey: BinaryLikeNode,
-    options: Record<string, any> = {},
-    iv?: BinaryLike | null
-  ) {
-    if (iv != null) {
-      iv = binaryLikeToArrayBuffer(iv);
-    }
-    super(cipherType, cipherKey, true, options, iv);
-  }
-}
-
-class Decipher extends CipherCommon {
-  constructor(
-    cipherType: string,
-    cipherKey: BinaryLikeNode,
-    options: Record<string, any> = {},
-    iv?: BinaryLike | null
-  ) {
-    if (iv != null) {
-      iv = binaryLikeToArrayBuffer(iv);
-    }
-
-    super(cipherType, cipherKey, false, options, iv);
-  }
-}
-
-export function createDecipher(
-  algorithm: CipherCCMTypes,
-  password: BinaryLikeNode,
-  options: CipherCCMOptions
-): DecipherCCM;
-export function createDecipher(
-  algorithm: CipherGCMTypes,
-  password: BinaryLikeNode,
-  options?: CipherGCMOptions
-): DecipherGCM;
-export function createDecipher(
-  algorithm: string,
-  password: BinaryLikeNode,
-  options?: CipherCCMOptions | CipherGCMOptions | Stream.TransformOptions
-): DecipherCCM | DecipherGCM | Decipher {
-  return new Decipher(algorithm, password, options);
-}
-
-export function createDecipheriv(
-  algorithm: CipherCCMTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options: CipherCCMOptions
-): DecipherCCM;
-export function createDecipheriv(
-  algorithm: CipherOCBTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options: CipherOCBOptions
-): DecipherOCB;
-export function createDecipheriv(
-  algorithm: CipherGCMTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options?: CipherGCMOptions
-): DecipherGCM;
-export function createDecipheriv(
-  algorithm: string,
-  key: BinaryLikeNode,
-  iv: BinaryLike | null,
-  options?:
-    | CipherCCMOptions
-    | CipherOCBOptions
-    | CipherGCMOptions
-    | Stream.TransformOptions
-): DecipherCCM | DecipherOCB | DecipherGCM | Decipher {
-  return new Decipher(algorithm, key, options, iv);
-}
-
-export function createCipher(
-  algorithm: CipherCCMTypes,
-  password: BinaryLikeNode,
-  options: CipherCCMOptions
-): CipherCCM;
-export function createCipher(
-  algorithm: CipherGCMTypes,
-  password: BinaryLikeNode,
-  options?: CipherGCMOptions
-): CipherGCM;
-export function createCipher(
-  algorithm: string,
-  password: BinaryLikeNode,
-  options?: CipherGCMOptions | CipherCCMOptions | Stream.TransformOptions
-): CipherCCM | CipherGCM | Cipher {
-  return new Cipher(algorithm, password, options);
-}
-
-export function createCipheriv(
-  algorithm: CipherCCMTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options: CipherCCMOptions
-): CipherCCM;
-export function createCipheriv(
-  algorithm: CipherOCBTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options: CipherOCBOptions
-): CipherOCB;
-export function createCipheriv(
-  algorithm: CipherGCMTypes,
-  key: BinaryLikeNode,
-  iv: BinaryLike,
-  options?: CipherGCMOptions
-): CipherGCM;
-export function createCipheriv(
-  algorithm: string,
-  key: BinaryLikeNode,
-  iv: BinaryLike | null,
-  options?:
-    | CipherCCMOptions
-    | CipherOCBOptions
-    | CipherGCMOptions
-    | Stream.TransformOptions
-): CipherCCM | CipherOCB | CipherGCM | Cipher {
-  return new Cipher(algorithm, key, options, iv);
-}
-
-// RSA Functions
-// Follows closely the model implemented in node
-
-// TODO(osp) types...
-function rsaFunctionFor(
-  method: (
-    data: ArrayBuffer,
-    format: number,
-    type: any,
-    passphrase: any,
-    buffer: ArrayBuffer,
-    padding: number,
-    oaepHash: any,
-    oaepLabel: any
-  ) => Buffer,
-  defaultPadding: number,
-  keyType: 'public' | 'private'
-) {
-  return (
-    options: {
-      key: any;
-      encoding?: string;
-      format?: any;
-      padding?: any;
-      oaepHash?: any;
-      oaepLabel?: any;
-      passphrase?: string;
-    },
-    buffer: BinaryLike
-  ) => {
-    const { format, type, data, passphrase } =
-      keyType === 'private'
-        ? preparePrivateKey(options)
-        : preparePublicOrPrivateKey(options);
-    const padding = options.padding || defaultPadding;
-    const { oaepHash, encoding } = options;
-    let { oaepLabel } = options;
-    if (oaepHash !== undefined) validateString(oaepHash, 'key.oaepHash');
-    if (oaepLabel !== undefined)
-      oaepLabel = binaryLikeToArrayBuffer(oaepLabel, encoding);
-    buffer = binaryLikeToArrayBuffer(buffer, encoding);
-
-    const rawRes = method(
-      data,
-      format,
-      type,
-      passphrase,
-      buffer,
-      padding,
-      oaepHash,
-      oaepLabel
-    );
-
-    return Buffer.from(rawRes);
-  };
-}
-
-export const publicEncrypt = rsaFunctionFor(
-  _publicEncrypt,
-  constants.RSA_PKCS1_OAEP_PADDING,
-  'public'
-);
-export const publicDecrypt = rsaFunctionFor(
-  _publicDecrypt,
-  constants.RSA_PKCS1_PADDING,
-  'public'
-);
-// const privateEncrypt = rsaFunctionFor(_privateEncrypt, constants.RSA_PKCS1_PADDING,
-//   'private');
-export const privateDecrypt = rsaFunctionFor(
-  _privateDecrypt,
-  constants.RSA_PKCS1_OAEP_PADDING,
-  'private'
-);
-
-//                                   _       _  __          _____      _
-//                                  | |     | |/ /         |  __ \    (_)
-//    __ _  ___ _ __   ___ _ __ __ _| |_ ___| ' / ___ _   _| |__) |_ _ _ _ __
-//   / _` |/ _ \ '_ \ / _ \ '__/ _` | __/ _ \  < / _ \ | | |  ___/ _` | | '__|
-//  | (_| |  __/ | | |  __/ | | (_| | ||  __/ . \  __/ |_| | |  | (_| | | |
-//   \__, |\___|_| |_|\___|_|  \__,_|\__\___|_|\_\___|\__, |_|   \__,_|_|_|
-//    __/ |                                            __/ |
-//   |___/                                            |___/
-export type GenerateKeyPairOptions = {
-  modulusLength?: number; // Key size in bits (RSA, DSA).
-  publicExponent?: number; // Public exponent (RSA). Default: 0x10001.
-  hashAlgorithm?: string; // Name of the message digest (RSA-PSS).
-  mgf1HashAlgorithm?: string; // string Name of the message digest used by MGF1 (RSA-PSS).
-  saltLength?: number; // Minimal salt length in bytes (RSA-PSS).
-  divisorLength?: number; // Size of q in bits (DSA).
-  namedCurve?: string; // Name of the curve to use (EC).
-  prime?: Buffer; // The prime parameter (DH).
-  primeLength?: number; // Prime length in bits (DH).
-  generator?: number; // Custom generator (DH). Default: 2.
-  groupName?: string; // Diffie-Hellman group name (DH). See crypto.getDiffieHellman().
-  publicKeyEncoding?: any; // See keyObject.export().
-  privateKeyEncoding?: any; // See keyObject.export().
-  paramEncoding?: string;
-  hash?: any;
-  mgf1Hash?: any;
-};
-
-export type KeyPairKey = Buffer | KeyObjectHandle | CryptoKey | undefined;
-
-export type GenerateKeyPairReturn = [
-  error?: Error,
-  privateKey?: KeyPairKey,
-  publicKey?: KeyPairKey,
-];
-
-export type GenerateKeyPairCallback = (
-  error?: Error,
-  publicKey?: KeyPairKey,
-  privateKey?: KeyPairKey
-) => GenerateKeyPairReturn | void;
-
-export type KeyPair = {
-  publicKey?: KeyPairKey;
-  privateKey?: KeyPairKey;
-};
-
-export type GenerateKeyPairPromiseReturn = [error?: Error, keypair?: KeyPair];
-
-function parseKeyEncoding(
-  keyType: string,
-  options: GenerateKeyPairOptions = kEmptyObject
-) {
-  const { publicKeyEncoding, privateKeyEncoding } = options;
-
-  let publicFormat, publicType;
-  if (publicKeyEncoding == null) {
-    publicFormat = publicType = undefined;
-  } else if (typeof publicKeyEncoding === 'object') {
-    ({ format: publicFormat, type: publicType } = parsePublicKeyEncoding(
-      publicKeyEncoding,
-      keyType,
-      'publicKeyEncoding'
-    ));
-  } else {
-    throw new Error(
-      'Invalid argument options.publicKeyEncoding',
-      publicKeyEncoding
-    );
-  }
-
-  let privateFormat, privateType, cipher, passphrase;
-  if (privateKeyEncoding == null) {
-    privateFormat = privateType = undefined;
-  } else if (typeof privateKeyEncoding === 'object') {
-    ({
-      format: privateFormat,
-      type: privateType,
-      cipher,
-      passphrase,
-    } = parsePrivateKeyEncoding(
-      privateKeyEncoding,
-      keyType,
-      'privateKeyEncoding'
-    ));
-  } else {
-    throw new Error(
-      'Invalid argument options.privateKeyEncoding',
-      publicKeyEncoding
-    );
-  }
-
-  return [
-    publicFormat,
-    publicType,
-    privateFormat,
-    privateType,
-    cipher,
-    passphrase,
-  ];
-}
-
-/** On node a very complex "job" chain is created, we are going for a far simpler approach and calling
- *  an internal function that basically executes the same byte shuffling on the native side
- */
-function internalGenerateKeyPair(
-  isAsync: boolean,
-  type: KeyPairType,
-  options: GenerateKeyPairOptions | undefined,
-  callback?: GenerateKeyPairCallback
-): GenerateKeyPairReturn | void {
-  const encoding = parseKeyEncoding(type, options);
-
-  // if (options !== undefined)
-  //   validateObject(options, 'options');
-
-  switch (type) {
-    case 'rsa-pss':
-    // fallthrough
-    case 'rsa':
-      validateObject<GenerateKeyPairOptions>(options, 'options');
-      const { modulusLength } = options!;
-      validateUint32(modulusLength as number, 'options.modulusLength');
-      let { publicExponent } = options!;
-      if (publicExponent == null) {
-        publicExponent = 0x10001;
-      } else {
-        validateUint32(publicExponent, 'options.publicExponent');
-      }
-
-      if (type === 'rsa') {
-        if (isAsync) {
-          NativeQuickCrypto.generateKeyPair(
-            KeyVariant.RSA_SSA_PKCS1_v1_5, // Used also for RSA-OAEP
-            modulusLength as number,
-            publicExponent,
-            ...encoding
-          )
-            .then(([err, publicKey, privateKey]) => {
-              if (publicKey instanceof Buffer) {
-                publicKey = Buffer.from(publicKey);
-              }
-              if (privateKey instanceof Buffer) {
-                privateKey = Buffer.from(privateKey);
-              }
-              callback!(err, publicKey, privateKey);
-            })
-            .catch((err) => {
-              callback!(err, undefined, undefined);
-            });
-        } else {
-          let [err, publicKey, privateKey] =
-            NativeQuickCrypto.generateKeyPairSync(
-              KeyVariant.RSA_SSA_PKCS1_v1_5,
-              modulusLength as number,
-              publicExponent,
-              ...encoding
-            );
-
-          if (publicKey instanceof Buffer) {
-            publicKey = Buffer.from(publicKey);
-          }
-          if (privateKey instanceof Buffer) {
-            privateKey = Buffer.from(privateKey);
-          }
-
-          return [err, publicKey, privateKey];
-        }
-      }
-
-      const { hash, mgf1Hash, hashAlgorithm, mgf1HashAlgorithm, saltLength } =
-        options!;
-
-      // // We don't have a process object on RN
-      // // const pendingDeprecation = getOptionValue('--pending-deprecation');
-
-      if (saltLength !== undefined)
-        validateInt32(saltLength, 'options.saltLength', 0);
-      if (hashAlgorithm !== undefined)
-        validateString(hashAlgorithm, 'options.hashAlgorithm');
-      if (mgf1HashAlgorithm !== undefined)
-        validateString(mgf1HashAlgorithm, 'options.mgf1HashAlgorithm');
-      if (hash !== undefined) {
-        // pendingDeprecation && process.emitWarning(
-        //   '"options.hash" is deprecated, ' +
-        //   'use "options.hashAlgorithm" instead.',
-        //   'DeprecationWarning',
-        //   'DEP0154');
-        validateString(hash, 'options.hash');
-        if (hashAlgorithm && hash !== hashAlgorithm) {
-          throw new Error(`Invalid Argument options.hash ${hash}`);
-        }
-      }
-      if (mgf1Hash !== undefined) {
-        // pendingDeprecation && process.emitWarning(
-        //   '"options.mgf1Hash" is deprecated, ' +
-        //   'use "options.mgf1HashAlgorithm" instead.',
-        //   'DeprecationWarning',
-        //   'DEP0154');
-        validateString(mgf1Hash, 'options.mgf1Hash');
-        if (mgf1HashAlgorithm && mgf1Hash !== mgf1HashAlgorithm) {
-          throw new Error(`Invalid Argument options.mgf1Hash ${mgf1Hash}`);
-        }
-      }
-
-      return NativeQuickCrypto.generateKeyPairSync(
-        KeyVariant.RSA_PSS,
-        modulusLength as number,
-        publicExponent,
-        hashAlgorithm || hash,
-        mgf1HashAlgorithm || mgf1Hash,
-        saltLength,
-        ...encoding
-      );
-
-    // case 'dsa': {
-    //   validateObject(options, 'options');
-    //   const { modulusLength } = options!;
-    //   validateUint32(modulusLength, 'options.modulusLength');
-
-    //   let { divisorLength } = options!;
-    //   if (divisorLength == null) {
-    //     divisorLength = -1;
-    //   } else validateInt32(divisorLength, 'options.divisorLength', 0);
-
-    //   // return new DsaKeyPairGenJob(
-    //   //   mode,
-    //   //   modulusLength,
-    //   //   divisorLength,
-    //   //   ...encoding);
-    // }
-
-    case 'ec':
-      validateObject<GenerateKeyPairOptions>(options, 'options');
-      const { namedCurve } = options!;
-      validateString(namedCurve, 'options.namedCurve');
-      let paramEncodingFlag = ECCurve.OPENSSL_EC_NAMED_CURVE;
-      const { paramEncoding } = options!;
-      if (paramEncoding == null || paramEncoding === 'named')
-        paramEncodingFlag = ECCurve.OPENSSL_EC_NAMED_CURVE;
-      else if (paramEncoding === 'explicit')
-        paramEncodingFlag = ECCurve.OPENSSL_EC_EXPLICIT_CURVE;
-      else
-        throw new Error(
-          `Invalid Argument options.paramEncoding ${paramEncoding}`
-        );
-
-      if (isAsync) {
-        NativeQuickCrypto.generateKeyPair(
-          KeyVariant.EC,
-          namedCurve as NamedCurve,
-          paramEncodingFlag,
-          ...encoding
-        )
-          .then(([err, publicKey, privateKey]) => {
-            if (publicKey instanceof Buffer) {
-              publicKey = Buffer.from(publicKey);
-            }
-            if (privateKey instanceof Buffer) {
-              privateKey = Buffer.from(privateKey);
-            }
-            callback?.(err, publicKey, privateKey);
-          })
-          .catch((err) => {
-            callback?.(err, undefined, undefined);
-          });
-      }
-
-      let [err, publicKey, privateKey] = NativeQuickCrypto.generateKeyPairSync(
-        KeyVariant.EC,
-        namedCurve as NamedCurve,
-        paramEncodingFlag,
-        ...encoding
-      );
-      if (publicKey instanceof Buffer) {
-        publicKey = Buffer.from(publicKey);
-      }
-      if (privateKey instanceof Buffer) {
-        privateKey = Buffer.from(privateKey);
-      }
-      return [err, publicKey, privateKey];
-
-    // case 'ed25519':
-    // case 'ed448':
-    // case 'x25519':
-    // case 'x448': {
-    //   let id;
-    //   switch (type) {
-    //     case 'ed25519':
-    //       id = EVP_PKEY_ED25519;
-    //       break;
-    //     case 'ed448':
-    //       id = EVP_PKEY_ED448;
-    //       break;
-    //     case 'x25519':
-    //       id = EVP_PKEY_X25519;
-    //       break;
-    //     case 'x448':
-    //       id = EVP_PKEY_X448;
-    //       break;
-    //   }
-    //   return new NidKeyPairGenJob(mode, id, ...encoding);
-    // }
-    // case 'dh': {
-    //   validateObject(options, 'options');
-    //   const { group, primeLength, prime, generator } = options;
-    //   if (group != null) {
-    //     if (prime != null)
-    //       throw new ERR_INCOMPATIBLE_OPTION_PAIR('group', 'prime');
-    //     if (primeLength != null)
-    //       throw new ERR_INCOMPATIBLE_OPTION_PAIR('group', 'primeLength');
-    //     if (generator != null)
-    //       throw new ERR_INCOMPATIBLE_OPTION_PAIR('group', 'generator');
-
-    //     validateString(group, 'options.group');
-
-    //     return new DhKeyPairGenJob(mode, group, ...encoding);
-    //   }
-
-    //   if (prime != null) {
-    //     if (primeLength != null)
-    //       throw new ERR_INCOMPATIBLE_OPTION_PAIR('prime', 'primeLength');
-
-    //     validateBuffer(prime, 'options.prime');
-    //   } else if (primeLength != null) {
-    //     validateInt32(primeLength, 'options.primeLength', 0);
-    //   } else {
-    //     throw new ERR_MISSING_OPTION(
-    //       'At least one of the group, prime, or primeLength options'
-    //     );
-    //   }
-
-    //   if (generator != null) {
-    //     validateInt32(generator, 'options.generator', 0);
-    //   }
-    //   return new DhKeyPairGenJob(
-    //     mode,
-    //     prime != null ? prime : primeLength,
-    //     generator == null ? 2 : generator,
-    //     ...encoding
-    //   );
-    // }
-    default:
-    // Fall through
-  }
-  const err = new Error(`
-      Invalid Argument options: '${type}' scheme not supported for generateKey().
-      Currently not all encryption methods are supported in quick-crypto.  Check
-      implementation_coverage.md for status.
-    `);
-  return [err, undefined, undefined];
-}
-
-export const generateKeyPair = (
-  type: KeyPairType,
-  options: GenerateKeyPairOptions,
-  callback: GenerateKeyPairCallback
-): void => {
-  validateFunction(callback);
-  internalGenerateKeyPair(true, type, options, callback);
-};
-
-// Promisify generateKeyPair
-// (attempted to use util.promisify, to no avail)
-export const generateKeyPairPromise = (
-  type: KeyPairType,
-  options: GenerateKeyPairOptions
-): Promise<GenerateKeyPairPromiseReturn> => {
-  return new Promise((resolve, reject) => {
-    generateKeyPair(type, options, (err, publicKey, privateKey) => {
-      if (err) {
-        reject([err, undefined]);
-      } else {
-        resolve([undefined, { publicKey, privateKey }]);
-      }
-    });
-  });
-};
-
-// generateKeyPairSync
-export function generateKeyPairSync(type: KeyPairType): CryptoKeyPair;
-export function generateKeyPairSync(
-  type: KeyPairType,
-  options: GenerateKeyPairOptions
-): CryptoKeyPair;
-export function generateKeyPairSync(
-  type: KeyPairType,
-  options?: GenerateKeyPairOptions
-): CryptoKeyPair {
-  const [_, publicKey, privateKey] = internalGenerateKeyPair(
-    false,
-    type,
-    options,
-    undefined
-  )!;
-
-  return {
-    publicKey,
-    privateKey,
-  };
-}
diff --git a/packages/react-native-quick-crypto/zzz/ts/keys.ts b/packages/react-native-quick-crypto/zzz/ts/keys.ts
deleted file mode 100644
index 4098c7db..00000000
--- a/packages/react-native-quick-crypto/zzz/ts/keys.ts
+++ /dev/null
@@ -1,553 +0,0 @@
-import {
-  type BinaryLike,
-  binaryLikeToArrayBuffer,
-  isStringOrBuffer,
-  type BufferLike,
-  type TypedArray,
-} from './utils';
-import type { KeyObjectHandle } from './NativeQuickCrypto/webcrypto';
-import { NativeQuickCrypto } from './NativeQuickCrypto/NativeQuickCrypto';
-import type { KeyPairKey } from './Cipher';
-
-export const kNamedCurveAliases = {
-  'P-256': 'prime256v1',
-  'P-384': 'secp384r1',
-  'P-521': 'secp521r1',
-} as const;
-
-export type ImportFormat = 'raw' | 'pkcs8' | 'spki' | 'jwk';
-
-export type KeyPairType = 'rsa' | 'rsa-pss' | 'ec';
-
-
-export type SecretKeyType = 'hmac' | 'aes';
-
-export type RsaOaepParams = {
-  name: 'RSA-OAEP';
-  label?: BufferLike;
-};
-
-export type AesCbcParams = {
-  name: 'AES-CBC';
-  iv: BufferLike;
-};
-
-export type AesCtrParams = {
-  name: 'AES-CTR';
-  counter: TypedArray;
-  length: number;
-};
-
-export type AesGcmParams = {
-  name: 'AES-GCM';
-  iv: BufferLike;
-  tagLength?: TagLength;
-  additionalData?: BufferLike;
-};
-
-export type AesKwParams = {
-  name: 'AES-KW';
-  wrappingKey?: BufferLike;
-};
-
-export type AesKeyGenParams = {
-  length: AESLength;
-  name?: AESAlgorithm;
-};
-
-export type TagLength = 32 | 64 | 96 | 104 | 112 | 120 | 128;
-
-export type AESLength = 128 | 192 | 256;
-
-export type EncryptDecryptParams =
-  | AesCbcParams
-  | AesCtrParams
-  | AesGcmParams
-  | RsaOaepParams;
-
-
-
-
-// Same as KFormatType, this enum needs to be defined on the native side
-export enum KWebCryptoKeyFormat {
-  kWebCryptoKeyFormatRaw,
-  kWebCryptoKeyFormatPKCS8,
-  kWebCryptoKeyFormatSPKI,
-  kWebCryptoKeyFormatJWK,
-}
-
-export enum WebCryptoKeyExportStatus {
-  OK,
-  INVALID_KEY_TYPE,
-  FAILED,
-}
-
-enum KeyInputContext {
-  kConsumePublic,
-  kConsumePrivate,
-  kCreatePublic,
-  kCreatePrivate,
-}
-
-const encodingNames = {
-  [KeyEncoding.kKeyEncodingPKCS1]: 'pkcs1',
-  [KeyEncoding.kKeyEncodingPKCS8]: 'pkcs8',
-  [KeyEncoding.kKeyEncodingSPKI]: 'spki',
-  [KeyEncoding.kKeyEncodingSEC1]: 'sec1',
-};
-
-export type CryptoKeyPair = {
-  publicKey: KeyPairKey;
-  privateKey: KeyPairKey;
-};
-
-export enum CipherOrWrapMode {
-  kWebCryptoCipherEncrypt,
-  kWebCryptoCipherDecrypt,
-  // kWebCryptoWrapKey,
-  // kWebCryptoUnwrapKey,
-}
-
-function option(name: string, objName: string | undefined) {
-  return objName === undefined
-    ? `options.${name}`
-    : `options.${objName}.${name}`;
-}
-
-function parseKeyFormat(
-  formatStr: string | undefined,
-  defaultFormat: KFormatType | undefined,
-  optionName?: string
-) {
-  if (formatStr === undefined && defaultFormat !== undefined)
-    return defaultFormat;
-  else if (formatStr === 'pem') return KFormatType.kKeyFormatPEM;
-  else if (formatStr === 'der') return KFormatType.kKeyFormatDER;
-  else if (formatStr === 'jwk') return KFormatType.kKeyFormatJWK;
-  throw new Error(`Invalid key format str: ${optionName}`);
-  // throw new ERR_INVALID_ARG_VALUE(optionName, formatStr);
-}
-
-function parseKeyType(
-  typeStr: string | undefined,
-  required: boolean,
-  keyType: string | undefined,
-  isPublic: boolean | undefined,
-  optionName: string
-): KeyEncoding | undefined {
-  if (typeStr === undefined && !required) {
-    return undefined;
-  } else if (typeStr === 'pkcs1') {
-    if (keyType !== undefined && keyType !== 'rsa') {
-      throw new Error(
-        `Crypto incompatible key options: ${typeStr} can only be used for RSA keys`
-      );
-    }
-    return KeyEncoding.kKeyEncodingPKCS1;
-  } else if (typeStr === 'spki' && isPublic !== false) {
-    return KeyEncoding.kKeyEncodingSPKI;
-  } else if (typeStr === 'pkcs8' && isPublic !== true) {
-    return KeyEncoding.kKeyEncodingPKCS8;
-  } else if (typeStr === 'sec1' && isPublic !== true) {
-    if (keyType !== undefined && keyType !== 'ec') {
-      throw new Error(
-        `Incompatible key options ${typeStr} can only be used for EC keys`
-      );
-    }
-    return KeyEncoding.kKeyEncodingSEC1;
-  }
-
-  throw new Error(`Invalid option ${optionName} - ${typeStr}`);
-}
-
-function parseKeyFormatAndType(
-  enc: EncodingOptions,
-  keyType?: string,
-  isPublic?: boolean,
-  objName?: string
-) {
-  const { format: formatStr, type: typeStr } = enc;
-
-  const isInput = keyType === undefined;
-  const format = parseKeyFormat(
-    formatStr,
-    isInput ? KFormatType.kKeyFormatPEM : undefined,
-    option('format', objName)
-  );
-
-  const isRequired =
-    (!isInput || format === KFormatType.kKeyFormatDER) &&
-    format !== KFormatType.kKeyFormatJWK;
-
-  const type = parseKeyType(
-    typeStr,
-    isRequired,
-    keyType,
-    isPublic,
-    option('type', objName)
-  );
-  return { format, type };
-}
-
-function parseKeyEncoding(
-  enc: EncodingOptions,
-  keyType?: string,
-  isPublic?: boolean,
-  objName?: string
-) {
-  // validateObject(enc, 'options');
-
-  const isInput = keyType === undefined;
-
-  const { format, type } = parseKeyFormatAndType(
-    enc,
-    keyType,
-    isPublic,
-    objName
-  );
-
-  let cipher, passphrase, encoding;
-  if (isPublic !== true) {
-    ({ cipher, passphrase, encoding } = enc);
-
-    if (!isInput) {
-      if (cipher != null) {
-        if (typeof cipher !== 'string')
-          throw new Error(
-            `Invalid argument ${option('cipher', objName)}: ${cipher}`
-          );
-        if (
-          format === KFormatType.kKeyFormatDER &&
-          (type === KeyEncoding.kKeyEncodingPKCS1 ||
-            type === KeyEncoding.kKeyEncodingSEC1)
-        ) {
-          throw new Error(
-            `Incompatible key options ${encodingNames[type]} does not support encryption`
-          );
-        }
-      } else if (passphrase !== undefined) {
-        throw new Error(
-          `invalid argument ${option('cipher', objName)}: ${cipher}`
-        );
-      }
-    }
-
-    if (
-      (isInput && passphrase !== undefined && !isStringOrBuffer(passphrase)) ||
-      (!isInput && cipher != null && !isStringOrBuffer(passphrase))
-    ) {
-      throw new Error(
-        `Invalid argument value ${option('passphrase', objName)}: ${passphrase}`
-      );
-    }
-  }
-
-  if (passphrase !== undefined)
-    passphrase = binaryLikeToArrayBuffer(passphrase, encoding);
-
-  return { format, type, cipher, passphrase };
-}
-
-function prepareAsymmetricKey(
-  key: BinaryLike | EncodingOptions,
-  ctx: KeyInputContext
-): {
-  format: KFormatType;
-  data: ArrayBuffer;
-  type?: KeyEncoding;
-  passphrase?: string | ArrayBuffer;
-} {
-  // TODO(osp) check, KeyObject some node object
-  // if (isKeyObject(key)) {
-  //   // Best case: A key object, as simple as that.
-  //   return { data: getKeyObjectHandle(key, ctx) };
-  // } else
-  // if (isCryptoKey(key)) {
-  //   return { data: getKeyObjectHandle(key[kKeyObject], ctx) };
-  // } else
-  if (isStringOrBuffer(key)) {
-    // Expect PEM by default, mostly for backward compatibility.
-    return {
-      format: KFormatType.kKeyFormatPEM,
-      data: binaryLikeToArrayBuffer(key),
-    };
-  } else if (typeof key === 'object') {
-    const { key: data, encoding } = key;
-    // // The 'key' property can be a KeyObject as well to allow specifying
-    // // additional options such as padding along with the key.
-    // if (isKeyObject(data)) {
-    //   return { data: getKeyObjectHandle(data, ctx) };
-    // }
-    // else if (isCryptoKey(data))
-    //   return { data: getKeyObjectHandle(data[kKeyObject], ctx) };
-    // else if (isJwk(data) && format === 'jwk')
-    //   return { data: getKeyObjectHandleFromJwk(data, ctx), format: 'jwk' };
-    // Either PEM or DER using PKCS#1 or SPKI.
-    if (!isStringOrBuffer(data)) {
-      throw new Error(
-        'prepareAsymmetricKey: key is not a string or ArrayBuffer'
-      );
-    }
-
-    const isPublic =
-      ctx === KeyInputContext.kConsumePrivate ||
-      ctx === KeyInputContext.kCreatePrivate
-        ? false
-        : undefined;
-
-    return {
-      data: binaryLikeToArrayBuffer(data, encoding),
-      ...parseKeyEncoding(key, undefined, isPublic),
-    };
-  }
-
-  throw new Error('[prepareAsymetricKey] Invalid argument key: ${key}');
-}
-
-// TODO(osp) any here is a node KeyObject
-export function preparePrivateKey(key: BinaryLike | EncodingOptions) {
-  return prepareAsymmetricKey(key, KeyInputContext.kConsumePrivate);
-}
-
-// TODO(osp) any here is a node KeyObject
-export function preparePublicOrPrivateKey(key: BinaryLike | EncodingOptions) {
-  return prepareAsymmetricKey(key, KeyInputContext.kConsumePublic);
-}
-
-// Parses the public key encoding based on an object. keyType must be undefined
-// when this is used to parse an input encoding and must be a valid key type if
-// used to parse an output encoding.
-export function parsePublicKeyEncoding(
-  enc: EncodingOptions,
-  keyType: string | undefined,
-  objName?: string
-) {
-  return parseKeyEncoding(enc, keyType, keyType ? true : undefined, objName);
-}
-
-// Parses the private key encoding based on an object. keyType must be undefined
-// when this is used to parse an input encoding and must be a valid key type if
-// used to parse an output encoding.
-export function parsePrivateKeyEncoding(
-  enc: EncodingOptions,
-  keyType: string | undefined,
-  objName?: string
-) {
-  return parseKeyEncoding(enc, keyType, false, objName);
-}
-
-// function getKeyObjectHandle(key: any, ctx: KeyInputContext) {
-//   if (ctx === KeyInputContext.kConsumePublic) {
-//     throw new Error(
-//       'Invalid argument type for "key". Need ArrayBuffer, TypeArray, KeyObject, CryptoKey, string'
-//     );
-//   }
-
-//   if (key.type !== 'private') {
-//     if (
-//       ctx === KeyInputContext.kConsumePrivate ||
-//       ctx === KeyInputContext.kCreatePublic
-//     )
-//       throw new Error(`Invalid KeyObject type: ${key.type}, expected 'public'`);
-//     if (key.type !== 'public') {
-//       throw new Error(
-//         `Invalid KeyObject type: ${key.type}, expected 'private' or 'public'`
-//       );
-//     }
-//   }
-
-//   return key.handle;
-// }
-
-function prepareSecretKey(
-  key: BinaryLike,
-  encoding?: string,
-  bufferOnly = false
-): any {
-  try {
-    if (!bufferOnly) {
-      // TODO: maybe use `key.constructor.name === 'KeyObject'` ?
-      if (key instanceof KeyObject) {
-        if (key.type !== 'secret')
-          throw new Error(
-            `invalid KeyObject type: ${key.type}, expected 'secret'`
-          );
-        return key.handle;
-      }
-      // TODO: maybe use `key.constructor.name === 'CryptoKey'` ?
-      else if (key instanceof CryptoKey) {
-        if (key.type !== 'secret')
-          throw new Error(
-            `invalid CryptoKey type: ${key.type}, expected 'secret'`
-          );
-        return key.keyObject.handle;
-      }
-    }
-
-    if (key instanceof ArrayBuffer) {
-      return key;
-    }
-
-    return binaryLikeToArrayBuffer(key, encoding);
-  } catch (error) {
-    throw new Error(
-      'Invalid argument type for "key". Need ArrayBuffer, TypedArray, KeyObject, CryptoKey, string',
-      { cause: error }
-    );
-  }
-}
-
-export function createSecretKey(key: any, encoding?: string) {
-  const k = prepareSecretKey(key, encoding, true);
-  const handle = NativeQuickCrypto.webcrypto.createKeyObjectHandle();
-  handle.init(KeyType.Secret, k);
-  return new SecretKeyObject(handle);
-}
-
-export function createPublicKey(
-  key: BinaryLike | EncodingOptions
-): PublicKeyObject {
-  const { format, type, data, passphrase } = prepareAsymmetricKey(
-    key,
-    KeyInputContext.kCreatePublic
-  );
-  const handle = NativeQuickCrypto.webcrypto.createKeyObjectHandle();
-  if (format === KFormatType.kKeyFormatJWK) {
-    handle.init(KeyType.Public, data);
-  } else {
-    handle.init(KeyType.Public, data, format, type, passphrase);
-  }
-  return new PublicKeyObject(handle);
-}
-
-export const createPrivateKey = (
-  key: BinaryLike | EncodingOptions
-): PrivateKeyObject => {
-  const { format, type, data, passphrase } = prepareAsymmetricKey(
-    key,
-    KeyInputContext.kCreatePrivate
-  );
-  const handle = NativeQuickCrypto.webcrypto.createKeyObjectHandle();
-  if (format === KFormatType.kKeyFormatJWK) {
-    handle.init(KeyType.Private, data);
-  } else {
-    handle.init(KeyType.Private, data, format, type, passphrase);
-  }
-  return new PrivateKeyObject(handle);
-};
-
-// const isKeyObject = (obj: any): obj is KeyObject => {
-//   return obj != null && obj.keyType !== undefined;
-// };
-
-
-
-export class SecretKeyObject extends KeyObject {
-  constructor(handle: KeyObjectHandle) {
-    super('secret', handle);
-  }
-
-  // get symmetricKeySize() {
-  //   return this[kHandle].getSymmetricKeySize();
-  // }
-
-  export(options?: EncodingOptions) {
-    if (options !== undefined) {
-      if (options.format === 'jwk') {
-        throw new Error('SecretKey export for jwk is not implemented');
-        // return this.handle.exportJwk({}, false);
-      }
-    }
-    return this.handle.export();
-  }
-}
-
-// const kAsymmetricKeyType = Symbol('kAsymmetricKeyType');
-// const kAsymmetricKeyDetails = Symbol('kAsymmetricKeyDetails');
-
-// function normalizeKeyDetails(details = {}) {
-//   if (details.publicExponent !== undefined) {
-//     return {
-//       ...details,
-//       publicExponent: bigIntArrayToUnsignedBigInt(
-//         new Uint8Array(details.publicExponent)
-//       ),
-//     };
-//   }
-//   return details;
-// }
-
-class AsymmetricKeyObject extends KeyObject {
-  constructor(type: string, handle: KeyObjectHandle) {
-    super(type, handle);
-  }
-
-  private _asymmetricKeyType?: AsymmetricKeyType;
-
-  get asymmetricKeyType(): AsymmetricKeyType {
-    if (!this._asymmetricKeyType) {
-      this._asymmetricKeyType = this.handle.getAsymmetricKeyType();
-    }
-    return this._asymmetricKeyType;
-  }
-
-  // get asymmetricKeyDetails() {
-  //   switch (this._asymmetricKeyType) {
-  //     case 'rsa':
-  //     case 'rsa-pss':
-  //     case 'dsa':
-  //     case 'ec':
-  //       return (
-  //         this[kAsymmetricKeyDetails] ||
-  //         (this[kAsymmetricKeyDetails] = normalizeKeyDetails(
-  //           this[kHandle].keyDetail({})
-  //         ))
-  //       );
-  //     default:
-  //       return {};
-  //   }
-  // }
-}
-
-export class PublicKeyObject extends AsymmetricKeyObject {
-  constructor(handle: KeyObjectHandle) {
-    super('public', handle);
-  }
-
-  export(options: EncodingOptions) {
-    if (options?.format === 'jwk') {
-      throw new Error('PublicKey export for jwk is not implemented');
-      // return this.handle.exportJwk({}, false);
-    }
-    const { format, type } = parsePublicKeyEncoding(
-      options,
-      this.asymmetricKeyType
-    );
-    return this.handle.export(format, type);
-  }
-}
-
-export class PrivateKeyObject extends AsymmetricKeyObject {
-  constructor(handle: KeyObjectHandle) {
-    super('private', handle);
-  }
-
-  export(options: EncodingOptions) {
-    if (options?.format === 'jwk') {
-      if (options.passphrase !== undefined) {
-        throw new Error('jwk does not support encryption');
-      }
-      throw new Error('PrivateKey export for jwk is not implemented');
-      // return this.handle.exportJwk({}, false);
-    }
-    const { format, type, cipher, passphrase } = parsePrivateKeyEncoding(
-      options,
-      this.asymmetricKeyType
-    );
-    return this.handle.export(format, type, cipher, passphrase);
-  }
-}
-
-export const isCryptoKey = (obj: any): boolean => {
-  return obj !== null && obj?.keyObject !== undefined;
-};