@smileid/usesmileid 12.0.0 → 12.0.1

package/src/__tests__/snapshots/screens_structural.test.tsx

@@ -0,0 +1,230 @@
+import { describe, it, expect } from "vitest";
+import * as React from "react";
+import { View } from "react-native";
+import { act, create as createRenderer } from "react-test-renderer";
+import { CaptureType } from "../../core/models/ml_config";
+import { UseSmileIDCaptureContent } from "../../presentation/components/use_smile_id_capture_content";
+import type { UseSmileIDCaptureContentState } from "../../presentation/components/use_smile_id_capture_content";
+import { UseSmileIDConsentScreen } from "../../presentation/screen/use_smile_id_consent_screen";
+import { UseSmileIDDocumentBackInstructions } from "../../presentation/screen/use_smile_id_document_back_instructions";
+import { UseSmileIDDocumentPreviewScreen } from "../../presentation/screen/use_smile_id_document_preview_screen";
+import { UseSmileIDInstructionsScreen } from "../../presentation/screen/use_smile_id_instructions_screen";
+import { UseSmileIDPreviewScreen } from "../../presentation/screen/use_smile_id_preview_screen";
+import { UseSmileIDProcessingScreen } from "../../presentation/screen/use_smile_id_processing_screen";
+import { UseSmileIDFaceOverlay } from "../../presentation/components/use_smile_id_face_overlay";
+import { UseSmileIDDocumentOverlay } from "../../presentation/components/use_smile_id_document_overlay";
+import {
+  OVERLAY_STATE_COUNT,
+  UseSmileIDOverlayState,
+} from "../../presentation/state/use_smile_id_overlay_state";
+
+/**
+ * Structural snapshots: pin the rendered element tree, not pixels (pixels are
+ * the Detox lane's job). Keys follow the `<flow>/<screen>/<state>` contract.
+ */
+
+function render(element: React.ReactElement) {
+  let tree!: ReturnType<typeof createRenderer>;
+  act(() => {
+    tree = createRenderer(element);
+  });
+  return tree;
+}
+
+const CONTAINER = { containerWidth: 390, containerHeight: 520 } as const;
+
+const DOCUMENT_STATES = Object.values(UseSmileIDOverlayState).filter((s) =>
+  s.startsWith("DOCUMENT_"),
+);
+const FACE_STATES = Object.values(UseSmileIDOverlayState).filter(
+  (s) => !s.startsWith("DOCUMENT_"),
+);
+
+describe("structural snapshots", () => {
+  it("pins the overlay state inventory", () => {
+    expect(FACE_STATES.length + DOCUMENT_STATES.length).toBe(
+      OVERLAY_STATE_COUNT,
+    );
+  });
+
+  describe("selfie/instructions", () => {
+    it("selfie/instructions/default", () => {
+      const tree = render(
+        <UseSmileIDInstructionsScreen
+          onBack={() => {}}
+          onContinue={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/capture overlay", () => {
+    it.each(FACE_STATES)("selfie/capture/%s", (state) => {
+      const tree = render(
+        <UseSmileIDFaceOverlay state={state} progress={0.5} {...CONTAINER} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/capture overlay", () => {
+    it.each(DOCUMENT_STATES)("document/capture/%s", (state) => {
+      const tree = render(
+        <UseSmileIDDocumentOverlay state={state} {...CONTAINER} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("consent", () => {
+    it("consent/default", () => {
+      const tree = render(
+        <UseSmileIDConsentScreen
+          partnerName="Acme Bank"
+          partnerPrivacyPolicyUrl="https://usesmileid.com/privacy"
+          onAllow={() => {}}
+          onDeny={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/back_instructions", () => {
+    it("document/back_instructions/default", () => {
+      const tree = render(
+        <UseSmileIDDocumentBackInstructions
+          documentTypeDisplayName="National ID"
+          onCaptureBack={() => {}}
+          allowSkip
+          onSkip={() => {}}
+          onBack={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/preview", () => {
+    it("document/preview/default", () => {
+      const tree = render(
+        <UseSmileIDDocumentPreviewScreen
+          documentAspectRatio={1.586}
+          onAccept={() => {}}
+          onReject={() => {}}
+          onClose={() => {}}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  // Composed capture screen: camera slot + overlay + feedback + controls.
+  function renderCaptureContent(
+    overrides: Partial<UseSmileIDCaptureContentState>,
+  ) {
+    return render(
+      <UseSmileIDCaptureContent
+        state={{
+          captureType: CaptureType.selfie,
+          overlayState: UseSmileIDOverlayState.INSTRUCTION,
+          enableEnhancedLiveness: false,
+          animationDirection: null,
+          poseMatched: false,
+          feedbackKey: null,
+          showCaptureButton: false,
+          ...overrides,
+        }}
+        captureProgress={0}
+        cameraPreview={<View testID="camera-slot" />}
+        onStartCapture={() => {}}
+        startCaptureEnabled={true}
+        showAttribution={true}
+        onManualShutter={() => {}}
+        onGalleryUpload={() => {}}
+      />,
+    );
+  }
+
+  describe("selfie/capture content", () => {
+    it("selfie/capture/start_button", () => {
+      const tree = renderCaptureContent({
+        overlayState: UseSmileIDOverlayState.INSTRUCTION,
+        feedbackKey: "si_start_capture_instruction",
+        showCaptureButton: true,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("document/capture content", () => {
+    const DOCUMENT_VARIANTS: ReadonlyArray<
+      [string, Partial<UseSmileIDCaptureContentState>]
+    > = [
+      ["card_front", { documentTypeKind: "genericDocument" }],
+      ["card_back", { documentTypeKind: "genericDocument", isBackSide: true }],
+      // TD3 passport data page ratio (125×88 mm).
+      ["passport", { documentTypeKind: "passport", knownIdAspectRatio: 1.42 }],
+      ["green_book", { documentTypeKind: "southAfricaGreenBook" }],
+    ];
+
+    it.each(DOCUMENT_VARIANTS)("document/capture/%s", (_name, overrides) => {
+      const tree = renderCaptureContent({
+        captureType: CaptureType.document,
+        overlayState: UseSmileIDOverlayState.IDLE,
+        knownIdAspectRatio: 1.586,
+        showGalleryUpload: true,
+        ...overrides,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("document/capture/manual_shutter", () => {
+      const tree = renderCaptureContent({
+        captureType: CaptureType.document,
+        overlayState: UseSmileIDOverlayState.DOCUMENT_TOO_FAR,
+        feedbackKey: "si_document_too_far",
+        documentTypeKind: "genericDocument",
+        knownIdAspectRatio: 1.586,
+        showManualShutter: true,
+        showGalleryUpload: true,
+      });
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/preview", () => {
+    it("selfie/preview/default", () => {
+      const tree = render(<UseSmileIDPreviewScreen />);
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+
+  describe("selfie/processing", () => {
+    it("selfie/processing/loading", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen state={{ kind: "loading" }} />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("selfie/processing/success", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen
+          state={{ kind: "success", message: "Verification submitted" }}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+
+    it("selfie/processing/failed", () => {
+      const tree = render(
+        <UseSmileIDProcessingScreen
+          state={{ kind: "failed", errorMessage: "Network unavailable" }}
+        />,
+      );
+      expect(tree.toJSON()).toMatchSnapshot();
+    });
+  });
+});

package/src/camera/__tests__/use_smile_id_camera_system.test.ts

@@ -0,0 +1,103 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+/**
+ * Boundary characterization for `UseSmileIDCameraSystem`'s lifecycle state machine
+ * (permission gating, running/streaming flags, lens config, listener fan-out). The
+ * frame loop is a vision-camera worklet pinned separately by
+ * `use_smile_id_frame_stream.test.ts`. Must hold byte-identically across any
+ * camera-implementation swap.
+ */
+const permissions = vi.hoisted(() => ({
+  getStatus: vi.fn(),
+  request: vi.fn(),
+}));
+
+vi.mock("../camera_permissions", () => ({
+  getCameraPermissionStatus: permissions.getStatus,
+  requestCameraPermission: permissions.request,
+}));
+
+import { CameraLens } from "../camera_lens";
+import { UseSmileIDCameraSystem } from "../use_smile_id_camera_system";
+
+describe("UseSmileIDCameraSystem — boundary characterization", () => {
+  beforeEach(() => {
+    permissions.getStatus.mockReset();
+    permissions.request.mockReset();
+  });
+
+  it("starts idle with the configured lens", () => {
+    const system = new UseSmileIDCameraSystem(CameraLens.back);
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.isStreaming).toBe(false);
+    expect(state.hasPermission).toBe(false);
+    expect(state.currentLens).toBe(CameraLens.back);
+  });
+
+  it("start() runs + streams when permission is already granted (no re-prompt)", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(true);
+    expect(state.isStreaming).toBe(true);
+    expect(state.hasPermission).toBe(true);
+    expect(permissions.request).not.toHaveBeenCalled();
+  });
+
+  it("start() prompts when undetermined, then runs on grant", async () => {
+    permissions.getStatus.mockResolvedValue("undetermined");
+    permissions.request.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    expect(permissions.request).toHaveBeenCalledTimes(1);
+    expect(system.getState().isCameraRunning).toBe(true);
+  });
+
+  it("start() stays off when permission is denied", async () => {
+    permissions.getStatus.mockResolvedValue("undetermined");
+    permissions.request.mockResolvedValue("denied");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.hasPermission).toBe(false);
+  });
+
+  it("start() after release() throws — a released system is unusable", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    system.release();
+    await expect(system.start()).rejects.toThrow(/after release/);
+  });
+
+  it("stop() pauses running + streaming without releasing (re-startable)", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    await system.start();
+    system.stop();
+    const state = system.getState();
+    expect(state.isCameraRunning).toBe(false);
+    expect(state.isStreaming).toBe(false);
+  });
+
+  it("configure() swaps the lens and notifies subscribers", () => {
+    const system = new UseSmileIDCameraSystem(CameraLens.front);
+    const seenLenses: CameraLens[] = [];
+    system.subscribe((state) => seenLenses.push(state.currentLens));
+    system.configure({ lens: CameraLens.back });
+    expect(system.getState().currentLens).toBe(CameraLens.back);
+    expect(seenLenses).toContain(CameraLens.back);
+  });
+
+  it("unsubscribe stops further notifications", async () => {
+    permissions.getStatus.mockResolvedValue("granted");
+    const system = new UseSmileIDCameraSystem();
+    const listener = vi.fn();
+    const unsubscribe = system.subscribe(listener);
+    unsubscribe();
+    await system.start();
+    expect(listener).not.toHaveBeenCalled();
+  });
+});

package/src/core/exception/__tests__/builder_validation_exceptions.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+
+import { DuplicateScreenTypeException } from "../duplicate_screen_type_exception";
+import { InvalidSelfieCaptureConfigException } from "../invalid_selfie_capture_config_exception";
+import { LivenessFrameCountException } from "../liveness_frame_count_exception";
+import { UseSmileIDErrorCode } from "../use_smile_id_error_code";
+
+/** Typed builder/validation exceptions: pin `errorCode`, message, and `errorDetails`. */
+describe("DuplicateScreenTypeException", () => {
+  it("names the duplicated type + indices and freezes the details", () => {
+    const exception = new DuplicateScreenTypeException({
+      screenType: "consent",
+      indices: [0, 3],
+    });
+
+    expect(exception).toBeInstanceOf(Error);
+    expect(exception.errorCode).toBe(
+      UseSmileIDErrorCode.Builder.DuplicateScreenType,
+    );
+    expect(exception.message).toContain("consent");
+    expect(exception.message).toContain("0, 3");
+    expect(exception.errorDetails).toEqual({
+      screenType: "consent",
+      indices: [0, 3],
+    });
+    expect(Object.isFrozen(exception.errorDetails?.["indices"])).toBe(true);
+  });
+});
+
+describe("LivenessFrameCountException", () => {
+  it("reports expected vs actual frame counts", () => {
+    const exception = new LivenessFrameCountException({
+      expected: 8,
+      actual: 3,
+    });
+
+    expect(exception.errorCode).toBe(
+      UseSmileIDErrorCode.Validation.ConstraintViolation,
+    );
+    expect(exception.message).toContain("8");
+    expect(exception.message).toContain("3");
+    expect(exception.errorDetails).toEqual({ expected: 8, actual: 3 });
+  });
+});
+
+describe("InvalidSelfieCaptureConfigException", () => {
+  it("omits the reason suffix and details when no reason is given", () => {
+    const exception = new InvalidSelfieCaptureConfigException();
+
+    expect(exception.errorCode).toBe(
+      UseSmileIDErrorCode.Builder.InvalidSelfieCaptureConfig,
+    );
+    expect(exception.message).toContain("configuration is missing");
+    expect(exception.errorDetails).toBeUndefined();
+  });
+
+  it("appends the reason and carries it in details when provided", () => {
+    const exception = new InvalidSelfieCaptureConfigException({
+      reason: "minConfidence out of range",
+    });
+
+    expect(exception.message).toContain("minConfidence out of range");
+    expect(exception.errorDetails).toEqual({
+      reason: "minConfidence out of range",
+    });
+  });
+});

package/src/core/exception/agent_mode_with_enhanced_liveness_exception.ts

@@ -0,0 +1,20 @@
+import { UseSmileIDBuilderException } from "./use_smile_id_builder_exception";
+import { UseSmileIDErrorCode } from "./use_smile_id_error_code";
+
+/**
+ * Agent mode was combined with enhanced liveness. The head-turn challenge is
+ * validated for front-camera capture only, so the two options are mutually
+ * exclusive.
+ */
+export class AgentModeWithEnhancedLivenessException extends UseSmileIDBuilderException {
+  readonly errorCode =
+    UseSmileIDErrorCode.Builder.AgentModeWithEnhancedLiveness;
+
+  constructor() {
+    super({
+      message: "allowAgentMode is not supported with enableEnhancedLiveness",
+      suggestedFix:
+        "Disable one of them inside selfie { }: allowAgentMode for rear-camera agent capture, or enableEnhancedLiveness for the head-turn challenge",
+    });
+  }
+}

package/src/core/exception/capture_validation_exceptions.ts

@@ -3,6 +3,7 @@
  * Each concrete class lives in its own file; this module keeps the
  * legacy import path stable.
  */
+export { AgentModeWithEnhancedLivenessException } from "./agent_mode_with_enhanced_liveness_exception";
 export { InvalidSelfieCaptureConfigException } from "./invalid_selfie_capture_config_exception";
 export { InvalidDocumentCaptureConfigException } from "./invalid_document_capture_config_exception";
 export { InvalidMissingCaptureTypeException } from "./invalid_missing_capture_type_exception";

package/src/core/exception/index.ts

@@ -43,6 +43,7 @@ export { MissingCaptureForPreviewException } from "./missing_capture_for_preview
 export { DuplicateScreenTypeException } from "./duplicate_screen_type_exception";
 
 // Capture-config validation (`capture { }` block).
+export { AgentModeWithEnhancedLivenessException } from "./agent_mode_with_enhanced_liveness_exception";
 export { InvalidSelfieCaptureConfigException } from "./invalid_selfie_capture_config_exception";
 export { InvalidDocumentCaptureConfigException } from "./invalid_document_capture_config_exception";
 export { InvalidMissingCaptureTypeException } from "./invalid_missing_capture_type_exception";

package/src/core/exception/use_smile_id_error_code.ts

@@ -24,6 +24,7 @@ export const UseSmileIDErrorCode = {
     MissingScreenConfiguration: "BUILDER_MISSING_SCREEN_CONFIG",
     DuplicateScreenType: "BUILDER_DUPLICATE_SCREEN",
     InvalidSelfieCaptureConfig: "BUILDER_INVALID_SELFIE_CONFIG",
+    AgentModeWithEnhancedLiveness: "BUILDER_AGENT_MODE_WITH_ENHANCED_LIVENESS",
     InvalidDocumentCaptureConfig: "BUILDER_INVALID_DOCUMENT_CONFIG",
     MissingMLConfiguration: "BUILDER_MISSING_ML_CONFIG",
     MissingNetworkConfiguration: "BUILDER_MISSING_NETWORK_CONFIG",

package/src/core/models/__tests__/document_type.test.ts

@@ -15,11 +15,11 @@ describe("DocumentType presets", () => {
     });
   });
 
-  it("Passport is a landscape, single-sided document", () => {
+  it("Passport is a landscape, two-sided document", () => {
     expect(DocumentType.Passport).toEqual({
       kind: "passport",
       displayName: "Passport",
-      hasBackSide: false,
+      hasBackSide: true,
       orientation: "Landscape",
       knownAspectRatio: 356 / 272,
     });

package/src/core/models/__tests__/flow_models.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+
+import { FlowStep } from "../flow_step";
+import { HEAD_TURN_DIRECTIONS } from "../head_turn_direction";
+
+/** FlowStep + head-turn direction order is load-bearing (nav advances through it); pin it. */
+describe("flow model constants", () => {
+  it("FlowStep lists the steps in forward-navigation order", () => {
+    expect(FlowStep).toEqual([
+      "instructions",
+      "consent",
+      "permission",
+      "capture",
+      "preview",
+      "processing",
+    ]);
+  });
+
+  it("HEAD_TURN_DIRECTIONS enumerates the three challenge directions in order", () => {
+    expect(HEAD_TURN_DIRECTIONS).toEqual([
+      "look_left",
+      "look_right",
+      "look_up",
+    ]);
+  });
+});

package/src/core/models/config.ts

@@ -1,3 +1,6 @@
+import type * as ScreenOrientation from "expo-screen-orientation";
+import type { GlobalPrivacyControl } from "./global_privacy_control";
+
 /**
  * Global SDK configuration flags. Snapshot produced by
  * `UseSmileIDConfigBuilder.build()` — every field is populated, with
@@ -33,4 +36,23 @@ export type ConfigOptions = {
    * `docs/Architecture.md § Rollout`.
    */
   readonly allowOfflineMode: boolean;
+
+  /**
+   * Partner-declared consent posture (`global_privacy_control`).
+   * `GlobalPrivacyControl.OptOut` (the default) forces the opt-out consent
+   * layout universally; `OptIn` keeps the legacy regional mechanics.
+   */
+  readonly globalPrivacyControl: GlobalPrivacyControl;
+
+  /**
+   * Orientation lock the SDK applies when a capture screen leaves the screen.
+   * Defaults to `PORTRAIT_UP`, the posture most hosts pin at their root
+   * layout; multi-orientation hosts set `DEFAULT` so the flow releases the
+   * clamp instead of leaving the app portrait-only after verification.
+   *
+   * Optional so a hand-written `ConfigOptions` literal still compiles; the
+   * builder always populates it, and an absent value takes the same
+   * `PORTRAIT_UP` default at the capture screen.
+   */
+  readonly exitOrientations?: ScreenOrientation.OrientationLock;
 };

package/src/core/models/document_type.ts

@@ -34,7 +34,7 @@ const SOUTH_AFRICA_GREEN_BOOK: DocumentType = Object.freeze({
 const PASSPORT: DocumentType = Object.freeze({
   kind: "passport",
   displayName: "Passport",
-  hasBackSide: false,
+  hasBackSide: true,
   orientation: "Landscape",
   knownAspectRatio: 356 / 272,
 });
@@ -51,7 +51,7 @@ export type GenericDocumentArgs = {
 export const DocumentType = {
   /** South Africa Green Book — booklet-style, single-side, portrait. */
   SouthAfricaGreenBook: SOUTH_AFRICA_GREEN_BOOK,
-  /** Passport — single data page, no back side, landscape. */
+  /** Passport — landscape data page followed by a back-side capture. */
   Passport: PASSPORT,
   /** Catch-all without a preset; defaults to a landscape, two-sided "Document". */
   GenericDocument(args: GenericDocumentArgs = {}): DocumentType {

package/src/core/models/global_privacy_control.ts

@@ -0,0 +1,45 @@
+/**
+ * Partner-declared Global Privacy Control posture for the consent screen
+ * (`global_privacy_control` on the wire).
+ *
+ * Native mobile platforms expose no OS-level equivalent of the web's GPC
+ * signal, so the SDK performs no runtime user-signal tracking: the partner
+ * declares the posture once at initialization
+ * (`b.config((c) => { c.globalPrivacyControl = ...; })`) and it governs
+ * every session.
+ *
+ * Const-object pattern (see `KameraEventType`-style types): enum ergonomics,
+ * string wire format.
+ */
+export const GlobalPrivacyControl = {
+  /**
+   * Default. Forces the opt-out consent layout universally: consent starts
+   * granted (pre-selected) for every session regardless of region — the
+   * user unticks to opt out. Regional detection is never consulted.
+   */
+  OptOut: "opt-out",
+
+  /**
+   * Legacy regional mechanics: consent starts granted outside the EU and
+   * starts ungranted (explicit opt-in required) when the device locale is
+   * an EU member state.
+   */
+  OptIn: "opt-in",
+} as const;
+export type GlobalPrivacyControl =
+  (typeof GlobalPrivacyControl)[keyof typeof GlobalPrivacyControl];
+
+/** Configuration key this setting is transported under. */
+export const GLOBAL_PRIVACY_CONTROL_WIRE_KEY = "global_privacy_control";
+
+/**
+ * Parses a wire value ("opt-out" / "opt-in"); anything else falls back to
+ * the `OptOut` baseline default.
+ */
+export function globalPrivacyControlFromWire(
+  value: string | null | undefined,
+): GlobalPrivacyControl {
+  return value === GlobalPrivacyControl.OptIn
+    ? GlobalPrivacyControl.OptIn
+    : GlobalPrivacyControl.OptOut;
+}

package/src/core/models/network_config.ts

@@ -97,10 +97,10 @@ export type CacheConfig = {
 };
 
 /**
- * Retry strategy.
+ * Retry strategy. `none` is the default.
+ *   - `none`: one attempt, no retry — `maxAttempts` is forced to 1
  *   - `exponential`: `delay = min(initialDelay × multiplier^attempt, maxDelay)` plus `±jitter`
  *   - `fixed`: constant `fixedDelay` between attempts
- *   - `none`: no retry (`maxAttempts: 1`)
  */
 export enum RetryStrategy {
   exponential = "exponential",

package/src/data/api/__tests__/smile_id_api.test.ts

@@ -109,7 +109,7 @@ const consent: ConsentInformation = Object.freeze({
 // builds this and it travels on every `JobRequest`; the API
 // serializes `request.metadata` as the `metadata` multipart part.
 const metadata = new UseSmileIDMetadata({
-  sdkVersion: "12.0.0",
+  sdkVersion: "12.0.1",
   sdk: "react-native-expo",
   deviceOs: "",
   deviceModel: "",