@symbiote-native/crypto 0.0.1

package/build-ngc/core/crypto.js

@@ -0,0 +1,133 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCrypto } from './native-module';
+import { CryptoDigestAlgorithm, CryptoEncoding } from './types';
+const NATIVE_MODULE_NAME = 'expo-crypto';
+const MIN_BYTE_COUNT = 0;
+const MAX_BYTE_COUNT = 1024;
+export class CryptoError extends TypeError {
+    code = 'ERR_CRYPTO';
+    constructor(message) {
+        super(`expo-crypto: ${message}`);
+    }
+}
+function assertByteCount(value, methodName) {
+    if (typeof value !== 'number' ||
+        Number.isNaN(value) ||
+        Math.floor(value) < MIN_BYTE_COUNT ||
+        Math.floor(value) > MAX_BYTE_COUNT) {
+        throw new TypeError(`expo-crypto: ${methodName}(${value}) expected a valid number from range ${MIN_BYTE_COUNT}...${MAX_BYTE_COUNT}`);
+    }
+}
+function assertAlgorithm(algorithm) {
+    if (!Object.values(CryptoDigestAlgorithm).includes(algorithm)) {
+        throw new CryptoError(`Invalid algorithm provided. Expected one of: CryptoDigestAlgorithm.${Object.keys(CryptoDigestAlgorithm).join(', CryptoDigestAlgorithm.')}`);
+    }
+}
+function assertData(data) {
+    if (typeof data !== 'string') {
+        throw new CryptoError('Invalid data provided. Expected a string.');
+    }
+}
+function assertEncoding(encoding) {
+    if (!Object.values(CryptoEncoding).includes(encoding)) {
+        throw new CryptoError(`Invalid encoding provided. Expected one of: CryptoEncoding.${Object.keys(CryptoEncoding).join(', CryptoEncoding.')}`);
+    }
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export function getRandomBytes(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytes');
+    const validByteCount = Math.floor(byteCount);
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomBytes');
+    }
+    const byteArray = new Uint8Array(validByteCount);
+    expoCrypto.getRandomValues(byteArray);
+    return byteArray;
+}
+/**
+ * Generates completely random bytes using native implementations. `byteCount` must be within
+ * `0`-`1024` (inclusive), anything else throws a `TypeError`.
+ */
+export async function getRandomBytesAsync(byteCount) {
+    assertByteCount(byteCount, 'getRandomBytesAsync');
+    const validByteCount = Math.floor(byteCount);
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomBytesAsync');
+    }
+    const byteArray = new Uint8Array(validByteCount);
+    expoCrypto.getRandomValues(byteArray);
+    return byteArray;
+}
+/**
+ * Fills the provided `TypedArray` with cryptographically secure random values in place, and
+ * returns it.
+ */
+export function getRandomValues(typedArray) {
+    if (!expoCrypto.getRandomValues) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getRandomValues');
+    }
+    expoCrypto.getRandomValues(typedArray);
+    return typedArray;
+}
+/**
+ * Returns a unique identifier based on the V4 UUID spec (RFC4122), using cryptographically
+ * secure random values.
+ */
+export function randomUUID() {
+    if (!expoCrypto.randomUUID) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'randomUUID');
+    }
+    return expoCrypto.randomUUID();
+}
+/**
+ * Generates a digest of the supplied `data` string with the provided digest `algorithm`,
+ * formatted as one of `CryptoEncoding` (defaults to `HEX`).
+ */
+export async function digestStringAsync(algorithm, data, options = { encoding: CryptoEncoding.HEX }) {
+    if (!expoCrypto.digestStringAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'digestStringAsync');
+    }
+    assertAlgorithm(algorithm);
+    assertData(data);
+    assertEncoding(options.encoding);
+    return expoCrypto.digestStringAsync(algorithm, data, options);
+}
+// Fixed output length (in bytes) per digest algorithm — used only as the sync fallback's
+// preallocated output buffer size when the native module has no digestAsync.
+const digestLengths = {
+    [CryptoDigestAlgorithm.SHA1]: 20,
+    [CryptoDigestAlgorithm.SHA256]: 32,
+    [CryptoDigestAlgorithm.SHA384]: 48,
+    [CryptoDigestAlgorithm.SHA512]: 64,
+    [CryptoDigestAlgorithm.MD2]: 16,
+    [CryptoDigestAlgorithm.MD4]: 16,
+    [CryptoDigestAlgorithm.MD5]: 16,
+};
+/**
+ * Generates a digest of the supplied `TypedArray`/`ArrayBuffer` of bytes with the provided digest
+ * `algorithm`. Prefers the native async `digestAsync` when present; otherwise falls back to
+ * allocating a fixed-size output buffer (sized via `digestLengths`) and the sync `digest`.
+ */
+export function digest(algorithm, data) {
+    return new Promise((resolve, reject) => {
+        try {
+            if (typeof expoCrypto.digestAsync === 'function') {
+                resolve(expoCrypto.digestAsync(algorithm, data));
+                return;
+            }
+            if (!expoCrypto.digest) {
+                throw new UnavailabilityError(NATIVE_MODULE_NAME, 'digest');
+            }
+            const output = new Uint8Array(digestLengths[algorithm]);
+            expoCrypto.digest(algorithm, output, data);
+            resolve(output.buffer);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+}
+//# sourceMappingURL=crypto.js.map

package/build-ngc/core/crypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/core/crypto.ts"],"names":[],"mappings":"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"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,2 @@
+export { CryptoError, getRandomBytes, getRandomBytesAsync, getRandomValues, randomUUID, digestStringAsync, digest, } from './crypto';
+export { CryptoDigestAlgorithm, CryptoEncoding, type ICryptoDigestOptions, type IDigest, type IUintBasedTypedArray, type IIntBasedTypedArray, type ITypedArray, } from './types';

package/build-ngc/core/index.js

@@ -0,0 +1,3 @@
+export { CryptoError, getRandomBytes, getRandomBytesAsync, getRandomValues, randomUUID, digestStringAsync, digest, } from './crypto';
+export { CryptoDigestAlgorithm, CryptoEncoding, } from './types';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,cAAc,EACd,mBAAmB,EACnB,eAAe,EACf,UAAU,EACV,iBAAiB,EACjB,MAAM,GACP,MAAM,UAAU,CAAC;AAClB,OAAO,EACL,qBAAqB,EACrB,cAAc,GAMf,MAAM,SAAS,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,9 @@
+import type { CryptoDigestAlgorithm, ICryptoDigestOptions, IDigest, ITypedArray } from './types';
+export type INativeCryptoModule = {
+    getRandomValues(typedArray: ITypedArray): void;
+    randomUUID(): string;
+    digest(algorithm: CryptoDigestAlgorithm, output: Uint8Array, data: BufferSource): void;
+    digestStringAsync?(algorithm: CryptoDigestAlgorithm, data: string, options: ICryptoDigestOptions): Promise<IDigest>;
+    digestAsync?(algorithm: CryptoDigestAlgorithm, data: BufferSource): Promise<ArrayBuffer>;
+};
+export declare const expoCrypto: INativeCryptoModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_CRYPTO_MODULE_NAME = 'ExpoCrypto';
+export const expoCrypto = requireNativeModule(EXPO_CRYPTO_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAIxD,MAAM,uBAAuB,GAAG,YAAY,CAAC;AAqB7C,MAAM,CAAC,MAAM,UAAU,GAAG,mBAAmB,CAAsB,uBAAuB,CAAC,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,24 @@
+export declare enum CryptoDigestAlgorithm {
+    SHA1 = "SHA-1",
+    SHA256 = "SHA-256",
+    SHA384 = "SHA-384",
+    SHA512 = "SHA-512",
+    /** @platform ios */
+    MD2 = "MD2",
+    /** @platform ios */
+    MD4 = "MD4",
+    MD5 = "MD5"
+}
+export declare enum CryptoEncoding {
+    HEX = "hex",
+    /** Has trailing padding. Does not wrap lines. Does not have a trailing newline. */
+    BASE64 = "base64"
+}
+export type ICryptoDigestOptions = {
+    /** Format the digest is returned in. */
+    encoding: CryptoEncoding;
+};
+export type IDigest = string;
+export type IUintBasedTypedArray = Uint8Array | Uint16Array | Uint32Array;
+export type IIntBasedTypedArray = Int8Array | Int16Array | Int32Array;
+export type ITypedArray = IUintBasedTypedArray | IIntBasedTypedArray;

package/build-ngc/core/types.js

@@ -0,0 +1,19 @@
+export var CryptoDigestAlgorithm;
+(function (CryptoDigestAlgorithm) {
+    CryptoDigestAlgorithm["SHA1"] = "SHA-1";
+    CryptoDigestAlgorithm["SHA256"] = "SHA-256";
+    CryptoDigestAlgorithm["SHA384"] = "SHA-384";
+    CryptoDigestAlgorithm["SHA512"] = "SHA-512";
+    /** @platform ios */
+    CryptoDigestAlgorithm["MD2"] = "MD2";
+    /** @platform ios */
+    CryptoDigestAlgorithm["MD4"] = "MD4";
+    CryptoDigestAlgorithm["MD5"] = "MD5";
+})(CryptoDigestAlgorithm || (CryptoDigestAlgorithm = {}));
+export var CryptoEncoding;
+(function (CryptoEncoding) {
+    CryptoEncoding["HEX"] = "hex";
+    /** Has trailing padding. Does not wrap lines. Does not have a trailing newline. */
+    CryptoEncoding["BASE64"] = "base64";
+})(CryptoEncoding || (CryptoEncoding = {}));
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,qBAUX;AAVD,WAAY,qBAAqB;IAC/B,uCAAc,CAAA;IACd,2CAAkB,CAAA;IAClB,2CAAkB,CAAA;IAClB,2CAAkB,CAAA;IAClB,oBAAoB;IACpB,oCAAW,CAAA;IACX,oBAAoB;IACpB,oCAAW,CAAA;IACX,oCAAW,CAAA;AACb,CAAC,EAVW,qBAAqB,KAArB,qBAAqB,QAUhC;AAED,MAAM,CAAN,IAAY,cAIX;AAJD,WAAY,cAAc;IACxB,6BAAW,CAAA;IACX,mFAAmF;IACnF,mCAAiB,CAAA;AACnB,CAAC,EAJW,cAAc,KAAd,cAAc,QAIzB"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-crypto",
+    "modules": [
+      {
+        "importPath": "expo.modules.crypto.CryptoModule",
+        "className": "CryptoModule",
+        "nativeName": "ExpoCrypto"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/crypto",
+  "version": "0.0.1",
+  "description": "expo-crypto wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Cryptographically secure random bytes, randomUUID, and string/buffer digest hashing (SHA-1/256/384/512, MD2/MD4/MD5).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/crypto"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/crypto#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-crypto": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/engine": "0.1.7"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/crypto/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/src/core/crypto.test.ts

@@ -0,0 +1,245 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_CRYPTO = {
+  getRandomValues: vi.fn((typedArray: Uint8Array) => {
+    typedArray.fill(7);
+  }),
+  randomUUID: vi.fn(() => '00000000-0000-4000-8000-000000000000'),
+  digestStringAsync: vi.fn(async () => 'fake-digest-hex'),
+  digestAsync: vi.fn(async () => new ArrayBuffer(32)),
+  digest: vi.fn((_algorithm: string, output: Uint8Array) => {
+    output.fill(9);
+  }),
+};
+
+// The real ExpoCrypto native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, the same
+// pattern packages/local-auth/src/core/local-authentication.test.ts uses.
+vi.mock('./native-module', () => ({
+  expoCrypto: FAKE_NATIVE_CRYPTO,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native' for Platform/
+// TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform can't parse — same fake
+// packages/local-auth/src/core/local-authentication.test.ts uses.
+vi.mock('expo-modules-core', () => ({
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const {
+  getRandomBytes,
+  getRandomBytesAsync,
+  getRandomValues,
+  randomUUID,
+  digestStringAsync,
+  digest,
+} = await import('./crypto');
+const { CryptoDigestAlgorithm, CryptoEncoding } = await import('./types');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('getRandomBytes', () => {
+  it('accepts the lower bound (0)', () => {
+    const result = getRandomBytes(0);
+    expect(result).toHaveLength(0);
+  });
+
+  it('accepts the upper bound (1024)', () => {
+    const result = getRandomBytes(1024);
+    expect(result).toHaveLength(1024);
+    expect(FAKE_NATIVE_CRYPTO.getRandomValues).toHaveBeenCalledTimes(1);
+  });
+
+  it('floors a fractional byteCount', () => {
+    const result = getRandomBytes(4.9);
+    expect(result).toHaveLength(4);
+  });
+
+  it('rejects a negative byteCount', () => {
+    expect(() => getRandomBytes(-1)).toThrow(TypeError);
+  });
+
+  it('rejects a byteCount above 1024', () => {
+    expect(() => getRandomBytes(1025)).toThrow(TypeError);
+  });
+
+  it('rejects a non-number byteCount', () => {
+    // @ts-expect-error -- exercising the runtime guard against a caller ignoring the types
+    expect(() => getRandomBytes('16')).toThrow(TypeError);
+  });
+
+  it('rejects NaN', () => {
+    expect(() => getRandomBytes(NaN)).toThrow(TypeError);
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', () => {
+    const { getRandomValues: native } = FAKE_NATIVE_CRYPTO;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_CRYPTO.getRandomValues = undefined;
+
+    expect(() => getRandomBytes(4)).toThrow('getRandomBytes is not available on expo-crypto');
+
+    FAKE_NATIVE_CRYPTO.getRandomValues = native;
+  });
+});
+
+describe('getRandomBytesAsync', () => {
+  it('accepts the lower and upper bound', async () => {
+    await expect(getRandomBytesAsync(0)).resolves.toHaveLength(0);
+    await expect(getRandomBytesAsync(1024)).resolves.toHaveLength(1024);
+  });
+
+  it('rejects a negative byteCount', async () => {
+    await expect(getRandomBytesAsync(-1)).rejects.toThrow(TypeError);
+  });
+
+  it('rejects a byteCount above 1024', async () => {
+    await expect(getRandomBytesAsync(1025)).rejects.toThrow(TypeError);
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', async () => {
+    const { getRandomValues: native } = FAKE_NATIVE_CRYPTO;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_CRYPTO.getRandomValues = undefined;
+
+    await expect(getRandomBytesAsync(4)).rejects.toThrow(
+      'getRandomBytesAsync is not available on expo-crypto',
+    );
+
+    FAKE_NATIVE_CRYPTO.getRandomValues = native;
+  });
+});
+
+describe('getRandomValues', () => {
+  it('fills the provided typed array in place and returns it', () => {
+    const typedArray = new Uint8Array(4);
+    const result = getRandomValues(typedArray);
+
+    expect(result).toBe(typedArray);
+    expect(FAKE_NATIVE_CRYPTO.getRandomValues).toHaveBeenCalledWith(typedArray);
+    expect(Array.from(typedArray)).toEqual([7, 7, 7, 7]);
+  });
+});
+
+describe('randomUUID', () => {
+  it('returns the native UUID directly', () => {
+    expect(randomUUID()).toBe('00000000-0000-4000-8000-000000000000');
+  });
+});
+
+describe('digestStringAsync', () => {
+  it('defaults to HEX encoding when options are omitted', async () => {
+    await digestStringAsync(CryptoDigestAlgorithm.SHA256, 'hello');
+
+    expect(FAKE_NATIVE_CRYPTO.digestStringAsync).toHaveBeenCalledWith(
+      CryptoDigestAlgorithm.SHA256,
+      'hello',
+      { encoding: CryptoEncoding.HEX },
+    );
+  });
+
+  it('passes through a custom encoding', async () => {
+    await digestStringAsync(CryptoDigestAlgorithm.SHA1, 'hello', {
+      encoding: CryptoEncoding.BASE64,
+    });
+
+    expect(FAKE_NATIVE_CRYPTO.digestStringAsync).toHaveBeenCalledWith(
+      CryptoDigestAlgorithm.SHA1,
+      'hello',
+      { encoding: CryptoEncoding.BASE64 },
+    );
+  });
+
+  it('resolves with the native digest', async () => {
+    await expect(digestStringAsync(CryptoDigestAlgorithm.MD5, 'hello')).resolves.toBe(
+      'fake-digest-hex',
+    );
+  });
+
+  it('rejects an invalid algorithm', async () => {
+    // @ts-expect-error -- exercising the runtime guard against an invalid algorithm value
+    await expect(digestStringAsync('NOT-A-REAL-ALGORITHM', 'hello')).rejects.toThrow(
+      'Invalid algorithm provided',
+    );
+    expect(FAKE_NATIVE_CRYPTO.digestStringAsync).not.toHaveBeenCalled();
+  });
+
+  it('rejects non-string data', async () => {
+    // @ts-expect-error -- exercising the runtime guard against non-string data
+    await expect(digestStringAsync(CryptoDigestAlgorithm.SHA256, 12345)).rejects.toThrow(
+      'Invalid data provided',
+    );
+  });
+
+  it('rejects an invalid encoding', async () => {
+    await expect(
+      // @ts-expect-error -- exercising the runtime guard against an invalid encoding value
+      digestStringAsync(CryptoDigestAlgorithm.SHA256, 'hello', { encoding: 'not-an-encoding' }),
+    ).rejects.toThrow('Invalid encoding provided');
+  });
+
+  it('throws an UnavailabilityError-shaped error when the native method is absent', async () => {
+    const { digestStringAsync: native } = FAKE_NATIVE_CRYPTO;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_CRYPTO.digestStringAsync = undefined;
+
+    await expect(digestStringAsync(CryptoDigestAlgorithm.SHA256, 'hello')).rejects.toThrow(
+      'digestStringAsync is not available on expo-crypto',
+    );
+
+    FAKE_NATIVE_CRYPTO.digestStringAsync = native;
+  });
+});
+
+describe('digest', () => {
+  it('prefers digestAsync when the native module implements it', async () => {
+    const data = new Uint8Array([1, 2, 3]);
+    const result = await digest(CryptoDigestAlgorithm.SHA256, data);
+
+    expect(FAKE_NATIVE_CRYPTO.digestAsync).toHaveBeenCalledWith(CryptoDigestAlgorithm.SHA256, data);
+    expect(FAKE_NATIVE_CRYPTO.digest).not.toHaveBeenCalled();
+    expect(result).toBeInstanceOf(ArrayBuffer);
+    expect(result.byteLength).toBe(32);
+  });
+
+  it('falls back to the sync digest + digestLengths lookup table when digestAsync is absent', async () => {
+    const { digestAsync: native } = FAKE_NATIVE_CRYPTO;
+    // @ts-expect-error -- simulating a platform where the native module has no digestAsync
+    FAKE_NATIVE_CRYPTO.digestAsync = undefined;
+
+    const data = new Uint8Array([1, 2, 3]);
+    const result = await digest(CryptoDigestAlgorithm.SHA1, data);
+
+    expect(FAKE_NATIVE_CRYPTO.digest).toHaveBeenCalledTimes(1);
+    const [algorithm, output, passedData] = FAKE_NATIVE_CRYPTO.digest.mock.calls[0];
+    expect(algorithm).toBe(CryptoDigestAlgorithm.SHA1);
+    expect(output).toHaveLength(20); // SHA1's entry in digestLengths
+    expect(passedData).toBe(data);
+    expect(result.byteLength).toBe(20);
+    expect(Array.from(new Uint8Array(result))).toEqual(new Array(20).fill(9));
+
+    FAKE_NATIVE_CRYPTO.digestAsync = native;
+  });
+
+  it('rejects when neither digestAsync nor digest is available', async () => {
+    const { digestAsync: nativeAsync, digest: nativeSync } = FAKE_NATIVE_CRYPTO;
+    // @ts-expect-error -- simulating a platform where the native module has neither method
+    FAKE_NATIVE_CRYPTO.digestAsync = undefined;
+    // @ts-expect-error -- simulating a platform where the native module has neither method
+    FAKE_NATIVE_CRYPTO.digest = undefined;
+
+    await expect(digest(CryptoDigestAlgorithm.SHA256, new Uint8Array([1]))).rejects.toThrow(
+      'digest is not available on expo-crypto',
+    );
+
+    FAKE_NATIVE_CRYPTO.digestAsync = nativeAsync;
+    FAKE_NATIVE_CRYPTO.digest = nativeSync;
+  });
+});