@smileid/usesmileid 12.0.2 → 12.1.1

package/src/data/repository/use_smile_id_repository.ts

@@ -1,19 +0,0 @@
-import type { JobRequest } from "../model/job_request";
-import type { JobSubmissionResponse } from "../model/job_submission_response";
-import type { UseSmileIDResult } from "../../core/models/result";
-
-/**
- * Repository abstraction over `SmileIDAPI` + retry policy.
- *
- * The orchestrator depends on this interface, not the concrete
- * `UseSmileIDRepositoryImpl`, so tests can substitute an in-memory
- * repository without spinning up a real axios chain.
- */
-export interface UseSmileIDRepository {
-  /**
-   * Submit a `JobRequest`, transparently retrying network-class
-   * failures per the configured retry policy. The `request.jobType`
-   * discriminator drives dispatch to the matching API method.
-   */
-  submit(request: JobRequest): Promise<UseSmileIDResult<JobSubmissionResponse>>;
-}

package/src/data/repository/use_smile_id_repository_impl.ts

@@ -1,181 +0,0 @@
-import type { JobRequest } from "../model/job_request";
-import type { JobSubmissionResponse } from "../model/job_submission_response";
-import type { SmileIDAPI } from "../api/smile_id_api";
-import type { RetryConfig } from "../../core/models/network_config";
-import type { UseSmileIDResult } from "../../core/models/result";
-import { failure, success } from "../../core/models/result";
-import { JobType } from "../../core/models/job_type";
-import { withRetry } from "../util/retry_util";
-import { InvalidFieldValueException } from "../../core/exception/job_validation_exceptions";
-import { UseSmileIDValidationException } from "../../core/exception/use_smile_id_validation_exception";
-import {
-  mapAxiosError,
-  type UseSmileIDNetworkException,
-} from "../../core/exception/use_smile_id_network_exception";
-import {
-  PayloadCompressionRunner,
-  type PayloadCompressionSizes,
-} from "../compression/payload_compression_runner";
-import type { MetadataEntry } from "../../metadata/use_smile_id_metadata";
-
-/** Builds the per-image original/final compressed size wire entries, omitting absent/zero sizes. */
-function compressionSizeEntries(
-  sizes: PayloadCompressionSizes,
-): MetadataEntry[] {
-  const entries: MetadataEntry[] = [];
-  const push = (name: string, value: number | undefined) => {
-    if (value !== undefined && value > 0)
-      entries.push({ name, value: String(value) });
-  };
-  push("selfie_original_size", sizes.selfieOriginalMb);
-  push("selfie_final_compressed_size", sizes.selfieFinalMb);
-  push("document_front_original_size", sizes.frontOriginalMb);
-  push("document_front_final_compressed_size", sizes.frontFinalMb);
-  push("document_back_original_size", sizes.backOriginalMb);
-  push("document_back_final_compressed_size", sizes.backFinalMb);
-  return entries;
-}
-
-/**
- * Concrete repository.
- *
- * Exhaustive-switch dispatch over the `JobRequest` discriminated
- * union — adding a new variant fails to compile here until the new
- * dispatch case lands, so partner orchestrator code never silently
- * skips a request type.
- */
-export class UseSmileIDRepositoryImpl {
-  private readonly _api: SmileIDAPI;
-  private readonly _retry: RetryConfig;
-
-  constructor(api: SmileIDAPI, retry: RetryConfig) {
-    this._api = api;
-    this._retry = retry;
-  }
-
-  async submit(
-    request: JobRequest,
-  ): Promise<UseSmileIDResult<JobSubmissionResponse>> {
-    // BVN is not yet supported. Fail fast at the repository boundary
-    // with the canonical typed exception so partner `onResult` sees a
-    // structured error rather than a wire-level failure from the
-    // server.
-    if (request.jobType === JobType.bvn) {
-      return failure(
-        new InvalidFieldValueException({
-          fieldName: "jobType",
-          reason: "BVN submission is not yet supported",
-        }),
-      );
-    }
-
-    // Pre-flight payload compression — best effort: shrink the captured JPEGs under the Lambda
-    // cap before transmission (runs once, outside the retry loop), but never block submission, so
-    // any compression failure ships the captured images as-is and lets the server validate. The
-    // per-image original + final compressed sizes are stamped onto the metadata for telemetry.
-    let submitted = request;
-    try {
-      const sizes = await this._compressPayload(request);
-      const sizeEntries = sizes ? compressionSizeEntries(sizes) : [];
-      if (sizeEntries.length > 0) {
-        submitted = {
-          ...request,
-          metadata: request.metadata.withAdditionalEntries(sizeEntries),
-        };
-      }
-    } catch {
-      // Best-effort: compression is an optimization; submit the captured images as-is on failure.
-    }
-
-    try {
-      const response = await withRetry(this._retry, (attempt) =>
-        this._dispatch(submitted, attempt),
-      );
-      return success(response);
-    } catch (error) {
-      // A validation failure (e.g. a liveness-count mismatch) is a
-      // pre-network constraint violation — surface the typed exception
-      // directly rather than collapsing it into the network hierarchy, so
-      // partners can catch it as the validation error it is.
-      if (error instanceof UseSmileIDValidationException) {
-        return failure(error);
-      }
-      return failure(this._mapError(error));
-    }
-  }
-
-  /**
-   * Pre-flight payload compression entry — extracts the captured image URIs for the job type and
-   * compresses the bundle under the transmission cap (metadata is measured, never modified).
-   * No-op for job types that carry no captured images (Enhanced KYC / BVN).
-   */
-  private async _compressPayload(
-    request: JobRequest,
-  ): Promise<PayloadCompressionSizes | undefined> {
-    const metadataBytes = JSON.stringify(request.metadata.toEntries()).length;
-    switch (request.jobType) {
-      case JobType.smartSelfieEnrollment:
-      case JobType.smartSelfieAuthentication:
-      case JobType.biometricKyc:
-        return PayloadCompressionRunner.compress({
-          selfieImage: request.selfieImage,
-          livenessImages: request.livenessImages,
-          metadataBytes,
-        });
-      case JobType.documentVerification:
-      case JobType.enhancedDocumentVerification:
-        return PayloadCompressionRunner.compress({
-          selfieImage: request.selfieImage,
-          livenessImages: request.livenessImages,
-          frontDocument: request.frontDocument,
-          backDocument: request.backDocument,
-          metadataBytes,
-        });
-      default:
-        return undefined;
-    }
-  }
-
-  private _dispatch(
-    request: Exclude<JobRequest, { jobType: typeof JobType.bvn }>,
-    attempt: number,
-  ): Promise<JobSubmissionResponse> {
-    // Stamp how many network retries preceded this attempt onto the metadata
-    // (re-evaluated per attempt inside the retry loop). Appended as a flow-state
-    // entry so the already-appended document / config entries are preserved.
-    const stamped: typeof request =
-      attempt > 0
-        ? {
-            ...request,
-            metadata: request.metadata.withAdditionalEntries([
-              { name: "network_retries", value: String(attempt) },
-            ]),
-          }
-        : request;
-    switch (stamped.jobType) {
-      case JobType.smartSelfieEnrollment:
-        return this._api.smartSelfieEnrollment(stamped);
-      case JobType.smartSelfieAuthentication:
-        return this._api.smartSelfieAuthentication(stamped);
-      case JobType.enhancedKyc:
-        return this._api.enhancedKyc(stamped);
-      case JobType.biometricKyc:
-        return this._api.biometricKyc(stamped);
-      case JobType.documentVerification:
-        return this._api.documentVerification(stamped);
-      case JobType.enhancedDocumentVerification:
-        return this._api.enhancedDocumentVerification(stamped);
-    }
-  }
-
-  /**
-   * Translate any caught error into the typed
-   * [UseSmileIDNetworkException] hierarchy. Delegates to the canonical
-   * [mapAxiosError] so a single mapper implementation covers both the
-   * repository layer and any future call sites (interceptors,
-   * partner-supplied error wrappers).
-   */
-  private _mapError(error: unknown): UseSmileIDNetworkException {
-    return mapAxiosError(error);
-  }
-}

package/src/data/security/__tests__/request_canonicalizer.test.ts

@@ -1,132 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { RequestCanonicalizer } from "../request_canonicalizer";
-import { SmileIDCryptoManager } from "../smile_id_crypto_manager";
-
-/**
- * Golden-vector suite for `RequestCanonicalizer`: pins the exact canonical bytes and the resulting
- * `smileid-request-mac` for a fixed key across the shapes `canonicalize()` distinguishes. This
- * SDK's own contract with the server, not a cross-SDK guarantee.
- */
-const TIMESTAMP = "1700000000000";
-const SIGNING_SECRET = "golden-vector-secret";
-const cryptoManager = new SmileIDCryptoManager(SIGNING_SECRET);
-
-const BASE_HEADERS = {
-  "smileid-token": "golden-token",
-  "smileid-request-timestamp": TIMESTAMP,
-};
-
-type FormDataPart = { fieldName: string; string?: string; uri?: string };
-
-/** Minimal stand-in for React Native's `FormData` (only `getParts` is read). */
-function formData(parts: readonly FormDataPart[]) {
-  return { getParts: () => parts };
-}
-
-function decode(bytes: Uint8Array): string {
-  return Buffer.from(bytes).toString("utf-8");
-}
-
-const MULTIPART_BODY = formData([
-  { fieldName: "country", string: "NG" },
-  { fieldName: "allow_new_enroll", string: "true" },
-  { fieldName: "partner_params", string: '{"job_id":"j1"}' },
-  {
-    fieldName: "selfie_image",
-    uri: "data:application/octet-stream;base64,c2VsZmll",
-  },
-]);
-
-// Same logical fields as MULTIPART_BODY, in reverse part order.
-const MULTIPART_BODY_REORDERED = formData([
-  {
-    fieldName: "selfie_image",
-    uri: "data:application/octet-stream;base64,c2VsZmll",
-  },
-  { fieldName: "partner_params", string: '{"job_id":"j1"}' },
-  { fieldName: "allow_new_enroll", string: "true" },
-  { fieldName: "country", string: "NG" },
-]);
-
-const MIXED_CASE_HEADERS = {
-  "Smileid-Token": "golden-token",
-  "SMILEID-REQUEST-TIMESTAMP": TIMESTAMP,
-};
-
-describe("RequestCanonicalizer golden vectors", () => {
-  it("(a) canonicalizes a bodyless request to the signed headers + `{}`", async () => {
-    const bytes = await RequestCanonicalizer.canonicalize(
-      BASE_HEADERS,
-      undefined,
-    );
-    expect(decode(bytes)).toBe(
-      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
-    );
-    expect(await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, undefined)).toBe(
-      "qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=",
-    );
-  });
-
-  it("(b) canonicalizes a raw JSON-string body the same as a bodyless request — only FormData-shaped bodies are reconstructed", async () => {
-    const bytes = await RequestCanonicalizer.canonicalize(
-      BASE_HEADERS,
-      '{"hello":"world"}',
-    );
-    // Same canonical bytes as case (a): a JSON string isn't FormData-like,
-    // so canonicalBody() falls through to the same `{}` as no body at all.
-    expect(decode(bytes)).toBe(
-      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
-    );
-    expect(
-      await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, '{"hello":"world"}'),
-    ).toBe("qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=");
-  });
-
-  it("(c) canonicalizes a multipart FormData body: scalar, boolean-coerced, JSON, and file parts", async () => {
-    const bytes = await RequestCanonicalizer.canonicalize(
-      BASE_HEADERS,
-      MULTIPART_BODY,
-    );
-    expect(decode(bytes)).toBe(
-      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}' +
-        '{"allow_new_enroll":true,"country":"NG","partner_params":{"job_id":"j1"},"selfie_image":"c2VsZmll"}',
-    );
-    expect(
-      await cryptoManager.sign(TIMESTAMP, BASE_HEADERS, MULTIPART_BODY),
-    ).toBe("eNJqKR45aNiou4JM0yVRNYrTdhfg1VblWvsbrRndoLQ=");
-  });
-
-  it("(d) part ordering does not change the canonical bytes or the MAC", async () => {
-    const bytes = await RequestCanonicalizer.canonicalize(
-      BASE_HEADERS,
-      MULTIPART_BODY_REORDERED,
-    );
-    expect(decode(bytes)).toBe(
-      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}' +
-        '{"allow_new_enroll":true,"country":"NG","partner_params":{"job_id":"j1"},"selfie_image":"c2VsZmll"}',
-    );
-    expect(
-      await cryptoManager.sign(
-        TIMESTAMP,
-        BASE_HEADERS,
-        MULTIPART_BODY_REORDERED,
-      ),
-    ).toBe("eNJqKR45aNiou4JM0yVRNYrTdhfg1VblWvsbrRndoLQ=");
-  });
-
-  it("(e) header key casing does not change the canonical bytes or the MAC", async () => {
-    const bytes = await RequestCanonicalizer.canonicalize(
-      MIXED_CASE_HEADERS,
-      undefined,
-    );
-    // Identical to case (a): canonicalHeaders() lower-cases every header
-    // name before signing, so casing at the call site is not observable.
-    expect(decode(bytes)).toBe(
-      '{"smileid-request-timestamp":"1700000000000","smileid-token":"golden-token"}{}',
-    );
-    expect(
-      await cryptoManager.sign(TIMESTAMP, MIXED_CASE_HEADERS, undefined),
-    ).toBe("qikeRL0jNa7bZKUZdoN7tY30VvVy4ol/hcMdyg4PU4w=");
-  });
-});

package/src/data/security/__tests__/security_policy.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { SecurityPolicy } from "../security_policy";
-
-/**
- * Pins down the server-driven security policy bit-code mapping (the contract lives in
- * `docs/Policy.md`):
- *   - `undefined` is fail-secure (every behaviour active).
- *   - bit 0 -> payload signing, bit 1 -> payload encryption, bit 2 -> rooted-device check,
- *     bit 3 -> device attestation (least-significant bit first).
- *   - Unrelated bits never cross-activate a behaviour.
- */
-describe("SecurityPolicy", () => {
-  it("undefined bit-code is fail-secure and enables every behaviour", () => {
-    const policy = SecurityPolicy.fromBitCode(undefined);
-
-    expect(policy.isPayloadSigningActive()).toBe(true);
-    expect(policy.isPayloadEncryptionActive()).toBe(true);
-    expect(policy.isRootedDeviceCheckActive()).toBe(true);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(true);
-  });
-
-  it("zero bit-code disables every behaviour", () => {
-    const policy = SecurityPolicy.fromBitCode(0);
-
-    expect(policy.isPayloadSigningActive()).toBe(false);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(false);
-  });
-
-  it("bit 0 maps to payload signing only", () => {
-    const policy = SecurityPolicy.fromBitCode(0b0001);
-
-    expect(policy.isPayloadSigningActive()).toBe(true);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(false);
-  });
-
-  it("bit 1 maps to payload encryption only", () => {
-    const policy = SecurityPolicy.fromBitCode(0b0010);
-
-    expect(policy.isPayloadSigningActive()).toBe(false);
-    expect(policy.isPayloadEncryptionActive()).toBe(true);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(false);
-  });
-
-  it("bit 2 maps to rooted-device check only", () => {
-    const policy = SecurityPolicy.fromBitCode(0b0100);
-
-    expect(policy.isPayloadSigningActive()).toBe(false);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(true);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(false);
-  });
-
-  it("bit 3 maps to play integrity check only", () => {
-    const policy = SecurityPolicy.fromBitCode(0b1000);
-
-    expect(policy.isPayloadSigningActive()).toBe(false);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(true);
-  });
-
-  it("combined bit-code activates exactly the set behaviours", () => {
-    // 0b1001 = payload signing (bit 0) + device attestation (bit 3).
-    const policy = SecurityPolicy.fromBitCode(0b1001);
-
-    expect(policy.isPayloadSigningActive()).toBe(true);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(true);
-  });
-
-  it("all four bits set activates every behaviour", () => {
-    const policy = SecurityPolicy.fromBitCode(0b1111);
-
-    expect(policy.isPayloadSigningActive()).toBe(true);
-    expect(policy.isPayloadEncryptionActive()).toBe(true);
-    expect(policy.isRootedDeviceCheckActive()).toBe(true);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(true);
-  });
-
-  it("higher unmapped bits do not affect the known behaviours", () => {
-    // bit 4 (0b10000) is beyond the defined mapping; the four known behaviours stay off.
-    const policy = SecurityPolicy.fromBitCode(0b10000);
-
-    expect(policy.isPayloadSigningActive()).toBe(false);
-    expect(policy.isPayloadEncryptionActive()).toBe(false);
-    expect(policy.isRootedDeviceCheckActive()).toBe(false);
-    expect(policy.isPlayIntegrityCheckActive()).toBe(false);
-  });
-});

package/src/data/security/__tests__/signing_crypto.test.ts

@@ -1,203 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
-import Module from "node:module";
-
-import { SigningCrypto, base64Encode, utf8Bytes } from "../signing_crypto";
-import { SmileIDCryptoError } from "../smile_id_crypto_error";
-
-/**
- * Provider resolution for request signing. Node supplies a global
- * `crypto.subtle`, so the on-device path — the lazy
- * `require("react-native-quick-crypto")` — is only reachable with the
- * global removed and the CommonJS loader intercepted. `resolveSubtle`
- * caches the first provider it finds, so these tests are ordered:
- * the not-found case runs before anything is cached.
- */
-
-type SubtleStub = {
-  importKey: ReturnType<typeof vi.fn>;
-  deriveBits: ReturnType<typeof vi.fn>;
-  sign: ReturnType<typeof vi.fn>;
-};
-
-type Loader = (id: string, parent: unknown, isMain: boolean) => unknown;
-const loaderHost = Module as unknown as { _load: Loader };
-const originalLoad: Loader = loaderHost._load;
-
-const QUICK_CRYPTO = "react-native-quick-crypto";
-
-let quickCryptoExports: unknown | null = null;
-let cryptoDescriptor: PropertyDescriptor | undefined;
-
-function makeSubtle(): SubtleStub {
-  return {
-    importKey: vi.fn(async () => ({ handle: "key" })),
-    deriveBits: vi.fn(async () => new Uint8Array(32).fill(7).buffer),
-    sign: vi.fn(async () => new Uint8Array(32).fill(9).buffer),
-  };
-}
-
-beforeAll(() => {
-  // Hermes exposes no global `crypto.subtle`; reproduce that here so the
-  // native-provider branch is the one under test.
-  cryptoDescriptor = Object.getOwnPropertyDescriptor(globalThis, "crypto");
-  Object.defineProperty(globalThis, "crypto", {
-    value: undefined,
-    configurable: true,
-    writable: true,
-  });
-  vi.spyOn(loaderHost, "_load").mockImplementation((id, parent, isMain) => {
-    if (id === QUICK_CRYPTO) {
-      if (quickCryptoExports === null) {
-        const error = new Error(
-          `Cannot find module '${QUICK_CRYPTO}'`,
-        ) as Error & {
-          code: string;
-        };
-        error.code = "MODULE_NOT_FOUND";
-        throw error;
-      }
-      return quickCryptoExports;
-    }
-    return originalLoad.call(Module, id, parent, isMain);
-  });
-});
-
-afterAll(() => {
-  vi.restoreAllMocks();
-  if (cryptoDescriptor) {
-    Object.defineProperty(globalThis, "crypto", cryptoDescriptor);
-  } else {
-    delete (globalThis as { crypto?: unknown }).crypto;
-  }
-});
-
-describe("SigningCrypto — encoding helpers", () => {
-  it("UTF-8 encodes multi-byte text", () => {
-    expect(Array.from(utf8Bytes("é"))).toEqual([0xc3, 0xa9]);
-  });
-
-  it("base64-encodes with the standard alphabet and padding", () => {
-    expect(base64Encode(utf8Bytes("any carnal pleasure"))).toBe(
-      "YW55IGNhcm5hbCBwbGVhc3VyZQ==",
-    );
-    expect(base64Encode(utf8Bytes("any carnal pleasur"))).toBe(
-      "YW55IGNhcm5hbCBwbGVhc3Vy",
-    );
-    expect(base64Encode(utf8Bytes("any carnal pleasu"))).toBe(
-      "YW55IGNhcm5hbCBwbGVhc3U=",
-    );
-    expect(base64Encode(new Uint8Array(0))).toBe("");
-  });
-});
-
-// Ordered: the not-found case must run before a provider is cached.
-describe("SigningCrypto — no provider available", () => {
-  it("fails key derivation with actionable install guidance", async () => {
-    quickCryptoExports = null;
-
-    await expect(
-      SigningCrypto.deriveKey("secret", new Uint8Array([1, 2, 3])),
-    ).rejects.toBeInstanceOf(SmileIDCryptoError);
-    await expect(
-      SigningCrypto.deriveKey("secret", new Uint8Array([1, 2, 3])),
-    ).rejects.toThrow(/react-native-quick-crypto/);
-  });
-
-  it("fails MAC computation the same way", async () => {
-    quickCryptoExports = null;
-
-    await expect(
-      SigningCrypto.hmacSha256(new Uint8Array(32), new Uint8Array([1])),
-    ).rejects.toThrow(/No Web Crypto provider available/);
-  });
-});
-
-describe("SigningCrypto — native provider", () => {
-  const subtle = makeSubtle();
-
-  beforeAll(() => {
-    // Deepest of the four export shapes the package is read across.
-    quickCryptoExports = { default: { webcrypto: { subtle } } };
-  });
-
-  it("derives a 32-byte key through the native subtle", async () => {
-    const salt = new Uint8Array([9, 8, 7]);
-    const key = await SigningCrypto.deriveKey("secret", salt);
-
-    expect(key).toHaveLength(32);
-    expect(subtle.importKey).toHaveBeenCalledWith(
-      "raw",
-      expect.anything(),
-      "PBKDF2",
-      false,
-      ["deriveBits"],
-    );
-    const deriveArgs = subtle.deriveBits.mock.calls[0] as [
-      { name: string; iterations: number; hash: string; salt: ArrayBuffer },
-      unknown,
-      number,
-    ];
-    expect(deriveArgs[0].name).toBe("PBKDF2");
-    expect(deriveArgs[0].iterations).toBe(200000);
-    expect(deriveArgs[2]).toBe(256);
-    // The salt crosses as its exact bytes, not the whole backing buffer.
-    expect(Array.from(new Uint8Array(deriveArgs[0].salt))).toEqual([9, 8, 7]);
-  });
-
-  it("computes an HMAC through the native subtle", async () => {
-    const mac = await SigningCrypto.hmacSha256(
-      new Uint8Array(32).fill(1),
-      utf8Bytes("payload"),
-    );
-
-    expect(mac).toHaveLength(32);
-    expect(subtle.sign).toHaveBeenCalledWith(
-      "HMAC",
-      expect.anything(),
-      expect.anything(),
-    );
-  });
-
-  it("passes only the view's own bytes when the input is a subarray", async () => {
-    const backing = new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]);
-    subtle.sign.mockClear();
-    await SigningCrypto.hmacSha256(new Uint8Array(32), backing.subarray(2, 5));
-
-    const dataBuffer = subtle.sign.mock.calls[0]?.[2] as ArrayBuffer;
-    expect(Array.from(new Uint8Array(dataBuffer))).toEqual([2, 3, 4]);
-  });
-
-  it("wraps a derivation failure in SmileIDCryptoError", async () => {
-    subtle.deriveBits.mockRejectedValueOnce(new Error("openssl exploded"));
-
-    await expect(
-      SigningCrypto.deriveKey("secret", new Uint8Array([1])),
-    ).rejects.toThrow(/Key derivation failed: .*openssl exploded/);
-  });
-
-  it("rethrows an already-typed crypto error from deriveKey unchanged", async () => {
-    const typed = new SmileIDCryptoError("key material rejected");
-    subtle.importKey.mockRejectedValueOnce(typed);
-
-    await expect(
-      SigningCrypto.deriveKey("secret", new Uint8Array([1])),
-    ).rejects.toBe(typed);
-  });
-
-  it("wraps a MAC failure in SmileIDCryptoError", async () => {
-    subtle.sign.mockRejectedValueOnce(new Error("bad key handle"));
-
-    await expect(
-      SigningCrypto.hmacSha256(new Uint8Array(32), new Uint8Array([1])),
-    ).rejects.toThrow(/MAC computation failed: .*bad key handle/);
-  });
-
-  it("rethrows an already-typed crypto error from hmacSha256 unchanged", async () => {
-    const typed = new SmileIDCryptoError("hmac key rejected");
-    subtle.importKey.mockRejectedValueOnce(typed);
-
-    await expect(
-      SigningCrypto.hmacSha256(new Uint8Array(32), new Uint8Array([1])),
-    ).rejects.toBe(typed);
-  });
-});