@smileid/usesmileid 12.0.0-beta01 → 12.0.1

package/src/data/dsl/builder/__tests__/config_builders.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+
+import { CacheConfigBuilder } from "../cache_config_builder";
+import { RetryConfigBuilder, RetryStrategy } from "../retry_config_builder";
+
+/** Retry/cache DSL builders: pin the documented defaults, frozen output, and overrides. */
+describe("RetryConfigBuilder", () => {
+  it("builds a frozen config with the documented defaults", () => {
+    const config = new RetryConfigBuilder().build();
+
+    expect(config).toEqual({
+      maxAttempts: 1,
+      strategy: RetryStrategy.none,
+      initialDelay: 1,
+      multiplier: 2,
+      maxDelay: 32,
+      jitter: 0.2,
+      fixedDelay: 1,
+    });
+    expect(Object.isFrozen(config)).toBe(true);
+  });
+
+  it("forces maxAttempts to 1 for none, whatever the field says", () => {
+    const builder = new RetryConfigBuilder();
+    builder.maxAttempts = 5;
+
+    expect(builder.build().maxAttempts).toBe(1);
+  });
+
+  it("applies the attempt budget once a strategy opts in", () => {
+    const builder = new RetryConfigBuilder();
+    builder.strategy = RetryStrategy.exponential;
+
+    expect(builder.build().maxAttempts).toBe(3);
+  });
+
+  it("carries overridden fields through build()", () => {
+    const builder = new RetryConfigBuilder();
+    builder.maxAttempts = 5;
+    builder.strategy = RetryStrategy.fixed;
+    builder.fixedDelay = 4;
+
+    const config = builder.build();
+
+    expect(config.maxAttempts).toBe(5);
+    expect(config.strategy).toBe(RetryStrategy.fixed);
+    expect(config.fixedDelay).toBe(4);
+  });
+});
+
+describe("CacheConfigBuilder", () => {
+  it("defaults to enabled with a 50 MB ceiling", () => {
+    const config = new CacheConfigBuilder().build();
+
+    expect(config).toEqual({ enabled: true, maxSize: 50 * 1024 * 1024 });
+    expect(Object.isFrozen(config)).toBe(true);
+  });
+
+  it("megabytes() converts MB to bytes", () => {
+    expect(new CacheConfigBuilder().megabytes(10)).toBe(10 * 1024 * 1024);
+  });
+});

package/src/data/dsl/builder/cache_config_builder.ts

@@ -7,8 +7,10 @@ import type { CacheConfig } from "../../../core/models/network_config";
  * verification flows without aggressive trimming.
  */
 export class CacheConfigBuilder {
+  /** Whether HTTP response caching is on. */
   enabled = true;
-  /** Bytes — default 50 MB. */
+
+  /** Maximum on-disk cache size, in bytes. Default 50 MB. */
   maxSize = 50 * 1024 * 1024;
 
   /**

package/src/data/dsl/builder/config_builder.ts

@@ -18,13 +18,25 @@ import {
  * identity.
  */
 export class PartnerConfigBuilder {
+  /** Your Smile ID partner id. Required. */
   partnerId = "";
+
+  /**
+   * Optional webhook URL Smile ID calls with the job result. It is also
+   * sent as a per-request identity header.
+   */
   callbackUrl = "";
+
+  /**
+   * When true, routes requests to the sandbox environment instead of
+   * production. Defaults to false.
+   */
   useSandbox = false;
+
   /**
-   * Optional partner-supplied key/value metadata. Forwarded onto the
-   * `partner_params` JSON multipart form part on Enhanced / Biometric
-   * KYC submissions when set.
+   * Optional free-form key/value pairs echoed back on the job result for
+   * your own correlation. Forwarded onto the `partner_params` JSON
+   * multipart form part on Enhanced / Biometric KYC submissions when set.
    */
   partnerParams?: Record<string, string>;
 
@@ -49,8 +61,16 @@ export class PartnerConfigBuilder {
  * redaction list with their own proxy-injected headers.
  */
 export class LoggingConfigBuilder {
+  /** Whether HTTP request/response logging is on. */
   enabled = true;
+
+  /** Logging verbosity: none, basic, headers, or full body. */
   level: LogLevel = LogLevel.basic;
+
+  /**
+   * Header names whose values are masked in logs (for example
+   * authorization headers).
+   */
   redactHeaders: readonly string[] = [];
 
   build(): NetworkLoggingConfig {
@@ -75,35 +95,46 @@ export class LoggingConfigBuilder {
  * omit blocks they don't need.
  */
 export class ConfigBuilder {
+  /**
+   * The verification job this flow submits (for example smart-selfie
+   * enrollment, biometric KYC, or document verification). Required.
+   */
   jobType?: JobType;
 
   /**
-   * Short-lived v3 auth token issued by `/v3/token`. The partner
-   * application is responsible for exchanging its API key for a token
-   * before invoking the SDK and supplying the result here. Stamped as
-   * the `smileid-token` HTTP header on every authenticated request.
+   * The short-lived authentication token for this session. Your backend
+   * obtains it from Smile ID's `/v3/token` endpoint using your API key;
+   * the SDK never exchanges credentials itself. Stamped as the
+   * `smileid-token` HTTP header on every authenticated request.
    */
   token = "";
 
   /**
-   * Optional async refresh callback invoked when the server responds
-   * with `401 Unauthorized`. The callback receives the token the SDK
-   * was using and returns a fresh token; the SDK then retries the
-   * original request once with the new value. Concurrent 401s collapse
-   * to a single callback invocation via the SDK's shared `TokenHolder`.
-   * If the callback throws or the retry also returns 401, the original
-   * 401 response is surfaced unchanged.
+   * Optional async callback invoked when the server rejects the token
+   * with a 401. Return a fresh token and the SDK retries the request
+   * once with it. The callback receives the token the SDK was using.
+   * Concurrent 401s collapse to a single callback invocation via the
+   * SDK's shared `TokenHolder`. If the callback throws or the retry also
+   * returns 401, the original 401 response is surfaced unchanged.
    */
   onTokenExpired?: (previousToken: string) => Promise<string>;
 
   private _partnerConfig?: PartnerConfigBuilder;
   private _logging?: LoggingConfigBuilder;
 
+  /**
+   * Configures partner identity and per-job environment settings —
+   * partner id, callback URL, sandbox mode, and partner params.
+   */
   partnerConfig(block: (p: PartnerConfigBuilder) => void): void {
     if (!this._partnerConfig) this._partnerConfig = new PartnerConfigBuilder();
     block(this._partnerConfig);
   }
 
+  /**
+   * Configures HTTP request/response logging: on/off, verbosity, and
+   * redacted headers.
+   */
   logging(block: (l: LoggingConfigBuilder) => void): void {
     if (!this._logging) this._logging = new LoggingConfigBuilder();
     block(this._logging);

package/src/data/dsl/builder/interceptor_config_builder.ts

@@ -28,24 +28,26 @@ import {
 export class InterceptorConfigBuilder {
   private _interceptors: Interceptor[] = [];
 
+  /** Appends a custom interceptor to the chain. */
   add(interceptor: Interceptor): void {
     this._interceptors.push(interceptor);
   }
 
   /**
-   * Returns an interceptor that stamps `Accept-Encoding: gzip` on
-   * every outbound request. Hint-only — the SDK does not pull in a
-   * JS gzip dependency to compress request bodies. See
-   * [createGzipInterceptor] for the rationale.
+   * Adds the gzip interceptor, which requests compressed responses by
+   * stamping `Accept-Encoding: gzip` on every outbound request.
+   * Hint-only — the SDK does not pull in a JS gzip dependency to
+   * compress request bodies. See [createGzipInterceptor] for the
+   * rationale.
    */
   gzip(): Interceptor {
     return createGzipInterceptor();
   }
 
   /**
-   * Returns a logging interceptor configured by `configure`. The
-   * partner block mutates a `LoggingInterceptorBuilder` carrying
-   * `level` and `redactHeaders`.
+   * Adds the logging interceptor with the given verbosity. The partner
+   * block mutates a `LoggingInterceptorBuilder` carrying `level` and
+   * `redactHeaders`.
    */
   logging(
     configure?: (builder: LoggingInterceptorBuilder) => void,

package/src/data/dsl/builder/retry_config_builder.ts

@@ -8,23 +8,44 @@ export { RetryStrategy };
 /**
  * DSL builder for request retry behaviour.
  *
- * Defaults to exponential backoff with 3 attempts, 1 s initial delay,
- * 32 s ceiling, ±20% jitter. `fixedDelay` is honoured only when
- * `strategy = RetryStrategy.fixed`.
+ * Defaults to no retry. Set `strategy` to opt in, and the remaining fields
+ * then apply: 3 attempts, 1 s initial delay, 32 s ceiling, ±20% jitter.
+ * `fixedDelay` is honoured only when `strategy = RetryStrategy.fixed`.
  */
 export class RetryConfigBuilder {
+  /** Attempts per request including the first; applies once `strategy` opts in. */
   maxAttempts = 3;
-  strategy: RetryStrategy = RetryStrategy.exponential;
+
+  /** Backoff strategy between attempts: exponential, fixed, or none. */
+  strategy: RetryStrategy = RetryStrategy.none;
+
+  /** Delay before the first retry, in seconds (exponential strategy). */
   initialDelay = 1;
+
+  /**
+   * Factor by which the delay grows after each attempt (exponential
+   * strategy).
+   */
   multiplier = 2;
+
+  /**
+   * Upper bound on the delay between attempts, in seconds (exponential
+   * strategy).
+   */
   maxDelay = 32;
-  /** ±20% randomized jitter on the computed delay, in [0, 1]. */
+
+  /**
+   * Random fraction between 0 and 1 added to each delay to avoid
+   * synchronized retry storms.
+   */
   jitter = 0.2;
+
+  /** Constant delay between attempts, in seconds (fixed strategy). */
   fixedDelay = 1;
 
   build(): RetryConfig {
     return Object.freeze({
-      maxAttempts: this.maxAttempts,
+      maxAttempts: this.strategy === RetryStrategy.none ? 1 : this.maxAttempts,
       strategy: this.strategy,
       initialDelay: this.initialDelay,
       multiplier: this.multiplier,

package/src/data/dsl/builder/timeout_config_builder.ts

@@ -8,9 +8,16 @@ import type { TimeoutConfig } from "../../../core/models/network_config";
  * the end-to-end ceiling for the whole request including retries.
  */
 export class TimeoutConfigBuilder {
+  /** Maximum time to establish a connection, in seconds. */
   connect = 60;
+
+  /** Maximum time to wait for response data, in seconds. */
   read = 60;
+
+  /** Maximum time to send request data, in seconds. */
   write = 60;
+
+  /** Maximum total time for the entire request, in seconds. */
   call = 120;
 
   build(): TimeoutConfig {

package/src/data/dsl/use_smile_id_network_builder.ts

@@ -29,26 +29,43 @@ export class UseSmileIDNetworkBuilder {
   private _retry?: RetryConfigBuilder;
   private _interceptors?: InterceptorConfigBuilder;
 
+  /**
+   * Configures the job type, authentication token, token-refresh
+   * callback, and partner identity for this flow.
+   */
   config(block: (c: ConfigBuilder) => void): void {
     if (!this._config) this._config = new ConfigBuilder();
     block(this._config);
   }
 
+  /**
+   * Configures per-phase HTTP timeouts — connect, read, write, and
+   * overall call — in seconds.
+   */
   timeouts(block: (t: TimeoutConfigBuilder) => void): void {
     if (!this._timeouts) this._timeouts = new TimeoutConfigBuilder();
     block(this._timeouts);
   }
 
+  /** Configures the HTTP response cache (on/off and maximum size). */
   cache(block: (c: CacheConfigBuilder) => void): void {
     if (!this._cache) this._cache = new CacheConfigBuilder();
     block(this._cache);
   }
 
+  /**
+   * Configures automatic retry of failed requests: strategy, attempt
+   * count, and backoff.
+   */
   retry(block: (r: RetryConfigBuilder) => void): void {
     if (!this._retry) this._retry = new RetryConfigBuilder();
     block(this._retry);
   }
 
+  /**
+   * Registers additional request/response interceptors, appended to the
+   * SDK's interceptor chain.
+   */
   interceptors(block: (i: InterceptorConfigBuilder) => void): void {
     if (!this._interceptors)
       this._interceptors = new InterceptorConfigBuilder();

package/src/data/factory/__tests__/retry_gzip_mac_composition.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, it } from "vitest";
+import {
+  AxiosError,
+  type AxiosResponse,
+  type InternalAxiosRequestConfig,
+} from "axios";
+
+import { JobType } from "../../../core/models/job_type";
+import type { NetworkConfig } from "../../../core/models/network_config";
+import { makeNetworkingFactory } from "../networking_factory";
+import { SmileIDCryptoManager } from "../../security/smile_id_crypto_manager";
+import {
+  REQUEST_MAC_HEADER,
+  REQUEST_MAC_OPT_IN_KEY,
+  REQUEST_TIMESTAMP_HEADER,
+} from "../../api/interceptors/smile_request_mac_interceptor";
+
+/**
+ * Standing-guard composition test for token-refresh × gzip × request-MAC on a
+ * 401 → refresh → retry. `TokenRefreshInterceptor` re-issues the config, re-running the whole
+ * chain (auth re-stamps the token, MAC re-signs, gzip re-stamps `Accept-Encoding`). If a future
+ * change made gzip replace `config.data` with compressed bytes, the MAC would sign a body the
+ * canonicalizer no longer sees as FormData → `{}`. Pins the retried MAC against the uncompressed
+ * body so that regression fails loud.
+ */
+describe("token-refresh x gzip x request-MAC composition", () => {
+  const initialToken = "token-1";
+  const refreshedToken = "token-2";
+  const signingSecret = "test-signing-secret";
+  const cryptoManager = new SmileIDCryptoManager(signingSecret);
+
+  type FormDataPart = { fieldName: string; string?: string; uri?: string };
+
+  /**
+   * Stand-in for RN's `FormData`. Besides `getParts()` (what the canonicalizer reads), it
+   * satisfies axios's `isFormData()` (`Symbol.toStringTag` + `append`) so axios's request
+   * transform leaves it untouched instead of JSON-stringifying it.
+   */
+  class FakeFormData {
+    constructor(private readonly parts: readonly FormDataPart[]) {}
+    get [Symbol.toStringTag](): string {
+      return "FormData";
+    }
+    append(): void {
+      /* not exercised — only presence is checked by axios's isFormData() */
+    }
+    getParts(): readonly FormDataPart[] {
+      return this.parts;
+    }
+  }
+
+  function submissionBody(): FakeFormData {
+    return new FakeFormData([
+      { fieldName: "country", string: "NG" },
+      { fieldName: "partner_params", string: '{"flow":"enhanced"}' },
+      {
+        fieldName: "selfie_image",
+        uri: "data:application/octet-stream;base64,c2VsZmll",
+      },
+    ]);
+  }
+
+  /** Flattens the observed AxiosHeaders to a lower-cased record, matching how
+   *  RequestCanonicalizer lower-cases header names before signing. */
+  function headersRecord(
+    headers: InternalAxiosRequestConfig["headers"],
+  ): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [key, value] of Object.entries(
+      headers as unknown as Record<string, unknown>,
+    )) {
+      if (value != null) out[key.toLowerCase()] = String(value);
+    }
+    return out;
+  }
+
+  function makeConfig(): NetworkConfig {
+    return {
+      config: {
+        jobType: JobType.smartSelfieEnrollment,
+        token: initialToken,
+        onTokenExpired: async () => refreshedToken,
+        partnerConfig: {
+          partnerId: "partner-1",
+          callbackUrl: "https://partner.example.com/cb",
+          useSandbox: true,
+        },
+      },
+    };
+  }
+
+  it("signs the refresh-retried request's MAC over the uncompressed submission body", async () => {
+    const requestsSeen: InternalAxiosRequestConfig[] = [];
+    const { client } = makeNetworkingFactory(makeConfig(), () => signingSecret);
+
+    // 401 first, 200 on the retry. A custom adapter bypasses axios's validateStatus, so it
+    // must reject non-2xx itself for TokenRefreshInterceptor's error handler to see it.
+    client.defaults.adapter = (
+      requestConfig: InternalAxiosRequestConfig,
+    ): Promise<AxiosResponse> => {
+      requestsSeen.push(requestConfig);
+      const isFirstCall = requestsSeen.length === 1;
+      const response: AxiosResponse = {
+        status: isFirstCall ? 401 : 200,
+        statusText: isFirstCall ? "Unauthorized" : "OK",
+        data: isFirstCall ? { error: "unauthorized" } : { jobId: "job-1" },
+        headers: {},
+        config: requestConfig,
+      };
+      if (isFirstCall) {
+        return Promise.reject(
+          new AxiosError(
+            "Request failed with status code 401",
+            AxiosError.ERR_BAD_REQUEST,
+            requestConfig,
+            undefined,
+            response,
+          ),
+        );
+      }
+      return Promise.resolve(response);
+    };
+
+    const body = submissionBody();
+    const response = await client.post("/v3/enhanced_kyc", body, {
+      [REQUEST_MAC_OPT_IN_KEY]: true,
+    } as Partial<InternalAxiosRequestConfig>);
+
+    expect(response.status).toBe(200);
+    expect(requestsSeen).toHaveLength(2);
+
+    const retried = requestsSeen[1]!;
+    const retriedHeaders = headersRecord(retried.headers);
+
+    expect(retriedHeaders["smileid-token"]).toBe(refreshedToken);
+    expect(retriedHeaders["accept-encoding"]).toBe("gzip");
+    // gzip is hint-only — it never compresses the body, so no Content-Encoding claim.
+    expect(retriedHeaders["content-encoding"]).toBeUndefined();
+
+    const retriedMac = retriedHeaders[REQUEST_MAC_HEADER];
+    const retriedTimestamp = retriedHeaders[REQUEST_TIMESTAMP_HEADER];
+    expect(retriedMac).toBeDefined();
+    expect(retriedTimestamp).toBeDefined();
+
+    // Recompute the server-verified MAC over the retried headers and the real body — gzip
+    // is hint-only (never replaces config.data), so `body` is the bytes that shipped.
+    const expectedMac = await cryptoManager.sign(
+      retriedTimestamp!,
+      retriedHeaders,
+      body,
+    );
+    expect(retriedMac).toBe(expectedMac);
+
+    // And it must not match a MAC computed against an empty body — the
+    // signature of the regression this test guards against.
+    const emptyBodyMac = await cryptoManager.sign(
+      retriedTimestamp!,
+      retriedHeaders,
+      undefined,
+    );
+    expect(retriedMac).not.toBe(emptyBodyMac);
+  });
+});

package/src/data/factory/__tests__/signed_job_submission_headers.test.ts

@@ -36,7 +36,7 @@ function makeBaseConfig(): NetworkConfig {
 }
 
 const metadata = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",

package/src/data/factory/networking_factory.ts

@@ -12,6 +12,8 @@ import { SmileIntegrityInterceptor } from "../api/interceptors/smile_integrity_i
 import { TokenRefreshInterceptor } from "../api/interceptors/token_refresh_interceptor";
 import { TokenHolder } from "../api/auth/token_holder";
 import { SmileIDCryptoManager } from "../security/smile_id_crypto_manager";
+import { SecurityPolicy } from "../security/security_policy";
+import { decodeSecurityPolicyBitCode } from "../util/use_smile_id_token_decoder";
 import { Attestation, SigningSecretProvider } from "@smileid/usesmileid_bridge";
 import { MissingPartnerConfigException } from "../../core/exception";
 import { UseSmileIDMetadataFactory } from "../../metadata/use_smile_id_metadata_factory";
@@ -107,6 +109,14 @@ export function makeNetworkingFactory(
   // next outgoing request automatically picks up the new token.
   const tokenHolder = new TokenHolder(config.config?.token ?? "");
 
+  // Server-driven security policy for this flow, decoded from the top-level `policy` claim on the
+  // JWT (a sibling of `sdk_config`). Decoding is fail-secure: a malformed token, an absent claim, or an absent
+  // bit-code all resolve to "every behaviour active", so a token without the claim keeps the
+  // pre-policy behaviour rather than dropping security.
+  const securityPolicy = SecurityPolicy.fromBitCode(
+    decodeSecurityPolicyBitCode(config.config?.token ?? ""),
+  );
+
   // 1. Gzip is registered FIRST so it runs LAST on the request path
   //    (innermost / closest to the wire). It stamps `Accept-Encoding:
   //    gzip` so the server can compress responses (axios
@@ -128,7 +138,9 @@ export function makeNetworkingFactory(
   //    request path — it reads the `smileid-request-mac` header the MAC
   //    interceptor sets and binds the per-request token to it. Per-request
   //    opt-in via `config._useSmileIDAttestation`; pass-through otherwise.
-  const integrityInterceptor = new SmileIntegrityInterceptor();
+  const integrityInterceptor = new SmileIntegrityInterceptor({
+    securityPolicy,
+  });
   integrityInterceptor.attach(client);
 
   // 4. Request MAC runs after auth (so the `smileid-*` headers + timestamp it
@@ -138,6 +150,7 @@ export function makeNetworkingFactory(
   const cryptoManager = new SmileIDCryptoManager(signingSecret());
   const requestMacInterceptor = new SmileRequestMacInterceptor({
     cryptoManager,
+    securityPolicy,
   });
   requestMacInterceptor.attach(client);
 

package/src/data/repository/__tests__/network_retries.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, it, vi } from "vitest";
+import { AxiosError, AxiosHeaders } from "axios";
+
+import { UseSmileIDRepositoryImpl } from "../use_smile_id_repository_impl";
+import {
+  RetryStrategy,
+  type RetryConfig,
+} from "../../dsl/builder/retry_config_builder";
+import { JobType } from "../../../core/models/job_type";
+import { UseSmileIDMetadata } from "../../../metadata/use_smile_id_metadata";
+import type { EnhancedKycRequest } from "../../model/job_request";
+import type { JobSubmissionResponse } from "../../model/job_submission_response";
+import type { ConsentInformation } from "../../../core/models/params";
+
+// This file intentionally does NOT mock axios: it exercises the real retry
+// classifier (`isRetryable` → `axios.isAxiosError`) so a genuine retry happens
+// and `network_retries` can be observed on the stamped metadata.
+
+const FIXED_RETRY: RetryConfig = Object.freeze({
+  maxAttempts: 2,
+  strategy: RetryStrategy.fixed,
+  initialDelay: 0,
+  multiplier: 1,
+  maxDelay: 0,
+  jitter: 0,
+  fixedDelay: 0,
+});
+
+const CONSENT: ConsentInformation = Object.freeze({
+  granted: true,
+  grantedAt: "2026-04-30T00:00:00.000Z",
+  noticeLanguage: "EN",
+  noticePrivacyPolicyUrl: "https://example.test/p",
+});
+
+const METADATA = new UseSmileIDMetadata({
+  sdkVersion: "12.0.1",
+  sdk: "react-native-expo",
+  deviceOs: "",
+  deviceModel: "",
+  appName: "",
+  sessionId: "test-session-id",
+  clientIp: "",
+  networkConnection: "",
+  carrierInfo: "",
+  proxy: false,
+  timezone: "",
+  locale: "",
+  screenResolution: "",
+  memoryInfoMb: 0,
+  deviceOrientation: "",
+  systemArchitecture: "",
+  numberOfCameras: 0,
+  hostApplication: "",
+  proximitySensor: false,
+  securityPolicyVersion: "12.0.0",
+});
+
+function makeAxiosError(status: number): AxiosError {
+  return new AxiosError("boom", `${status}`, undefined, undefined, {
+    status,
+    statusText: "X",
+    data: undefined,
+    headers: {},
+    config: { headers: new AxiosHeaders() },
+  });
+}
+
+function networkRetriesOf(metadata: UseSmileIDMetadata): string | undefined {
+  return metadata.toEntries().find((e) => e.name === "network_retries")?.value;
+}
+
+describe("UseSmileIDRepositoryImpl — network_retries", () => {
+  it("stamps network_retries on the retried attempt and omits it on the first", async () => {
+    const response: JobSubmissionResponse = {
+      jobId: "job-1",
+      userId: "user-1",
+      status: "approved",
+      message: "ok",
+    };
+    const seenRetries: (string | undefined)[] = [];
+    const enhancedKyc = vi
+      .fn()
+      .mockImplementation((request: EnhancedKycRequest) => {
+        seenRetries.push(networkRetriesOf(request.metadata));
+        // Fail the first attempt with a retryable 500, succeed on the retry.
+        if (enhancedKyc.mock.calls.length === 1) {
+          return Promise.reject(makeAxiosError(500));
+        }
+        return Promise.resolve(response);
+      });
+    const stubApi = {
+      enhancedKyc,
+      biometricKyc: vi.fn(),
+      smartSelfieEnrollment: vi.fn(),
+      smartSelfieAuthentication: vi.fn(),
+      documentVerification: vi.fn(),
+      enhancedDocumentVerification: vi.fn(),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+    const repository = new UseSmileIDRepositoryImpl(stubApi, FIXED_RETRY);
+    const request: EnhancedKycRequest = {
+      jobType: JobType.enhancedKyc,
+      params: { idType: "NIN", idNumber: "1", country: "NG" },
+      userDetails: { givenNames: "A", lastName: "B", email: "a@b.test" },
+      consent: CONSENT,
+      metadata: METADATA,
+    };
+
+    const result = await repository.submit(request);
+
+    expect(result.status).toBe("success");
+    expect(enhancedKyc).toHaveBeenCalledTimes(2);
+    // First attempt: no retries yet. Retry attempt: one retry preceded it.
+    expect(seenRetries).toEqual([undefined, "1"]);
+  });
+});

package/src/data/repository/__tests__/use_smile_id_repository.test.ts

@@ -51,7 +51,7 @@ const CONSENT: ConsentInformation = Object.freeze({
 // BVN path short-circuits before the API serializes it, but the field
 // is required on `BaseJobRequest` so the fixture must supply one.
 const METADATA = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",